client.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"log"
	"reflect"

	"github.com/agui-coder/simple-admin-product-rpc/ent/migrate"

	"github.com/agui-coder/simple-admin-product-rpc/ent/brand"
	"github.com/agui-coder/simple-admin-product-rpc/ent/category"
	"github.com/agui-coder/simple-admin-product-rpc/ent/comment"
	"github.com/agui-coder/simple-admin-product-rpc/ent/property"
	"github.com/agui-coder/simple-admin-product-rpc/ent/propertyvalue"
	"github.com/agui-coder/simple-admin-product-rpc/ent/sku"
	"github.com/agui-coder/simple-admin-product-rpc/ent/spu"

	"entgo.io/ent"
	"entgo.io/ent/dialect"
	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
)

// Client is the client that holds all ent builders.
type Client struct {
	config
	// Schema is the client for creating, migrating and dropping schema.
	Schema *migrate.Schema
	// Brand is the client for interacting with the Brand builders.
	Brand *BrandClient
	// Category is the client for interacting with the Category builders.
	Category *CategoryClient
	// Comment is the client for interacting with the Comment builders.
	Comment *CommentClient
	// Property is the client for interacting with the Property builders.
	Property *PropertyClient
	// PropertyValue is the client for interacting with the PropertyValue builders.
	PropertyValue *PropertyValueClient
	// Sku is the client for interacting with the Sku builders.
	Sku *SkuClient
	// Spu is the client for interacting with the Spu builders.
	Spu *SpuClient
}

// NewClient creates a new client configured with the given options.
func NewClient(opts ...Option) *Client {
	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
	cfg.options(opts...)
	client := &Client{config: cfg}
	client.init()
	return client
}

func (c *Client) init() {
	c.Schema = migrate.NewSchema(c.driver)
	c.Brand = NewBrandClient(c.config)
	c.Category = NewCategoryClient(c.config)
	c.Comment = NewCommentClient(c.config)
	c.Property = NewPropertyClient(c.config)
	c.PropertyValue = NewPropertyValueClient(c.config)
	c.Sku = NewSkuClient(c.config)
	c.Spu = NewSpuClient(c.config)
}

type (
	// config is the configuration for the client and its builder.
	config struct {
		// driver used for executing database requests.
		driver dialect.Driver
		// debug enable a debug logging.
		debug bool
		// log used for logging on debug mode.
		log func(...any)
		// hooks to execute on mutations.
		hooks *hooks
		// interceptors to execute on queries.
		inters *inters
	}
	// Option function to configure the client.
	Option func(*config)
)

// options applies the options on the config object.
func (c *config) options(opts ...Option) {
	for _, opt := range opts {
		opt(c)
	}
	if c.debug {
		c.driver = dialect.Debug(c.driver, c.log)
	}
}

// Debug enables debug logging on the ent.Driver.
func Debug() Option {
	return func(c *config) {
		c.debug = true
	}
}

// Log sets the logging function for debug mode.
func Log(fn func(...any)) Option {
	return func(c *config) {
		c.log = fn
	}
}

// Driver configures the client driver.
func Driver(driver dialect.Driver) Option {
	return func(c *config) {
		c.driver = driver
	}
}

// Open opens a database/sql.DB specified by the driver name and
// the data source name, and returns a new client attached to it.
// Optional parameters can be added for configuring the client.
func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
	switch driverName {
	case dialect.MySQL, dialect.Postgres, dialect.SQLite:
		drv, err := sql.Open(driverName, dataSourceName)
		if err != nil {
			return nil, err
		}
		return NewClient(append(options, Driver(drv))...), nil
	default:
		return nil, fmt.Errorf("unsupported driver: %q", driverName)
	}
}

// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction")

// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, ErrTxStarted
	}
	tx, err := newTx(ctx, c.driver)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = tx
	return &Tx{
		ctx:           ctx,
		config:        cfg,
		Brand:         NewBrandClient(cfg),
		Category:      NewCategoryClient(cfg),
		Comment:       NewCommentClient(cfg),
		Property:      NewPropertyClient(cfg),
		PropertyValue: NewPropertyValueClient(cfg),
		Sku:           NewSkuClient(cfg),
		Spu:           NewSpuClient(cfg),
	}, nil
}

// BeginTx returns a transactional client with specified options.
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
	if _, ok := c.driver.(*txDriver); ok {
		return nil, errors.New("ent: cannot start a transaction within a transaction")
	}
	tx, err := c.driver.(interface {
		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
	}).BeginTx(ctx, opts)
	if err != nil {
		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
	}
	cfg := c.config
	cfg.driver = &txDriver{tx: tx, drv: c.driver}
	return &Tx{
		ctx:           ctx,
		config:        cfg,
		Brand:         NewBrandClient(cfg),
		Category:      NewCategoryClient(cfg),
		Comment:       NewCommentClient(cfg),
		Property:      NewPropertyClient(cfg),
		PropertyValue: NewPropertyValueClient(cfg),
		Sku:           NewSkuClient(cfg),
		Spu:           NewSpuClient(cfg),
	}, nil
}

// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
//	client.Debug().
//		Brand.
//		Query().
//		Count(ctx)
func (c *Client) Debug() *Client {
	if c.debug {
		return c
	}
	cfg := c.config
	cfg.driver = dialect.Debug(c.driver, c.log)
	client := &Client{config: cfg}
	client.init()
	return client
}

// Close closes the database connection and prevents new queries from starting.
func (c *Client) Close() error {
	return c.driver.Close()
}

// Use adds the mutation hooks to all the entity clients.
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
func (c *Client) Use(hooks ...Hook) {
	for _, n := range []interface{ Use(...Hook) }{
		c.Brand, c.Category, c.Comment, c.Property, c.PropertyValue, c.Sku, c.Spu,
	} {
		n.Use(hooks...)
	}
}

// Intercept adds the query interceptors to all the entity clients.
// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
func (c *Client) Intercept(interceptors ...Interceptor) {
	for _, n := range []interface{ Intercept(...Interceptor) }{
		c.Brand, c.Category, c.Comment, c.Property, c.PropertyValue, c.Sku, c.Spu,
	} {
		n.Intercept(interceptors...)
	}
}

// Mutate implements the ent.Mutator interface.
func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
	switch m := m.(type) {
	case *BrandMutation:
		return c.Brand.mutate(ctx, m)
	case *CategoryMutation:
		return c.Category.mutate(ctx, m)
	case *CommentMutation:
		return c.Comment.mutate(ctx, m)
	case *PropertyMutation:
		return c.Property.mutate(ctx, m)
	case *PropertyValueMutation:
		return c.PropertyValue.mutate(ctx, m)
	case *SkuMutation:
		return c.Sku.mutate(ctx, m)
	case *SpuMutation:
		return c.Spu.mutate(ctx, m)
	default:
		return nil, fmt.Errorf("ent: unknown mutation type %T", m)
	}
}

// BrandClient is a client for the Brand schema.
type BrandClient struct {
	config
}

// NewBrandClient returns a client for the Brand from the given config.
func NewBrandClient(c config) *BrandClient {
	return &BrandClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `brand.Hooks(f(g(h())))`.
func (c *BrandClient) Use(hooks ...Hook) {
	c.hooks.Brand = append(c.hooks.Brand, hooks...)
}

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `brand.Intercept(f(g(h())))`.
func (c *BrandClient) Intercept(interceptors ...Interceptor) {
	c.inters.Brand = append(c.inters.Brand, interceptors...)
}

// Create returns a builder for creating a Brand entity.
func (c *BrandClient) Create() *BrandCreate {
	mutation := newBrandMutation(c.config, OpCreate)
	return &BrandCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Brand entities.
func (c *BrandClient) CreateBulk(builders ...*BrandCreate) *BrandCreateBulk {
	return &BrandCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *BrandClient) MapCreateBulk(slice any, setFunc func(*BrandCreate, int)) *BrandCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &BrandCreateBulk{err: fmt.Errorf("calling to BrandClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*BrandCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &BrandCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Brand.
func (c *BrandClient) Update() *BrandUpdate {
	mutation := newBrandMutation(c.config, OpUpdate)
	return &BrandUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *BrandClient) UpdateOne(b *Brand) *BrandUpdateOne {
	mutation := newBrandMutation(c.config, OpUpdateOne, withBrand(b))
	return &BrandUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *BrandClient) UpdateOneID(id uint64) *BrandUpdateOne {
	mutation := newBrandMutation(c.config, OpUpdateOne, withBrandID(id))
	return &BrandUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Brand.
func (c *BrandClient) Delete() *BrandDelete {
	mutation := newBrandMutation(c.config, OpDelete)
	return &BrandDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *BrandClient) DeleteOne(b *Brand) *BrandDeleteOne {
	return c.DeleteOneID(b.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *BrandClient) DeleteOneID(id uint64) *BrandDeleteOne {
	builder := c.Delete().Where(brand.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &BrandDeleteOne{builder}
}

// Query returns a query builder for Brand.
func (c *BrandClient) Query() *BrandQuery {
	return &BrandQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeBrand},
		inters: c.Interceptors(),
	}
}

// Get returns a Brand entity by its id.
func (c *BrandClient) Get(ctx context.Context, id uint64) (*Brand, error) {
	return c.Query().Where(brand.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *BrandClient) GetX(ctx context.Context, id uint64) *Brand {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QuerySpus queries the spus edge of a Brand.
func (c *BrandClient) QuerySpus(b *Brand) *SpuQuery {
	query := (&SpuClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := b.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(brand.Table, brand.FieldID, id),
			sqlgraph.To(spu.Table, spu.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, brand.SpusTable, brand.SpusColumn),
		)
		fromV = sqlgraph.Neighbors(b.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *BrandClient) Hooks() []Hook {
	hooks := c.hooks.Brand
	return append(hooks[:len(hooks):len(hooks)], brand.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *BrandClient) Interceptors() []Interceptor {
	inters := c.inters.Brand
	return append(inters[:len(inters):len(inters)], brand.Interceptors[:]...)
}

func (c *BrandClient) mutate(ctx context.Context, m *BrandMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&BrandCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&BrandUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&BrandUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&BrandDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Brand mutation op: %q", m.Op())
	}
}

// CategoryClient is a client for the Category schema.
type CategoryClient struct {
	config
}

// NewCategoryClient returns a client for the Category from the given config.
func NewCategoryClient(c config) *CategoryClient {
	return &CategoryClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `category.Hooks(f(g(h())))`.
func (c *CategoryClient) Use(hooks ...Hook) {
	c.hooks.Category = append(c.hooks.Category, hooks...)
}

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `category.Intercept(f(g(h())))`.
func (c *CategoryClient) Intercept(interceptors ...Interceptor) {
	c.inters.Category = append(c.inters.Category, interceptors...)
}

// Create returns a builder for creating a Category entity.
func (c *CategoryClient) Create() *CategoryCreate {
	mutation := newCategoryMutation(c.config, OpCreate)
	return &CategoryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Category entities.
func (c *CategoryClient) CreateBulk(builders ...*CategoryCreate) *CategoryCreateBulk {
	return &CategoryCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *CategoryClient) MapCreateBulk(slice any, setFunc func(*CategoryCreate, int)) *CategoryCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &CategoryCreateBulk{err: fmt.Errorf("calling to CategoryClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*CategoryCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &CategoryCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Category.
func (c *CategoryClient) Update() *CategoryUpdate {
	mutation := newCategoryMutation(c.config, OpUpdate)
	return &CategoryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CategoryClient) UpdateOne(ca *Category) *CategoryUpdateOne {
	mutation := newCategoryMutation(c.config, OpUpdateOne, withCategory(ca))
	return &CategoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CategoryClient) UpdateOneID(id uint64) *CategoryUpdateOne {
	mutation := newCategoryMutation(c.config, OpUpdateOne, withCategoryID(id))
	return &CategoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Category.
func (c *CategoryClient) Delete() *CategoryDelete {
	mutation := newCategoryMutation(c.config, OpDelete)
	return &CategoryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CategoryClient) DeleteOne(ca *Category) *CategoryDeleteOne {
	return c.DeleteOneID(ca.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *CategoryClient) DeleteOneID(id uint64) *CategoryDeleteOne {
	builder := c.Delete().Where(category.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CategoryDeleteOne{builder}
}

// Query returns a query builder for Category.
func (c *CategoryClient) Query() *CategoryQuery {
	return &CategoryQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeCategory},
		inters: c.Interceptors(),
	}
}

// Get returns a Category entity by its id.
func (c *CategoryClient) Get(ctx context.Context, id uint64) (*Category, error) {
	return c.Query().Where(category.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CategoryClient) GetX(ctx context.Context, id uint64) *Category {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QuerySpus queries the spus edge of a Category.
func (c *CategoryClient) QuerySpus(ca *Category) *SpuQuery {
	query := (&SpuClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ca.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(category.Table, category.FieldID, id),
			sqlgraph.To(spu.Table, spu.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, category.SpusTable, category.SpusColumn),
		)
		fromV = sqlgraph.Neighbors(ca.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryParent queries the parent edge of a Category.
func (c *CategoryClient) QueryParent(ca *Category) *CategoryQuery {
	query := (&CategoryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ca.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(category.Table, category.FieldID, id),
			sqlgraph.To(category.Table, category.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, category.ParentTable, category.ParentColumn),
		)
		fromV = sqlgraph.Neighbors(ca.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryChildren queries the children edge of a Category.
func (c *CategoryClient) QueryChildren(ca *Category) *CategoryQuery {
	query := (&CategoryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := ca.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(category.Table, category.FieldID, id),
			sqlgraph.To(category.Table, category.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, category.ChildrenTable, category.ChildrenColumn),
		)
		fromV = sqlgraph.Neighbors(ca.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *CategoryClient) Hooks() []Hook {
	hooks := c.hooks.Category
	return append(hooks[:len(hooks):len(hooks)], category.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *CategoryClient) Interceptors() []Interceptor {
	inters := c.inters.Category
	return append(inters[:len(inters):len(inters)], category.Interceptors[:]...)
}

func (c *CategoryClient) mutate(ctx context.Context, m *CategoryMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&CategoryCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&CategoryUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&CategoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&CategoryDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Category mutation op: %q", m.Op())
	}
}

// CommentClient is a client for the Comment schema.
type CommentClient struct {
	config
}

// NewCommentClient returns a client for the Comment from the given config.
func NewCommentClient(c config) *CommentClient {
	return &CommentClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `comment.Hooks(f(g(h())))`.
func (c *CommentClient) Use(hooks ...Hook) {
	c.hooks.Comment = append(c.hooks.Comment, hooks...)
}

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `comment.Intercept(f(g(h())))`.
func (c *CommentClient) Intercept(interceptors ...Interceptor) {
	c.inters.Comment = append(c.inters.Comment, interceptors...)
}

// Create returns a builder for creating a Comment entity.
func (c *CommentClient) Create() *CommentCreate {
	mutation := newCommentMutation(c.config, OpCreate)
	return &CommentCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Comment entities.
func (c *CommentClient) CreateBulk(builders ...*CommentCreate) *CommentCreateBulk {
	return &CommentCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *CommentClient) MapCreateBulk(slice any, setFunc func(*CommentCreate, int)) *CommentCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &CommentCreateBulk{err: fmt.Errorf("calling to CommentClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*CommentCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &CommentCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Comment.
func (c *CommentClient) Update() *CommentUpdate {
	mutation := newCommentMutation(c.config, OpUpdate)
	return &CommentUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *CommentClient) UpdateOne(co *Comment) *CommentUpdateOne {
	mutation := newCommentMutation(c.config, OpUpdateOne, withComment(co))
	return &CommentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *CommentClient) UpdateOneID(id uint64) *CommentUpdateOne {
	mutation := newCommentMutation(c.config, OpUpdateOne, withCommentID(id))
	return &CommentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Comment.
func (c *CommentClient) Delete() *CommentDelete {
	mutation := newCommentMutation(c.config, OpDelete)
	return &CommentDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *CommentClient) DeleteOne(co *Comment) *CommentDeleteOne {
	return c.DeleteOneID(co.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *CommentClient) DeleteOneID(id uint64) *CommentDeleteOne {
	builder := c.Delete().Where(comment.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &CommentDeleteOne{builder}
}

// Query returns a query builder for Comment.
func (c *CommentClient) Query() *CommentQuery {
	return &CommentQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeComment},
		inters: c.Interceptors(),
	}
}

// Get returns a Comment entity by its id.
func (c *CommentClient) Get(ctx context.Context, id uint64) (*Comment, error) {
	return c.Query().Where(comment.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *CommentClient) GetX(ctx context.Context, id uint64) *Comment {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QuerySkus queries the skus edge of a Comment.
func (c *CommentClient) QuerySkus(co *Comment) *SkuQuery {
	query := (&SkuClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := co.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(comment.Table, comment.FieldID, id),
			sqlgraph.To(sku.Table, sku.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, comment.SkusTable, comment.SkusColumn),
		)
		fromV = sqlgraph.Neighbors(co.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *CommentClient) Hooks() []Hook {
	hooks := c.hooks.Comment
	return append(hooks[:len(hooks):len(hooks)], comment.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *CommentClient) Interceptors() []Interceptor {
	inters := c.inters.Comment
	return append(inters[:len(inters):len(inters)], comment.Interceptors[:]...)
}

func (c *CommentClient) mutate(ctx context.Context, m *CommentMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&CommentCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&CommentUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&CommentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&CommentDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Comment mutation op: %q", m.Op())
	}
}

// PropertyClient is a client for the Property schema.
type PropertyClient struct {
	config
}

// NewPropertyClient returns a client for the Property from the given config.
func NewPropertyClient(c config) *PropertyClient {
	return &PropertyClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `property.Hooks(f(g(h())))`.
func (c *PropertyClient) Use(hooks ...Hook) {
	c.hooks.Property = append(c.hooks.Property, hooks...)
}

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `property.Intercept(f(g(h())))`.
func (c *PropertyClient) Intercept(interceptors ...Interceptor) {
	c.inters.Property = append(c.inters.Property, interceptors...)
}

// Create returns a builder for creating a Property entity.
func (c *PropertyClient) Create() *PropertyCreate {
	mutation := newPropertyMutation(c.config, OpCreate)
	return &PropertyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Property entities.
func (c *PropertyClient) CreateBulk(builders ...*PropertyCreate) *PropertyCreateBulk {
	return &PropertyCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *PropertyClient) MapCreateBulk(slice any, setFunc func(*PropertyCreate, int)) *PropertyCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &PropertyCreateBulk{err: fmt.Errorf("calling to PropertyClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*PropertyCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &PropertyCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Property.
func (c *PropertyClient) Update() *PropertyUpdate {
	mutation := newPropertyMutation(c.config, OpUpdate)
	return &PropertyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *PropertyClient) UpdateOne(pr *Property) *PropertyUpdateOne {
	mutation := newPropertyMutation(c.config, OpUpdateOne, withProperty(pr))
	return &PropertyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *PropertyClient) UpdateOneID(id uint64) *PropertyUpdateOne {
	mutation := newPropertyMutation(c.config, OpUpdateOne, withPropertyID(id))
	return &PropertyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Property.
func (c *PropertyClient) Delete() *PropertyDelete {
	mutation := newPropertyMutation(c.config, OpDelete)
	return &PropertyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *PropertyClient) DeleteOne(pr *Property) *PropertyDeleteOne {
	return c.DeleteOneID(pr.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *PropertyClient) DeleteOneID(id uint64) *PropertyDeleteOne {
	builder := c.Delete().Where(property.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &PropertyDeleteOne{builder}
}

// Query returns a query builder for Property.
func (c *PropertyClient) Query() *PropertyQuery {
	return &PropertyQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeProperty},
		inters: c.Interceptors(),
	}
}

// Get returns a Property entity by its id.
func (c *PropertyClient) Get(ctx context.Context, id uint64) (*Property, error) {
	return c.Query().Where(property.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *PropertyClient) GetX(ctx context.Context, id uint64) *Property {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryPropertyValues queries the property_values edge of a Property.
func (c *PropertyClient) QueryPropertyValues(pr *Property) *PropertyValueQuery {
	query := (&PropertyValueClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := pr.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(property.Table, property.FieldID, id),
			sqlgraph.To(propertyvalue.Table, propertyvalue.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, property.PropertyValuesTable, property.PropertyValuesColumn),
		)
		fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *PropertyClient) Hooks() []Hook {
	hooks := c.hooks.Property
	return append(hooks[:len(hooks):len(hooks)], property.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *PropertyClient) Interceptors() []Interceptor {
	inters := c.inters.Property
	return append(inters[:len(inters):len(inters)], property.Interceptors[:]...)
}

func (c *PropertyClient) mutate(ctx context.Context, m *PropertyMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&PropertyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&PropertyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&PropertyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&PropertyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Property mutation op: %q", m.Op())
	}
}

// PropertyValueClient is a client for the PropertyValue schema.
type PropertyValueClient struct {
	config
}

// NewPropertyValueClient returns a client for the PropertyValue from the given config.
func NewPropertyValueClient(c config) *PropertyValueClient {
	return &PropertyValueClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `propertyvalue.Hooks(f(g(h())))`.
func (c *PropertyValueClient) Use(hooks ...Hook) {
	c.hooks.PropertyValue = append(c.hooks.PropertyValue, hooks...)
}

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `propertyvalue.Intercept(f(g(h())))`.
func (c *PropertyValueClient) Intercept(interceptors ...Interceptor) {
	c.inters.PropertyValue = append(c.inters.PropertyValue, interceptors...)
}

// Create returns a builder for creating a PropertyValue entity.
func (c *PropertyValueClient) Create() *PropertyValueCreate {
	mutation := newPropertyValueMutation(c.config, OpCreate)
	return &PropertyValueCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of PropertyValue entities.
func (c *PropertyValueClient) CreateBulk(builders ...*PropertyValueCreate) *PropertyValueCreateBulk {
	return &PropertyValueCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *PropertyValueClient) MapCreateBulk(slice any, setFunc func(*PropertyValueCreate, int)) *PropertyValueCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &PropertyValueCreateBulk{err: fmt.Errorf("calling to PropertyValueClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*PropertyValueCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &PropertyValueCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for PropertyValue.
func (c *PropertyValueClient) Update() *PropertyValueUpdate {
	mutation := newPropertyValueMutation(c.config, OpUpdate)
	return &PropertyValueUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *PropertyValueClient) UpdateOne(pv *PropertyValue) *PropertyValueUpdateOne {
	mutation := newPropertyValueMutation(c.config, OpUpdateOne, withPropertyValue(pv))
	return &PropertyValueUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *PropertyValueClient) UpdateOneID(id uint64) *PropertyValueUpdateOne {
	mutation := newPropertyValueMutation(c.config, OpUpdateOne, withPropertyValueID(id))
	return &PropertyValueUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for PropertyValue.
func (c *PropertyValueClient) Delete() *PropertyValueDelete {
	mutation := newPropertyValueMutation(c.config, OpDelete)
	return &PropertyValueDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *PropertyValueClient) DeleteOne(pv *PropertyValue) *PropertyValueDeleteOne {
	return c.DeleteOneID(pv.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *PropertyValueClient) DeleteOneID(id uint64) *PropertyValueDeleteOne {
	builder := c.Delete().Where(propertyvalue.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &PropertyValueDeleteOne{builder}
}

// Query returns a query builder for PropertyValue.
func (c *PropertyValueClient) Query() *PropertyValueQuery {
	return &PropertyValueQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypePropertyValue},
		inters: c.Interceptors(),
	}
}

// Get returns a PropertyValue entity by its id.
func (c *PropertyValueClient) Get(ctx context.Context, id uint64) (*PropertyValue, error) {
	return c.Query().Where(propertyvalue.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *PropertyValueClient) GetX(ctx context.Context, id uint64) *PropertyValue {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QueryPropertys queries the propertys edge of a PropertyValue.
func (c *PropertyValueClient) QueryPropertys(pv *PropertyValue) *PropertyQuery {
	query := (&PropertyClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := pv.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(propertyvalue.Table, propertyvalue.FieldID, id),
			sqlgraph.To(property.Table, property.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, propertyvalue.PropertysTable, propertyvalue.PropertysColumn),
		)
		fromV = sqlgraph.Neighbors(pv.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *PropertyValueClient) Hooks() []Hook {
	hooks := c.hooks.PropertyValue
	return append(hooks[:len(hooks):len(hooks)], propertyvalue.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *PropertyValueClient) Interceptors() []Interceptor {
	inters := c.inters.PropertyValue
	return append(inters[:len(inters):len(inters)], propertyvalue.Interceptors[:]...)
}

func (c *PropertyValueClient) mutate(ctx context.Context, m *PropertyValueMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&PropertyValueCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&PropertyValueUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&PropertyValueUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&PropertyValueDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown PropertyValue mutation op: %q", m.Op())
	}
}

// SkuClient is a client for the Sku schema.
type SkuClient struct {
	config
}

// NewSkuClient returns a client for the Sku from the given config.
func NewSkuClient(c config) *SkuClient {
	return &SkuClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `sku.Hooks(f(g(h())))`.
func (c *SkuClient) Use(hooks ...Hook) {
	c.hooks.Sku = append(c.hooks.Sku, hooks...)
}

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `sku.Intercept(f(g(h())))`.
func (c *SkuClient) Intercept(interceptors ...Interceptor) {
	c.inters.Sku = append(c.inters.Sku, interceptors...)
}

// Create returns a builder for creating a Sku entity.
func (c *SkuClient) Create() *SkuCreate {
	mutation := newSkuMutation(c.config, OpCreate)
	return &SkuCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Sku entities.
func (c *SkuClient) CreateBulk(builders ...*SkuCreate) *SkuCreateBulk {
	return &SkuCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *SkuClient) MapCreateBulk(slice any, setFunc func(*SkuCreate, int)) *SkuCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &SkuCreateBulk{err: fmt.Errorf("calling to SkuClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*SkuCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &SkuCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Sku.
func (c *SkuClient) Update() *SkuUpdate {
	mutation := newSkuMutation(c.config, OpUpdate)
	return &SkuUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SkuClient) UpdateOne(s *Sku) *SkuUpdateOne {
	mutation := newSkuMutation(c.config, OpUpdateOne, withSku(s))
	return &SkuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SkuClient) UpdateOneID(id uint64) *SkuUpdateOne {
	mutation := newSkuMutation(c.config, OpUpdateOne, withSkuID(id))
	return &SkuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Sku.
func (c *SkuClient) Delete() *SkuDelete {
	mutation := newSkuMutation(c.config, OpDelete)
	return &SkuDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SkuClient) DeleteOne(s *Sku) *SkuDeleteOne {
	return c.DeleteOneID(s.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *SkuClient) DeleteOneID(id uint64) *SkuDeleteOne {
	builder := c.Delete().Where(sku.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SkuDeleteOne{builder}
}

// Query returns a query builder for Sku.
func (c *SkuClient) Query() *SkuQuery {
	return &SkuQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeSku},
		inters: c.Interceptors(),
	}
}

// Get returns a Sku entity by its id.
func (c *SkuClient) Get(ctx context.Context, id uint64) (*Sku, error) {
	return c.Query().Where(sku.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *SkuClient) GetX(ctx context.Context, id uint64) *Sku {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QuerySpus queries the spus edge of a Sku.
func (c *SkuClient) QuerySpus(s *Sku) *SpuQuery {
	query := (&SpuClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := s.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(sku.Table, sku.FieldID, id),
			sqlgraph.To(spu.Table, spu.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, sku.SpusTable, sku.SpusColumn),
		)
		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryComments queries the comments edge of a Sku.
func (c *SkuClient) QueryComments(s *Sku) *CommentQuery {
	query := (&CommentClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := s.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(sku.Table, sku.FieldID, id),
			sqlgraph.To(comment.Table, comment.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, sku.CommentsTable, sku.CommentsColumn),
		)
		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *SkuClient) Hooks() []Hook {
	hooks := c.hooks.Sku
	return append(hooks[:len(hooks):len(hooks)], sku.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *SkuClient) Interceptors() []Interceptor {
	inters := c.inters.Sku
	return append(inters[:len(inters):len(inters)], sku.Interceptors[:]...)
}

func (c *SkuClient) mutate(ctx context.Context, m *SkuMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&SkuCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&SkuUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&SkuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&SkuDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Sku mutation op: %q", m.Op())
	}
}

// SpuClient is a client for the Spu schema.
type SpuClient struct {
	config
}

// NewSpuClient returns a client for the Spu from the given config.
func NewSpuClient(c config) *SpuClient {
	return &SpuClient{config: c}
}

// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `spu.Hooks(f(g(h())))`.
func (c *SpuClient) Use(hooks ...Hook) {
	c.hooks.Spu = append(c.hooks.Spu, hooks...)
}

// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `spu.Intercept(f(g(h())))`.
func (c *SpuClient) Intercept(interceptors ...Interceptor) {
	c.inters.Spu = append(c.inters.Spu, interceptors...)
}

// Create returns a builder for creating a Spu entity.
func (c *SpuClient) Create() *SpuCreate {
	mutation := newSpuMutation(c.config, OpCreate)
	return &SpuCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// CreateBulk returns a builder for creating a bulk of Spu entities.
func (c *SpuClient) CreateBulk(builders ...*SpuCreate) *SpuCreateBulk {
	return &SpuCreateBulk{config: c.config, builders: builders}
}

// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
// a builder and applies setFunc on it.
func (c *SpuClient) MapCreateBulk(slice any, setFunc func(*SpuCreate, int)) *SpuCreateBulk {
	rv := reflect.ValueOf(slice)
	if rv.Kind() != reflect.Slice {
		return &SpuCreateBulk{err: fmt.Errorf("calling to SpuClient.MapCreateBulk with wrong type %T, need slice", slice)}
	}
	builders := make([]*SpuCreate, rv.Len())
	for i := 0; i < rv.Len(); i++ {
		builders[i] = c.Create()
		setFunc(builders[i], i)
	}
	return &SpuCreateBulk{config: c.config, builders: builders}
}

// Update returns an update builder for Spu.
func (c *SpuClient) Update() *SpuUpdate {
	mutation := newSpuMutation(c.config, OpUpdate)
	return &SpuUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOne returns an update builder for the given entity.
func (c *SpuClient) UpdateOne(s *Spu) *SpuUpdateOne {
	mutation := newSpuMutation(c.config, OpUpdateOne, withSpu(s))
	return &SpuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// UpdateOneID returns an update builder for the given id.
func (c *SpuClient) UpdateOneID(id uint64) *SpuUpdateOne {
	mutation := newSpuMutation(c.config, OpUpdateOne, withSpuID(id))
	return &SpuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// Delete returns a delete builder for Spu.
func (c *SpuClient) Delete() *SpuDelete {
	mutation := newSpuMutation(c.config, OpDelete)
	return &SpuDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}

// DeleteOne returns a builder for deleting the given entity.
func (c *SpuClient) DeleteOne(s *Spu) *SpuDeleteOne {
	return c.DeleteOneID(s.ID)
}

// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *SpuClient) DeleteOneID(id uint64) *SpuDeleteOne {
	builder := c.Delete().Where(spu.ID(id))
	builder.mutation.id = &id
	builder.mutation.op = OpDeleteOne
	return &SpuDeleteOne{builder}
}

// Query returns a query builder for Spu.
func (c *SpuClient) Query() *SpuQuery {
	return &SpuQuery{
		config: c.config,
		ctx:    &QueryContext{Type: TypeSpu},
		inters: c.Interceptors(),
	}
}

// Get returns a Spu entity by its id.
func (c *SpuClient) Get(ctx context.Context, id uint64) (*Spu, error) {
	return c.Query().Where(spu.ID(id)).Only(ctx)
}

// GetX is like Get, but panics if an error occurs.
func (c *SpuClient) GetX(ctx context.Context, id uint64) *Spu {
	obj, err := c.Get(ctx, id)
	if err != nil {
		panic(err)
	}
	return obj
}

// QuerySkus queries the skus edge of a Spu.
func (c *SpuClient) QuerySkus(s *Spu) *SkuQuery {
	query := (&SkuClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := s.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(spu.Table, spu.FieldID, id),
			sqlgraph.To(sku.Table, sku.FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, spu.SkusTable, spu.SkusColumn),
		)
		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryBrands queries the brands edge of a Spu.
func (c *SpuClient) QueryBrands(s *Spu) *BrandQuery {
	query := (&BrandClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := s.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(spu.Table, spu.FieldID, id),
			sqlgraph.To(brand.Table, brand.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, spu.BrandsTable, spu.BrandsColumn),
		)
		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// QueryCategorys queries the categorys edge of a Spu.
func (c *SpuClient) QueryCategorys(s *Spu) *CategoryQuery {
	query := (&CategoryClient{config: c.config}).Query()
	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
		id := s.ID
		step := sqlgraph.NewStep(
			sqlgraph.From(spu.Table, spu.FieldID, id),
			sqlgraph.To(category.Table, category.FieldID),
			sqlgraph.Edge(sqlgraph.M2O, true, spu.CategorysTable, spu.CategorysColumn),
		)
		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
		return fromV, nil
	}
	return query
}

// Hooks returns the client hooks.
func (c *SpuClient) Hooks() []Hook {
	hooks := c.hooks.Spu
	return append(hooks[:len(hooks):len(hooks)], spu.Hooks[:]...)
}

// Interceptors returns the client interceptors.
func (c *SpuClient) Interceptors() []Interceptor {
	inters := c.inters.Spu
	return append(inters[:len(inters):len(inters)], spu.Interceptors[:]...)
}

func (c *SpuClient) mutate(ctx context.Context, m *SpuMutation) (Value, error) {
	switch m.Op() {
	case OpCreate:
		return (&SpuCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdate:
		return (&SpuUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpUpdateOne:
		return (&SpuUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
	case OpDelete, OpDeleteOne:
		return (&SpuDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
	default:
		return nil, fmt.Errorf("ent: unknown Spu mutation op: %q", m.Op())
	}
}

// hooks and interceptors per client, for fast access.
type (
	hooks struct {
		Brand, Category, Comment, Property, PropertyValue, Sku, Spu []ent.Hook
	}
	inters struct {
		Brand, Category, Comment, Property, PropertyValue, Sku, Spu []ent.Interceptor
	}
)