更改表结构

db/ent/client.go

@@ -17,6 +17,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 	"github.com/xmdhs/authlib-skin/db/ent/usertoken"
 )
 
@@ -31,6 +32,8 @@ type Client struct {
 	User *UserClient
 	// UserProfile is the client for interacting with the UserProfile builders.
 	UserProfile *UserProfileClient
+	// UserTexture is the client for interacting with the UserTexture builders.
+	UserTexture *UserTextureClient
 	// UserToken is the client for interacting with the UserToken builders.
 	UserToken *UserTokenClient
 }
@@ -49,6 +52,7 @@ func (c *Client) init() {
 	c.Texture = NewTextureClient(c.config)
 	c.User = NewUserClient(c.config)
 	c.UserProfile = NewUserProfileClient(c.config)
+	c.UserTexture = NewUserTextureClient(c.config)
 	c.UserToken = NewUserTokenClient(c.config)
 }
 
@@ -135,6 +139,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 		Texture:     NewTextureClient(cfg),
 		User:        NewUserClient(cfg),
 		UserProfile: NewUserProfileClient(cfg),
+		UserTexture: NewUserTextureClient(cfg),
 		UserToken:   NewUserTokenClient(cfg),
 	}, nil
 }
@@ -158,6 +163,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 		Texture:     NewTextureClient(cfg),
 		User:        NewUserClient(cfg),
 		UserProfile: NewUserProfileClient(cfg),
+		UserTexture: NewUserTextureClient(cfg),
 		UserToken:   NewUserTokenClient(cfg),
 	}, nil
 }
@@ -190,6 +196,7 @@ func (c *Client) Use(hooks ...Hook) {
 	c.Texture.Use(hooks...)
 	c.User.Use(hooks...)
 	c.UserProfile.Use(hooks...)
+	c.UserTexture.Use(hooks...)
 	c.UserToken.Use(hooks...)
 }
 
@@ -199,6 +206,7 @@ func (c *Client) Intercept(interceptors ...Interceptor) {
 	c.Texture.Intercept(interceptors...)
 	c.User.Intercept(interceptors...)
 	c.UserProfile.Intercept(interceptors...)
+	c.UserTexture.Intercept(interceptors...)
 	c.UserToken.Intercept(interceptors...)
 }
 
@@ -211,6 +219,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.User.mutate(ctx, m)
 	case *UserProfileMutation:
 		return c.UserProfile.mutate(ctx, m)
+	case *UserTextureMutation:
+		return c.UserTexture.mutate(ctx, m)
 	case *UserTokenMutation:
 		return c.UserToken.mutate(ctx, m)
 	default:
@@ -335,7 +345,23 @@ func (c *TextureClient) QueryUser(t *Texture) *UserProfileQuery {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(texture.Table, texture.FieldID, id),
 			sqlgraph.To(userprofile.Table, userprofile.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, texture.UserTable, texture.UserColumn),
+			sqlgraph.Edge(sqlgraph.M2M, true, texture.UserTable, texture.UserPrimaryKey...),
+		)
+		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QueryUsertexture queries the usertexture edge of a Texture.
+func (c *TextureClient) QueryUsertexture(t *Texture) *UserTextureQuery {
+	query := (&UserTextureClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := t.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(texture.Table, texture.FieldID, id),
+			sqlgraph.To(usertexture.Table, usertexture.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, true, texture.UsertextureTable, texture.UsertextureColumn),
 		)
 		fromV = sqlgraph.Neighbors(t.driver.Dialect(), step)
 		return fromV, nil
@@ -651,7 +677,23 @@ func (c *UserProfileClient) QueryTexture(up *UserProfile) *TextureQuery {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(userprofile.Table, userprofile.FieldID, id),
 			sqlgraph.To(texture.Table, texture.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, userprofile.TextureTable, userprofile.TextureColumn),
+			sqlgraph.Edge(sqlgraph.M2M, false, userprofile.TextureTable, userprofile.TexturePrimaryKey...),
+		)
+		fromV = sqlgraph.Neighbors(up.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QueryUsertexture queries the usertexture edge of a UserProfile.
+func (c *UserProfileClient) QueryUsertexture(up *UserProfile) *UserTextureQuery {
+	query := (&UserTextureClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := up.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(userprofile.Table, userprofile.FieldID, id),
+			sqlgraph.To(usertexture.Table, usertexture.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, true, userprofile.UsertextureTable, userprofile.UsertextureColumn),
 		)
 		fromV = sqlgraph.Neighbors(up.driver.Dialect(), step)
 		return fromV, nil
@@ -684,6 +726,156 @@ func (c *UserProfileClient) mutate(ctx context.Context, m *UserProfileMutation)
 	}
 }
 
+// UserTextureClient is a client for the UserTexture schema.
+type UserTextureClient struct {
+	config
+}
+
+// NewUserTextureClient returns a client for the UserTexture from the given config.
+func NewUserTextureClient(c config) *UserTextureClient {
+	return &UserTextureClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `usertexture.Hooks(f(g(h())))`.
+func (c *UserTextureClient) Use(hooks ...Hook) {
+	c.hooks.UserTexture = append(c.hooks.UserTexture, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `usertexture.Intercept(f(g(h())))`.
+func (c *UserTextureClient) Intercept(interceptors ...Interceptor) {
+	c.inters.UserTexture = append(c.inters.UserTexture, interceptors...)
+}
+
+// Create returns a builder for creating a UserTexture entity.
+func (c *UserTextureClient) Create() *UserTextureCreate {
+	mutation := newUserTextureMutation(c.config, OpCreate)
+	return &UserTextureCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of UserTexture entities.
+func (c *UserTextureClient) CreateBulk(builders ...*UserTextureCreate) *UserTextureCreateBulk {
+	return &UserTextureCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for UserTexture.
+func (c *UserTextureClient) Update() *UserTextureUpdate {
+	mutation := newUserTextureMutation(c.config, OpUpdate)
+	return &UserTextureUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserTextureClient) UpdateOne(ut *UserTexture) *UserTextureUpdateOne {
+	mutation := newUserTextureMutation(c.config, OpUpdateOne, withUserTexture(ut))
+	return &UserTextureUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserTextureClient) UpdateOneID(id int) *UserTextureUpdateOne {
+	mutation := newUserTextureMutation(c.config, OpUpdateOne, withUserTextureID(id))
+	return &UserTextureUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for UserTexture.
+func (c *UserTextureClient) Delete() *UserTextureDelete {
+	mutation := newUserTextureMutation(c.config, OpDelete)
+	return &UserTextureDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserTextureClient) DeleteOne(ut *UserTexture) *UserTextureDeleteOne {
+	return c.DeleteOneID(ut.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserTextureClient) DeleteOneID(id int) *UserTextureDeleteOne {
+	builder := c.Delete().Where(usertexture.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &UserTextureDeleteOne{builder}
+}
+
+// Query returns a query builder for UserTexture.
+func (c *UserTextureClient) Query() *UserTextureQuery {
+	return &UserTextureQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeUserTexture},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a UserTexture entity by its id.
+func (c *UserTextureClient) Get(ctx context.Context, id int) (*UserTexture, error) {
+	return c.Query().Where(usertexture.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserTextureClient) GetX(ctx context.Context, id int) *UserTexture {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryUserProfile queries the user_profile edge of a UserTexture.
+func (c *UserTextureClient) QueryUserProfile(ut *UserTexture) *UserProfileQuery {
+	query := (&UserProfileClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := ut.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usertexture.Table, usertexture.FieldID, id),
+			sqlgraph.To(userprofile.Table, userprofile.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, false, usertexture.UserProfileTable, usertexture.UserProfileColumn),
+		)
+		fromV = sqlgraph.Neighbors(ut.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// QueryTexture queries the texture edge of a UserTexture.
+func (c *UserTextureClient) QueryTexture(ut *UserTexture) *TextureQuery {
+	query := (&TextureClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := ut.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usertexture.Table, usertexture.FieldID, id),
+			sqlgraph.To(texture.Table, texture.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, false, usertexture.TextureTable, usertexture.TextureColumn),
+		)
+		fromV = sqlgraph.Neighbors(ut.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *UserTextureClient) Hooks() []Hook {
+	return c.hooks.UserTexture
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserTextureClient) Interceptors() []Interceptor {
+	return c.inters.UserTexture
+}
+
+func (c *UserTextureClient) mutate(ctx context.Context, m *UserTextureMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&UserTextureCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&UserTextureUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&UserTextureUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&UserTextureDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown UserTexture mutation op: %q", m.Op())
+	}
+}
+
 // UserTokenClient is a client for the UserToken schema.
 type UserTokenClient struct {
 	config
@@ -821,9 +1013,9 @@ func (c *UserTokenClient) mutate(ctx context.Context, m *UserTokenMutation) (Val
 // hooks and interceptors per client, for fast access.
 type (
 	hooks struct {
-		Texture, User, UserProfile, UserToken []ent.Hook
+		Texture, User, UserProfile, UserTexture, UserToken []ent.Hook
 	}
 	inters struct {
-		Texture, User, UserProfile, UserToken []ent.Interceptor
+		Texture, User, UserProfile, UserTexture, UserToken []ent.Interceptor
 	}
 )

db/ent/ent.go

@@ -15,6 +15,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 	"github.com/xmdhs/authlib-skin/db/ent/usertoken"
 )
 
@@ -79,6 +80,7 @@ func checkColumn(table, column string) error {
 			texture.Table:     texture.ValidColumn,
 			user.Table:        user.ValidColumn,
 			userprofile.Table: userprofile.ValidColumn,
+			usertexture.Table: usertexture.ValidColumn,
 			usertoken.Table:   usertoken.ValidColumn,
 		})
 	})

db/ent/hook/hook.go

@@ -45,6 +45,18 @@ func (f UserProfileFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value,
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserProfileMutation", m)
 }
 
+// The UserTextureFunc type is an adapter to allow the use of ordinary
+// function as UserTexture mutator.
+type UserTextureFunc func(context.Context, *ent.UserTextureMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserTextureFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.UserTextureMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserTextureMutation", m)
+}
+
 // The UserTokenFunc type is an adapter to allow the use of ordinary
 // function as UserToken mutator.
 type UserTokenFunc func(context.Context, *ent.UserTokenMutation) (ent.Value, error)

db/ent/migrate/schema.go

@@ -15,7 +15,6 @@ var (
 		{Name: "type", Type: field.TypeString, SchemaType: map[string]string{"mysql": "VARCHAR(10)"}},
 		{Name: "variant", Type: field.TypeString, SchemaType: map[string]string{"mysql": "VARCHAR(10)"}},
 		{Name: "texture_created_user", Type: field.TypeInt},
-		{Name: "user_profile_texture", Type: field.TypeInt},
 	}
 	// TexturesTable holds the schema information for the "textures" table.
 	TexturesTable = &schema.Table{
@@ -29,19 +28,6 @@ var (
 				RefColumns: []*schema.Column{UsersColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
-			{
-				Symbol:     "textures_user_profiles_texture",
-				Columns:    []*schema.Column{TexturesColumns[5]},
-				RefColumns: []*schema.Column{UserProfilesColumns[0]},
-				OnDelete:   schema.NoAction,
-			},
-		},
-		Indexes: []*schema.Index{
-			{
-				Name:    "texture_user_profile_texture",
-				Unique:  false,
-				Columns: []*schema.Column{TexturesColumns[5]},
-			},
 		},
 	}
 	// UsersColumns holds the columns for the "users" table.
@@ -100,6 +86,49 @@ var (
 			},
 		},
 	}
+	// UserTexturesColumns holds the columns for the "user_textures" table.
+	UserTexturesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "user_profile_id", Type: field.TypeInt},
+		{Name: "texture_id", Type: field.TypeInt},
+	}
+	// UserTexturesTable holds the schema information for the "user_textures" table.
+	UserTexturesTable = &schema.Table{
+		Name:       "user_textures",
+		Columns:    UserTexturesColumns,
+		PrimaryKey: []*schema.Column{UserTexturesColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "user_textures_user_profiles_user_profile",
+				Columns:    []*schema.Column{UserTexturesColumns[1]},
+				RefColumns: []*schema.Column{UserProfilesColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+			{
+				Symbol:     "user_textures_textures_texture",
+				Columns:    []*schema.Column{UserTexturesColumns[2]},
+				RefColumns: []*schema.Column{TexturesColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "usertexture_user_profile_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserTexturesColumns[1]},
+			},
+			{
+				Name:    "usertexture_texture_id",
+				Unique:  false,
+				Columns: []*schema.Column{UserTexturesColumns[2]},
+			},
+			{
+				Name:    "usertexture_user_profile_id_texture_id",
+				Unique:  true,
+				Columns: []*schema.Column{UserTexturesColumns[1], UserTexturesColumns[2]},
+			},
+		},
+	}
 	// UserTokensColumns holds the columns for the "user_tokens" table.
 	UserTokensColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
@@ -132,13 +161,15 @@ var (
 		TexturesTable,
 		UsersTable,
 		UserProfilesTable,
+		UserTexturesTable,
 		UserTokensTable,
 	}
 )
 
 func init() {
 	TexturesTable.ForeignKeys[0].RefTable = UsersTable
-	TexturesTable.ForeignKeys[1].RefTable = UserProfilesTable
 	UserProfilesTable.ForeignKeys[0].RefTable = UsersTable
+	UserTexturesTable.ForeignKeys[0].RefTable = UserProfilesTable
+	UserTexturesTable.ForeignKeys[1].RefTable = TexturesTable
 	UserTokensTable.ForeignKeys[0].RefTable = UsersTable
 }

db/ent/mutation.go

@@ -14,6 +14,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 	"github.com/xmdhs/authlib-skin/db/ent/usertoken"
 )
 
@@ -29,6 +30,7 @@ const (
 	TypeTexture     = "Texture"
 	TypeUser        = "User"
 	TypeUserProfile = "UserProfile"
+	TypeUserTexture = "UserTexture"
 	TypeUserToken   = "UserToken"
 )
 
@@ -44,8 +46,12 @@ type TextureMutation struct {
 	clearedFields       map[string]struct{}
 	created_user        *int
 	clearedcreated_user bool
-	user                *int
+	user                map[int]struct{}
+	removeduser         map[int]struct{}
 	cleareduser         bool
+	usertexture         map[int]struct{}
+	removedusertexture  map[int]struct{}
+	clearedusertexture  bool
 	done                bool
 	oldValue            func(context.Context) (*Texture, error)
 	predicates          []predicate.Texture
@@ -296,9 +302,14 @@ func (m *TextureMutation) ResetCreatedUser() {
 	m.clearedcreated_user = false
 }
 
-// SetUserID sets the "user" edge to the UserProfile entity by id.
+// AddUserIDs adds the "user" edge to the UserProfile entity by ids.
-func (m *TextureMutation) SetUserID(id int) {
+func (m *TextureMutation) AddUserIDs(ids ...int) {
-	m.user = &id
+	if m.user == nil {
+		m.user = make(map[int]struct{})
+	}
+	for i := range ids {
+		m.user[ids[i]] = struct{}{}
+	}
 }
 
 // ClearUser clears the "user" edge to the UserProfile entity.
@@ -311,20 +322,29 @@ func (m *TextureMutation) UserCleared() bool {
 	return m.cleareduser
 }
 
-// UserID returns the "user" edge ID in the mutation.
+// RemoveUserIDs removes the "user" edge to the UserProfile entity by IDs.
-func (m *TextureMutation) UserID() (id int, exists bool) {
+func (m *TextureMutation) RemoveUserIDs(ids ...int) {
-	if m.user != nil {
+	if m.removeduser == nil {
-		return *m.user, true
+		m.removeduser = make(map[int]struct{})
+	}
+	for i := range ids {
+		delete(m.user, ids[i])
+		m.removeduser[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedUser returns the removed IDs of the "user" edge to the UserProfile entity.
+func (m *TextureMutation) RemovedUserIDs() (ids []int) {
+	for id := range m.removeduser {
+		ids = append(ids, id)
 	}
 	return
 }
 
 // UserIDs returns the "user" edge IDs in the mutation.
-// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
-// UserID instead. It exists only for internal usage by the builders.
 func (m *TextureMutation) UserIDs() (ids []int) {
-	if id := m.user; id != nil {
+	for id := range m.user {
-		ids = append(ids, *id)
+		ids = append(ids, id)
 	}
 	return
 }
@@ -333,6 +353,61 @@ func (m *TextureMutation) UserIDs() (ids []int) {
 func (m *TextureMutation) ResetUser() {
 	m.user = nil
 	m.cleareduser = false
+	m.removeduser = nil
+}
+
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by ids.
+func (m *TextureMutation) AddUsertextureIDs(ids ...int) {
+	if m.usertexture == nil {
+		m.usertexture = make(map[int]struct{})
+	}
+	for i := range ids {
+		m.usertexture[ids[i]] = struct{}{}
+	}
+}
+
+// ClearUsertexture clears the "usertexture" edge to the UserTexture entity.
+func (m *TextureMutation) ClearUsertexture() {
+	m.clearedusertexture = true
+}
+
+// UsertextureCleared reports if the "usertexture" edge to the UserTexture entity was cleared.
+func (m *TextureMutation) UsertextureCleared() bool {
+	return m.clearedusertexture
+}
+
+// RemoveUsertextureIDs removes the "usertexture" edge to the UserTexture entity by IDs.
+func (m *TextureMutation) RemoveUsertextureIDs(ids ...int) {
+	if m.removedusertexture == nil {
+		m.removedusertexture = make(map[int]struct{})
+	}
+	for i := range ids {
+		delete(m.usertexture, ids[i])
+		m.removedusertexture[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedUsertexture returns the removed IDs of the "usertexture" edge to the UserTexture entity.
+func (m *TextureMutation) RemovedUsertextureIDs() (ids []int) {
+	for id := range m.removedusertexture {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// UsertextureIDs returns the "usertexture" edge IDs in the mutation.
+func (m *TextureMutation) UsertextureIDs() (ids []int) {
+	for id := range m.usertexture {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetUsertexture resets all changes to the "usertexture" edge.
+func (m *TextureMutation) ResetUsertexture() {
+	m.usertexture = nil
+	m.clearedusertexture = false
+	m.removedusertexture = nil
 }
 
 // Where appends a list predicates to the TextureMutation builder.
@@ -502,13 +577,16 @@ func (m *TextureMutation) ResetField(name string) error {
 
 // AddedEdges returns all edge names that were set/added in this mutation.
 func (m *TextureMutation) AddedEdges() []string {
-	edges := make([]string, 0, 2)
+	edges := make([]string, 0, 3)
 	if m.created_user != nil {
 		edges = append(edges, texture.EdgeCreatedUser)
 	}
 	if m.user != nil {
 		edges = append(edges, texture.EdgeUser)
 	}
+	if m.usertexture != nil {
+		edges = append(edges, texture.EdgeUsertexture)
+	}
 	return edges
 }
 
@@ -521,34 +599,65 @@ func (m *TextureMutation) AddedIDs(name string) []ent.Value {
 			return []ent.Value{*id}
 		}
 	case texture.EdgeUser:
-		if id := m.user; id != nil {
+		ids := make([]ent.Value, 0, len(m.user))
-			return []ent.Value{*id}
+		for id := range m.user {
+			ids = append(ids, id)
 		}
+		return ids
+	case texture.EdgeUsertexture:
+		ids := make([]ent.Value, 0, len(m.usertexture))
+		for id := range m.usertexture {
+			ids = append(ids, id)
+		}
+		return ids
 	}
 	return nil
 }
 
 // RemovedEdges returns all edge names that were removed in this mutation.
 func (m *TextureMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 2)
+	edges := make([]string, 0, 3)
+	if m.removeduser != nil {
+		edges = append(edges, texture.EdgeUser)
+	}
+	if m.removedusertexture != nil {
+		edges = append(edges, texture.EdgeUsertexture)
+	}
 	return edges
 }
 
 // RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
 // the given name in this mutation.
 func (m *TextureMutation) RemovedIDs(name string) []ent.Value {
+	switch name {
+	case texture.EdgeUser:
+		ids := make([]ent.Value, 0, len(m.removeduser))
+		for id := range m.removeduser {
+			ids = append(ids, id)
+		}
+		return ids
+	case texture.EdgeUsertexture:
+		ids := make([]ent.Value, 0, len(m.removedusertexture))
+		for id := range m.removedusertexture {
+			ids = append(ids, id)
+		}
+		return ids
+	}
 	return nil
 }
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
 func (m *TextureMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 2)
+	edges := make([]string, 0, 3)
 	if m.clearedcreated_user {
 		edges = append(edges, texture.EdgeCreatedUser)
 	}
 	if m.cleareduser {
 		edges = append(edges, texture.EdgeUser)
 	}
+	if m.clearedusertexture {
+		edges = append(edges, texture.EdgeUsertexture)
+	}
 	return edges
 }
 
@@ -560,6 +669,8 @@ func (m *TextureMutation) EdgeCleared(name string) bool {
 		return m.clearedcreated_user
 	case texture.EdgeUser:
 		return m.cleareduser
+	case texture.EdgeUsertexture:
+		return m.clearedusertexture
 	}
 	return false
 }
@@ -571,9 +682,6 @@ func (m *TextureMutation) ClearEdge(name string) error {
 	case texture.EdgeCreatedUser:
 		m.ClearCreatedUser()
 		return nil
-	case texture.EdgeUser:
-		m.ClearUser()
-		return nil
 	}
 	return fmt.Errorf("unknown Texture unique edge %s", name)
 }
@@ -588,6 +696,9 @@ func (m *TextureMutation) ResetEdge(name string) error {
 	case texture.EdgeUser:
 		m.ResetUser()
 		return nil
+	case texture.EdgeUsertexture:
+		m.ResetUsertexture()
+		return nil
 	}
 	return fmt.Errorf("unknown Texture edge %s", name)
 }
@@ -1471,20 +1582,23 @@ func (m *UserMutation) ResetEdge(name string) error {
 // UserProfileMutation represents an operation that mutates the UserProfile nodes in the graph.
 type UserProfileMutation struct {
 	config
-	op             Op
+	op                 Op
-	typ            string
+	typ                string
-	id             *int
+	id                 *int
-	name           *string
+	name               *string
-	uuid           *string
+	uuid               *string
-	clearedFields  map[string]struct{}
+	clearedFields      map[string]struct{}
-	user           *int
+	user               *int
-	cleareduser    bool
+	cleareduser        bool
-	texture        map[int]struct{}
+	texture            map[int]struct{}
-	removedtexture map[int]struct{}
+	removedtexture     map[int]struct{}
-	clearedtexture bool
+	clearedtexture     bool
-	done           bool
+	usertexture        map[int]struct{}
-	oldValue       func(context.Context) (*UserProfile, error)
+	removedusertexture map[int]struct{}
-	predicates     []predicate.UserProfile
+	clearedusertexture bool
+	done               bool
+	oldValue           func(context.Context) (*UserProfile, error)
+	predicates         []predicate.UserProfile
 }
 
 var _ ent.Mutation = (*UserProfileMutation)(nil)
@@ -1750,6 +1864,60 @@ func (m *UserProfileMutation) ResetTexture() {
 	m.removedtexture = nil
 }
 
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by ids.
+func (m *UserProfileMutation) AddUsertextureIDs(ids ...int) {
+	if m.usertexture == nil {
+		m.usertexture = make(map[int]struct{})
+	}
+	for i := range ids {
+		m.usertexture[ids[i]] = struct{}{}
+	}
+}
+
+// ClearUsertexture clears the "usertexture" edge to the UserTexture entity.
+func (m *UserProfileMutation) ClearUsertexture() {
+	m.clearedusertexture = true
+}
+
+// UsertextureCleared reports if the "usertexture" edge to the UserTexture entity was cleared.
+func (m *UserProfileMutation) UsertextureCleared() bool {
+	return m.clearedusertexture
+}
+
+// RemoveUsertextureIDs removes the "usertexture" edge to the UserTexture entity by IDs.
+func (m *UserProfileMutation) RemoveUsertextureIDs(ids ...int) {
+	if m.removedusertexture == nil {
+		m.removedusertexture = make(map[int]struct{})
+	}
+	for i := range ids {
+		delete(m.usertexture, ids[i])
+		m.removedusertexture[ids[i]] = struct{}{}
+	}
+}
+
+// RemovedUsertexture returns the removed IDs of the "usertexture" edge to the UserTexture entity.
+func (m *UserProfileMutation) RemovedUsertextureIDs() (ids []int) {
+	for id := range m.removedusertexture {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// UsertextureIDs returns the "usertexture" edge IDs in the mutation.
+func (m *UserProfileMutation) UsertextureIDs() (ids []int) {
+	for id := range m.usertexture {
+		ids = append(ids, id)
+	}
+	return
+}
+
+// ResetUsertexture resets all changes to the "usertexture" edge.
+func (m *UserProfileMutation) ResetUsertexture() {
+	m.usertexture = nil
+	m.clearedusertexture = false
+	m.removedusertexture = nil
+}
+
 // Where appends a list predicates to the UserProfileMutation builder.
 func (m *UserProfileMutation) Where(ps ...predicate.UserProfile) {
 	m.predicates = append(m.predicates, ps...)
@@ -1900,13 +2068,16 @@ func (m *UserProfileMutation) ResetField(name string) error {
 
 // AddedEdges returns all edge names that were set/added in this mutation.
 func (m *UserProfileMutation) AddedEdges() []string {
-	edges := make([]string, 0, 2)
+	edges := make([]string, 0, 3)
 	if m.user != nil {
 		edges = append(edges, userprofile.EdgeUser)
 	}
 	if m.texture != nil {
 		edges = append(edges, userprofile.EdgeTexture)
 	}
+	if m.usertexture != nil {
+		edges = append(edges, userprofile.EdgeUsertexture)
+	}
 	return edges
 }
 
@@ -1924,16 +2095,25 @@ func (m *UserProfileMutation) AddedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
+	case userprofile.EdgeUsertexture:
+		ids := make([]ent.Value, 0, len(m.usertexture))
+		for id := range m.usertexture {
+			ids = append(ids, id)
+		}
+		return ids
 	}
 	return nil
 }
 
 // RemovedEdges returns all edge names that were removed in this mutation.
 func (m *UserProfileMutation) RemovedEdges() []string {
-	edges := make([]string, 0, 2)
+	edges := make([]string, 0, 3)
 	if m.removedtexture != nil {
 		edges = append(edges, userprofile.EdgeTexture)
 	}
+	if m.removedusertexture != nil {
+		edges = append(edges, userprofile.EdgeUsertexture)
+	}
 	return edges
 }
 
@@ -1947,19 +2127,28 @@ func (m *UserProfileMutation) RemovedIDs(name string) []ent.Value {
 			ids = append(ids, id)
 		}
 		return ids
+	case userprofile.EdgeUsertexture:
+		ids := make([]ent.Value, 0, len(m.removedusertexture))
+		for id := range m.removedusertexture {
+			ids = append(ids, id)
+		}
+		return ids
 	}
 	return nil
 }
 
 // ClearedEdges returns all edge names that were cleared in this mutation.
 func (m *UserProfileMutation) ClearedEdges() []string {
-	edges := make([]string, 0, 2)
+	edges := make([]string, 0, 3)
 	if m.cleareduser {
 		edges = append(edges, userprofile.EdgeUser)
 	}
 	if m.clearedtexture {
 		edges = append(edges, userprofile.EdgeTexture)
 	}
+	if m.clearedusertexture {
+		edges = append(edges, userprofile.EdgeUsertexture)
+	}
 	return edges
 }
 
@@ -1971,6 +2160,8 @@ func (m *UserProfileMutation) EdgeCleared(name string) bool {
 		return m.cleareduser
 	case userprofile.EdgeTexture:
 		return m.clearedtexture
+	case userprofile.EdgeUsertexture:
+		return m.clearedusertexture
 	}
 	return false
 }
@@ -1996,10 +2187,494 @@ func (m *UserProfileMutation) ResetEdge(name string) error {
 	case userprofile.EdgeTexture:
 		m.ResetTexture()
 		return nil
+	case userprofile.EdgeUsertexture:
+		m.ResetUsertexture()
+		return nil
 	}
 	return fmt.Errorf("unknown UserProfile edge %s", name)
 }
 
+// UserTextureMutation represents an operation that mutates the UserTexture nodes in the graph.
+type UserTextureMutation struct {
+	config
+	op                  Op
+	typ                 string
+	id                  *int
+	clearedFields       map[string]struct{}
+	user_profile        *int
+	cleareduser_profile bool
+	texture             *int
+	clearedtexture      bool
+	done                bool
+	oldValue            func(context.Context) (*UserTexture, error)
+	predicates          []predicate.UserTexture
+}
+
+var _ ent.Mutation = (*UserTextureMutation)(nil)
+
+// usertextureOption allows management of the mutation configuration using functional options.
+type usertextureOption func(*UserTextureMutation)
+
+// newUserTextureMutation creates new mutation for the UserTexture entity.
+func newUserTextureMutation(c config, op Op, opts ...usertextureOption) *UserTextureMutation {
+	m := &UserTextureMutation{
+		config:        c,
+		op:            op,
+		typ:           TypeUserTexture,
+		clearedFields: make(map[string]struct{}),
+	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
+}
+
+// withUserTextureID sets the ID field of the mutation.
+func withUserTextureID(id int) usertextureOption {
+	return func(m *UserTextureMutation) {
+		var (
+			err   error
+			once  sync.Once
+			value *UserTexture
+		)
+		m.oldValue = func(ctx context.Context) (*UserTexture, error) {
+			once.Do(func() {
+				if m.done {
+					err = errors.New("querying old values post mutation is not allowed")
+				} else {
+					value, err = m.Client().UserTexture.Get(ctx, id)
+				}
+			})
+			return value, err
+		}
+		m.id = &id
+	}
+}
+
+// withUserTexture sets the old UserTexture of the mutation.
+func withUserTexture(node *UserTexture) usertextureOption {
+	return func(m *UserTextureMutation) {
+		m.oldValue = func(context.Context) (*UserTexture, error) {
+			return node, nil
+		}
+		m.id = &node.ID
+	}
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m UserTextureMutation) Client() *Client {
+	client := &Client{config: m.config}
+	client.init()
+	return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m UserTextureMutation) Tx() (*Tx, error) {
+	if _, ok := m.driver.(*txDriver); !ok {
+		return nil, errors.New("ent: mutation is not running in a transaction")
+	}
+	tx := &Tx{config: m.config}
+	tx.init()
+	return tx, nil
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *UserTextureMutation) ID() (id int, exists bool) {
+	if m.id == nil {
+		return
+	}
+	return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *UserTextureMutation) IDs(ctx context.Context) ([]int, error) {
+	switch {
+	case m.op.Is(OpUpdateOne | OpDeleteOne):
+		id, exists := m.ID()
+		if exists {
+			return []int{id}, nil
+		}
+		fallthrough
+	case m.op.Is(OpUpdate | OpDelete):
+		return m.Client().UserTexture.Query().Where(m.predicates...).IDs(ctx)
+	default:
+		return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+	}
+}
+
+// SetUserProfileID sets the "user_profile_id" field.
+func (m *UserTextureMutation) SetUserProfileID(i int) {
+	m.user_profile = &i
+}
+
+// UserProfileID returns the value of the "user_profile_id" field in the mutation.
+func (m *UserTextureMutation) UserProfileID() (r int, exists bool) {
+	v := m.user_profile
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUserProfileID returns the old "user_profile_id" field's value of the UserTexture entity.
+// If the UserTexture object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserTextureMutation) OldUserProfileID(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUserProfileID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUserProfileID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUserProfileID: %w", err)
+	}
+	return oldValue.UserProfileID, nil
+}
+
+// ResetUserProfileID resets all changes to the "user_profile_id" field.
+func (m *UserTextureMutation) ResetUserProfileID() {
+	m.user_profile = nil
+}
+
+// SetTextureID sets the "texture_id" field.
+func (m *UserTextureMutation) SetTextureID(i int) {
+	m.texture = &i
+}
+
+// TextureID returns the value of the "texture_id" field in the mutation.
+func (m *UserTextureMutation) TextureID() (r int, exists bool) {
+	v := m.texture
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldTextureID returns the old "texture_id" field's value of the UserTexture entity.
+// If the UserTexture object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserTextureMutation) OldTextureID(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldTextureID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldTextureID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldTextureID: %w", err)
+	}
+	return oldValue.TextureID, nil
+}
+
+// ResetTextureID resets all changes to the "texture_id" field.
+func (m *UserTextureMutation) ResetTextureID() {
+	m.texture = nil
+}
+
+// ClearUserProfile clears the "user_profile" edge to the UserProfile entity.
+func (m *UserTextureMutation) ClearUserProfile() {
+	m.cleareduser_profile = true
+}
+
+// UserProfileCleared reports if the "user_profile" edge to the UserProfile entity was cleared.
+func (m *UserTextureMutation) UserProfileCleared() bool {
+	return m.cleareduser_profile
+}
+
+// UserProfileIDs returns the "user_profile" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserProfileID instead. It exists only for internal usage by the builders.
+func (m *UserTextureMutation) UserProfileIDs() (ids []int) {
+	if id := m.user_profile; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetUserProfile resets all changes to the "user_profile" edge.
+func (m *UserTextureMutation) ResetUserProfile() {
+	m.user_profile = nil
+	m.cleareduser_profile = false
+}
+
+// ClearTexture clears the "texture" edge to the Texture entity.
+func (m *UserTextureMutation) ClearTexture() {
+	m.clearedtexture = true
+}
+
+// TextureCleared reports if the "texture" edge to the Texture entity was cleared.
+func (m *UserTextureMutation) TextureCleared() bool {
+	return m.clearedtexture
+}
+
+// TextureIDs returns the "texture" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// TextureID instead. It exists only for internal usage by the builders.
+func (m *UserTextureMutation) TextureIDs() (ids []int) {
+	if id := m.texture; id != nil {
+		ids = append(ids, *id)
+	}
+	return
+}
+
+// ResetTexture resets all changes to the "texture" edge.
+func (m *UserTextureMutation) ResetTexture() {
+	m.texture = nil
+	m.clearedtexture = false
+}
+
+// Where appends a list predicates to the UserTextureMutation builder.
+func (m *UserTextureMutation) Where(ps ...predicate.UserTexture) {
+	m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the UserTextureMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *UserTextureMutation) WhereP(ps ...func(*sql.Selector)) {
+	p := make([]predicate.UserTexture, len(ps))
+	for i := range ps {
+		p[i] = ps[i]
+	}
+	m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *UserTextureMutation) Op() Op {
+	return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *UserTextureMutation) SetOp(op Op) {
+	m.op = op
+}
+
+// Type returns the node type of this mutation (UserTexture).
+func (m *UserTextureMutation) Type() string {
+	return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *UserTextureMutation) Fields() []string {
+	fields := make([]string, 0, 2)
+	if m.user_profile != nil {
+		fields = append(fields, usertexture.FieldUserProfileID)
+	}
+	if m.texture != nil {
+		fields = append(fields, usertexture.FieldTextureID)
+	}
+	return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *UserTextureMutation) Field(name string) (ent.Value, bool) {
+	switch name {
+	case usertexture.FieldUserProfileID:
+		return m.UserProfileID()
+	case usertexture.FieldTextureID:
+		return m.TextureID()
+	}
+	return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *UserTextureMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+	switch name {
+	case usertexture.FieldUserProfileID:
+		return m.OldUserProfileID(ctx)
+	case usertexture.FieldTextureID:
+		return m.OldTextureID(ctx)
+	}
+	return nil, fmt.Errorf("unknown UserTexture field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserTextureMutation) SetField(name string, value ent.Value) error {
+	switch name {
+	case usertexture.FieldUserProfileID:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUserProfileID(v)
+		return nil
+	case usertexture.FieldTextureID:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetTextureID(v)
+		return nil
+	}
+	return fmt.Errorf("unknown UserTexture field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *UserTextureMutation) AddedFields() []string {
+	var fields []string
+	return fields
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *UserTextureMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	}
+	return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserTextureMutation) AddField(name string, value ent.Value) error {
+	switch name {
+	}
+	return fmt.Errorf("unknown UserTexture numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *UserTextureMutation) ClearedFields() []string {
+	return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *UserTextureMutation) FieldCleared(name string) bool {
+	_, ok := m.clearedFields[name]
+	return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *UserTextureMutation) ClearField(name string) error {
+	return fmt.Errorf("unknown UserTexture nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *UserTextureMutation) ResetField(name string) error {
+	switch name {
+	case usertexture.FieldUserProfileID:
+		m.ResetUserProfileID()
+		return nil
+	case usertexture.FieldTextureID:
+		m.ResetTextureID()
+		return nil
+	}
+	return fmt.Errorf("unknown UserTexture field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *UserTextureMutation) AddedEdges() []string {
+	edges := make([]string, 0, 2)
+	if m.user_profile != nil {
+		edges = append(edges, usertexture.EdgeUserProfile)
+	}
+	if m.texture != nil {
+		edges = append(edges, usertexture.EdgeTexture)
+	}
+	return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *UserTextureMutation) AddedIDs(name string) []ent.Value {
+	switch name {
+	case usertexture.EdgeUserProfile:
+		if id := m.user_profile; id != nil {
+			return []ent.Value{*id}
+		}
+	case usertexture.EdgeTexture:
+		if id := m.texture; id != nil {
+			return []ent.Value{*id}
+		}
+	}
+	return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *UserTextureMutation) RemovedEdges() []string {
+	edges := make([]string, 0, 2)
+	return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *UserTextureMutation) RemovedIDs(name string) []ent.Value {
+	return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *UserTextureMutation) ClearedEdges() []string {
+	edges := make([]string, 0, 2)
+	if m.cleareduser_profile {
+		edges = append(edges, usertexture.EdgeUserProfile)
+	}
+	if m.clearedtexture {
+		edges = append(edges, usertexture.EdgeTexture)
+	}
+	return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *UserTextureMutation) EdgeCleared(name string) bool {
+	switch name {
+	case usertexture.EdgeUserProfile:
+		return m.cleareduser_profile
+	case usertexture.EdgeTexture:
+		return m.clearedtexture
+	}
+	return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *UserTextureMutation) ClearEdge(name string) error {
+	switch name {
+	case usertexture.EdgeUserProfile:
+		m.ClearUserProfile()
+		return nil
+	case usertexture.EdgeTexture:
+		m.ClearTexture()
+		return nil
+	}
+	return fmt.Errorf("unknown UserTexture unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *UserTextureMutation) ResetEdge(name string) error {
+	switch name {
+	case usertexture.EdgeUserProfile:
+		m.ResetUserProfile()
+		return nil
+	case usertexture.EdgeTexture:
+		m.ResetTexture()
+		return nil
+	}
+	return fmt.Errorf("unknown UserTexture edge %s", name)
+}
+
 // UserTokenMutation represents an operation that mutates the UserToken nodes in the graph.
 type UserTokenMutation struct {
 	config

db/ent/predicate/predicate.go

@@ -15,5 +15,8 @@ type User func(*sql.Selector)
 // UserProfile is the predicate function for userprofile builders.
 type UserProfile func(*sql.Selector)
 
+// UserTexture is the predicate function for usertexture builders.
+type UserTexture func(*sql.Selector)
+
 // UserToken is the predicate function for usertoken builders.
 type UserToken func(*sql.Selector)

db/ent/schema/texture.go

@@ -5,7 +5,6 @@ import (
 	"entgo.io/ent/dialect"
 	"entgo.io/ent/schema/edge"
 	"entgo.io/ent/schema/field"
-	"entgo.io/ent/schema/index"
 )
 
 // Texture holds the schema definition for the Texture entity.
@@ -34,12 +33,10 @@ func (Texture) Fields() []ent.Field {
 func (Texture) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.To("created_user", User.Type).Unique().Required(),
-		edge.From("user", UserProfile.Type).Ref("texture").Required().Unique(),
+		edge.From("user", UserProfile.Type).Ref("texture").Through("usertexture", UserTexture.Type),
 	}
 }
 
 func (Texture) Indexes() []ent.Index {
-	return []ent.Index{
+	return nil
-		index.Edges("user"),
-	}
 }

db/ent/schema/userprofile.go

@@ -29,7 +29,7 @@ func (UserProfile) Fields() []ent.Field {
 func (UserProfile) Edges() []ent.Edge {
 	return []ent.Edge{
 		edge.From("user", User.Type).Ref("profile").Required().Unique(),
-		edge.To("texture", Texture.Type),
+		edge.To("texture", Texture.Type).Through("usertexture", UserTexture.Type),
 	}
 }
 

db/ent/schema/usertexture.go

@@ -0,0 +1,42 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// UserTexture holds the schema definition for the UserTexture entity.
+type UserTexture struct {
+	ent.Schema
+}
+
+// Fields of the UserTexture.
+func (UserTexture) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int("user_profile_id"),
+		field.Int("texture_id"),
+	}
+}
+
+// Edges of the UserTexture.
+func (UserTexture) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.To("user_profile", UserProfile.Type).
+			Unique().
+			Required().
+			Field("user_profile_id"),
+		edge.To("texture", Texture.Type).
+			Unique().
+			Required().
+			Field("texture_id"),
+	}
+}
+
+func (UserTexture) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Edges("user_profile"),
+		index.Edges("texture"),
+	}
+}

db/ent/texture.go

@@ -10,7 +10,6 @@ import (
 	"entgo.io/ent/dialect/sql"
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
-	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
 )
 
 // Texture is the model entity for the Texture schema.
@@ -28,7 +27,6 @@ type Texture struct {
 	// The values are being populated by the TextureQuery when eager-loading is set.
 	Edges                TextureEdges `json:"edges"`
 	texture_created_user *int
-	user_profile_texture *int
 	selectValues         sql.SelectValues
 }
 
@@ -37,10 +35,12 @@ type TextureEdges struct {
 	// CreatedUser holds the value of the created_user edge.
 	CreatedUser *User `json:"created_user,omitempty"`
 	// User holds the value of the user edge.
-	User *UserProfile `json:"user,omitempty"`
+	User []*UserProfile `json:"user,omitempty"`
+	// Usertexture holds the value of the usertexture edge.
+	Usertexture []*UserTexture `json:"usertexture,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [2]bool
+	loadedTypes [3]bool
 }
 
 // CreatedUserOrErr returns the CreatedUser value or an error if the edge
@@ -57,18 +57,23 @@ func (e TextureEdges) CreatedUserOrErr() (*User, error) {
 }
 
 // UserOrErr returns the User value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
+// was not loaded in eager-loading.
-func (e TextureEdges) UserOrErr() (*UserProfile, error) {
+func (e TextureEdges) UserOrErr() ([]*UserProfile, error) {
 	if e.loadedTypes[1] {
-		if e.User == nil {
-			// Edge was loaded but was not found.
-			return nil, &NotFoundError{label: userprofile.Label}
-		}
 		return e.User, nil
 	}
 	return nil, &NotLoadedError{edge: "user"}
 }
 
+// UsertextureOrErr returns the Usertexture value or an error if the edge
+// was not loaded in eager-loading.
+func (e TextureEdges) UsertextureOrErr() ([]*UserTexture, error) {
+	if e.loadedTypes[2] {
+		return e.Usertexture, nil
+	}
+	return nil, &NotLoadedError{edge: "usertexture"}
+}
+
 // scanValues returns the types for scanning values from sql.Rows.
 func (*Texture) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
@@ -80,8 +85,6 @@ func (*Texture) scanValues(columns []string) ([]any, error) {
 			values[i] = new(sql.NullString)
 		case texture.ForeignKeys[0]: // texture_created_user
 			values[i] = new(sql.NullInt64)
-		case texture.ForeignKeys[1]: // user_profile_texture
-			values[i] = new(sql.NullInt64)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -128,13 +131,6 @@ func (t *Texture) assignValues(columns []string, values []any) error {
 				t.texture_created_user = new(int)
 				*t.texture_created_user = int(value.Int64)
 			}
-		case texture.ForeignKeys[1]:
-			if value, ok := values[i].(*sql.NullInt64); !ok {
-				return fmt.Errorf("unexpected type %T for edge-field user_profile_texture", value)
-			} else if value.Valid {
-				t.user_profile_texture = new(int)
-				*t.user_profile_texture = int(value.Int64)
-			}
 		default:
 			t.selectValues.Set(columns[i], values[i])
 		}
@@ -158,6 +154,11 @@ func (t *Texture) QueryUser() *UserProfileQuery {
 	return NewTextureClient(t.config).QueryUser(t)
 }
 
+// QueryUsertexture queries the "usertexture" edge of the Texture entity.
+func (t *Texture) QueryUsertexture() *UserTextureQuery {
+	return NewTextureClient(t.config).QueryUsertexture(t)
+}
+
 // Update returns a builder for updating this Texture.
 // Note that you need to call Texture.Unwrap() before calling this method if this Texture
 // was returned from a transaction, and the transaction was committed or rolled back.

db/ent/texture/texture.go

@@ -22,6 +22,8 @@ const (
 	EdgeCreatedUser = "created_user"
 	// EdgeUser holds the string denoting the user edge name in mutations.
 	EdgeUser = "user"
+	// EdgeUsertexture holds the string denoting the usertexture edge name in mutations.
+	EdgeUsertexture = "usertexture"
 	// Table holds the table name of the texture in the database.
 	Table = "textures"
 	// CreatedUserTable is the table that holds the created_user relation/edge.
@@ -31,13 +33,18 @@ const (
 	CreatedUserInverseTable = "users"
 	// CreatedUserColumn is the table column denoting the created_user relation/edge.
 	CreatedUserColumn = "texture_created_user"
-	// UserTable is the table that holds the user relation/edge.
+	// UserTable is the table that holds the user relation/edge. The primary key declared below.
-	UserTable = "textures"
+	UserTable = "user_textures"
 	// UserInverseTable is the table name for the UserProfile entity.
 	// It exists in this package in order to avoid circular dependency with the "userprofile" package.
 	UserInverseTable = "user_profiles"
-	// UserColumn is the table column denoting the user relation/edge.
+	// UsertextureTable is the table that holds the usertexture relation/edge.
-	UserColumn = "user_profile_texture"
+	UsertextureTable = "user_textures"
+	// UsertextureInverseTable is the table name for the UserTexture entity.
+	// It exists in this package in order to avoid circular dependency with the "usertexture" package.
+	UsertextureInverseTable = "user_textures"
+	// UsertextureColumn is the table column denoting the usertexture relation/edge.
+	UsertextureColumn = "texture_id"
 )
 
 // Columns holds all SQL columns for texture fields.
@@ -52,9 +59,14 @@ var Columns = []string{
 // table and are not defined as standalone fields in the schema.
 var ForeignKeys = []string{
 	"texture_created_user",
-	"user_profile_texture",
 }
 
+var (
+	// UserPrimaryKey and UserColumn2 are the table columns denoting the
+	// primary key for the user relation (M2M).
+	UserPrimaryKey = []string{"user_profile_id", "texture_id"}
+)
+
 // ValidColumn reports if the column name is valid (part of the table columns).
 func ValidColumn(column string) bool {
 	for i := range Columns {
@@ -100,10 +112,31 @@ func ByCreatedUserField(field string, opts ...sql.OrderTermOption) OrderOption {
 	}
 }
 
-// ByUserField orders the results by user field.
+// ByUserCount orders the results by user count.
-func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+func ByUserCount(opts ...sql.OrderTermOption) OrderOption {
 	return func(s *sql.Selector) {
-		sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+		sqlgraph.OrderByNeighborsCount(s, newUserStep(), opts...)
+	}
+}
+
+// ByUser orders the results by user terms.
+func ByUser(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUserStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+
+// ByUsertextureCount orders the results by usertexture count.
+func ByUsertextureCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newUsertextureStep(), opts...)
+	}
+}
+
+// ByUsertexture orders the results by usertexture terms.
+func ByUsertexture(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUsertextureStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
 func newCreatedUserStep() *sqlgraph.Step {
@@ -117,6 +150,13 @@ func newUserStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
 		sqlgraph.To(UserInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+		sqlgraph.Edge(sqlgraph.M2M, true, UserTable, UserPrimaryKey...),
+	)
+}
+func newUsertextureStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UsertextureInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, true, UsertextureTable, UsertextureColumn),
 	)
 }

db/ent/texture/where.go

@@ -291,7 +291,7 @@ func HasUser() predicate.Texture {
 	return predicate.Texture(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+			sqlgraph.Edge(sqlgraph.M2M, true, UserTable, UserPrimaryKey...),
 		)
 		sqlgraph.HasNeighbors(s, step)
 	})
@@ -309,6 +309,29 @@ func HasUserWith(preds ...predicate.UserProfile) predicate.Texture {
 	})
 }
 
+// HasUsertexture applies the HasEdge predicate on the "usertexture" edge.
+func HasUsertexture() predicate.Texture {
+	return predicate.Texture(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, true, UsertextureTable, UsertextureColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUsertextureWith applies the HasEdge predicate on the "usertexture" edge with a given conditions (other predicates).
+func HasUsertextureWith(preds ...predicate.UserTexture) predicate.Texture {
+	return predicate.Texture(func(s *sql.Selector) {
+		step := newUsertextureStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.Texture) predicate.Texture {
 	return predicate.Texture(func(s *sql.Selector) {

db/ent/texture_create.go

@@ -12,6 +12,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 )
 
 // TextureCreate is the builder for creating a Texture entity.
@@ -50,15 +51,34 @@ func (tc *TextureCreate) SetCreatedUser(u *User) *TextureCreate {
 	return tc.SetCreatedUserID(u.ID)
 }
 
-// SetUserID sets the "user" edge to the UserProfile entity by ID.
+// AddUserIDs adds the "user" edge to the UserProfile entity by IDs.
-func (tc *TextureCreate) SetUserID(id int) *TextureCreate {
+func (tc *TextureCreate) AddUserIDs(ids ...int) *TextureCreate {
-	tc.mutation.SetUserID(id)
+	tc.mutation.AddUserIDs(ids...)
 	return tc
 }
 
-// SetUser sets the "user" edge to the UserProfile entity.
+// AddUser adds the "user" edges to the UserProfile entity.
-func (tc *TextureCreate) SetUser(u *UserProfile) *TextureCreate {
+func (tc *TextureCreate) AddUser(u ...*UserProfile) *TextureCreate {
-	return tc.SetUserID(u.ID)
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tc.AddUserIDs(ids...)
+}
+
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by IDs.
+func (tc *TextureCreate) AddUsertextureIDs(ids ...int) *TextureCreate {
+	tc.mutation.AddUsertextureIDs(ids...)
+	return tc
+}
+
+// AddUsertexture adds the "usertexture" edges to the UserTexture entity.
+func (tc *TextureCreate) AddUsertexture(u ...*UserTexture) *TextureCreate {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tc.AddUsertextureIDs(ids...)
 }
 
 // Mutation returns the TextureMutation object of the builder.
@@ -107,9 +127,6 @@ func (tc *TextureCreate) check() error {
 	if _, ok := tc.mutation.CreatedUserID(); !ok {
 		return &ValidationError{Name: "created_user", err: errors.New(`ent: missing required edge "Texture.created_user"`)}
 	}
-	if _, ok := tc.mutation.UserID(); !ok {
-		return &ValidationError{Name: "user", err: errors.New(`ent: missing required edge "Texture.user"`)}
-	}
 	return nil
 }
 
@@ -167,10 +184,10 @@ func (tc *TextureCreate) createSpec() (*Texture, *sqlgraph.CreateSpec) {
 	}
 	if nodes := tc.mutation.UserIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
+			Rel:     sqlgraph.M2M,
 			Inverse: true,
 			Table:   texture.UserTable,
-			Columns: []string{texture.UserColumn},
+			Columns: texture.UserPrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
@@ -179,7 +196,22 @@ func (tc *TextureCreate) createSpec() (*Texture, *sqlgraph.CreateSpec) {
 		for _, k := range nodes {
 			edge.Target.Nodes = append(edge.Target.Nodes, k)
 		}
-		_node.user_profile_texture = &nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := tc.mutation.UsertextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   texture.UsertextureTable,
+			Columns: []string{texture.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
 	return _node, _spec

db/ent/texture_query.go

@@ -4,6 +4,7 @@ package ent
 
 import (
 	"context"
+	"database/sql/driver"
 	"fmt"
 	"math"
 
@@ -15,6 +16,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 )
 
 // TextureQuery is the builder for querying Texture entities.
@@ -26,6 +28,7 @@ type TextureQuery struct {
 	predicates      []predicate.Texture
 	withCreatedUser *UserQuery
 	withUser        *UserProfileQuery
+	withUsertexture *UserTextureQuery
 	withFKs         bool
 	modifiers       []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
@@ -100,7 +103,29 @@ func (tq *TextureQuery) QueryUser() *UserProfileQuery {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(texture.Table, texture.FieldID, selector),
 			sqlgraph.To(userprofile.Table, userprofile.FieldID),
-			sqlgraph.Edge(sqlgraph.M2O, true, texture.UserTable, texture.UserColumn),
+			sqlgraph.Edge(sqlgraph.M2M, true, texture.UserTable, texture.UserPrimaryKey...),
+		)
+		fromU = sqlgraph.SetNeighbors(tq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryUsertexture chains the current query on the "usertexture" edge.
+func (tq *TextureQuery) QueryUsertexture() *UserTextureQuery {
+	query := (&UserTextureClient{config: tq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := tq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := tq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(texture.Table, texture.FieldID, selector),
+			sqlgraph.To(usertexture.Table, usertexture.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, true, texture.UsertextureTable, texture.UsertextureColumn),
 		)
 		fromU = sqlgraph.SetNeighbors(tq.driver.Dialect(), step)
 		return fromU, nil
@@ -302,6 +327,7 @@ func (tq *TextureQuery) Clone() *TextureQuery {
 		predicates:      append([]predicate.Texture{}, tq.predicates...),
 		withCreatedUser: tq.withCreatedUser.Clone(),
 		withUser:        tq.withUser.Clone(),
+		withUsertexture: tq.withUsertexture.Clone(),
 		// clone intermediate query.
 		sql:  tq.sql.Clone(),
 		path: tq.path,
@@ -330,6 +356,17 @@ func (tq *TextureQuery) WithUser(opts ...func(*UserProfileQuery)) *TextureQuery
 	return tq
 }
 
+// WithUsertexture tells the query-builder to eager-load the nodes that are connected to
+// the "usertexture" edge. The optional arguments are used to configure the query builder of the edge.
+func (tq *TextureQuery) WithUsertexture(opts ...func(*UserTextureQuery)) *TextureQuery {
+	query := (&UserTextureClient{config: tq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	tq.withUsertexture = query
+	return tq
+}
+
 // GroupBy is used to group vertices by one or more fields/columns.
 // It is often used with aggregate functions, like: count, max, mean, min, sum.
 //
@@ -409,12 +446,13 @@ func (tq *TextureQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Text
 		nodes       = []*Texture{}
 		withFKs     = tq.withFKs
 		_spec       = tq.querySpec()
-		loadedTypes = [2]bool{
+		loadedTypes = [3]bool{
 			tq.withCreatedUser != nil,
 			tq.withUser != nil,
+			tq.withUsertexture != nil,
 		}
 	)
-	if tq.withCreatedUser != nil || tq.withUser != nil {
+	if tq.withCreatedUser != nil {
 		withFKs = true
 	}
 	if withFKs {
@@ -448,8 +486,16 @@ func (tq *TextureQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Text
 		}
 	}
 	if query := tq.withUser; query != nil {
-		if err := tq.loadUser(ctx, query, nodes, nil,
+		if err := tq.loadUser(ctx, query, nodes,
-			func(n *Texture, e *UserProfile) { n.Edges.User = e }); err != nil {
+			func(n *Texture) { n.Edges.User = []*UserProfile{} },
+			func(n *Texture, e *UserProfile) { n.Edges.User = append(n.Edges.User, e) }); err != nil {
+			return nil, err
+		}
+	}
+	if query := tq.withUsertexture; query != nil {
+		if err := tq.loadUsertexture(ctx, query, nodes,
+			func(n *Texture) { n.Edges.Usertexture = []*UserTexture{} },
+			func(n *Texture, e *UserTexture) { n.Edges.Usertexture = append(n.Edges.Usertexture, e) }); err != nil {
 			return nil, err
 		}
 	}
@@ -489,34 +535,93 @@ func (tq *TextureQuery) loadCreatedUser(ctx context.Context, query *UserQuery, n
 	return nil
 }
 func (tq *TextureQuery) loadUser(ctx context.Context, query *UserProfileQuery, nodes []*Texture, init func(*Texture), assign func(*Texture, *UserProfile)) error {
-	ids := make([]int, 0, len(nodes))
+	edgeIDs := make([]driver.Value, len(nodes))
-	nodeids := make(map[int][]*Texture)
+	byID := make(map[int]*Texture)
+	nids := make(map[int]map[*Texture]struct{})
+	for i, node := range nodes {
+		edgeIDs[i] = node.ID
+		byID[node.ID] = node
+		if init != nil {
+			init(node)
+		}
+	}
+	query.Where(func(s *sql.Selector) {
+		joinT := sql.Table(texture.UserTable)
+		s.Join(joinT).On(s.C(userprofile.FieldID), joinT.C(texture.UserPrimaryKey[0]))
+		s.Where(sql.InValues(joinT.C(texture.UserPrimaryKey[1]), edgeIDs...))
+		columns := s.SelectedColumns()
+		s.Select(joinT.C(texture.UserPrimaryKey[1]))
+		s.AppendSelect(columns...)
+		s.SetDistinct(false)
+	})
+	if err := query.prepareQuery(ctx); err != nil {
+		return err
+	}
+	qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+			assign := spec.Assign
+			values := spec.ScanValues
+			spec.ScanValues = func(columns []string) ([]any, error) {
+				values, err := values(columns[1:])
+				if err != nil {
+					return nil, err
+				}
+				return append([]any{new(sql.NullInt64)}, values...), nil
+			}
+			spec.Assign = func(columns []string, values []any) error {
+				outValue := int(values[0].(*sql.NullInt64).Int64)
+				inValue := int(values[1].(*sql.NullInt64).Int64)
+				if nids[inValue] == nil {
+					nids[inValue] = map[*Texture]struct{}{byID[outValue]: {}}
+					return assign(columns[1:], values[1:])
+				}
+				nids[inValue][byID[outValue]] = struct{}{}
+				return nil
+			}
+		})
+	})
+	neighbors, err := withInterceptors[[]*UserProfile](ctx, query, qr, query.inters)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected "user" node returned %v`, n.ID)
+		}
+		for kn := range nodes {
+			assign(kn, n)
+		}
+	}
+	return nil
+}
+func (tq *TextureQuery) loadUsertexture(ctx context.Context, query *UserTextureQuery, nodes []*Texture, init func(*Texture), assign func(*Texture, *UserTexture)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[int]*Texture)
 	for i := range nodes {
-		if nodes[i].user_profile_texture == nil {
+		fks = append(fks, nodes[i].ID)
-			continue
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
 		}
-		fk := *nodes[i].user_profile_texture
-		if _, ok := nodeids[fk]; !ok {
-			ids = append(ids, fk)
-		}
-		nodeids[fk] = append(nodeids[fk], nodes[i])
 	}
-	if len(ids) == 0 {
+	if len(query.ctx.Fields) > 0 {
-		return nil
+		query.ctx.AppendFieldOnce(usertexture.FieldTextureID)
 	}
-	query.Where(userprofile.IDIn(ids...))
+	query.Where(predicate.UserTexture(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(texture.UsertextureColumn), fks...))
+	}))
 	neighbors, err := query.All(ctx)
 	if err != nil {
 		return err
 	}
 	for _, n := range neighbors {
-		nodes, ok := nodeids[n.ID]
+		fk := n.TextureID
+		node, ok := nodeids[fk]
 		if !ok {
-			return fmt.Errorf(`unexpected foreign-key "user_profile_texture" returned %v`, n.ID)
+			return fmt.Errorf(`unexpected referenced foreign-key "texture_id" returned %v for node %v`, fk, n.ID)
-		}
-		for i := range nodes {
-			assign(nodes[i], n)
 		}
+		assign(node, n)
 	}
 	return nil
 }

db/ent/texture_update.go

@@ -14,6 +14,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 )
 
 // TextureUpdate is the builder for updating Texture entities.
@@ -58,15 +59,34 @@ func (tu *TextureUpdate) SetCreatedUser(u *User) *TextureUpdate {
 	return tu.SetCreatedUserID(u.ID)
 }
 
-// SetUserID sets the "user" edge to the UserProfile entity by ID.
+// AddUserIDs adds the "user" edge to the UserProfile entity by IDs.
-func (tu *TextureUpdate) SetUserID(id int) *TextureUpdate {
+func (tu *TextureUpdate) AddUserIDs(ids ...int) *TextureUpdate {
-	tu.mutation.SetUserID(id)
+	tu.mutation.AddUserIDs(ids...)
 	return tu
 }
 
-// SetUser sets the "user" edge to the UserProfile entity.
+// AddUser adds the "user" edges to the UserProfile entity.
-func (tu *TextureUpdate) SetUser(u *UserProfile) *TextureUpdate {
+func (tu *TextureUpdate) AddUser(u ...*UserProfile) *TextureUpdate {
-	return tu.SetUserID(u.ID)
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tu.AddUserIDs(ids...)
+}
+
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by IDs.
+func (tu *TextureUpdate) AddUsertextureIDs(ids ...int) *TextureUpdate {
+	tu.mutation.AddUsertextureIDs(ids...)
+	return tu
+}
+
+// AddUsertexture adds the "usertexture" edges to the UserTexture entity.
+func (tu *TextureUpdate) AddUsertexture(u ...*UserTexture) *TextureUpdate {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tu.AddUsertextureIDs(ids...)
 }
 
 // Mutation returns the TextureMutation object of the builder.
@@ -80,12 +100,48 @@ func (tu *TextureUpdate) ClearCreatedUser() *TextureUpdate {
 	return tu
 }
 
-// ClearUser clears the "user" edge to the UserProfile entity.
+// ClearUser clears all "user" edges to the UserProfile entity.
 func (tu *TextureUpdate) ClearUser() *TextureUpdate {
 	tu.mutation.ClearUser()
 	return tu
 }
 
+// RemoveUserIDs removes the "user" edge to UserProfile entities by IDs.
+func (tu *TextureUpdate) RemoveUserIDs(ids ...int) *TextureUpdate {
+	tu.mutation.RemoveUserIDs(ids...)
+	return tu
+}
+
+// RemoveUser removes "user" edges to UserProfile entities.
+func (tu *TextureUpdate) RemoveUser(u ...*UserProfile) *TextureUpdate {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tu.RemoveUserIDs(ids...)
+}
+
+// ClearUsertexture clears all "usertexture" edges to the UserTexture entity.
+func (tu *TextureUpdate) ClearUsertexture() *TextureUpdate {
+	tu.mutation.ClearUsertexture()
+	return tu
+}
+
+// RemoveUsertextureIDs removes the "usertexture" edge to UserTexture entities by IDs.
+func (tu *TextureUpdate) RemoveUsertextureIDs(ids ...int) *TextureUpdate {
+	tu.mutation.RemoveUsertextureIDs(ids...)
+	return tu
+}
+
+// RemoveUsertexture removes "usertexture" edges to UserTexture entities.
+func (tu *TextureUpdate) RemoveUsertexture(u ...*UserTexture) *TextureUpdate {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tu.RemoveUsertextureIDs(ids...)
+}
+
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (tu *TextureUpdate) Save(ctx context.Context) (int, error) {
 	return withHooks(ctx, tu.sqlSave, tu.mutation, tu.hooks)
@@ -118,9 +174,6 @@ func (tu *TextureUpdate) check() error {
 	if _, ok := tu.mutation.CreatedUserID(); tu.mutation.CreatedUserCleared() && !ok {
 		return errors.New(`ent: clearing a required unique edge "Texture.created_user"`)
 	}
-	if _, ok := tu.mutation.UserID(); tu.mutation.UserCleared() && !ok {
-		return errors.New(`ent: clearing a required unique edge "Texture.user"`)
-	}
 	return nil
 }
 
@@ -176,10 +229,10 @@ func (tu *TextureUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	}
 	if tu.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
+			Rel:     sqlgraph.M2M,
 			Inverse: true,
 			Table:   texture.UserTable,
-			Columns: []string{texture.UserColumn},
+			Columns: texture.UserPrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
@@ -187,12 +240,12 @@ func (tu *TextureUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := tu.mutation.UserIDs(); len(nodes) > 0 {
+	if nodes := tu.mutation.RemovedUserIDs(); len(nodes) > 0 && !tu.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
+			Rel:     sqlgraph.M2M,
 			Inverse: true,
 			Table:   texture.UserTable,
-			Columns: []string{texture.UserColumn},
+			Columns: texture.UserPrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
@@ -201,6 +254,67 @@ func (tu *TextureUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		for _, k := range nodes {
 			edge.Target.Nodes = append(edge.Target.Nodes, k)
 		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := tu.mutation.UserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2M,
+			Inverse: true,
+			Table:   texture.UserTable,
+			Columns: texture.UserPrimaryKey,
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if tu.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   texture.UsertextureTable,
+			Columns: []string{texture.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := tu.mutation.RemovedUsertextureIDs(); len(nodes) > 0 && !tu.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   texture.UsertextureTable,
+			Columns: []string{texture.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := tu.mutation.UsertextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   texture.UsertextureTable,
+			Columns: []string{texture.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
 	if n, err = sqlgraph.UpdateNodes(ctx, tu.driver, _spec); err != nil {
@@ -252,15 +366,34 @@ func (tuo *TextureUpdateOne) SetCreatedUser(u *User) *TextureUpdateOne {
 	return tuo.SetCreatedUserID(u.ID)
 }
 
-// SetUserID sets the "user" edge to the UserProfile entity by ID.
+// AddUserIDs adds the "user" edge to the UserProfile entity by IDs.
-func (tuo *TextureUpdateOne) SetUserID(id int) *TextureUpdateOne {
+func (tuo *TextureUpdateOne) AddUserIDs(ids ...int) *TextureUpdateOne {
-	tuo.mutation.SetUserID(id)
+	tuo.mutation.AddUserIDs(ids...)
 	return tuo
 }
 
-// SetUser sets the "user" edge to the UserProfile entity.
+// AddUser adds the "user" edges to the UserProfile entity.
-func (tuo *TextureUpdateOne) SetUser(u *UserProfile) *TextureUpdateOne {
+func (tuo *TextureUpdateOne) AddUser(u ...*UserProfile) *TextureUpdateOne {
-	return tuo.SetUserID(u.ID)
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tuo.AddUserIDs(ids...)
+}
+
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by IDs.
+func (tuo *TextureUpdateOne) AddUsertextureIDs(ids ...int) *TextureUpdateOne {
+	tuo.mutation.AddUsertextureIDs(ids...)
+	return tuo
+}
+
+// AddUsertexture adds the "usertexture" edges to the UserTexture entity.
+func (tuo *TextureUpdateOne) AddUsertexture(u ...*UserTexture) *TextureUpdateOne {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tuo.AddUsertextureIDs(ids...)
 }
 
 // Mutation returns the TextureMutation object of the builder.
@@ -274,12 +407,48 @@ func (tuo *TextureUpdateOne) ClearCreatedUser() *TextureUpdateOne {
 	return tuo
 }
 
-// ClearUser clears the "user" edge to the UserProfile entity.
+// ClearUser clears all "user" edges to the UserProfile entity.
 func (tuo *TextureUpdateOne) ClearUser() *TextureUpdateOne {
 	tuo.mutation.ClearUser()
 	return tuo
 }
 
+// RemoveUserIDs removes the "user" edge to UserProfile entities by IDs.
+func (tuo *TextureUpdateOne) RemoveUserIDs(ids ...int) *TextureUpdateOne {
+	tuo.mutation.RemoveUserIDs(ids...)
+	return tuo
+}
+
+// RemoveUser removes "user" edges to UserProfile entities.
+func (tuo *TextureUpdateOne) RemoveUser(u ...*UserProfile) *TextureUpdateOne {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tuo.RemoveUserIDs(ids...)
+}
+
+// ClearUsertexture clears all "usertexture" edges to the UserTexture entity.
+func (tuo *TextureUpdateOne) ClearUsertexture() *TextureUpdateOne {
+	tuo.mutation.ClearUsertexture()
+	return tuo
+}
+
+// RemoveUsertextureIDs removes the "usertexture" edge to UserTexture entities by IDs.
+func (tuo *TextureUpdateOne) RemoveUsertextureIDs(ids ...int) *TextureUpdateOne {
+	tuo.mutation.RemoveUsertextureIDs(ids...)
+	return tuo
+}
+
+// RemoveUsertexture removes "usertexture" edges to UserTexture entities.
+func (tuo *TextureUpdateOne) RemoveUsertexture(u ...*UserTexture) *TextureUpdateOne {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return tuo.RemoveUsertextureIDs(ids...)
+}
+
 // Where appends a list predicates to the TextureUpdate builder.
 func (tuo *TextureUpdateOne) Where(ps ...predicate.Texture) *TextureUpdateOne {
 	tuo.mutation.Where(ps...)
@@ -325,9 +494,6 @@ func (tuo *TextureUpdateOne) check() error {
 	if _, ok := tuo.mutation.CreatedUserID(); tuo.mutation.CreatedUserCleared() && !ok {
 		return errors.New(`ent: clearing a required unique edge "Texture.created_user"`)
 	}
-	if _, ok := tuo.mutation.UserID(); tuo.mutation.UserCleared() && !ok {
-		return errors.New(`ent: clearing a required unique edge "Texture.user"`)
-	}
 	return nil
 }
 
@@ -400,10 +566,10 @@ func (tuo *TextureUpdateOne) sqlSave(ctx context.Context) (_node *Texture, err e
 	}
 	if tuo.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
+			Rel:     sqlgraph.M2M,
 			Inverse: true,
 			Table:   texture.UserTable,
-			Columns: []string{texture.UserColumn},
+			Columns: texture.UserPrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
@@ -411,12 +577,12 @@ func (tuo *TextureUpdateOne) sqlSave(ctx context.Context) (_node *Texture, err e
 		}
 		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
 	}
-	if nodes := tuo.mutation.UserIDs(); len(nodes) > 0 {
+	if nodes := tuo.mutation.RemovedUserIDs(); len(nodes) > 0 && !tuo.mutation.UserCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.M2O,
+			Rel:     sqlgraph.M2M,
 			Inverse: true,
 			Table:   texture.UserTable,
-			Columns: []string{texture.UserColumn},
+			Columns: texture.UserPrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
@@ -425,6 +591,67 @@ func (tuo *TextureUpdateOne) sqlSave(ctx context.Context) (_node *Texture, err e
 		for _, k := range nodes {
 			edge.Target.Nodes = append(edge.Target.Nodes, k)
 		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := tuo.mutation.UserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2M,
+			Inverse: true,
+			Table:   texture.UserTable,
+			Columns: texture.UserPrimaryKey,
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if tuo.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   texture.UsertextureTable,
+			Columns: []string{texture.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := tuo.mutation.RemovedUsertextureIDs(); len(nodes) > 0 && !tuo.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   texture.UsertextureTable,
+			Columns: []string{texture.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := tuo.mutation.UsertextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   texture.UsertextureTable,
+			Columns: []string{texture.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
 	_node = &Texture{config: tuo.config}

db/ent/tx.go

@@ -18,6 +18,8 @@ type Tx struct {
 	User *UserClient
 	// UserProfile is the client for interacting with the UserProfile builders.
 	UserProfile *UserProfileClient
+	// UserTexture is the client for interacting with the UserTexture builders.
+	UserTexture *UserTextureClient
 	// UserToken is the client for interacting with the UserToken builders.
 	UserToken *UserTokenClient
 
@@ -154,6 +156,7 @@ func (tx *Tx) init() {
 	tx.Texture = NewTextureClient(tx.config)
 	tx.User = NewUserClient(tx.config)
 	tx.UserProfile = NewUserProfileClient(tx.config)
+	tx.UserTexture = NewUserTextureClient(tx.config)
 	tx.UserToken = NewUserTokenClient(tx.config)
 }
 

db/ent/userprofile.go

@@ -34,9 +34,11 @@ type UserProfileEdges struct {
 	User *User `json:"user,omitempty"`
 	// Texture holds the value of the texture edge.
 	Texture []*Texture `json:"texture,omitempty"`
+	// Usertexture holds the value of the usertexture edge.
+	Usertexture []*UserTexture `json:"usertexture,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [2]bool
+	loadedTypes [3]bool
 }
 
 // UserOrErr returns the User value or an error if the edge
@@ -61,6 +63,15 @@ func (e UserProfileEdges) TextureOrErr() ([]*Texture, error) {
 	return nil, &NotLoadedError{edge: "texture"}
 }
 
+// UsertextureOrErr returns the Usertexture value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserProfileEdges) UsertextureOrErr() ([]*UserTexture, error) {
+	if e.loadedTypes[2] {
+		return e.Usertexture, nil
+	}
+	return nil, &NotLoadedError{edge: "usertexture"}
+}
+
 // scanValues returns the types for scanning values from sql.Rows.
 func (*UserProfile) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
@@ -135,6 +146,11 @@ func (up *UserProfile) QueryTexture() *TextureQuery {
 	return NewUserProfileClient(up.config).QueryTexture(up)
 }
 
+// QueryUsertexture queries the "usertexture" edge of the UserProfile entity.
+func (up *UserProfile) QueryUsertexture() *UserTextureQuery {
+	return NewUserProfileClient(up.config).QueryUsertexture(up)
+}
+
 // Update returns a builder for updating this UserProfile.
 // Note that you need to call UserProfile.Unwrap() before calling this method if this UserProfile
 // was returned from a transaction, and the transaction was committed or rolled back.

db/ent/userprofile/userprofile.go

@@ -20,6 +20,8 @@ const (
 	EdgeUser = "user"
 	// EdgeTexture holds the string denoting the texture edge name in mutations.
 	EdgeTexture = "texture"
+	// EdgeUsertexture holds the string denoting the usertexture edge name in mutations.
+	EdgeUsertexture = "usertexture"
 	// Table holds the table name of the userprofile in the database.
 	Table = "user_profiles"
 	// UserTable is the table that holds the user relation/edge.
@@ -29,13 +31,18 @@ const (
 	UserInverseTable = "users"
 	// UserColumn is the table column denoting the user relation/edge.
 	UserColumn = "user_profile"
-	// TextureTable is the table that holds the texture relation/edge.
+	// TextureTable is the table that holds the texture relation/edge. The primary key declared below.
-	TextureTable = "textures"
+	TextureTable = "user_textures"
 	// TextureInverseTable is the table name for the Texture entity.
 	// It exists in this package in order to avoid circular dependency with the "texture" package.
 	TextureInverseTable = "textures"
-	// TextureColumn is the table column denoting the texture relation/edge.
+	// UsertextureTable is the table that holds the usertexture relation/edge.
-	TextureColumn = "user_profile_texture"
+	UsertextureTable = "user_textures"
+	// UsertextureInverseTable is the table name for the UserTexture entity.
+	// It exists in this package in order to avoid circular dependency with the "usertexture" package.
+	UsertextureInverseTable = "user_textures"
+	// UsertextureColumn is the table column denoting the usertexture relation/edge.
+	UsertextureColumn = "user_profile_id"
 )
 
 // Columns holds all SQL columns for userprofile fields.
@@ -51,6 +58,12 @@ var ForeignKeys = []string{
 	"user_profile",
 }
 
+var (
+	// TexturePrimaryKey and TextureColumn2 are the table columns denoting the
+	// primary key for the texture relation (M2M).
+	TexturePrimaryKey = []string{"user_profile_id", "texture_id"}
+)
+
 // ValidColumn reports if the column name is valid (part of the table columns).
 func ValidColumn(column string) bool {
 	for i := range Columns {
@@ -104,6 +117,20 @@ func ByTexture(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 		sqlgraph.OrderByNeighborTerms(s, newTextureStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
+
+// ByUsertextureCount orders the results by usertexture count.
+func ByUsertextureCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newUsertextureStep(), opts...)
+	}
+}
+
+// ByUsertexture orders the results by usertexture terms.
+func ByUsertexture(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUsertextureStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
 func newUserStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
@@ -115,6 +142,13 @@ func newTextureStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
 		sqlgraph.To(TextureInverseTable, FieldID),
-		sqlgraph.Edge(sqlgraph.O2M, false, TextureTable, TextureColumn),
+		sqlgraph.Edge(sqlgraph.M2M, false, TextureTable, TexturePrimaryKey...),
+	)
+}
+func newUsertextureStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UsertextureInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, true, UsertextureTable, UsertextureColumn),
 	)
 }

db/ent/userprofile/where.go

@@ -221,7 +221,7 @@ func HasTexture() predicate.UserProfile {
 	return predicate.UserProfile(func(s *sql.Selector) {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(Table, FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, TextureTable, TextureColumn),
+			sqlgraph.Edge(sqlgraph.M2M, false, TextureTable, TexturePrimaryKey...),
 		)
 		sqlgraph.HasNeighbors(s, step)
 	})
@@ -239,6 +239,29 @@ func HasTextureWith(preds ...predicate.Texture) predicate.UserProfile {
 	})
 }
 
+// HasUsertexture applies the HasEdge predicate on the "usertexture" edge.
+func HasUsertexture() predicate.UserProfile {
+	return predicate.UserProfile(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, true, UsertextureTable, UsertextureColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUsertextureWith applies the HasEdge predicate on the "usertexture" edge with a given conditions (other predicates).
+func HasUsertextureWith(preds ...predicate.UserTexture) predicate.UserProfile {
+	return predicate.UserProfile(func(s *sql.Selector) {
+		step := newUsertextureStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.UserProfile) predicate.UserProfile {
 	return predicate.UserProfile(func(s *sql.Selector) {

db/ent/userprofile_create.go

@@ -12,6 +12,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 )
 
 // UserProfileCreate is the builder for creating a UserProfile entity.
@@ -59,6 +60,21 @@ func (upc *UserProfileCreate) AddTexture(t ...*Texture) *UserProfileCreate {
 	return upc.AddTextureIDs(ids...)
 }
 
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by IDs.
+func (upc *UserProfileCreate) AddUsertextureIDs(ids ...int) *UserProfileCreate {
+	upc.mutation.AddUsertextureIDs(ids...)
+	return upc
+}
+
+// AddUsertexture adds the "usertexture" edges to the UserTexture entity.
+func (upc *UserProfileCreate) AddUsertexture(u ...*UserTexture) *UserProfileCreate {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return upc.AddUsertextureIDs(ids...)
+}
+
 // Mutation returns the UserProfileMutation object of the builder.
 func (upc *UserProfileCreate) Mutation() *UserProfileMutation {
 	return upc.mutation
@@ -155,10 +171,10 @@ func (upc *UserProfileCreate) createSpec() (*UserProfile, *sqlgraph.CreateSpec)
 	}
 	if nodes := upc.mutation.TextureIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
+			Rel:     sqlgraph.M2M,
 			Inverse: false,
 			Table:   userprofile.TextureTable,
-			Columns: []string{userprofile.TextureColumn},
+			Columns: userprofile.TexturePrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
@@ -169,6 +185,22 @@ func (upc *UserProfileCreate) createSpec() (*UserProfile, *sqlgraph.CreateSpec)
 		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
+	if nodes := upc.mutation.UsertextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   userprofile.UsertextureTable,
+			Columns: []string{userprofile.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
 	return _node, _spec
 }
 

db/ent/userprofile_query.go

@@ -16,19 +16,21 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 )
 
 // UserProfileQuery is the builder for querying UserProfile entities.
 type UserProfileQuery struct {
 	config
-	ctx         *QueryContext
+	ctx             *QueryContext
-	order       []userprofile.OrderOption
+	order           []userprofile.OrderOption
-	inters      []Interceptor
+	inters          []Interceptor
-	predicates  []predicate.UserProfile
+	predicates      []predicate.UserProfile
-	withUser    *UserQuery
+	withUser        *UserQuery
-	withTexture *TextureQuery
+	withTexture     *TextureQuery
-	withFKs     bool
+	withUsertexture *UserTextureQuery
-	modifiers   []func(*sql.Selector)
+	withFKs         bool
+	modifiers       []func(*sql.Selector)
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
 	path func(context.Context) (*sql.Selector, error)
@@ -101,7 +103,29 @@ func (upq *UserProfileQuery) QueryTexture() *TextureQuery {
 		step := sqlgraph.NewStep(
 			sqlgraph.From(userprofile.Table, userprofile.FieldID, selector),
 			sqlgraph.To(texture.Table, texture.FieldID),
-			sqlgraph.Edge(sqlgraph.O2M, false, userprofile.TextureTable, userprofile.TextureColumn),
+			sqlgraph.Edge(sqlgraph.M2M, false, userprofile.TextureTable, userprofile.TexturePrimaryKey...),
+		)
+		fromU = sqlgraph.SetNeighbors(upq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryUsertexture chains the current query on the "usertexture" edge.
+func (upq *UserProfileQuery) QueryUsertexture() *UserTextureQuery {
+	query := (&UserTextureClient{config: upq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := upq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := upq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(userprofile.Table, userprofile.FieldID, selector),
+			sqlgraph.To(usertexture.Table, usertexture.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, true, userprofile.UsertextureTable, userprofile.UsertextureColumn),
 		)
 		fromU = sqlgraph.SetNeighbors(upq.driver.Dialect(), step)
 		return fromU, nil
@@ -296,13 +320,14 @@ func (upq *UserProfileQuery) Clone() *UserProfileQuery {
 		return nil
 	}
 	return &UserProfileQuery{
-		config:      upq.config,
+		config:          upq.config,
-		ctx:         upq.ctx.Clone(),
+		ctx:             upq.ctx.Clone(),
-		order:       append([]userprofile.OrderOption{}, upq.order...),
+		order:           append([]userprofile.OrderOption{}, upq.order...),
-		inters:      append([]Interceptor{}, upq.inters...),
+		inters:          append([]Interceptor{}, upq.inters...),
-		predicates:  append([]predicate.UserProfile{}, upq.predicates...),
+		predicates:      append([]predicate.UserProfile{}, upq.predicates...),
-		withUser:    upq.withUser.Clone(),
+		withUser:        upq.withUser.Clone(),
-		withTexture: upq.withTexture.Clone(),
+		withTexture:     upq.withTexture.Clone(),
+		withUsertexture: upq.withUsertexture.Clone(),
 		// clone intermediate query.
 		sql:  upq.sql.Clone(),
 		path: upq.path,
@@ -331,6 +356,17 @@ func (upq *UserProfileQuery) WithTexture(opts ...func(*TextureQuery)) *UserProfi
 	return upq
 }
 
+// WithUsertexture tells the query-builder to eager-load the nodes that are connected to
+// the "usertexture" edge. The optional arguments are used to configure the query builder of the edge.
+func (upq *UserProfileQuery) WithUsertexture(opts ...func(*UserTextureQuery)) *UserProfileQuery {
+	query := (&UserTextureClient{config: upq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	upq.withUsertexture = query
+	return upq
+}
+
 // GroupBy is used to group vertices by one or more fields/columns.
 // It is often used with aggregate functions, like: count, max, mean, min, sum.
 //
@@ -410,9 +446,10 @@ func (upq *UserProfileQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]
 		nodes       = []*UserProfile{}
 		withFKs     = upq.withFKs
 		_spec       = upq.querySpec()
-		loadedTypes = [2]bool{
+		loadedTypes = [3]bool{
 			upq.withUser != nil,
 			upq.withTexture != nil,
+			upq.withUsertexture != nil,
 		}
 	)
 	if upq.withUser != nil {
@@ -455,6 +492,13 @@ func (upq *UserProfileQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]
 			return nil, err
 		}
 	}
+	if query := upq.withUsertexture; query != nil {
+		if err := upq.loadUsertexture(ctx, query, nodes,
+			func(n *UserProfile) { n.Edges.Usertexture = []*UserTexture{} },
+			func(n *UserProfile, e *UserTexture) { n.Edges.Usertexture = append(n.Edges.Usertexture, e) }); err != nil {
+			return nil, err
+		}
+	}
 	return nodes, nil
 }
 
@@ -491,6 +535,67 @@ func (upq *UserProfileQuery) loadUser(ctx context.Context, query *UserQuery, nod
 	return nil
 }
 func (upq *UserProfileQuery) loadTexture(ctx context.Context, query *TextureQuery, nodes []*UserProfile, init func(*UserProfile), assign func(*UserProfile, *Texture)) error {
+	edgeIDs := make([]driver.Value, len(nodes))
+	byID := make(map[int]*UserProfile)
+	nids := make(map[int]map[*UserProfile]struct{})
+	for i, node := range nodes {
+		edgeIDs[i] = node.ID
+		byID[node.ID] = node
+		if init != nil {
+			init(node)
+		}
+	}
+	query.Where(func(s *sql.Selector) {
+		joinT := sql.Table(userprofile.TextureTable)
+		s.Join(joinT).On(s.C(texture.FieldID), joinT.C(userprofile.TexturePrimaryKey[1]))
+		s.Where(sql.InValues(joinT.C(userprofile.TexturePrimaryKey[0]), edgeIDs...))
+		columns := s.SelectedColumns()
+		s.Select(joinT.C(userprofile.TexturePrimaryKey[0]))
+		s.AppendSelect(columns...)
+		s.SetDistinct(false)
+	})
+	if err := query.prepareQuery(ctx); err != nil {
+		return err
+	}
+	qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+			assign := spec.Assign
+			values := spec.ScanValues
+			spec.ScanValues = func(columns []string) ([]any, error) {
+				values, err := values(columns[1:])
+				if err != nil {
+					return nil, err
+				}
+				return append([]any{new(sql.NullInt64)}, values...), nil
+			}
+			spec.Assign = func(columns []string, values []any) error {
+				outValue := int(values[0].(*sql.NullInt64).Int64)
+				inValue := int(values[1].(*sql.NullInt64).Int64)
+				if nids[inValue] == nil {
+					nids[inValue] = map[*UserProfile]struct{}{byID[outValue]: {}}
+					return assign(columns[1:], values[1:])
+				}
+				nids[inValue][byID[outValue]] = struct{}{}
+				return nil
+			}
+		})
+	})
+	neighbors, err := withInterceptors[[]*Texture](ctx, query, qr, query.inters)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected "texture" node returned %v`, n.ID)
+		}
+		for kn := range nodes {
+			assign(kn, n)
+		}
+	}
+	return nil
+}
+func (upq *UserProfileQuery) loadUsertexture(ctx context.Context, query *UserTextureQuery, nodes []*UserProfile, init func(*UserProfile), assign func(*UserProfile, *UserTexture)) error {
 	fks := make([]driver.Value, 0, len(nodes))
 	nodeids := make(map[int]*UserProfile)
 	for i := range nodes {
@@ -500,22 +605,21 @@ func (upq *UserProfileQuery) loadTexture(ctx context.Context, query *TextureQuer
 			init(nodes[i])
 		}
 	}
-	query.withFKs = true
+	if len(query.ctx.Fields) > 0 {
-	query.Where(predicate.Texture(func(s *sql.Selector) {
+		query.ctx.AppendFieldOnce(usertexture.FieldUserProfileID)
-		s.Where(sql.InValues(s.C(userprofile.TextureColumn), fks...))
+	}
+	query.Where(predicate.UserTexture(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(userprofile.UsertextureColumn), fks...))
 	}))
 	neighbors, err := query.All(ctx)
 	if err != nil {
 		return err
 	}
 	for _, n := range neighbors {
-		fk := n.user_profile_texture
+		fk := n.UserProfileID
-		if fk == nil {
+		node, ok := nodeids[fk]
-			return fmt.Errorf(`foreign-key "user_profile_texture" is nil for node %v`, n.ID)
-		}
-		node, ok := nodeids[*fk]
 		if !ok {
-			return fmt.Errorf(`unexpected referenced foreign-key "user_profile_texture" returned %v for node %v`, *fk, n.ID)
+			return fmt.Errorf(`unexpected referenced foreign-key "user_profile_id" returned %v for node %v`, fk, n.ID)
 		}
 		assign(node, n)
 	}

db/ent/userprofile_update.go

@@ -14,6 +14,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 )
 
 // UserProfileUpdate is the builder for updating UserProfile entities.
@@ -67,6 +68,21 @@ func (upu *UserProfileUpdate) AddTexture(t ...*Texture) *UserProfileUpdate {
 	return upu.AddTextureIDs(ids...)
 }
 
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by IDs.
+func (upu *UserProfileUpdate) AddUsertextureIDs(ids ...int) *UserProfileUpdate {
+	upu.mutation.AddUsertextureIDs(ids...)
+	return upu
+}
+
+// AddUsertexture adds the "usertexture" edges to the UserTexture entity.
+func (upu *UserProfileUpdate) AddUsertexture(u ...*UserTexture) *UserProfileUpdate {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return upu.AddUsertextureIDs(ids...)
+}
+
 // Mutation returns the UserProfileMutation object of the builder.
 func (upu *UserProfileUpdate) Mutation() *UserProfileMutation {
 	return upu.mutation
@@ -99,6 +115,27 @@ func (upu *UserProfileUpdate) RemoveTexture(t ...*Texture) *UserProfileUpdate {
 	return upu.RemoveTextureIDs(ids...)
 }
 
+// ClearUsertexture clears all "usertexture" edges to the UserTexture entity.
+func (upu *UserProfileUpdate) ClearUsertexture() *UserProfileUpdate {
+	upu.mutation.ClearUsertexture()
+	return upu
+}
+
+// RemoveUsertextureIDs removes the "usertexture" edge to UserTexture entities by IDs.
+func (upu *UserProfileUpdate) RemoveUsertextureIDs(ids ...int) *UserProfileUpdate {
+	upu.mutation.RemoveUsertextureIDs(ids...)
+	return upu
+}
+
+// RemoveUsertexture removes "usertexture" edges to UserTexture entities.
+func (upu *UserProfileUpdate) RemoveUsertexture(u ...*UserTexture) *UserProfileUpdate {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return upu.RemoveUsertextureIDs(ids...)
+}
+
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (upu *UserProfileUpdate) Save(ctx context.Context) (int, error) {
 	return withHooks(ctx, upu.sqlSave, upu.mutation, upu.hooks)
@@ -183,10 +220,10 @@ func (upu *UserProfileUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	}
 	if upu.mutation.TextureCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
+			Rel:     sqlgraph.M2M,
 			Inverse: false,
 			Table:   userprofile.TextureTable,
-			Columns: []string{userprofile.TextureColumn},
+			Columns: userprofile.TexturePrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
@@ -196,10 +233,10 @@ func (upu *UserProfileUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	}
 	if nodes := upu.mutation.RemovedTextureIDs(); len(nodes) > 0 && !upu.mutation.TextureCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
+			Rel:     sqlgraph.M2M,
 			Inverse: false,
 			Table:   userprofile.TextureTable,
-			Columns: []string{userprofile.TextureColumn},
+			Columns: userprofile.TexturePrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
@@ -212,10 +249,10 @@ func (upu *UserProfileUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	}
 	if nodes := upu.mutation.TextureIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
+			Rel:     sqlgraph.M2M,
 			Inverse: false,
 			Table:   userprofile.TextureTable,
-			Columns: []string{userprofile.TextureColumn},
+			Columns: userprofile.TexturePrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
@@ -226,6 +263,51 @@ func (upu *UserProfileUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	if upu.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   userprofile.UsertextureTable,
+			Columns: []string{userprofile.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := upu.mutation.RemovedUsertextureIDs(); len(nodes) > 0 && !upu.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   userprofile.UsertextureTable,
+			Columns: []string{userprofile.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := upu.mutation.UsertextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   userprofile.UsertextureTable,
+			Columns: []string{userprofile.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if n, err = sqlgraph.UpdateNodes(ctx, upu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{userprofile.Label}
@@ -284,6 +366,21 @@ func (upuo *UserProfileUpdateOne) AddTexture(t ...*Texture) *UserProfileUpdateOn
 	return upuo.AddTextureIDs(ids...)
 }
 
+// AddUsertextureIDs adds the "usertexture" edge to the UserTexture entity by IDs.
+func (upuo *UserProfileUpdateOne) AddUsertextureIDs(ids ...int) *UserProfileUpdateOne {
+	upuo.mutation.AddUsertextureIDs(ids...)
+	return upuo
+}
+
+// AddUsertexture adds the "usertexture" edges to the UserTexture entity.
+func (upuo *UserProfileUpdateOne) AddUsertexture(u ...*UserTexture) *UserProfileUpdateOne {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return upuo.AddUsertextureIDs(ids...)
+}
+
 // Mutation returns the UserProfileMutation object of the builder.
 func (upuo *UserProfileUpdateOne) Mutation() *UserProfileMutation {
 	return upuo.mutation
@@ -316,6 +413,27 @@ func (upuo *UserProfileUpdateOne) RemoveTexture(t ...*Texture) *UserProfileUpdat
 	return upuo.RemoveTextureIDs(ids...)
 }
 
+// ClearUsertexture clears all "usertexture" edges to the UserTexture entity.
+func (upuo *UserProfileUpdateOne) ClearUsertexture() *UserProfileUpdateOne {
+	upuo.mutation.ClearUsertexture()
+	return upuo
+}
+
+// RemoveUsertextureIDs removes the "usertexture" edge to UserTexture entities by IDs.
+func (upuo *UserProfileUpdateOne) RemoveUsertextureIDs(ids ...int) *UserProfileUpdateOne {
+	upuo.mutation.RemoveUsertextureIDs(ids...)
+	return upuo
+}
+
+// RemoveUsertexture removes "usertexture" edges to UserTexture entities.
+func (upuo *UserProfileUpdateOne) RemoveUsertexture(u ...*UserTexture) *UserProfileUpdateOne {
+	ids := make([]int, len(u))
+	for i := range u {
+		ids[i] = u[i].ID
+	}
+	return upuo.RemoveUsertextureIDs(ids...)
+}
+
 // Where appends a list predicates to the UserProfileUpdate builder.
 func (upuo *UserProfileUpdateOne) Where(ps ...predicate.UserProfile) *UserProfileUpdateOne {
 	upuo.mutation.Where(ps...)
@@ -430,10 +548,10 @@ func (upuo *UserProfileUpdateOne) sqlSave(ctx context.Context) (_node *UserProfi
 	}
 	if upuo.mutation.TextureCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
+			Rel:     sqlgraph.M2M,
 			Inverse: false,
 			Table:   userprofile.TextureTable,
-			Columns: []string{userprofile.TextureColumn},
+			Columns: userprofile.TexturePrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
@@ -443,10 +561,10 @@ func (upuo *UserProfileUpdateOne) sqlSave(ctx context.Context) (_node *UserProfi
 	}
 	if nodes := upuo.mutation.RemovedTextureIDs(); len(nodes) > 0 && !upuo.mutation.TextureCleared() {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
+			Rel:     sqlgraph.M2M,
 			Inverse: false,
 			Table:   userprofile.TextureTable,
-			Columns: []string{userprofile.TextureColumn},
+			Columns: userprofile.TexturePrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
@@ -459,10 +577,10 @@ func (upuo *UserProfileUpdateOne) sqlSave(ctx context.Context) (_node *UserProfi
 	}
 	if nodes := upuo.mutation.TextureIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
-			Rel:     sqlgraph.O2M,
+			Rel:     sqlgraph.M2M,
 			Inverse: false,
 			Table:   userprofile.TextureTable,
-			Columns: []string{userprofile.TextureColumn},
+			Columns: userprofile.TexturePrimaryKey,
 			Bidi:    false,
 			Target: &sqlgraph.EdgeTarget{
 				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
@@ -473,6 +591,51 @@ func (upuo *UserProfileUpdateOne) sqlSave(ctx context.Context) (_node *UserProfi
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	if upuo.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   userprofile.UsertextureTable,
+			Columns: []string{userprofile.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := upuo.mutation.RemovedUsertextureIDs(); len(nodes) > 0 && !upuo.mutation.UsertextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   userprofile.UsertextureTable,
+			Columns: []string{userprofile.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := upuo.mutation.UsertextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: true,
+			Table:   userprofile.UsertextureTable,
+			Columns: []string{userprofile.UsertextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	_node = &UserProfile{config: upuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues

db/ent/usertexture.go

@@ -0,0 +1,164 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/xmdhs/authlib-skin/db/ent/texture"
+	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
+)
+
+// UserTexture is the model entity for the UserTexture schema.
+type UserTexture struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID int `json:"id,omitempty"`
+	// UserProfileID holds the value of the "user_profile_id" field.
+	UserProfileID int `json:"user_profile_id,omitempty"`
+	// TextureID holds the value of the "texture_id" field.
+	TextureID int `json:"texture_id,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the UserTextureQuery when eager-loading is set.
+	Edges        UserTextureEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// UserTextureEdges holds the relations/edges for other nodes in the graph.
+type UserTextureEdges struct {
+	// UserProfile holds the value of the user_profile edge.
+	UserProfile *UserProfile `json:"user_profile,omitempty"`
+	// Texture holds the value of the texture edge.
+	Texture *Texture `json:"texture,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [2]bool
+}
+
+// UserProfileOrErr returns the UserProfile value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e UserTextureEdges) UserProfileOrErr() (*UserProfile, error) {
+	if e.loadedTypes[0] {
+		if e.UserProfile == nil {
+			// Edge was loaded but was not found.
+			return nil, &NotFoundError{label: userprofile.Label}
+		}
+		return e.UserProfile, nil
+	}
+	return nil, &NotLoadedError{edge: "user_profile"}
+}
+
+// TextureOrErr returns the Texture value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e UserTextureEdges) TextureOrErr() (*Texture, error) {
+	if e.loadedTypes[1] {
+		if e.Texture == nil {
+			// Edge was loaded but was not found.
+			return nil, &NotFoundError{label: texture.Label}
+		}
+		return e.Texture, nil
+	}
+	return nil, &NotLoadedError{edge: "texture"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*UserTexture) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case usertexture.FieldID, usertexture.FieldUserProfileID, usertexture.FieldTextureID:
+			values[i] = new(sql.NullInt64)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the UserTexture fields.
+func (ut *UserTexture) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case usertexture.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			ut.ID = int(value.Int64)
+		case usertexture.FieldUserProfileID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field user_profile_id", values[i])
+			} else if value.Valid {
+				ut.UserProfileID = int(value.Int64)
+			}
+		case usertexture.FieldTextureID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field texture_id", values[i])
+			} else if value.Valid {
+				ut.TextureID = int(value.Int64)
+			}
+		default:
+			ut.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the UserTexture.
+// This includes values selected through modifiers, order, etc.
+func (ut *UserTexture) Value(name string) (ent.Value, error) {
+	return ut.selectValues.Get(name)
+}
+
+// QueryUserProfile queries the "user_profile" edge of the UserTexture entity.
+func (ut *UserTexture) QueryUserProfile() *UserProfileQuery {
+	return NewUserTextureClient(ut.config).QueryUserProfile(ut)
+}
+
+// QueryTexture queries the "texture" edge of the UserTexture entity.
+func (ut *UserTexture) QueryTexture() *TextureQuery {
+	return NewUserTextureClient(ut.config).QueryTexture(ut)
+}
+
+// Update returns a builder for updating this UserTexture.
+// Note that you need to call UserTexture.Unwrap() before calling this method if this UserTexture
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (ut *UserTexture) Update() *UserTextureUpdateOne {
+	return NewUserTextureClient(ut.config).UpdateOne(ut)
+}
+
+// Unwrap unwraps the UserTexture entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (ut *UserTexture) Unwrap() *UserTexture {
+	_tx, ok := ut.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: UserTexture is not a transactional entity")
+	}
+	ut.config.driver = _tx.drv
+	return ut
+}
+
+// String implements the fmt.Stringer.
+func (ut *UserTexture) String() string {
+	var builder strings.Builder
+	builder.WriteString("UserTexture(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", ut.ID))
+	builder.WriteString("user_profile_id=")
+	builder.WriteString(fmt.Sprintf("%v", ut.UserProfileID))
+	builder.WriteString(", ")
+	builder.WriteString("texture_id=")
+	builder.WriteString(fmt.Sprintf("%v", ut.TextureID))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// UserTextures is a parsable slice of UserTexture.
+type UserTextures []*UserTexture

db/ent/usertexture/usertexture.go

@@ -0,0 +1,102 @@
+// Code generated by ent, DO NOT EDIT.
+
+package usertexture
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the usertexture type in the database.
+	Label = "user_texture"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldUserProfileID holds the string denoting the user_profile_id field in the database.
+	FieldUserProfileID = "user_profile_id"
+	// FieldTextureID holds the string denoting the texture_id field in the database.
+	FieldTextureID = "texture_id"
+	// EdgeUserProfile holds the string denoting the user_profile edge name in mutations.
+	EdgeUserProfile = "user_profile"
+	// EdgeTexture holds the string denoting the texture edge name in mutations.
+	EdgeTexture = "texture"
+	// Table holds the table name of the usertexture in the database.
+	Table = "user_textures"
+	// UserProfileTable is the table that holds the user_profile relation/edge.
+	UserProfileTable = "user_textures"
+	// UserProfileInverseTable is the table name for the UserProfile entity.
+	// It exists in this package in order to avoid circular dependency with the "userprofile" package.
+	UserProfileInverseTable = "user_profiles"
+	// UserProfileColumn is the table column denoting the user_profile relation/edge.
+	UserProfileColumn = "user_profile_id"
+	// TextureTable is the table that holds the texture relation/edge.
+	TextureTable = "user_textures"
+	// TextureInverseTable is the table name for the Texture entity.
+	// It exists in this package in order to avoid circular dependency with the "texture" package.
+	TextureInverseTable = "textures"
+	// TextureColumn is the table column denoting the texture relation/edge.
+	TextureColumn = "texture_id"
+)
+
+// Columns holds all SQL columns for usertexture fields.
+var Columns = []string{
+	FieldID,
+	FieldUserProfileID,
+	FieldTextureID,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+// OrderOption defines the ordering options for the UserTexture queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByUserProfileID orders the results by the user_profile_id field.
+func ByUserProfileID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserProfileID, opts...).ToFunc()
+}
+
+// ByTextureID orders the results by the texture_id field.
+func ByTextureID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTextureID, opts...).ToFunc()
+}
+
+// ByUserProfileField orders the results by user_profile field.
+func ByUserProfileField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newUserProfileStep(), sql.OrderByField(field, opts...))
+	}
+}
+
+// ByTextureField orders the results by texture field.
+func ByTextureField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newTextureStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newUserProfileStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(UserProfileInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, false, UserProfileTable, UserProfileColumn),
+	)
+}
+func newTextureStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(TextureInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, false, TextureTable, TextureColumn),
+	)
+}

db/ent/usertexture/where.go

@@ -0,0 +1,182 @@
+// Code generated by ent, DO NOT EDIT.
+
+package usertexture
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/xmdhs/authlib-skin/db/ent/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldLTE(FieldID, id))
+}
+
+// UserProfileID applies equality check predicate on the "user_profile_id" field. It's identical to UserProfileIDEQ.
+func UserProfileID(v int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldEQ(FieldUserProfileID, v))
+}
+
+// TextureID applies equality check predicate on the "texture_id" field. It's identical to TextureIDEQ.
+func TextureID(v int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldEQ(FieldTextureID, v))
+}
+
+// UserProfileIDEQ applies the EQ predicate on the "user_profile_id" field.
+func UserProfileIDEQ(v int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldEQ(FieldUserProfileID, v))
+}
+
+// UserProfileIDNEQ applies the NEQ predicate on the "user_profile_id" field.
+func UserProfileIDNEQ(v int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldNEQ(FieldUserProfileID, v))
+}
+
+// UserProfileIDIn applies the In predicate on the "user_profile_id" field.
+func UserProfileIDIn(vs ...int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldIn(FieldUserProfileID, vs...))
+}
+
+// UserProfileIDNotIn applies the NotIn predicate on the "user_profile_id" field.
+func UserProfileIDNotIn(vs ...int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldNotIn(FieldUserProfileID, vs...))
+}
+
+// TextureIDEQ applies the EQ predicate on the "texture_id" field.
+func TextureIDEQ(v int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldEQ(FieldTextureID, v))
+}
+
+// TextureIDNEQ applies the NEQ predicate on the "texture_id" field.
+func TextureIDNEQ(v int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldNEQ(FieldTextureID, v))
+}
+
+// TextureIDIn applies the In predicate on the "texture_id" field.
+func TextureIDIn(vs ...int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldIn(FieldTextureID, vs...))
+}
+
+// TextureIDNotIn applies the NotIn predicate on the "texture_id" field.
+func TextureIDNotIn(vs ...int) predicate.UserTexture {
+	return predicate.UserTexture(sql.FieldNotIn(FieldTextureID, vs...))
+}
+
+// HasUserProfile applies the HasEdge predicate on the "user_profile" edge.
+func HasUserProfile() predicate.UserTexture {
+	return predicate.UserTexture(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, false, UserProfileTable, UserProfileColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasUserProfileWith applies the HasEdge predicate on the "user_profile" edge with a given conditions (other predicates).
+func HasUserProfileWith(preds ...predicate.UserProfile) predicate.UserTexture {
+	return predicate.UserTexture(func(s *sql.Selector) {
+		step := newUserProfileStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// HasTexture applies the HasEdge predicate on the "texture" edge.
+func HasTexture() predicate.UserTexture {
+	return predicate.UserTexture(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, false, TextureTable, TextureColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasTextureWith applies the HasEdge predicate on the "texture" edge with a given conditions (other predicates).
+func HasTextureWith(preds ...predicate.Texture) predicate.UserTexture {
+	return predicate.UserTexture(func(s *sql.Selector) {
+		step := newTextureStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.UserTexture) predicate.UserTexture {
+	return predicate.UserTexture(func(s *sql.Selector) {
+		s1 := s.Clone().SetP(nil)
+		for _, p := range predicates {
+			p(s1)
+		}
+		s.Where(s1.P())
+	})
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.UserTexture) predicate.UserTexture {
+	return predicate.UserTexture(func(s *sql.Selector) {
+		s1 := s.Clone().SetP(nil)
+		for i, p := range predicates {
+			if i > 0 {
+				s1.Or()
+			}
+			p(s1)
+		}
+		s.Where(s1.P())
+	})
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.UserTexture) predicate.UserTexture {
+	return predicate.UserTexture(func(s *sql.Selector) {
+		p(s.Not())
+	})
+}

db/ent/usertexture_create.go

@@ -0,0 +1,236 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/xmdhs/authlib-skin/db/ent/texture"
+	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
+)
+
+// UserTextureCreate is the builder for creating a UserTexture entity.
+type UserTextureCreate struct {
+	config
+	mutation *UserTextureMutation
+	hooks    []Hook
+}
+
+// SetUserProfileID sets the "user_profile_id" field.
+func (utc *UserTextureCreate) SetUserProfileID(i int) *UserTextureCreate {
+	utc.mutation.SetUserProfileID(i)
+	return utc
+}
+
+// SetTextureID sets the "texture_id" field.
+func (utc *UserTextureCreate) SetTextureID(i int) *UserTextureCreate {
+	utc.mutation.SetTextureID(i)
+	return utc
+}
+
+// SetUserProfile sets the "user_profile" edge to the UserProfile entity.
+func (utc *UserTextureCreate) SetUserProfile(u *UserProfile) *UserTextureCreate {
+	return utc.SetUserProfileID(u.ID)
+}
+
+// SetTexture sets the "texture" edge to the Texture entity.
+func (utc *UserTextureCreate) SetTexture(t *Texture) *UserTextureCreate {
+	return utc.SetTextureID(t.ID)
+}
+
+// Mutation returns the UserTextureMutation object of the builder.
+func (utc *UserTextureCreate) Mutation() *UserTextureMutation {
+	return utc.mutation
+}
+
+// Save creates the UserTexture in the database.
+func (utc *UserTextureCreate) Save(ctx context.Context) (*UserTexture, error) {
+	return withHooks(ctx, utc.sqlSave, utc.mutation, utc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (utc *UserTextureCreate) SaveX(ctx context.Context) *UserTexture {
+	v, err := utc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (utc *UserTextureCreate) Exec(ctx context.Context) error {
+	_, err := utc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (utc *UserTextureCreate) ExecX(ctx context.Context) {
+	if err := utc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (utc *UserTextureCreate) check() error {
+	if _, ok := utc.mutation.UserProfileID(); !ok {
+		return &ValidationError{Name: "user_profile_id", err: errors.New(`ent: missing required field "UserTexture.user_profile_id"`)}
+	}
+	if _, ok := utc.mutation.TextureID(); !ok {
+		return &ValidationError{Name: "texture_id", err: errors.New(`ent: missing required field "UserTexture.texture_id"`)}
+	}
+	if _, ok := utc.mutation.UserProfileID(); !ok {
+		return &ValidationError{Name: "user_profile", err: errors.New(`ent: missing required edge "UserTexture.user_profile"`)}
+	}
+	if _, ok := utc.mutation.TextureID(); !ok {
+		return &ValidationError{Name: "texture", err: errors.New(`ent: missing required edge "UserTexture.texture"`)}
+	}
+	return nil
+}
+
+func (utc *UserTextureCreate) sqlSave(ctx context.Context) (*UserTexture, error) {
+	if err := utc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := utc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, utc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	id := _spec.ID.Value.(int64)
+	_node.ID = int(id)
+	utc.mutation.id = &_node.ID
+	utc.mutation.done = true
+	return _node, nil
+}
+
+func (utc *UserTextureCreate) createSpec() (*UserTexture, *sqlgraph.CreateSpec) {
+	var (
+		_node = &UserTexture{config: utc.config}
+		_spec = sqlgraph.NewCreateSpec(usertexture.Table, sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt))
+	)
+	if nodes := utc.mutation.UserProfileIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.UserProfileTable,
+			Columns: []string{usertexture.UserProfileColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.UserProfileID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := utc.mutation.TextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.TextureTable,
+			Columns: []string{usertexture.TextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.TextureID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// UserTextureCreateBulk is the builder for creating many UserTexture entities in bulk.
+type UserTextureCreateBulk struct {
+	config
+	builders []*UserTextureCreate
+}
+
+// Save creates the UserTexture entities in the database.
+func (utcb *UserTextureCreateBulk) Save(ctx context.Context) ([]*UserTexture, error) {
+	specs := make([]*sqlgraph.CreateSpec, len(utcb.builders))
+	nodes := make([]*UserTexture, len(utcb.builders))
+	mutators := make([]Mutator, len(utcb.builders))
+	for i := range utcb.builders {
+		func(i int, root context.Context) {
+			builder := utcb.builders[i]
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*UserTextureMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, utcb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, utcb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				if specs[i].ID.Value != nil {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int(id)
+				}
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, utcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (utcb *UserTextureCreateBulk) SaveX(ctx context.Context) []*UserTexture {
+	v, err := utcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (utcb *UserTextureCreateBulk) Exec(ctx context.Context) error {
+	_, err := utcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (utcb *UserTextureCreateBulk) ExecX(ctx context.Context) {
+	if err := utcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

db/ent/usertexture_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/xmdhs/authlib-skin/db/ent/predicate"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
+)
+
+// UserTextureDelete is the builder for deleting a UserTexture entity.
+type UserTextureDelete struct {
+	config
+	hooks    []Hook
+	mutation *UserTextureMutation
+}
+
+// Where appends a list predicates to the UserTextureDelete builder.
+func (utd *UserTextureDelete) Where(ps ...predicate.UserTexture) *UserTextureDelete {
+	utd.mutation.Where(ps...)
+	return utd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (utd *UserTextureDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, utd.sqlExec, utd.mutation, utd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (utd *UserTextureDelete) ExecX(ctx context.Context) int {
+	n, err := utd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (utd *UserTextureDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(usertexture.Table, sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt))
+	if ps := utd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, utd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	utd.mutation.done = true
+	return affected, err
+}
+
+// UserTextureDeleteOne is the builder for deleting a single UserTexture entity.
+type UserTextureDeleteOne struct {
+	utd *UserTextureDelete
+}
+
+// Where appends a list predicates to the UserTextureDelete builder.
+func (utdo *UserTextureDeleteOne) Where(ps ...predicate.UserTexture) *UserTextureDeleteOne {
+	utdo.utd.mutation.Where(ps...)
+	return utdo
+}
+
+// Exec executes the deletion query.
+func (utdo *UserTextureDeleteOne) Exec(ctx context.Context) error {
+	n, err := utdo.utd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{usertexture.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (utdo *UserTextureDeleteOne) ExecX(ctx context.Context) {
+	if err := utdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

db/ent/usertexture_query.go

@@ -0,0 +1,717 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/xmdhs/authlib-skin/db/ent/predicate"
+	"github.com/xmdhs/authlib-skin/db/ent/texture"
+	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
+)
+
+// UserTextureQuery is the builder for querying UserTexture entities.
+type UserTextureQuery struct {
+	config
+	ctx             *QueryContext
+	order           []usertexture.OrderOption
+	inters          []Interceptor
+	predicates      []predicate.UserTexture
+	withUserProfile *UserProfileQuery
+	withTexture     *TextureQuery
+	modifiers       []func(*sql.Selector)
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the UserTextureQuery builder.
+func (utq *UserTextureQuery) Where(ps ...predicate.UserTexture) *UserTextureQuery {
+	utq.predicates = append(utq.predicates, ps...)
+	return utq
+}
+
+// Limit the number of records to be returned by this query.
+func (utq *UserTextureQuery) Limit(limit int) *UserTextureQuery {
+	utq.ctx.Limit = &limit
+	return utq
+}
+
+// Offset to start from.
+func (utq *UserTextureQuery) Offset(offset int) *UserTextureQuery {
+	utq.ctx.Offset = &offset
+	return utq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (utq *UserTextureQuery) Unique(unique bool) *UserTextureQuery {
+	utq.ctx.Unique = &unique
+	return utq
+}
+
+// Order specifies how the records should be ordered.
+func (utq *UserTextureQuery) Order(o ...usertexture.OrderOption) *UserTextureQuery {
+	utq.order = append(utq.order, o...)
+	return utq
+}
+
+// QueryUserProfile chains the current query on the "user_profile" edge.
+func (utq *UserTextureQuery) QueryUserProfile() *UserProfileQuery {
+	query := (&UserProfileClient{config: utq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := utq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := utq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usertexture.Table, usertexture.FieldID, selector),
+			sqlgraph.To(userprofile.Table, userprofile.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, false, usertexture.UserProfileTable, usertexture.UserProfileColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(utq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryTexture chains the current query on the "texture" edge.
+func (utq *UserTextureQuery) QueryTexture() *TextureQuery {
+	query := (&TextureClient{config: utq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := utq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := utq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(usertexture.Table, usertexture.FieldID, selector),
+			sqlgraph.To(texture.Table, texture.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, false, usertexture.TextureTable, usertexture.TextureColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(utq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first UserTexture entity from the query.
+// Returns a *NotFoundError when no UserTexture was found.
+func (utq *UserTextureQuery) First(ctx context.Context) (*UserTexture, error) {
+	nodes, err := utq.Limit(1).All(setContextOp(ctx, utq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{usertexture.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (utq *UserTextureQuery) FirstX(ctx context.Context) *UserTexture {
+	node, err := utq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first UserTexture ID from the query.
+// Returns a *NotFoundError when no UserTexture ID was found.
+func (utq *UserTextureQuery) FirstID(ctx context.Context) (id int, err error) {
+	var ids []int
+	if ids, err = utq.Limit(1).IDs(setContextOp(ctx, utq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{usertexture.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (utq *UserTextureQuery) FirstIDX(ctx context.Context) int {
+	id, err := utq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single UserTexture entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one UserTexture entity is found.
+// Returns a *NotFoundError when no UserTexture entities are found.
+func (utq *UserTextureQuery) Only(ctx context.Context) (*UserTexture, error) {
+	nodes, err := utq.Limit(2).All(setContextOp(ctx, utq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{usertexture.Label}
+	default:
+		return nil, &NotSingularError{usertexture.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (utq *UserTextureQuery) OnlyX(ctx context.Context) *UserTexture {
+	node, err := utq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only UserTexture ID in the query.
+// Returns a *NotSingularError when more than one UserTexture ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (utq *UserTextureQuery) OnlyID(ctx context.Context) (id int, err error) {
+	var ids []int
+	if ids, err = utq.Limit(2).IDs(setContextOp(ctx, utq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{usertexture.Label}
+	default:
+		err = &NotSingularError{usertexture.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (utq *UserTextureQuery) OnlyIDX(ctx context.Context) int {
+	id, err := utq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of UserTextures.
+func (utq *UserTextureQuery) All(ctx context.Context) ([]*UserTexture, error) {
+	ctx = setContextOp(ctx, utq.ctx, "All")
+	if err := utq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*UserTexture, *UserTextureQuery]()
+	return withInterceptors[[]*UserTexture](ctx, utq, qr, utq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (utq *UserTextureQuery) AllX(ctx context.Context) []*UserTexture {
+	nodes, err := utq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of UserTexture IDs.
+func (utq *UserTextureQuery) IDs(ctx context.Context) (ids []int, err error) {
+	if utq.ctx.Unique == nil && utq.path != nil {
+		utq.Unique(true)
+	}
+	ctx = setContextOp(ctx, utq.ctx, "IDs")
+	if err = utq.Select(usertexture.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (utq *UserTextureQuery) IDsX(ctx context.Context) []int {
+	ids, err := utq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (utq *UserTextureQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, utq.ctx, "Count")
+	if err := utq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, utq, querierCount[*UserTextureQuery](), utq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (utq *UserTextureQuery) CountX(ctx context.Context) int {
+	count, err := utq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (utq *UserTextureQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, utq.ctx, "Exist")
+	switch _, err := utq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (utq *UserTextureQuery) ExistX(ctx context.Context) bool {
+	exist, err := utq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the UserTextureQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (utq *UserTextureQuery) Clone() *UserTextureQuery {
+	if utq == nil {
+		return nil
+	}
+	return &UserTextureQuery{
+		config:          utq.config,
+		ctx:             utq.ctx.Clone(),
+		order:           append([]usertexture.OrderOption{}, utq.order...),
+		inters:          append([]Interceptor{}, utq.inters...),
+		predicates:      append([]predicate.UserTexture{}, utq.predicates...),
+		withUserProfile: utq.withUserProfile.Clone(),
+		withTexture:     utq.withTexture.Clone(),
+		// clone intermediate query.
+		sql:  utq.sql.Clone(),
+		path: utq.path,
+	}
+}
+
+// WithUserProfile tells the query-builder to eager-load the nodes that are connected to
+// the "user_profile" edge. The optional arguments are used to configure the query builder of the edge.
+func (utq *UserTextureQuery) WithUserProfile(opts ...func(*UserProfileQuery)) *UserTextureQuery {
+	query := (&UserProfileClient{config: utq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	utq.withUserProfile = query
+	return utq
+}
+
+// WithTexture tells the query-builder to eager-load the nodes that are connected to
+// the "texture" edge. The optional arguments are used to configure the query builder of the edge.
+func (utq *UserTextureQuery) WithTexture(opts ...func(*TextureQuery)) *UserTextureQuery {
+	query := (&TextureClient{config: utq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	utq.withTexture = query
+	return utq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		UserProfileID int `json:"user_profile_id,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.UserTexture.Query().
+//		GroupBy(usertexture.FieldUserProfileID).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (utq *UserTextureQuery) GroupBy(field string, fields ...string) *UserTextureGroupBy {
+	utq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &UserTextureGroupBy{build: utq}
+	grbuild.flds = &utq.ctx.Fields
+	grbuild.label = usertexture.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		UserProfileID int `json:"user_profile_id,omitempty"`
+//	}
+//
+//	client.UserTexture.Query().
+//		Select(usertexture.FieldUserProfileID).
+//		Scan(ctx, &v)
+func (utq *UserTextureQuery) Select(fields ...string) *UserTextureSelect {
+	utq.ctx.Fields = append(utq.ctx.Fields, fields...)
+	sbuild := &UserTextureSelect{UserTextureQuery: utq}
+	sbuild.label = usertexture.Label
+	sbuild.flds, sbuild.scan = &utq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a UserTextureSelect configured with the given aggregations.
+func (utq *UserTextureQuery) Aggregate(fns ...AggregateFunc) *UserTextureSelect {
+	return utq.Select().Aggregate(fns...)
+}
+
+func (utq *UserTextureQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range utq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, utq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range utq.ctx.Fields {
+		if !usertexture.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if utq.path != nil {
+		prev, err := utq.path(ctx)
+		if err != nil {
+			return err
+		}
+		utq.sql = prev
+	}
+	return nil
+}
+
+func (utq *UserTextureQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*UserTexture, error) {
+	var (
+		nodes       = []*UserTexture{}
+		_spec       = utq.querySpec()
+		loadedTypes = [2]bool{
+			utq.withUserProfile != nil,
+			utq.withTexture != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*UserTexture).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &UserTexture{config: utq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	if len(utq.modifiers) > 0 {
+		_spec.Modifiers = utq.modifiers
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, utq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := utq.withUserProfile; query != nil {
+		if err := utq.loadUserProfile(ctx, query, nodes, nil,
+			func(n *UserTexture, e *UserProfile) { n.Edges.UserProfile = e }); err != nil {
+			return nil, err
+		}
+	}
+	if query := utq.withTexture; query != nil {
+		if err := utq.loadTexture(ctx, query, nodes, nil,
+			func(n *UserTexture, e *Texture) { n.Edges.Texture = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (utq *UserTextureQuery) loadUserProfile(ctx context.Context, query *UserProfileQuery, nodes []*UserTexture, init func(*UserTexture), assign func(*UserTexture, *UserProfile)) error {
+	ids := make([]int, 0, len(nodes))
+	nodeids := make(map[int][]*UserTexture)
+	for i := range nodes {
+		fk := nodes[i].UserProfileID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(userprofile.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "user_profile_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+func (utq *UserTextureQuery) loadTexture(ctx context.Context, query *TextureQuery, nodes []*UserTexture, init func(*UserTexture), assign func(*UserTexture, *Texture)) error {
+	ids := make([]int, 0, len(nodes))
+	nodeids := make(map[int][]*UserTexture)
+	for i := range nodes {
+		fk := nodes[i].TextureID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(texture.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "texture_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (utq *UserTextureQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := utq.querySpec()
+	if len(utq.modifiers) > 0 {
+		_spec.Modifiers = utq.modifiers
+	}
+	_spec.Node.Columns = utq.ctx.Fields
+	if len(utq.ctx.Fields) > 0 {
+		_spec.Unique = utq.ctx.Unique != nil && *utq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, utq.driver, _spec)
+}
+
+func (utq *UserTextureQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(usertexture.Table, usertexture.Columns, sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt))
+	_spec.From = utq.sql
+	if unique := utq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if utq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := utq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, usertexture.FieldID)
+		for i := range fields {
+			if fields[i] != usertexture.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if utq.withUserProfile != nil {
+			_spec.Node.AddColumnOnce(usertexture.FieldUserProfileID)
+		}
+		if utq.withTexture != nil {
+			_spec.Node.AddColumnOnce(usertexture.FieldTextureID)
+		}
+	}
+	if ps := utq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := utq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := utq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := utq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (utq *UserTextureQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(utq.driver.Dialect())
+	t1 := builder.Table(usertexture.Table)
+	columns := utq.ctx.Fields
+	if len(columns) == 0 {
+		columns = usertexture.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if utq.sql != nil {
+		selector = utq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if utq.ctx.Unique != nil && *utq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, m := range utq.modifiers {
+		m(selector)
+	}
+	for _, p := range utq.predicates {
+		p(selector)
+	}
+	for _, p := range utq.order {
+		p(selector)
+	}
+	if offset := utq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := utq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (utq *UserTextureQuery) ForUpdate(opts ...sql.LockOption) *UserTextureQuery {
+	if utq.driver.Dialect() == dialect.Postgres {
+		utq.Unique(false)
+	}
+	utq.modifiers = append(utq.modifiers, func(s *sql.Selector) {
+		s.ForUpdate(opts...)
+	})
+	return utq
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (utq *UserTextureQuery) ForShare(opts ...sql.LockOption) *UserTextureQuery {
+	if utq.driver.Dialect() == dialect.Postgres {
+		utq.Unique(false)
+	}
+	utq.modifiers = append(utq.modifiers, func(s *sql.Selector) {
+		s.ForShare(opts...)
+	})
+	return utq
+}
+
+// UserTextureGroupBy is the group-by builder for UserTexture entities.
+type UserTextureGroupBy struct {
+	selector
+	build *UserTextureQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (utgb *UserTextureGroupBy) Aggregate(fns ...AggregateFunc) *UserTextureGroupBy {
+	utgb.fns = append(utgb.fns, fns...)
+	return utgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (utgb *UserTextureGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, utgb.build.ctx, "GroupBy")
+	if err := utgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserTextureQuery, *UserTextureGroupBy](ctx, utgb.build, utgb, utgb.build.inters, v)
+}
+
+func (utgb *UserTextureGroupBy) sqlScan(ctx context.Context, root *UserTextureQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(utgb.fns))
+	for _, fn := range utgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*utgb.flds)+len(utgb.fns))
+		for _, f := range *utgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*utgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := utgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// UserTextureSelect is the builder for selecting fields of UserTexture entities.
+type UserTextureSelect struct {
+	*UserTextureQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (uts *UserTextureSelect) Aggregate(fns ...AggregateFunc) *UserTextureSelect {
+	uts.fns = append(uts.fns, fns...)
+	return uts
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (uts *UserTextureSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, uts.ctx, "Select")
+	if err := uts.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*UserTextureQuery, *UserTextureSelect](ctx, uts.UserTextureQuery, uts, uts.inters, v)
+}
+
+func (uts *UserTextureSelect) sqlScan(ctx context.Context, root *UserTextureQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(uts.fns))
+	for _, fn := range uts.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*uts.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := uts.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

db/ent/usertexture_update.go

@@ -0,0 +1,389 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/xmdhs/authlib-skin/db/ent/predicate"
+	"github.com/xmdhs/authlib-skin/db/ent/texture"
+	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
+)
+
+// UserTextureUpdate is the builder for updating UserTexture entities.
+type UserTextureUpdate struct {
+	config
+	hooks    []Hook
+	mutation *UserTextureMutation
+}
+
+// Where appends a list predicates to the UserTextureUpdate builder.
+func (utu *UserTextureUpdate) Where(ps ...predicate.UserTexture) *UserTextureUpdate {
+	utu.mutation.Where(ps...)
+	return utu
+}
+
+// SetUserProfileID sets the "user_profile_id" field.
+func (utu *UserTextureUpdate) SetUserProfileID(i int) *UserTextureUpdate {
+	utu.mutation.SetUserProfileID(i)
+	return utu
+}
+
+// SetTextureID sets the "texture_id" field.
+func (utu *UserTextureUpdate) SetTextureID(i int) *UserTextureUpdate {
+	utu.mutation.SetTextureID(i)
+	return utu
+}
+
+// SetUserProfile sets the "user_profile" edge to the UserProfile entity.
+func (utu *UserTextureUpdate) SetUserProfile(u *UserProfile) *UserTextureUpdate {
+	return utu.SetUserProfileID(u.ID)
+}
+
+// SetTexture sets the "texture" edge to the Texture entity.
+func (utu *UserTextureUpdate) SetTexture(t *Texture) *UserTextureUpdate {
+	return utu.SetTextureID(t.ID)
+}
+
+// Mutation returns the UserTextureMutation object of the builder.
+func (utu *UserTextureUpdate) Mutation() *UserTextureMutation {
+	return utu.mutation
+}
+
+// ClearUserProfile clears the "user_profile" edge to the UserProfile entity.
+func (utu *UserTextureUpdate) ClearUserProfile() *UserTextureUpdate {
+	utu.mutation.ClearUserProfile()
+	return utu
+}
+
+// ClearTexture clears the "texture" edge to the Texture entity.
+func (utu *UserTextureUpdate) ClearTexture() *UserTextureUpdate {
+	utu.mutation.ClearTexture()
+	return utu
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (utu *UserTextureUpdate) Save(ctx context.Context) (int, error) {
+	return withHooks(ctx, utu.sqlSave, utu.mutation, utu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (utu *UserTextureUpdate) SaveX(ctx context.Context) int {
+	affected, err := utu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (utu *UserTextureUpdate) Exec(ctx context.Context) error {
+	_, err := utu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (utu *UserTextureUpdate) ExecX(ctx context.Context) {
+	if err := utu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (utu *UserTextureUpdate) check() error {
+	if _, ok := utu.mutation.UserProfileID(); utu.mutation.UserProfileCleared() && !ok {
+		return errors.New(`ent: clearing a required unique edge "UserTexture.user_profile"`)
+	}
+	if _, ok := utu.mutation.TextureID(); utu.mutation.TextureCleared() && !ok {
+		return errors.New(`ent: clearing a required unique edge "UserTexture.texture"`)
+	}
+	return nil
+}
+
+func (utu *UserTextureUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := utu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(usertexture.Table, usertexture.Columns, sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt))
+	if ps := utu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if utu.mutation.UserProfileCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.UserProfileTable,
+			Columns: []string{usertexture.UserProfileColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := utu.mutation.UserProfileIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.UserProfileTable,
+			Columns: []string{usertexture.UserProfileColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if utu.mutation.TextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.TextureTable,
+			Columns: []string{usertexture.TextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := utu.mutation.TextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.TextureTable,
+			Columns: []string{usertexture.TextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, utu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{usertexture.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	utu.mutation.done = true
+	return n, nil
+}
+
+// UserTextureUpdateOne is the builder for updating a single UserTexture entity.
+type UserTextureUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *UserTextureMutation
+}
+
+// SetUserProfileID sets the "user_profile_id" field.
+func (utuo *UserTextureUpdateOne) SetUserProfileID(i int) *UserTextureUpdateOne {
+	utuo.mutation.SetUserProfileID(i)
+	return utuo
+}
+
+// SetTextureID sets the "texture_id" field.
+func (utuo *UserTextureUpdateOne) SetTextureID(i int) *UserTextureUpdateOne {
+	utuo.mutation.SetTextureID(i)
+	return utuo
+}
+
+// SetUserProfile sets the "user_profile" edge to the UserProfile entity.
+func (utuo *UserTextureUpdateOne) SetUserProfile(u *UserProfile) *UserTextureUpdateOne {
+	return utuo.SetUserProfileID(u.ID)
+}
+
+// SetTexture sets the "texture" edge to the Texture entity.
+func (utuo *UserTextureUpdateOne) SetTexture(t *Texture) *UserTextureUpdateOne {
+	return utuo.SetTextureID(t.ID)
+}
+
+// Mutation returns the UserTextureMutation object of the builder.
+func (utuo *UserTextureUpdateOne) Mutation() *UserTextureMutation {
+	return utuo.mutation
+}
+
+// ClearUserProfile clears the "user_profile" edge to the UserProfile entity.
+func (utuo *UserTextureUpdateOne) ClearUserProfile() *UserTextureUpdateOne {
+	utuo.mutation.ClearUserProfile()
+	return utuo
+}
+
+// ClearTexture clears the "texture" edge to the Texture entity.
+func (utuo *UserTextureUpdateOne) ClearTexture() *UserTextureUpdateOne {
+	utuo.mutation.ClearTexture()
+	return utuo
+}
+
+// Where appends a list predicates to the UserTextureUpdate builder.
+func (utuo *UserTextureUpdateOne) Where(ps ...predicate.UserTexture) *UserTextureUpdateOne {
+	utuo.mutation.Where(ps...)
+	return utuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (utuo *UserTextureUpdateOne) Select(field string, fields ...string) *UserTextureUpdateOne {
+	utuo.fields = append([]string{field}, fields...)
+	return utuo
+}
+
+// Save executes the query and returns the updated UserTexture entity.
+func (utuo *UserTextureUpdateOne) Save(ctx context.Context) (*UserTexture, error) {
+	return withHooks(ctx, utuo.sqlSave, utuo.mutation, utuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (utuo *UserTextureUpdateOne) SaveX(ctx context.Context) *UserTexture {
+	node, err := utuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (utuo *UserTextureUpdateOne) Exec(ctx context.Context) error {
+	_, err := utuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (utuo *UserTextureUpdateOne) ExecX(ctx context.Context) {
+	if err := utuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (utuo *UserTextureUpdateOne) check() error {
+	if _, ok := utuo.mutation.UserProfileID(); utuo.mutation.UserProfileCleared() && !ok {
+		return errors.New(`ent: clearing a required unique edge "UserTexture.user_profile"`)
+	}
+	if _, ok := utuo.mutation.TextureID(); utuo.mutation.TextureCleared() && !ok {
+		return errors.New(`ent: clearing a required unique edge "UserTexture.texture"`)
+	}
+	return nil
+}
+
+func (utuo *UserTextureUpdateOne) sqlSave(ctx context.Context) (_node *UserTexture, err error) {
+	if err := utuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(usertexture.Table, usertexture.Columns, sqlgraph.NewFieldSpec(usertexture.FieldID, field.TypeInt))
+	id, ok := utuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "UserTexture.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := utuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, usertexture.FieldID)
+		for _, f := range fields {
+			if !usertexture.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != usertexture.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := utuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if utuo.mutation.UserProfileCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.UserProfileTable,
+			Columns: []string{usertexture.UserProfileColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := utuo.mutation.UserProfileIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.UserProfileTable,
+			Columns: []string{usertexture.UserProfileColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(userprofile.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if utuo.mutation.TextureCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.TextureTable,
+			Columns: []string{usertexture.TextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := utuo.mutation.TextureIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: false,
+			Table:   usertexture.TextureTable,
+			Columns: []string{usertexture.TextureColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(texture.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &UserTexture{config: utuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, utuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{usertexture.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	utuo.mutation.done = true
+	return _node, nil
+}

service/yggdrasil/texture.go

@@ -13,6 +13,7 @@ import (
 	"github.com/xmdhs/authlib-skin/db/ent/texture"
 	"github.com/xmdhs/authlib-skin/db/ent/user"
 	"github.com/xmdhs/authlib-skin/db/ent/userprofile"
+	"github.com/xmdhs/authlib-skin/db/ent/usertexture"
 	"github.com/xmdhs/authlib-skin/model/yggdrasil"
 	utilsService "github.com/xmdhs/authlib-skin/service/utils"
 	"github.com/xmdhs/authlib-skin/utils"
@@ -36,7 +37,10 @@ func (y *Yggdrasil) PutTexture(ctx context.Context, token string, texturebyte []
 
 	err = utils.WithTx(ctx, y.client, func(tx *ent.Tx) error {
 		// 查找此用户该类型下是否已经存在皮肤
-		tl, err := tx.UserProfile.QueryTexture(up).Where(texture.TypeEQ(textureType)).ForUpdate().All(ctx)
+		tl, err := tx.UserTexture.Query().Where(usertexture.And(
+			usertexture.UserProfileID(up.ID),
+			usertexture.HasTextureWith(texture.Type(textureType)),
+		)).ForUpdate().All(ctx)
 		if err != nil {
 			return err
 		}
@@ -45,27 +49,34 @@ func (y *Yggdrasil) PutTexture(ctx context.Context, token string, texturebyte []
 		}
 		// 若存在，查找是否被引用
 		for _, v := range tl {
-			c, err := tx.UserProfile.Query().Where(userprofile.HasTextureWith(texture.IDEQ(v.ID))).Count(ctx)
+			c, err := tx.UserTexture.Query().Where(usertexture.TextureID(v.TextureID)).ForUpdate().Count(ctx)
 			if err != nil {
 				return err
 			}
 			if c == 1 {
 				// 若没有其他用户使用该皮肤，删除文件和记录
-				path := filepath.Join(y.TexturePath, v.TextureHash[:2], v.TextureHash[2:4], v.TextureHash)
+				t, err := tx.Texture.Query().Where(texture.ID(v.TextureID)).Only(ctx)
+				if err != nil {
+					return err
+				}
+				path := filepath.Join(y.TexturePath, t.TextureHash[:2], t.TextureHash[2:4], t.TextureHash)
 				err = os.Remove(path)
 				if err != nil {
 					return err
 				}
-				err = tx.Texture.DeleteOneID(v.ID).Exec(ctx)
+				// Texture 表中删除记录
+				err = tx.Texture.DeleteOneID(v.TextureID).Exec(ctx)
 				if err != nil {
 					return err
 				}
 			}
 		}
-		ids := lo.Map[*ent.Texture, int](tl, func(item *ent.Texture, index int) int {
+		ids := lo.Map[*ent.UserTexture, int](tl, func(item *ent.UserTexture, index int) int {
-			return item.ID
+			return item.UserProfileID
 		})
-		return tx.UserProfile.UpdateOne(up).RemoveTextureIDs(ids...).Exec(ctx)
+		// 中间表删除记录
+		_, err = tx.UserTexture.Delete().Where(usertexture.UserProfileIDIn(ids...)).Exec(ctx)
+		return err
 	})
 
 	hashstr, err := createTextureFile(y.config.TexturePath, texturebyte)
@@ -73,25 +84,12 @@ func (y *Yggdrasil) PutTexture(ctx context.Context, token string, texturebyte []
 		return fmt.Errorf("PutTexture: %w", err)
 	}
 
-	var textureEnt *ent.Texture
 	err = utils.WithTx(ctx, y.client, func(tx *ent.Tx) error {
-		textureEnt, err = tx.Texture.Query().Where(texture.TextureHashEQ(hashstr)).ForUpdate().First(ctx)
+		tx.Texture.
-		var nr *ent.NotFoundError
+
-		if err != nil && !errors.As(err, &nr) {
+
-			return err
-		}
-		if textureEnt == nil {
-			textureEnt, err = tx.Texture.Create().SetCreatedUser(up.Edges.User).
-				SetTextureHash(hashstr).
-				SetType(textureType).
-				SetVariant(model).
-				Save(ctx)
-			if err != nil {
-				return err
-			}
-		}
-		return tx.UserProfile.UpdateOne(up).AddTexture(textureEnt).Exec(ctx)
 	})
+
 	if err != nil {
 		return fmt.Errorf("PutTexture: %w", err)
 	}

service/yggdrasil/user.go

@@ -67,10 +67,6 @@ func (y *Yggdrasil) Authenticate(cxt context.Context, auth yggdrasil.Authenticat
 			if err != nil {
 				return err
 			}
-			err = tx.User.UpdateOne(u).SetToken(ut).Exec(cxt)
-			if err != nil {
-				return err
-			}
 			utoken = ut
 		}
 		return nil