fix: some api bug

2026-03-31 22:12:06 +08:00
parent c5ff4f0216
commit e7970ac25f
219 changed files with 16195 additions and 2126 deletions
@@ -11,6 +11,8 @@ import (

 	"juwan-backend/app/users/rpc/internal/models/migrate"

+	"juwan-backend/app/users/rpc/internal/models/userfollows"
+	"juwan-backend/app/users/rpc/internal/models/userpreferences"
 	"juwan-backend/app/users/rpc/internal/models/users"

 	"entgo.io/ent"
@@ -23,6 +25,10 @@ type Client struct {
 	config
 	// Schema is the client for creating, migrating and dropping schema.
 	Schema *migrate.Schema
+	// UserFollows is the client for interacting with the UserFollows builders.
+	UserFollows *UserFollowsClient
+	// UserPreferences is the client for interacting with the UserPreferences builders.
+	UserPreferences *UserPreferencesClient
 	// Users is the client for interacting with the Users builders.
 	Users *UsersClient
 }
@@ -36,6 +42,8 @@ func NewClient(opts ...Option) *Client {

 func (c *Client) init() {
 	c.Schema = migrate.NewSchema(c.driver)
+	c.UserFollows = NewUserFollowsClient(c.config)
+	c.UserPreferences = NewUserPreferencesClient(c.config)
 	c.Users = NewUsersClient(c.config)
 }

@@ -127,9 +135,11 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 	cfg := c.config
 	cfg.driver = tx
 	return &Tx{
-		ctx:    ctx,
-		config: cfg,
-		Users:  NewUsersClient(cfg),
+		ctx:             ctx,
+		config:          cfg,
+		UserFollows:     NewUserFollowsClient(cfg),
+		UserPreferences: NewUserPreferencesClient(cfg),
+		Users:           NewUsersClient(cfg),
 	}, nil
 }

@@ -147,16 +157,18 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 	cfg := c.config
 	cfg.driver = &txDriver{tx: tx, drv: c.driver}
 	return &Tx{
-		ctx:    ctx,
-		config: cfg,
-		Users:  NewUsersClient(cfg),
+		ctx:             ctx,
+		config:          cfg,
+		UserFollows:     NewUserFollowsClient(cfg),
+		UserPreferences: NewUserPreferencesClient(cfg),
+		Users:           NewUsersClient(cfg),
 	}, nil
 }

 // Debug returns a new debug-client. It's used to get verbose logging on specific operations.
 //
 //	client.Debug().
-//		Users.
+//		UserFollows.
 //		Query().
 //		Count(ctx)
 func (c *Client) Debug() *Client {
@@ -178,18 +190,26 @@ func (c *Client) Close() error {
 // 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) {
+	c.UserFollows.Use(hooks...)
+	c.UserPreferences.Use(hooks...)
 	c.Users.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) {
+	c.UserFollows.Intercept(interceptors...)
+	c.UserPreferences.Intercept(interceptors...)
 	c.Users.Intercept(interceptors...)
 }

 // Mutate implements the ent.Mutator interface.
 func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 	switch m := m.(type) {
+	case *UserFollowsMutation:
+		return c.UserFollows.mutate(ctx, m)
+	case *UserPreferencesMutation:
+		return c.UserPreferences.mutate(ctx, m)
 	case *UsersMutation:
 		return c.Users.mutate(ctx, m)
 	default:
@@ -197,6 +217,272 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 	}
 }

+// UserFollowsClient is a client for the UserFollows schema.
+type UserFollowsClient struct {
+	config
+}
+
+// NewUserFollowsClient returns a client for the UserFollows from the given config.
+func NewUserFollowsClient(c config) *UserFollowsClient {
+	return &UserFollowsClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `userfollows.Hooks(f(g(h())))`.
+func (c *UserFollowsClient) Use(hooks ...Hook) {
+	c.hooks.UserFollows = append(c.hooks.UserFollows, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `userfollows.Intercept(f(g(h())))`.
+func (c *UserFollowsClient) Intercept(interceptors ...Interceptor) {
+	c.inters.UserFollows = append(c.inters.UserFollows, interceptors...)
+}
+
+// Create returns a builder for creating a UserFollows entity.
+func (c *UserFollowsClient) Create() *UserFollowsCreate {
+	mutation := newUserFollowsMutation(c.config, OpCreate)
+	return &UserFollowsCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of UserFollows entities.
+func (c *UserFollowsClient) CreateBulk(builders ...*UserFollowsCreate) *UserFollowsCreateBulk {
+	return &UserFollowsCreateBulk{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 *UserFollowsClient) MapCreateBulk(slice any, setFunc func(*UserFollowsCreate, int)) *UserFollowsCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &UserFollowsCreateBulk{err: fmt.Errorf("calling to UserFollowsClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*UserFollowsCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &UserFollowsCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for UserFollows.
+func (c *UserFollowsClient) Update() *UserFollowsUpdate {
+	mutation := newUserFollowsMutation(c.config, OpUpdate)
+	return &UserFollowsUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserFollowsClient) UpdateOne(_m *UserFollows) *UserFollowsUpdateOne {
+	mutation := newUserFollowsMutation(c.config, OpUpdateOne, withUserFollows(_m))
+	return &UserFollowsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserFollowsClient) UpdateOneID(id int64) *UserFollowsUpdateOne {
+	mutation := newUserFollowsMutation(c.config, OpUpdateOne, withUserFollowsID(id))
+	return &UserFollowsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for UserFollows.
+func (c *UserFollowsClient) Delete() *UserFollowsDelete {
+	mutation := newUserFollowsMutation(c.config, OpDelete)
+	return &UserFollowsDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserFollowsClient) DeleteOne(_m *UserFollows) *UserFollowsDeleteOne {
+	return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserFollowsClient) DeleteOneID(id int64) *UserFollowsDeleteOne {
+	builder := c.Delete().Where(userfollows.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &UserFollowsDeleteOne{builder}
+}
+
+// Query returns a query builder for UserFollows.
+func (c *UserFollowsClient) Query() *UserFollowsQuery {
+	return &UserFollowsQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeUserFollows},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a UserFollows entity by its id.
+func (c *UserFollowsClient) Get(ctx context.Context, id int64) (*UserFollows, error) {
+	return c.Query().Where(userfollows.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserFollowsClient) GetX(ctx context.Context, id int64) *UserFollows {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *UserFollowsClient) Hooks() []Hook {
+	return c.hooks.UserFollows
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserFollowsClient) Interceptors() []Interceptor {
+	return c.inters.UserFollows
+}
+
+func (c *UserFollowsClient) mutate(ctx context.Context, m *UserFollowsMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&UserFollowsCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&UserFollowsUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&UserFollowsUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&UserFollowsDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("models: unknown UserFollows mutation op: %q", m.Op())
+	}
+}
+
+// UserPreferencesClient is a client for the UserPreferences schema.
+type UserPreferencesClient struct {
+	config
+}
+
+// NewUserPreferencesClient returns a client for the UserPreferences from the given config.
+func NewUserPreferencesClient(c config) *UserPreferencesClient {
+	return &UserPreferencesClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `userpreferences.Hooks(f(g(h())))`.
+func (c *UserPreferencesClient) Use(hooks ...Hook) {
+	c.hooks.UserPreferences = append(c.hooks.UserPreferences, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `userpreferences.Intercept(f(g(h())))`.
+func (c *UserPreferencesClient) Intercept(interceptors ...Interceptor) {
+	c.inters.UserPreferences = append(c.inters.UserPreferences, interceptors...)
+}
+
+// Create returns a builder for creating a UserPreferences entity.
+func (c *UserPreferencesClient) Create() *UserPreferencesCreate {
+	mutation := newUserPreferencesMutation(c.config, OpCreate)
+	return &UserPreferencesCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of UserPreferences entities.
+func (c *UserPreferencesClient) CreateBulk(builders ...*UserPreferencesCreate) *UserPreferencesCreateBulk {
+	return &UserPreferencesCreateBulk{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 *UserPreferencesClient) MapCreateBulk(slice any, setFunc func(*UserPreferencesCreate, int)) *UserPreferencesCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &UserPreferencesCreateBulk{err: fmt.Errorf("calling to UserPreferencesClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*UserPreferencesCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &UserPreferencesCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for UserPreferences.
+func (c *UserPreferencesClient) Update() *UserPreferencesUpdate {
+	mutation := newUserPreferencesMutation(c.config, OpUpdate)
+	return &UserPreferencesUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserPreferencesClient) UpdateOne(_m *UserPreferences) *UserPreferencesUpdateOne {
+	mutation := newUserPreferencesMutation(c.config, OpUpdateOne, withUserPreferences(_m))
+	return &UserPreferencesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserPreferencesClient) UpdateOneID(id int) *UserPreferencesUpdateOne {
+	mutation := newUserPreferencesMutation(c.config, OpUpdateOne, withUserPreferencesID(id))
+	return &UserPreferencesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for UserPreferences.
+func (c *UserPreferencesClient) Delete() *UserPreferencesDelete {
+	mutation := newUserPreferencesMutation(c.config, OpDelete)
+	return &UserPreferencesDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserPreferencesClient) DeleteOne(_m *UserPreferences) *UserPreferencesDeleteOne {
+	return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserPreferencesClient) DeleteOneID(id int) *UserPreferencesDeleteOne {
+	builder := c.Delete().Where(userpreferences.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &UserPreferencesDeleteOne{builder}
+}
+
+// Query returns a query builder for UserPreferences.
+func (c *UserPreferencesClient) Query() *UserPreferencesQuery {
+	return &UserPreferencesQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeUserPreferences},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a UserPreferences entity by its id.
+func (c *UserPreferencesClient) Get(ctx context.Context, id int) (*UserPreferences, error) {
+	return c.Query().Where(userpreferences.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserPreferencesClient) GetX(ctx context.Context, id int) *UserPreferences {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *UserPreferencesClient) Hooks() []Hook {
+	return c.hooks.UserPreferences
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserPreferencesClient) Interceptors() []Interceptor {
+	return c.inters.UserPreferences
+}
+
+func (c *UserPreferencesClient) mutate(ctx context.Context, m *UserPreferencesMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&UserPreferencesCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&UserPreferencesUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&UserPreferencesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&UserPreferencesDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("models: unknown UserPreferences mutation op: %q", m.Op())
+	}
+}
+
 // UsersClient is a client for the Users schema.
 type UsersClient struct {
 	config
@@ -333,9 +619,9 @@ func (c *UsersClient) mutate(ctx context.Context, m *UsersMutation) (Value, erro
 // hooks and interceptors per client, for fast access.
 type (
 	hooks struct {
-		Users []ent.Hook
+		UserFollows, UserPreferences, Users []ent.Hook
 	}
 	inters struct {
-		Users []ent.Interceptor
+		UserFollows, UserPreferences, Users []ent.Interceptor
 	}
 )