✨ add mongodb/jwt

app/core/api/core.api

@@ -0,0 +1,69 @@
+syntax = "v1"
+
+info (
+	title:   "核心服务"
+	desc:    "核心服务"
+	author:  "landaiqing"
+	email:   "landaiqing@126.com"
+	version: "v1.0.0"
+)
+
+// 登录请求参数
+type (
+	// 账户登录请求参数
+	AccountLoginRequest {
+		Account   string `json:"account"`
+		Password  string `json:"password"`
+		AutoLogin bool   `json:"auto_login"`
+		Angle     int64  `json:"angle"`
+		Key       string `json:"key"`
+	}
+	// 手机号登录请求参数
+	PhoneLoginRequest {
+		Phone     string `json:"phone"`
+		Captcha   string `json:"captcha"`
+		AutoLogin bool   `json:"auto_login"`
+	}
+	// 重置密码请求参数
+	ResetPasswordRequest {
+		Phone      string `json:"phone"`
+		Captcha    string `json:"captcha"`
+		Password   string `json:"password"`
+		Repassword string `json:"repassword"`
+	}
+	// 登录响应参数
+	LoginResponse {
+		AccessToken string `json:"access_token"`
+		UID         string `json:"uid"`
+		Username    string `json:"username,optional"`
+		Nickname    string `json:"nickname"`
+		Avatar      string `json:"avatar"`
+		Status      int64  `json:"status"`
+	}
+)
+
+// 用户服务
+@server (
+	group:      user // 微服务分组
+	prefix:     /api/auth/user // 微服务前缀
+	timeout:    10s // 超时时间
+	maxBytes:   1048576 // 最大请求大小
+	signature:  true // 是否开启签名验证
+	middleware: SecurityHeadersMiddleware // 注册中间件
+	MaxConns:   true // 是否开启最大连接数限制
+	Recover:    true // 是否开启自动恢复
+)
+service core {
+	// 账户登录
+	@handler accountLogin
+	post /login (AccountLoginRequest) returns (LoginResponse)
+
+	// 手机号登录
+	@handler phoneLogin
+	post /phone_login (PhoneLoginRequest) returns (LoginResponse)
+
+	// 重置密码
+	@handler resetPassword
+	post /reset_password (ResetPasswordRequest) returns (string)
+}
+

app/core/api/core.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/config"
+	"schisandra-album-cloud-microservices/app/core/api/internal/handler"
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+	"schisandra-album-cloud-microservices/common/middleware"
+
+	"github.com/zeromicro/go-zero/core/conf"
+	"github.com/zeromicro/go-zero/rest"
+)
+
+var configFile = flag.String("f", "etc/core.yaml", "the config file")
+
+func main() {
+	flag.Parse()
+
+	var c config.Config
+	conf.MustLoad(*configFile, &c)
+
+	server := rest.MustNewServer(c.RestConf, rest.WithCustomCors(middleware.CORSMiddleware(), nil, "*"))
+	defer server.Stop()
+	// i18n middleware
+	server.Use(middleware.I18nMiddleware)
+	ctx := svc.NewServiceContext(c)
+	handler.RegisterHandlers(server, ctx)
+
+	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
+	server.Start()
+}

app/core/api/etc/core.yaml

@@ -0,0 +1,19 @@
+Name: main
+Host: 0.0.0.0
+Port: 8888
+Mysql:
+  DataSource: root:1611@tcp(localhost:3306)/schisandra-cloud-album?charset=utf8mb4&parseTime=True&loc=Local
+Auth:
+  AccessSecret: uOvKLmVfztaXGpNYd4Z0I1SiT7MweJhl
+  AccessExpire: 86400
+Redis:
+  Host: 1.95.0.111:6379
+  Type: node
+  Pass: LDQ20020618xxx
+  Tls: false
+Mongo:
+  Uri: mongodb://1.95.0.111:27017
+  Username: landaiqing
+  Password: LDQ20020618xxx
+  Database: schisandra-cloud-album
+  AuthSource: admin

app/core/api/generate.go

@@ -0,0 +1,3 @@
+package main
+
+//go:generate goctl api go -api core.api -dir . --style=go_zero

app/core/api/internal/config/config.go

@@ -0,0 +1,27 @@
+package config
+
+import "github.com/zeromicro/go-zero/rest"
+
+type Config struct {
+	rest.RestConf
+	Auth struct {
+		AccessSecret string
+		AccessExpire int64
+	}
+	Mysql struct {
+		DataSource string
+	}
+	Redis struct {
+		Host string
+		Type string
+		Pass string
+		Tls  bool
+	}
+	Mongo struct {
+		Uri        string
+		Username   string
+		Password   string
+		AuthSource string
+		Database   string
+	}
+}

app/core/api/internal/handler/routes.go

@@ -0,0 +1,43 @@
+// Code generated by goctl. DO NOT EDIT.
+// goctl 1.7.3
+
+package handler
+
+import (
+	"net/http"
+	"time"
+
+	user "schisandra-album-cloud-microservices/app/core/api/internal/handler/user"
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+
+	"github.com/zeromicro/go-zero/rest"
+)
+
+func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
+	server.AddRoutes(
+		rest.WithMiddlewares(
+			[]rest.Middleware{serverCtx.SecurityHeadersMiddleware},
+			[]rest.Route{
+				{
+					Method:  http.MethodPost,
+					Path:    "/login",
+					Handler: user.AccountLoginHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/phone_login",
+					Handler: user.PhoneLoginHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/reset_password",
+					Handler: user.ResetPasswordHandler(serverCtx),
+				},
+			}...,
+		),
+		rest.WithSignature(serverCtx.Config.Signature),
+		rest.WithPrefix("/api/auth/user"),
+		rest.WithTimeout(10000*time.Millisecond),
+		rest.WithMaxBytes(1048576),
+	)
+}

app/core/api/internal/handler/user/account_login_handler.go

@@ -0,0 +1,29 @@
+package user
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/logic/user"
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/core/api/internal/types"
+)
+
+func AccountLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.AccountLoginRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := user.NewAccountLoginLogic(r.Context(), svcCtx)
+		resp, err := l.AccountLogin(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/core/api/internal/handler/user/phone_login_handler.go

@@ -0,0 +1,29 @@
+package user
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/logic/user"
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/core/api/internal/types"
+)
+
+func PhoneLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.PhoneLoginRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := user.NewPhoneLoginLogic(r.Context(), svcCtx)
+		resp, err := l.PhoneLogin(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/core/api/internal/handler/user/reset_password_handler.go

@@ -0,0 +1,29 @@
+package user
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/logic/user"
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/core/api/internal/types"
+)
+
+func ResetPasswordHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ResetPasswordRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := user.NewResetPasswordLogic(r.Context(), svcCtx)
+		resp, err := l.ResetPassword(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/core/api/internal/logic/user/account_login_logic.go

@@ -0,0 +1,38 @@
+package user
+
+import (
+	"context"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/core/api/internal/types"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mongodb/collection"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mongodb/model"
+	"schisandra-album-cloud-microservices/common/i18n"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AccountLoginLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAccountLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AccountLoginLogic {
+	return &AccountLoginLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AccountLoginLogic) AccountLogin(req *types.AccountLoginRequest) (resp *types.LoginResponse, err error) {
+	// todo: add your logic here and delete this line
+	i18n.IsHasI18n(l.ctx)
+	text := i18n.FormatText(l.ctx, "user.name", "landaiqing")
+	collection.MustNewCollection[model.CommentImage](l.svcCtx, "comment_image")
+
+	return &types.LoginResponse{
+		AccessToken: text,
+	}, nil
+}

app/core/api/internal/logic/user/phone_login_logic.go

@@ -0,0 +1,30 @@
+package user
+
+import (
+	"context"
+
+	"github.com/zeromicro/go-zero/core/logx"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/core/api/internal/types"
+)
+
+type PhoneLoginLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewPhoneLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PhoneLoginLogic {
+	return &PhoneLoginLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *PhoneLoginLogic) PhoneLogin(req *types.PhoneLoginRequest) (resp *types.LoginResponse, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

app/core/api/internal/logic/user/reset_password_logic.go

@@ -0,0 +1,30 @@
+package user
+
+import (
+	"context"
+
+	"github.com/zeromicro/go-zero/core/logx"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/core/api/internal/types"
+)
+
+type ResetPasswordLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewResetPasswordLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ResetPasswordLogic {
+	return &ResetPasswordLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ResetPasswordLogic) ResetPassword(req *types.ResetPasswordRequest) (resp string, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

app/core/api/internal/middleware/securityheaders_middleware.go

@@ -0,0 +1,21 @@
+package middleware
+
+import (
+	"net/http"
+
+	"schisandra-album-cloud-microservices/common/middleware"
+)
+
+type SecurityHeadersMiddleware struct {
+}
+
+func NewSecurityHeadersMiddleware() *SecurityHeadersMiddleware {
+	return &SecurityHeadersMiddleware{}
+}
+
+func (m *SecurityHeadersMiddleware) Handle(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		middleware.SecurityHeadersMiddleware(w, r)
+		next(w, r)
+	}
+}

app/core/api/internal/svc/service_context.go

@@ -0,0 +1,37 @@
+package svc
+
+import (
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"github.com/zeromicro/go-zero/rest"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/config"
+	"schisandra-album-cloud-microservices/app/core/api/internal/middleware"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mongodb"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql"
+)
+
+type ServiceContext struct {
+	Config                    config.Config
+	SecurityHeadersMiddleware rest.Middleware
+	MySQLClient               *ent.Client
+	RedisClient               *redis.Redis
+	MongoClient               *mongo.Database
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	return &ServiceContext{
+		Config:                    c,
+		SecurityHeadersMiddleware: middleware.NewSecurityHeadersMiddleware().Handle,
+		MySQLClient:               mysql.NewMySQL(c.Mysql.DataSource),
+		RedisClient: redis.MustNewRedis(redis.RedisConf{
+			Host: c.Redis.Host,
+			Pass: c.Redis.Pass,
+			Type: c.Redis.Type,
+			Tls:  c.Redis.Tls,
+		}),
+		MongoClient: mongodb.NewMongoDB(c.Mongo.Uri, c.Mongo.Username, c.Mongo.Password, c.Mongo.AuthSource, c.Mongo.Database),
+	}
+}

app/core/api/internal/types/types.go

@@ -0,0 +1,34 @@
+// Code generated by goctl. DO NOT EDIT.
+// goctl 1.7.3
+
+package types
+
+type AccountLoginRequest struct {
+	Account   string `json:"account"`
+	Password  string `json:"password"`
+	AutoLogin bool   `json:"auto_login"`
+	Angle     int64  `json:"angle"`
+	Key       string `json:"key"`
+}
+
+type LoginResponse struct {
+	AccessToken string `json:"access_token"`
+	UID         string `json:"uid"`
+	Username    string `json:"username,optional"`
+	Nickname    string `json:"nickname"`
+	Avatar      string `json:"avatar"`
+	Status      int64  `json:"status"`
+}
+
+type PhoneLoginRequest struct {
+	Phone     string `json:"phone"`
+	Captcha   string `json:"captcha"`
+	AutoLogin bool   `json:"auto_login"`
+}
+
+type ResetPasswordRequest struct {
+	Phone      string `json:"phone"`
+	Captcha    string `json:"captcha"`
+	Password   string `json:"password"`
+	Repassword string `json:"repassword"`
+}

app/core/api/repository/mongodb/collection/collection.go

@@ -0,0 +1,13 @@
+package collection
+
+import (
+	"github.com/chenmingyong0423/go-mongox/v2"
+
+	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
+)
+
+// MustNewCollection creates a new Collection instance with the given name.
+func MustNewCollection[T any](svcCtx *svc.ServiceContext, collectionName string) *mongox.Collection[T] {
+	collection := svcCtx.MongoClient.Collection(collectionName)
+	return mongox.NewCollection[T](collection)
+}

app/core/api/repository/mongodb/init.go

@@ -0,0 +1,28 @@
+package mongodb
+
+import (
+	"context"
+	"log"
+
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
+	"go.mongodb.org/mongo-driver/v2/mongo/readpref"
+)
+
+// NewMongoDB initializes the MongoDB connection and returns the database object
+func NewMongoDB(uri string, username string, password string, authSource string, database string) *mongo.Database {
+	client, err := mongo.Connect(options.Client().ApplyURI(uri).SetAuth(options.Credential{
+		Username:   username,
+		Password:   password,
+		AuthSource: authSource,
+	}))
+	if err != nil {
+		log.Panic(err)
+	}
+	err = client.Ping(context.Background(), readpref.Primary())
+	if err != nil {
+		log.Panic(err)
+	}
+	db := client.Database(database)
+	return db
+}

app/core/api/repository/mongodb/model/comment_image.go

@@ -0,0 +1,11 @@
+package model
+
+import "github.com/chenmingyong0423/go-mongox/v2"
+
+type CommentImage struct {
+	mongox.Model `bson:",inline"`
+	TopicID      string   `bson:"topic_id"`
+	CommentID    string   `bson:"comment_id"`
+	UserID       string   `bson:"user_id"`
+	Images       []string `bson:"images"`
+}

app/core/api/repository/mysql/ent/ent.go

@@ -0,0 +1,616 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+	"sync"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+// ent aliases to avoid import conflicts in user's code.
+type (
+	Op            = ent.Op
+	Hook          = ent.Hook
+	Value         = ent.Value
+	Query         = ent.Query
+	QueryContext  = ent.QueryContext
+	Querier       = ent.Querier
+	QuerierFunc   = ent.QuerierFunc
+	Interceptor   = ent.Interceptor
+	InterceptFunc = ent.InterceptFunc
+	Traverser     = ent.Traverser
+	TraverseFunc  = ent.TraverseFunc
+	Policy        = ent.Policy
+	Mutator       = ent.Mutator
+	Mutation      = ent.Mutation
+	MutateFunc    = ent.MutateFunc
+)
+
+type clientCtxKey struct{}
+
+// FromContext returns a Client stored inside a context, or nil if there isn't one.
+func FromContext(ctx context.Context) *Client {
+	c, _ := ctx.Value(clientCtxKey{}).(*Client)
+	return c
+}
+
+// NewContext returns a new context with the given Client attached.
+func NewContext(parent context.Context, c *Client) context.Context {
+	return context.WithValue(parent, clientCtxKey{}, c)
+}
+
+type txCtxKey struct{}
+
+// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
+func TxFromContext(ctx context.Context) *Tx {
+	tx, _ := ctx.Value(txCtxKey{}).(*Tx)
+	return tx
+}
+
+// NewTxContext returns a new context with the given Tx attached.
+func NewTxContext(parent context.Context, tx *Tx) context.Context {
+	return context.WithValue(parent, txCtxKey{}, tx)
+}
+
+// OrderFunc applies an ordering on the sql selector.
+// Deprecated: Use Asc/Desc functions or the package builders instead.
+type OrderFunc func(*sql.Selector)
+
+var (
+	initCheck   sync.Once
+	columnCheck sql.ColumnCheck
+)
+
+// checkColumn checks if the column exists in the given table.
+func checkColumn(table, column string) error {
+	initCheck.Do(func() {
+		columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
+			scaauthpermissionrule.Table: scaauthpermissionrule.ValidColumn,
+			scaauthrole.Table:           scaauthrole.ValidColumn,
+			scaauthuser.Table:           scaauthuser.ValidColumn,
+			scaauthuserdevice.Table:     scaauthuserdevice.ValidColumn,
+			scaauthusersocial.Table:     scaauthusersocial.ValidColumn,
+		})
+	})
+	return columnCheck(table, column)
+}
+
+// Asc applies the given fields in ASC order.
+func Asc(fields ...string) func(*sql.Selector) {
+	return func(s *sql.Selector) {
+		for _, f := range fields {
+			if err := checkColumn(s.TableName(), f); err != nil {
+				s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
+			}
+			s.OrderBy(sql.Asc(s.C(f)))
+		}
+	}
+}
+
+// Desc applies the given fields in DESC order.
+func Desc(fields ...string) func(*sql.Selector) {
+	return func(s *sql.Selector) {
+		for _, f := range fields {
+			if err := checkColumn(s.TableName(), f); err != nil {
+				s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
+			}
+			s.OrderBy(sql.Desc(s.C(f)))
+		}
+	}
+}
+
+// AggregateFunc applies an aggregation step on the group-by traversal/selector.
+type AggregateFunc func(*sql.Selector) string
+
+// As is a pseudo aggregation function for renaming another other functions with custom names. For example:
+//
+//	GroupBy(field1, field2).
+//	Aggregate(ent.As(ent.Sum(field1), "sum_field1"), (ent.As(ent.Sum(field2), "sum_field2")).
+//	Scan(ctx, &v)
+func As(fn AggregateFunc, end string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		return sql.As(fn(s), end)
+	}
+}
+
+// Count applies the "count" aggregation function on each group.
+func Count() AggregateFunc {
+	return func(s *sql.Selector) string {
+		return sql.Count("*")
+	}
+}
+
+// Max applies the "max" aggregation function on the given field of each group.
+func Max(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
+			return ""
+		}
+		return sql.Max(s.C(field))
+	}
+}
+
+// Mean applies the "mean" aggregation function on the given field of each group.
+func Mean(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
+			return ""
+		}
+		return sql.Avg(s.C(field))
+	}
+}
+
+// Min applies the "min" aggregation function on the given field of each group.
+func Min(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
+			return ""
+		}
+		return sql.Min(s.C(field))
+	}
+}
+
+// Sum applies the "sum" aggregation function on the given field of each group.
+func Sum(field string) AggregateFunc {
+	return func(s *sql.Selector) string {
+		if err := checkColumn(s.TableName(), field); err != nil {
+			s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
+			return ""
+		}
+		return sql.Sum(s.C(field))
+	}
+}
+
+// ValidationError returns when validating a field or edge fails.
+type ValidationError struct {
+	Name string // Field or edge name.
+	err  error
+}
+
+// Error implements the error interface.
+func (e *ValidationError) Error() string {
+	return e.err.Error()
+}
+
+// Unwrap implements the errors.Wrapper interface.
+func (e *ValidationError) Unwrap() error {
+	return e.err
+}
+
+// IsValidationError returns a boolean indicating whether the error is a validation error.
+func IsValidationError(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *ValidationError
+	return errors.As(err, &e)
+}
+
+// NotFoundError returns when trying to fetch a specific entity and it was not found in the database.
+type NotFoundError struct {
+	label string
+}
+
+// Error implements the error interface.
+func (e *NotFoundError) Error() string {
+	return "ent: " + e.label + " not found"
+}
+
+// IsNotFound returns a boolean indicating whether the error is a not found error.
+func IsNotFound(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *NotFoundError
+	return errors.As(err, &e)
+}
+
+// MaskNotFound masks not found error.
+func MaskNotFound(err error) error {
+	if IsNotFound(err) {
+		return nil
+	}
+	return err
+}
+
+// NotSingularError returns when trying to fetch a singular entity and more then one was found in the database.
+type NotSingularError struct {
+	label string
+}
+
+// Error implements the error interface.
+func (e *NotSingularError) Error() string {
+	return "ent: " + e.label + " not singular"
+}
+
+// IsNotSingular returns a boolean indicating whether the error is a not singular error.
+func IsNotSingular(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *NotSingularError
+	return errors.As(err, &e)
+}
+
+// NotLoadedError returns when trying to get a node that was not loaded by the query.
+type NotLoadedError struct {
+	edge string
+}
+
+// Error implements the error interface.
+func (e *NotLoadedError) Error() string {
+	return "ent: " + e.edge + " edge was not loaded"
+}
+
+// IsNotLoaded returns a boolean indicating whether the error is a not loaded error.
+func IsNotLoaded(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *NotLoadedError
+	return errors.As(err, &e)
+}
+
+// ConstraintError returns when trying to create/update one or more entities and
+// one or more of their constraints failed. For example, violation of edge or
+// field uniqueness.
+type ConstraintError struct {
+	msg  string
+	wrap error
+}
+
+// Error implements the error interface.
+func (e ConstraintError) Error() string {
+	return "ent: constraint failed: " + e.msg
+}
+
+// Unwrap implements the errors.Wrapper interface.
+func (e *ConstraintError) Unwrap() error {
+	return e.wrap
+}
+
+// IsConstraintError returns a boolean indicating whether the error is a constraint failure.
+func IsConstraintError(err error) bool {
+	if err == nil {
+		return false
+	}
+	var e *ConstraintError
+	return errors.As(err, &e)
+}
+
+// selector embedded by the different Select/GroupBy builders.
+type selector struct {
+	label string
+	flds  *[]string
+	fns   []AggregateFunc
+	scan  func(context.Context, any) error
+}
+
+// ScanX is like Scan, but panics if an error occurs.
+func (s *selector) ScanX(ctx context.Context, v any) {
+	if err := s.scan(ctx, v); err != nil {
+		panic(err)
+	}
+}
+
+// Strings returns list of strings from a selector. It is only allowed when selecting one field.
+func (s *selector) Strings(ctx context.Context) ([]string, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("ent: Strings is not achievable when selecting more than 1 field")
+	}
+	var v []string
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// StringsX is like Strings, but panics if an error occurs.
+func (s *selector) StringsX(ctx context.Context) []string {
+	v, err := s.Strings(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// String returns a single string from a selector. It is only allowed when selecting one field.
+func (s *selector) String(ctx context.Context) (_ string, err error) {
+	var v []string
+	if v, err = s.Strings(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("ent: Strings returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// StringX is like String, but panics if an error occurs.
+func (s *selector) StringX(ctx context.Context) string {
+	v, err := s.String(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Ints returns list of ints from a selector. It is only allowed when selecting one field.
+func (s *selector) Ints(ctx context.Context) ([]int, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("ent: Ints is not achievable when selecting more than 1 field")
+	}
+	var v []int
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// IntsX is like Ints, but panics if an error occurs.
+func (s *selector) IntsX(ctx context.Context) []int {
+	v, err := s.Ints(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Int returns a single int from a selector. It is only allowed when selecting one field.
+func (s *selector) Int(ctx context.Context) (_ int, err error) {
+	var v []int
+	if v, err = s.Ints(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("ent: Ints returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// IntX is like Int, but panics if an error occurs.
+func (s *selector) IntX(ctx context.Context) int {
+	v, err := s.Int(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Float64s returns list of float64s from a selector. It is only allowed when selecting one field.
+func (s *selector) Float64s(ctx context.Context) ([]float64, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("ent: Float64s is not achievable when selecting more than 1 field")
+	}
+	var v []float64
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// Float64sX is like Float64s, but panics if an error occurs.
+func (s *selector) Float64sX(ctx context.Context) []float64 {
+	v, err := s.Float64s(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Float64 returns a single float64 from a selector. It is only allowed when selecting one field.
+func (s *selector) Float64(ctx context.Context) (_ float64, err error) {
+	var v []float64
+	if v, err = s.Float64s(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("ent: Float64s returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// Float64X is like Float64, but panics if an error occurs.
+func (s *selector) Float64X(ctx context.Context) float64 {
+	v, err := s.Float64(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Bools returns list of bools from a selector. It is only allowed when selecting one field.
+func (s *selector) Bools(ctx context.Context) ([]bool, error) {
+	if len(*s.flds) > 1 {
+		return nil, errors.New("ent: Bools is not achievable when selecting more than 1 field")
+	}
+	var v []bool
+	if err := s.scan(ctx, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+// BoolsX is like Bools, but panics if an error occurs.
+func (s *selector) BoolsX(ctx context.Context) []bool {
+	v, err := s.Bools(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Bool returns a single bool from a selector. It is only allowed when selecting one field.
+func (s *selector) Bool(ctx context.Context) (_ bool, err error) {
+	var v []bool
+	if v, err = s.Bools(ctx); err != nil {
+		return
+	}
+	switch len(v) {
+	case 1:
+		return v[0], nil
+	case 0:
+		err = &NotFoundError{s.label}
+	default:
+		err = fmt.Errorf("ent: Bools returned %d results when one was expected", len(v))
+	}
+	return
+}
+
+// BoolX is like Bool, but panics if an error occurs.
+func (s *selector) BoolX(ctx context.Context) bool {
+	v, err := s.Bool(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// withHooks invokes the builder operation with the given hooks, if any.
+func withHooks[V Value, M any, PM interface {
+	*M
+	Mutation
+}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) {
+	if len(hooks) == 0 {
+		return exec(ctx)
+	}
+	var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+		mutationT, ok := any(m).(PM)
+		if !ok {
+			return nil, fmt.Errorf("unexpected mutation type %T", m)
+		}
+		// Set the mutation to the builder.
+		*mutation = *mutationT
+		return exec(ctx)
+	})
+	for i := len(hooks) - 1; i >= 0; i-- {
+		if hooks[i] == nil {
+			return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
+		}
+		mut = hooks[i](mut)
+	}
+	v, err := mut.Mutate(ctx, mutation)
+	if err != nil {
+		return value, err
+	}
+	nv, ok := v.(V)
+	if !ok {
+		return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation)
+	}
+	return nv, nil
+}
+
+// setContextOp returns a new context with the given QueryContext attached (including its op) in case it does not exist.
+func setContextOp(ctx context.Context, qc *QueryContext, op string) context.Context {
+	if ent.QueryFromContext(ctx) == nil {
+		qc.Op = op
+		ctx = ent.NewQueryContext(ctx, qc)
+	}
+	return ctx
+}
+
+func querierAll[V Value, Q interface {
+	sqlAll(context.Context, ...queryHook) (V, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlAll(ctx)
+	})
+}
+
+func querierCount[Q interface {
+	sqlCount(context.Context) (int, error)
+}]() Querier {
+	return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		return query.sqlCount(ctx)
+	})
+}
+
+func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) {
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	rv, err := qr.Query(ctx, q)
+	if err != nil {
+		return v, err
+	}
+	vt, ok := rv.(V)
+	if !ok {
+		return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v)
+	}
+	return vt, nil
+}
+
+func scanWithInterceptors[Q1 ent.Query, Q2 interface {
+	sqlScan(context.Context, Q1, any) error
+}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error {
+	rv := reflect.ValueOf(v)
+	var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+		query, ok := q.(Q1)
+		if !ok {
+			return nil, fmt.Errorf("unexpected query type %T", q)
+		}
+		if err := selectOrGroup.sqlScan(ctx, query, v); err != nil {
+			return nil, err
+		}
+		if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() {
+			return rv.Elem().Interface(), nil
+		}
+		return v, nil
+	})
+	for i := len(inters) - 1; i >= 0; i-- {
+		qr = inters[i].Intercept(qr)
+	}
+	vv, err := qr.Query(ctx, rootQuery)
+	if err != nil {
+		return err
+	}
+	switch rv2 := reflect.ValueOf(vv); {
+	case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer:
+	case rv.Type() == rv2.Type():
+		rv.Elem().Set(rv2.Elem())
+	case rv.Elem().Type() == rv2.Type():
+		rv.Elem().Set(rv2)
+	}
+	return nil
+}
+
+// queryHook describes an internal hook for the different sqlAll methods.
+type queryHook func(context.Context, *sqlgraph.QuerySpec)

app/core/api/repository/mysql/ent/entql.go

@@ -0,0 +1,756 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/entql"
+	"entgo.io/ent/schema/field"
+)
+
+// schemaGraph holds a representation of ent/schema at runtime.
+var schemaGraph = func() *sqlgraph.Schema {
+	graph := &sqlgraph.Schema{Nodes: make([]*sqlgraph.Node, 5)}
+	graph.Nodes[0] = &sqlgraph.Node{
+		NodeSpec: sqlgraph.NodeSpec{
+			Table:   scaauthpermissionrule.Table,
+			Columns: scaauthpermissionrule.Columns,
+			ID: &sqlgraph.FieldSpec{
+				Type:   field.TypeInt64,
+				Column: scaauthpermissionrule.FieldID,
+			},
+		},
+		Type: "ScaAuthPermissionRule",
+		Fields: map[string]*sqlgraph.FieldSpec{
+			scaauthpermissionrule.FieldPtype: {Type: field.TypeString, Column: scaauthpermissionrule.FieldPtype},
+			scaauthpermissionrule.FieldV0:    {Type: field.TypeString, Column: scaauthpermissionrule.FieldV0},
+			scaauthpermissionrule.FieldV1:    {Type: field.TypeString, Column: scaauthpermissionrule.FieldV1},
+			scaauthpermissionrule.FieldV2:    {Type: field.TypeString, Column: scaauthpermissionrule.FieldV2},
+			scaauthpermissionrule.FieldV3:    {Type: field.TypeString, Column: scaauthpermissionrule.FieldV3},
+			scaauthpermissionrule.FieldV4:    {Type: field.TypeString, Column: scaauthpermissionrule.FieldV4},
+			scaauthpermissionrule.FieldV5:    {Type: field.TypeString, Column: scaauthpermissionrule.FieldV5},
+		},
+	}
+	graph.Nodes[1] = &sqlgraph.Node{
+		NodeSpec: sqlgraph.NodeSpec{
+			Table:   scaauthrole.Table,
+			Columns: scaauthrole.Columns,
+			ID: &sqlgraph.FieldSpec{
+				Type:   field.TypeInt64,
+				Column: scaauthrole.FieldID,
+			},
+		},
+		Type: "ScaAuthRole",
+		Fields: map[string]*sqlgraph.FieldSpec{
+			scaauthrole.FieldCreatedAt: {Type: field.TypeTime, Column: scaauthrole.FieldCreatedAt},
+			scaauthrole.FieldUpdatedAt: {Type: field.TypeTime, Column: scaauthrole.FieldUpdatedAt},
+			scaauthrole.FieldDeleted:   {Type: field.TypeInt8, Column: scaauthrole.FieldDeleted},
+			scaauthrole.FieldRoleName:  {Type: field.TypeString, Column: scaauthrole.FieldRoleName},
+			scaauthrole.FieldRoleKey:   {Type: field.TypeString, Column: scaauthrole.FieldRoleKey},
+		},
+	}
+	graph.Nodes[2] = &sqlgraph.Node{
+		NodeSpec: sqlgraph.NodeSpec{
+			Table:   scaauthuser.Table,
+			Columns: scaauthuser.Columns,
+			ID: &sqlgraph.FieldSpec{
+				Type:   field.TypeInt64,
+				Column: scaauthuser.FieldID,
+			},
+		},
+		Type: "ScaAuthUser",
+		Fields: map[string]*sqlgraph.FieldSpec{
+			scaauthuser.FieldCreatedAt: {Type: field.TypeTime, Column: scaauthuser.FieldCreatedAt},
+			scaauthuser.FieldUpdatedAt: {Type: field.TypeTime, Column: scaauthuser.FieldUpdatedAt},
+			scaauthuser.FieldDeleted:   {Type: field.TypeInt8, Column: scaauthuser.FieldDeleted},
+			scaauthuser.FieldUID:       {Type: field.TypeString, Column: scaauthuser.FieldUID},
+			scaauthuser.FieldUsername:  {Type: field.TypeString, Column: scaauthuser.FieldUsername},
+			scaauthuser.FieldNickname:  {Type: field.TypeString, Column: scaauthuser.FieldNickname},
+			scaauthuser.FieldEmail:     {Type: field.TypeString, Column: scaauthuser.FieldEmail},
+			scaauthuser.FieldPhone:     {Type: field.TypeString, Column: scaauthuser.FieldPhone},
+			scaauthuser.FieldPassword:  {Type: field.TypeString, Column: scaauthuser.FieldPassword},
+			scaauthuser.FieldGender:    {Type: field.TypeString, Column: scaauthuser.FieldGender},
+			scaauthuser.FieldAvatar:    {Type: field.TypeString, Column: scaauthuser.FieldAvatar},
+			scaauthuser.FieldStatus:    {Type: field.TypeInt8, Column: scaauthuser.FieldStatus},
+			scaauthuser.FieldIntroduce: {Type: field.TypeString, Column: scaauthuser.FieldIntroduce},
+			scaauthuser.FieldBlog:      {Type: field.TypeString, Column: scaauthuser.FieldBlog},
+			scaauthuser.FieldLocation:  {Type: field.TypeString, Column: scaauthuser.FieldLocation},
+			scaauthuser.FieldCompany:   {Type: field.TypeString, Column: scaauthuser.FieldCompany},
+		},
+	}
+	graph.Nodes[3] = &sqlgraph.Node{
+		NodeSpec: sqlgraph.NodeSpec{
+			Table:   scaauthuserdevice.Table,
+			Columns: scaauthuserdevice.Columns,
+			ID: &sqlgraph.FieldSpec{
+				Type:   field.TypeInt64,
+				Column: scaauthuserdevice.FieldID,
+			},
+		},
+		Type: "ScaAuthUserDevice",
+		Fields: map[string]*sqlgraph.FieldSpec{
+			scaauthuserdevice.FieldCreatedAt:       {Type: field.TypeTime, Column: scaauthuserdevice.FieldCreatedAt},
+			scaauthuserdevice.FieldUpdatedAt:       {Type: field.TypeTime, Column: scaauthuserdevice.FieldUpdatedAt},
+			scaauthuserdevice.FieldDeleted:         {Type: field.TypeInt8, Column: scaauthuserdevice.FieldDeleted},
+			scaauthuserdevice.FieldUserID:          {Type: field.TypeString, Column: scaauthuserdevice.FieldUserID},
+			scaauthuserdevice.FieldIP:              {Type: field.TypeString, Column: scaauthuserdevice.FieldIP},
+			scaauthuserdevice.FieldLocation:        {Type: field.TypeString, Column: scaauthuserdevice.FieldLocation},
+			scaauthuserdevice.FieldAgent:           {Type: field.TypeString, Column: scaauthuserdevice.FieldAgent},
+			scaauthuserdevice.FieldBrowser:         {Type: field.TypeString, Column: scaauthuserdevice.FieldBrowser},
+			scaauthuserdevice.FieldOperatingSystem: {Type: field.TypeString, Column: scaauthuserdevice.FieldOperatingSystem},
+			scaauthuserdevice.FieldBrowserVersion:  {Type: field.TypeString, Column: scaauthuserdevice.FieldBrowserVersion},
+			scaauthuserdevice.FieldMobile:          {Type: field.TypeInt, Column: scaauthuserdevice.FieldMobile},
+			scaauthuserdevice.FieldBot:             {Type: field.TypeInt, Column: scaauthuserdevice.FieldBot},
+			scaauthuserdevice.FieldMozilla:         {Type: field.TypeString, Column: scaauthuserdevice.FieldMozilla},
+			scaauthuserdevice.FieldPlatform:        {Type: field.TypeString, Column: scaauthuserdevice.FieldPlatform},
+			scaauthuserdevice.FieldEngineName:      {Type: field.TypeString, Column: scaauthuserdevice.FieldEngineName},
+			scaauthuserdevice.FieldEngineVersion:   {Type: field.TypeString, Column: scaauthuserdevice.FieldEngineVersion},
+		},
+	}
+	graph.Nodes[4] = &sqlgraph.Node{
+		NodeSpec: sqlgraph.NodeSpec{
+			Table:   scaauthusersocial.Table,
+			Columns: scaauthusersocial.Columns,
+			ID: &sqlgraph.FieldSpec{
+				Type:   field.TypeInt64,
+				Column: scaauthusersocial.FieldID,
+			},
+		},
+		Type: "ScaAuthUserSocial",
+		Fields: map[string]*sqlgraph.FieldSpec{
+			scaauthusersocial.FieldCreatedAt: {Type: field.TypeTime, Column: scaauthusersocial.FieldCreatedAt},
+			scaauthusersocial.FieldUpdatedAt: {Type: field.TypeTime, Column: scaauthusersocial.FieldUpdatedAt},
+			scaauthusersocial.FieldDeleted:   {Type: field.TypeInt8, Column: scaauthusersocial.FieldDeleted},
+			scaauthusersocial.FieldUserID:    {Type: field.TypeString, Column: scaauthusersocial.FieldUserID},
+			scaauthusersocial.FieldOpenID:    {Type: field.TypeString, Column: scaauthusersocial.FieldOpenID},
+			scaauthusersocial.FieldSource:    {Type: field.TypeString, Column: scaauthusersocial.FieldSource},
+			scaauthusersocial.FieldStatus:    {Type: field.TypeInt, Column: scaauthusersocial.FieldStatus},
+		},
+	}
+	graph.MustAddE(
+		"sca_auth_role",
+		&sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthpermissionrule.ScaAuthRoleTable,
+			Columns: []string{scaauthpermissionrule.ScaAuthRoleColumn},
+			Bidi:    false,
+		},
+		"ScaAuthPermissionRule",
+		"ScaAuthRole",
+	)
+	graph.MustAddE(
+		"sca_auth_permission_rule",
+		&sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+		},
+		"ScaAuthRole",
+		"ScaAuthPermissionRule",
+	)
+	graph.MustAddE(
+		"sca_auth_user_social",
+		&sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthuser.ScaAuthUserSocialTable,
+			Columns: []string{scaauthuser.ScaAuthUserSocialColumn},
+			Bidi:    false,
+		},
+		"ScaAuthUser",
+		"ScaAuthUserSocial",
+	)
+	graph.MustAddE(
+		"sca_auth_user_device",
+		&sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthuser.ScaAuthUserDeviceTable,
+			Columns: []string{scaauthuser.ScaAuthUserDeviceColumn},
+			Bidi:    false,
+		},
+		"ScaAuthUser",
+		"ScaAuthUserDevice",
+	)
+	graph.MustAddE(
+		"sca_auth_user",
+		&sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthuserdevice.ScaAuthUserTable,
+			Columns: []string{scaauthuserdevice.ScaAuthUserColumn},
+			Bidi:    false,
+		},
+		"ScaAuthUserDevice",
+		"ScaAuthUser",
+	)
+	graph.MustAddE(
+		"sca_auth_user",
+		&sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthusersocial.ScaAuthUserTable,
+			Columns: []string{scaauthusersocial.ScaAuthUserColumn},
+			Bidi:    false,
+		},
+		"ScaAuthUserSocial",
+		"ScaAuthUser",
+	)
+	return graph
+}()
+
+// predicateAdder wraps the addPredicate method.
+// All update, update-one and query builders implement this interface.
+type predicateAdder interface {
+	addPredicate(func(s *sql.Selector))
+}
+
+// addPredicate implements the predicateAdder interface.
+func (saprq *ScaAuthPermissionRuleQuery) addPredicate(pred func(s *sql.Selector)) {
+	saprq.predicates = append(saprq.predicates, pred)
+}
+
+// Filter returns a Filter implementation to apply filters on the ScaAuthPermissionRuleQuery builder.
+func (saprq *ScaAuthPermissionRuleQuery) Filter() *ScaAuthPermissionRuleFilter {
+	return &ScaAuthPermissionRuleFilter{config: saprq.config, predicateAdder: saprq}
+}
+
+// addPredicate implements the predicateAdder interface.
+func (m *ScaAuthPermissionRuleMutation) addPredicate(pred func(s *sql.Selector)) {
+	m.predicates = append(m.predicates, pred)
+}
+
+// Filter returns an entql.Where implementation to apply filters on the ScaAuthPermissionRuleMutation builder.
+func (m *ScaAuthPermissionRuleMutation) Filter() *ScaAuthPermissionRuleFilter {
+	return &ScaAuthPermissionRuleFilter{config: m.config, predicateAdder: m}
+}
+
+// ScaAuthPermissionRuleFilter provides a generic filtering capability at runtime for ScaAuthPermissionRuleQuery.
+type ScaAuthPermissionRuleFilter struct {
+	predicateAdder
+	config
+}
+
+// Where applies the entql predicate on the query filter.
+func (f *ScaAuthPermissionRuleFilter) Where(p entql.P) {
+	f.addPredicate(func(s *sql.Selector) {
+		if err := schemaGraph.EvalP(schemaGraph.Nodes[0].Type, p, s); err != nil {
+			s.AddError(err)
+		}
+	})
+}
+
+// WhereID applies the entql int64 predicate on the id field.
+func (f *ScaAuthPermissionRuleFilter) WhereID(p entql.Int64P) {
+	f.Where(p.Field(scaauthpermissionrule.FieldID))
+}
+
+// WherePtype applies the entql string predicate on the ptype field.
+func (f *ScaAuthPermissionRuleFilter) WherePtype(p entql.StringP) {
+	f.Where(p.Field(scaauthpermissionrule.FieldPtype))
+}
+
+// WhereV0 applies the entql string predicate on the v0 field.
+func (f *ScaAuthPermissionRuleFilter) WhereV0(p entql.StringP) {
+	f.Where(p.Field(scaauthpermissionrule.FieldV0))
+}
+
+// WhereV1 applies the entql string predicate on the v1 field.
+func (f *ScaAuthPermissionRuleFilter) WhereV1(p entql.StringP) {
+	f.Where(p.Field(scaauthpermissionrule.FieldV1))
+}
+
+// WhereV2 applies the entql string predicate on the v2 field.
+func (f *ScaAuthPermissionRuleFilter) WhereV2(p entql.StringP) {
+	f.Where(p.Field(scaauthpermissionrule.FieldV2))
+}
+
+// WhereV3 applies the entql string predicate on the v3 field.
+func (f *ScaAuthPermissionRuleFilter) WhereV3(p entql.StringP) {
+	f.Where(p.Field(scaauthpermissionrule.FieldV3))
+}
+
+// WhereV4 applies the entql string predicate on the v4 field.
+func (f *ScaAuthPermissionRuleFilter) WhereV4(p entql.StringP) {
+	f.Where(p.Field(scaauthpermissionrule.FieldV4))
+}
+
+// WhereV5 applies the entql string predicate on the v5 field.
+func (f *ScaAuthPermissionRuleFilter) WhereV5(p entql.StringP) {
+	f.Where(p.Field(scaauthpermissionrule.FieldV5))
+}
+
+// WhereHasScaAuthRole applies a predicate to check if query has an edge sca_auth_role.
+func (f *ScaAuthPermissionRuleFilter) WhereHasScaAuthRole() {
+	f.Where(entql.HasEdge("sca_auth_role"))
+}
+
+// WhereHasScaAuthRoleWith applies a predicate to check if query has an edge sca_auth_role with a given conditions (other predicates).
+func (f *ScaAuthPermissionRuleFilter) WhereHasScaAuthRoleWith(preds ...predicate.ScaAuthRole) {
+	f.Where(entql.HasEdgeWith("sca_auth_role", sqlgraph.WrapFunc(func(s *sql.Selector) {
+		for _, p := range preds {
+			p(s)
+		}
+	})))
+}
+
+// addPredicate implements the predicateAdder interface.
+func (sarq *ScaAuthRoleQuery) addPredicate(pred func(s *sql.Selector)) {
+	sarq.predicates = append(sarq.predicates, pred)
+}
+
+// Filter returns a Filter implementation to apply filters on the ScaAuthRoleQuery builder.
+func (sarq *ScaAuthRoleQuery) Filter() *ScaAuthRoleFilter {
+	return &ScaAuthRoleFilter{config: sarq.config, predicateAdder: sarq}
+}
+
+// addPredicate implements the predicateAdder interface.
+func (m *ScaAuthRoleMutation) addPredicate(pred func(s *sql.Selector)) {
+	m.predicates = append(m.predicates, pred)
+}
+
+// Filter returns an entql.Where implementation to apply filters on the ScaAuthRoleMutation builder.
+func (m *ScaAuthRoleMutation) Filter() *ScaAuthRoleFilter {
+	return &ScaAuthRoleFilter{config: m.config, predicateAdder: m}
+}
+
+// ScaAuthRoleFilter provides a generic filtering capability at runtime for ScaAuthRoleQuery.
+type ScaAuthRoleFilter struct {
+	predicateAdder
+	config
+}
+
+// Where applies the entql predicate on the query filter.
+func (f *ScaAuthRoleFilter) Where(p entql.P) {
+	f.addPredicate(func(s *sql.Selector) {
+		if err := schemaGraph.EvalP(schemaGraph.Nodes[1].Type, p, s); err != nil {
+			s.AddError(err)
+		}
+	})
+}
+
+// WhereID applies the entql int64 predicate on the id field.
+func (f *ScaAuthRoleFilter) WhereID(p entql.Int64P) {
+	f.Where(p.Field(scaauthrole.FieldID))
+}
+
+// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
+func (f *ScaAuthRoleFilter) WhereCreatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthrole.FieldCreatedAt))
+}
+
+// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
+func (f *ScaAuthRoleFilter) WhereUpdatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthrole.FieldUpdatedAt))
+}
+
+// WhereDeleted applies the entql int8 predicate on the deleted field.
+func (f *ScaAuthRoleFilter) WhereDeleted(p entql.Int8P) {
+	f.Where(p.Field(scaauthrole.FieldDeleted))
+}
+
+// WhereRoleName applies the entql string predicate on the role_name field.
+func (f *ScaAuthRoleFilter) WhereRoleName(p entql.StringP) {
+	f.Where(p.Field(scaauthrole.FieldRoleName))
+}
+
+// WhereRoleKey applies the entql string predicate on the role_key field.
+func (f *ScaAuthRoleFilter) WhereRoleKey(p entql.StringP) {
+	f.Where(p.Field(scaauthrole.FieldRoleKey))
+}
+
+// WhereHasScaAuthPermissionRule applies a predicate to check if query has an edge sca_auth_permission_rule.
+func (f *ScaAuthRoleFilter) WhereHasScaAuthPermissionRule() {
+	f.Where(entql.HasEdge("sca_auth_permission_rule"))
+}
+
+// WhereHasScaAuthPermissionRuleWith applies a predicate to check if query has an edge sca_auth_permission_rule with a given conditions (other predicates).
+func (f *ScaAuthRoleFilter) WhereHasScaAuthPermissionRuleWith(preds ...predicate.ScaAuthPermissionRule) {
+	f.Where(entql.HasEdgeWith("sca_auth_permission_rule", sqlgraph.WrapFunc(func(s *sql.Selector) {
+		for _, p := range preds {
+			p(s)
+		}
+	})))
+}
+
+// addPredicate implements the predicateAdder interface.
+func (sauq *ScaAuthUserQuery) addPredicate(pred func(s *sql.Selector)) {
+	sauq.predicates = append(sauq.predicates, pred)
+}
+
+// Filter returns a Filter implementation to apply filters on the ScaAuthUserQuery builder.
+func (sauq *ScaAuthUserQuery) Filter() *ScaAuthUserFilter {
+	return &ScaAuthUserFilter{config: sauq.config, predicateAdder: sauq}
+}
+
+// addPredicate implements the predicateAdder interface.
+func (m *ScaAuthUserMutation) addPredicate(pred func(s *sql.Selector)) {
+	m.predicates = append(m.predicates, pred)
+}
+
+// Filter returns an entql.Where implementation to apply filters on the ScaAuthUserMutation builder.
+func (m *ScaAuthUserMutation) Filter() *ScaAuthUserFilter {
+	return &ScaAuthUserFilter{config: m.config, predicateAdder: m}
+}
+
+// ScaAuthUserFilter provides a generic filtering capability at runtime for ScaAuthUserQuery.
+type ScaAuthUserFilter struct {
+	predicateAdder
+	config
+}
+
+// Where applies the entql predicate on the query filter.
+func (f *ScaAuthUserFilter) Where(p entql.P) {
+	f.addPredicate(func(s *sql.Selector) {
+		if err := schemaGraph.EvalP(schemaGraph.Nodes[2].Type, p, s); err != nil {
+			s.AddError(err)
+		}
+	})
+}
+
+// WhereID applies the entql int64 predicate on the id field.
+func (f *ScaAuthUserFilter) WhereID(p entql.Int64P) {
+	f.Where(p.Field(scaauthuser.FieldID))
+}
+
+// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
+func (f *ScaAuthUserFilter) WhereCreatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthuser.FieldCreatedAt))
+}
+
+// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
+func (f *ScaAuthUserFilter) WhereUpdatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthuser.FieldUpdatedAt))
+}
+
+// WhereDeleted applies the entql int8 predicate on the deleted field.
+func (f *ScaAuthUserFilter) WhereDeleted(p entql.Int8P) {
+	f.Where(p.Field(scaauthuser.FieldDeleted))
+}
+
+// WhereUID applies the entql string predicate on the uid field.
+func (f *ScaAuthUserFilter) WhereUID(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldUID))
+}
+
+// WhereUsername applies the entql string predicate on the username field.
+func (f *ScaAuthUserFilter) WhereUsername(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldUsername))
+}
+
+// WhereNickname applies the entql string predicate on the nickname field.
+func (f *ScaAuthUserFilter) WhereNickname(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldNickname))
+}
+
+// WhereEmail applies the entql string predicate on the email field.
+func (f *ScaAuthUserFilter) WhereEmail(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldEmail))
+}
+
+// WherePhone applies the entql string predicate on the phone field.
+func (f *ScaAuthUserFilter) WherePhone(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldPhone))
+}
+
+// WherePassword applies the entql string predicate on the password field.
+func (f *ScaAuthUserFilter) WherePassword(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldPassword))
+}
+
+// WhereGender applies the entql string predicate on the gender field.
+func (f *ScaAuthUserFilter) WhereGender(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldGender))
+}
+
+// WhereAvatar applies the entql string predicate on the avatar field.
+func (f *ScaAuthUserFilter) WhereAvatar(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldAvatar))
+}
+
+// WhereStatus applies the entql int8 predicate on the status field.
+func (f *ScaAuthUserFilter) WhereStatus(p entql.Int8P) {
+	f.Where(p.Field(scaauthuser.FieldStatus))
+}
+
+// WhereIntroduce applies the entql string predicate on the introduce field.
+func (f *ScaAuthUserFilter) WhereIntroduce(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldIntroduce))
+}
+
+// WhereBlog applies the entql string predicate on the blog field.
+func (f *ScaAuthUserFilter) WhereBlog(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldBlog))
+}
+
+// WhereLocation applies the entql string predicate on the location field.
+func (f *ScaAuthUserFilter) WhereLocation(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldLocation))
+}
+
+// WhereCompany applies the entql string predicate on the company field.
+func (f *ScaAuthUserFilter) WhereCompany(p entql.StringP) {
+	f.Where(p.Field(scaauthuser.FieldCompany))
+}
+
+// WhereHasScaAuthUserSocial applies a predicate to check if query has an edge sca_auth_user_social.
+func (f *ScaAuthUserFilter) WhereHasScaAuthUserSocial() {
+	f.Where(entql.HasEdge("sca_auth_user_social"))
+}
+
+// WhereHasScaAuthUserSocialWith applies a predicate to check if query has an edge sca_auth_user_social with a given conditions (other predicates).
+func (f *ScaAuthUserFilter) WhereHasScaAuthUserSocialWith(preds ...predicate.ScaAuthUserSocial) {
+	f.Where(entql.HasEdgeWith("sca_auth_user_social", sqlgraph.WrapFunc(func(s *sql.Selector) {
+		for _, p := range preds {
+			p(s)
+		}
+	})))
+}
+
+// WhereHasScaAuthUserDevice applies a predicate to check if query has an edge sca_auth_user_device.
+func (f *ScaAuthUserFilter) WhereHasScaAuthUserDevice() {
+	f.Where(entql.HasEdge("sca_auth_user_device"))
+}
+
+// WhereHasScaAuthUserDeviceWith applies a predicate to check if query has an edge sca_auth_user_device with a given conditions (other predicates).
+func (f *ScaAuthUserFilter) WhereHasScaAuthUserDeviceWith(preds ...predicate.ScaAuthUserDevice) {
+	f.Where(entql.HasEdgeWith("sca_auth_user_device", sqlgraph.WrapFunc(func(s *sql.Selector) {
+		for _, p := range preds {
+			p(s)
+		}
+	})))
+}
+
+// addPredicate implements the predicateAdder interface.
+func (saudq *ScaAuthUserDeviceQuery) addPredicate(pred func(s *sql.Selector)) {
+	saudq.predicates = append(saudq.predicates, pred)
+}
+
+// Filter returns a Filter implementation to apply filters on the ScaAuthUserDeviceQuery builder.
+func (saudq *ScaAuthUserDeviceQuery) Filter() *ScaAuthUserDeviceFilter {
+	return &ScaAuthUserDeviceFilter{config: saudq.config, predicateAdder: saudq}
+}
+
+// addPredicate implements the predicateAdder interface.
+func (m *ScaAuthUserDeviceMutation) addPredicate(pred func(s *sql.Selector)) {
+	m.predicates = append(m.predicates, pred)
+}
+
+// Filter returns an entql.Where implementation to apply filters on the ScaAuthUserDeviceMutation builder.
+func (m *ScaAuthUserDeviceMutation) Filter() *ScaAuthUserDeviceFilter {
+	return &ScaAuthUserDeviceFilter{config: m.config, predicateAdder: m}
+}
+
+// ScaAuthUserDeviceFilter provides a generic filtering capability at runtime for ScaAuthUserDeviceQuery.
+type ScaAuthUserDeviceFilter struct {
+	predicateAdder
+	config
+}
+
+// Where applies the entql predicate on the query filter.
+func (f *ScaAuthUserDeviceFilter) Where(p entql.P) {
+	f.addPredicate(func(s *sql.Selector) {
+		if err := schemaGraph.EvalP(schemaGraph.Nodes[3].Type, p, s); err != nil {
+			s.AddError(err)
+		}
+	})
+}
+
+// WhereID applies the entql int64 predicate on the id field.
+func (f *ScaAuthUserDeviceFilter) WhereID(p entql.Int64P) {
+	f.Where(p.Field(scaauthuserdevice.FieldID))
+}
+
+// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
+func (f *ScaAuthUserDeviceFilter) WhereCreatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthuserdevice.FieldCreatedAt))
+}
+
+// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
+func (f *ScaAuthUserDeviceFilter) WhereUpdatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthuserdevice.FieldUpdatedAt))
+}
+
+// WhereDeleted applies the entql int8 predicate on the deleted field.
+func (f *ScaAuthUserDeviceFilter) WhereDeleted(p entql.Int8P) {
+	f.Where(p.Field(scaauthuserdevice.FieldDeleted))
+}
+
+// WhereUserID applies the entql string predicate on the user_id field.
+func (f *ScaAuthUserDeviceFilter) WhereUserID(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldUserID))
+}
+
+// WhereIP applies the entql string predicate on the ip field.
+func (f *ScaAuthUserDeviceFilter) WhereIP(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldIP))
+}
+
+// WhereLocation applies the entql string predicate on the location field.
+func (f *ScaAuthUserDeviceFilter) WhereLocation(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldLocation))
+}
+
+// WhereAgent applies the entql string predicate on the agent field.
+func (f *ScaAuthUserDeviceFilter) WhereAgent(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldAgent))
+}
+
+// WhereBrowser applies the entql string predicate on the browser field.
+func (f *ScaAuthUserDeviceFilter) WhereBrowser(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldBrowser))
+}
+
+// WhereOperatingSystem applies the entql string predicate on the operating_system field.
+func (f *ScaAuthUserDeviceFilter) WhereOperatingSystem(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldOperatingSystem))
+}
+
+// WhereBrowserVersion applies the entql string predicate on the browser_version field.
+func (f *ScaAuthUserDeviceFilter) WhereBrowserVersion(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldBrowserVersion))
+}
+
+// WhereMobile applies the entql int predicate on the mobile field.
+func (f *ScaAuthUserDeviceFilter) WhereMobile(p entql.IntP) {
+	f.Where(p.Field(scaauthuserdevice.FieldMobile))
+}
+
+// WhereBot applies the entql int predicate on the bot field.
+func (f *ScaAuthUserDeviceFilter) WhereBot(p entql.IntP) {
+	f.Where(p.Field(scaauthuserdevice.FieldBot))
+}
+
+// WhereMozilla applies the entql string predicate on the mozilla field.
+func (f *ScaAuthUserDeviceFilter) WhereMozilla(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldMozilla))
+}
+
+// WherePlatform applies the entql string predicate on the platform field.
+func (f *ScaAuthUserDeviceFilter) WherePlatform(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldPlatform))
+}
+
+// WhereEngineName applies the entql string predicate on the engine_name field.
+func (f *ScaAuthUserDeviceFilter) WhereEngineName(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldEngineName))
+}
+
+// WhereEngineVersion applies the entql string predicate on the engine_version field.
+func (f *ScaAuthUserDeviceFilter) WhereEngineVersion(p entql.StringP) {
+	f.Where(p.Field(scaauthuserdevice.FieldEngineVersion))
+}
+
+// WhereHasScaAuthUser applies a predicate to check if query has an edge sca_auth_user.
+func (f *ScaAuthUserDeviceFilter) WhereHasScaAuthUser() {
+	f.Where(entql.HasEdge("sca_auth_user"))
+}
+
+// WhereHasScaAuthUserWith applies a predicate to check if query has an edge sca_auth_user with a given conditions (other predicates).
+func (f *ScaAuthUserDeviceFilter) WhereHasScaAuthUserWith(preds ...predicate.ScaAuthUser) {
+	f.Where(entql.HasEdgeWith("sca_auth_user", sqlgraph.WrapFunc(func(s *sql.Selector) {
+		for _, p := range preds {
+			p(s)
+		}
+	})))
+}
+
+// addPredicate implements the predicateAdder interface.
+func (sausq *ScaAuthUserSocialQuery) addPredicate(pred func(s *sql.Selector)) {
+	sausq.predicates = append(sausq.predicates, pred)
+}
+
+// Filter returns a Filter implementation to apply filters on the ScaAuthUserSocialQuery builder.
+func (sausq *ScaAuthUserSocialQuery) Filter() *ScaAuthUserSocialFilter {
+	return &ScaAuthUserSocialFilter{config: sausq.config, predicateAdder: sausq}
+}
+
+// addPredicate implements the predicateAdder interface.
+func (m *ScaAuthUserSocialMutation) addPredicate(pred func(s *sql.Selector)) {
+	m.predicates = append(m.predicates, pred)
+}
+
+// Filter returns an entql.Where implementation to apply filters on the ScaAuthUserSocialMutation builder.
+func (m *ScaAuthUserSocialMutation) Filter() *ScaAuthUserSocialFilter {
+	return &ScaAuthUserSocialFilter{config: m.config, predicateAdder: m}
+}
+
+// ScaAuthUserSocialFilter provides a generic filtering capability at runtime for ScaAuthUserSocialQuery.
+type ScaAuthUserSocialFilter struct {
+	predicateAdder
+	config
+}
+
+// Where applies the entql predicate on the query filter.
+func (f *ScaAuthUserSocialFilter) Where(p entql.P) {
+	f.addPredicate(func(s *sql.Selector) {
+		if err := schemaGraph.EvalP(schemaGraph.Nodes[4].Type, p, s); err != nil {
+			s.AddError(err)
+		}
+	})
+}
+
+// WhereID applies the entql int64 predicate on the id field.
+func (f *ScaAuthUserSocialFilter) WhereID(p entql.Int64P) {
+	f.Where(p.Field(scaauthusersocial.FieldID))
+}
+
+// WhereCreatedAt applies the entql time.Time predicate on the created_at field.
+func (f *ScaAuthUserSocialFilter) WhereCreatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthusersocial.FieldCreatedAt))
+}
+
+// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field.
+func (f *ScaAuthUserSocialFilter) WhereUpdatedAt(p entql.TimeP) {
+	f.Where(p.Field(scaauthusersocial.FieldUpdatedAt))
+}
+
+// WhereDeleted applies the entql int8 predicate on the deleted field.
+func (f *ScaAuthUserSocialFilter) WhereDeleted(p entql.Int8P) {
+	f.Where(p.Field(scaauthusersocial.FieldDeleted))
+}
+
+// WhereUserID applies the entql string predicate on the user_id field.
+func (f *ScaAuthUserSocialFilter) WhereUserID(p entql.StringP) {
+	f.Where(p.Field(scaauthusersocial.FieldUserID))
+}
+
+// WhereOpenID applies the entql string predicate on the open_id field.
+func (f *ScaAuthUserSocialFilter) WhereOpenID(p entql.StringP) {
+	f.Where(p.Field(scaauthusersocial.FieldOpenID))
+}
+
+// WhereSource applies the entql string predicate on the source field.
+func (f *ScaAuthUserSocialFilter) WhereSource(p entql.StringP) {
+	f.Where(p.Field(scaauthusersocial.FieldSource))
+}
+
+// WhereStatus applies the entql int predicate on the status field.
+func (f *ScaAuthUserSocialFilter) WhereStatus(p entql.IntP) {
+	f.Where(p.Field(scaauthusersocial.FieldStatus))
+}
+
+// WhereHasScaAuthUser applies a predicate to check if query has an edge sca_auth_user.
+func (f *ScaAuthUserSocialFilter) WhereHasScaAuthUser() {
+	f.Where(entql.HasEdge("sca_auth_user"))
+}
+
+// WhereHasScaAuthUserWith applies a predicate to check if query has an edge sca_auth_user with a given conditions (other predicates).
+func (f *ScaAuthUserSocialFilter) WhereHasScaAuthUserWith(preds ...predicate.ScaAuthUser) {
+	f.Where(entql.HasEdgeWith("sca_auth_user", sqlgraph.WrapFunc(func(s *sql.Selector) {
+		for _, p := range preds {
+			p(s)
+		}
+	})))
+}

app/core/api/repository/mysql/ent/enttest/enttest.go

@@ -0,0 +1,85 @@
+// Code generated by ent, DO NOT EDIT.
+
+package enttest
+
+import (
+	"context"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent"
+	// required by schema hooks.
+	_ "schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/runtime"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/migrate"
+
+	"entgo.io/ent/dialect/sql/schema"
+)
+
+type (
+	// TestingT is the interface that is shared between
+	// testing.T and testing.B and used by enttest.
+	TestingT interface {
+		FailNow()
+		Error(...any)
+	}
+
+	// Option configures client creation.
+	Option func(*options)
+
+	options struct {
+		opts        []ent.Option
+		migrateOpts []schema.MigrateOption
+	}
+)
+
+// WithOptions forwards options to client creation.
+func WithOptions(opts ...ent.Option) Option {
+	return func(o *options) {
+		o.opts = append(o.opts, opts...)
+	}
+}
+
+// WithMigrateOptions forwards options to auto migration.
+func WithMigrateOptions(opts ...schema.MigrateOption) Option {
+	return func(o *options) {
+		o.migrateOpts = append(o.migrateOpts, opts...)
+	}
+}
+
+func newOptions(opts []Option) *options {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+	return o
+}
+
+// Open calls ent.Open and auto-run migration.
+func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *ent.Client {
+	o := newOptions(opts)
+	c, err := ent.Open(driverName, dataSourceName, o.opts...)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	migrateSchema(t, c, o)
+	return c
+}
+
+// NewClient calls ent.NewClient and auto-run migration.
+func NewClient(t TestingT, opts ...Option) *ent.Client {
+	o := newOptions(opts)
+	c := ent.NewClient(o.opts...)
+	migrateSchema(t, c, o)
+	return c
+}
+func migrateSchema(t TestingT, c *ent.Client, o *options) {
+	tables, err := schema.CopyTables(migrate.Tables)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	if err := migrate.Create(context.Background(), c.Schema, tables, o.migrateOpts...); err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+}

app/core/api/repository/mysql/ent/hook/hook.go

@@ -0,0 +1,246 @@
+// Code generated by ent, DO NOT EDIT.
+
+package hook
+
+import (
+	"context"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent"
+)
+
+// The ScaAuthPermissionRuleFunc type is an adapter to allow the use of ordinary
+// function as ScaAuthPermissionRule mutator.
+type ScaAuthPermissionRuleFunc func(context.Context, *ent.ScaAuthPermissionRuleMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ScaAuthPermissionRuleFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.ScaAuthPermissionRuleMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ScaAuthPermissionRuleMutation", m)
+}
+
+// The ScaAuthRoleFunc type is an adapter to allow the use of ordinary
+// function as ScaAuthRole mutator.
+type ScaAuthRoleFunc func(context.Context, *ent.ScaAuthRoleMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ScaAuthRoleFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.ScaAuthRoleMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ScaAuthRoleMutation", m)
+}
+
+// The ScaAuthUserFunc type is an adapter to allow the use of ordinary
+// function as ScaAuthUser mutator.
+type ScaAuthUserFunc func(context.Context, *ent.ScaAuthUserMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ScaAuthUserFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.ScaAuthUserMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ScaAuthUserMutation", m)
+}
+
+// The ScaAuthUserDeviceFunc type is an adapter to allow the use of ordinary
+// function as ScaAuthUserDevice mutator.
+type ScaAuthUserDeviceFunc func(context.Context, *ent.ScaAuthUserDeviceMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ScaAuthUserDeviceFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.ScaAuthUserDeviceMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ScaAuthUserDeviceMutation", m)
+}
+
+// The ScaAuthUserSocialFunc type is an adapter to allow the use of ordinary
+// function as ScaAuthUserSocial mutator.
+type ScaAuthUserSocialFunc func(context.Context, *ent.ScaAuthUserSocialMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ScaAuthUserSocialFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.ScaAuthUserSocialMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ScaAuthUserSocialMutation", m)
+}
+
+// Condition is a hook condition function.
+type Condition func(context.Context, ent.Mutation) bool
+
+// And groups conditions with the AND operator.
+func And(first, second Condition, rest ...Condition) Condition {
+	return func(ctx context.Context, m ent.Mutation) bool {
+		if !first(ctx, m) || !second(ctx, m) {
+			return false
+		}
+		for _, cond := range rest {
+			if !cond(ctx, m) {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// Or groups conditions with the OR operator.
+func Or(first, second Condition, rest ...Condition) Condition {
+	return func(ctx context.Context, m ent.Mutation) bool {
+		if first(ctx, m) || second(ctx, m) {
+			return true
+		}
+		for _, cond := range rest {
+			if cond(ctx, m) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// Not negates a given condition.
+func Not(cond Condition) Condition {
+	return func(ctx context.Context, m ent.Mutation) bool {
+		return !cond(ctx, m)
+	}
+}
+
+// HasOp is a condition testing mutation operation.
+func HasOp(op ent.Op) Condition {
+	return func(_ context.Context, m ent.Mutation) bool {
+		return m.Op().Is(op)
+	}
+}
+
+// HasAddedFields is a condition validating `.AddedField` on fields.
+func HasAddedFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m ent.Mutation) bool {
+		if _, exists := m.AddedField(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if _, exists := m.AddedField(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// HasClearedFields is a condition validating `.FieldCleared` on fields.
+func HasClearedFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m ent.Mutation) bool {
+		if exists := m.FieldCleared(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if exists := m.FieldCleared(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// HasFields is a condition validating `.Field` on fields.
+func HasFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m ent.Mutation) bool {
+		if _, exists := m.Field(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if _, exists := m.Field(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// If executes the given hook under condition.
+//
+//	hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
+func If(hk ent.Hook, cond Condition) ent.Hook {
+	return func(next ent.Mutator) ent.Mutator {
+		return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+			if cond(ctx, m) {
+				return hk(next).Mutate(ctx, m)
+			}
+			return next.Mutate(ctx, m)
+		})
+	}
+}
+
+// On executes the given hook only for the given operation.
+//
+//	hook.On(Log, ent.Delete|ent.Create)
+func On(hk ent.Hook, op ent.Op) ent.Hook {
+	return If(hk, HasOp(op))
+}
+
+// Unless skips the given hook only for the given operation.
+//
+//	hook.Unless(Log, ent.Update|ent.UpdateOne)
+func Unless(hk ent.Hook, op ent.Op) ent.Hook {
+	return If(hk, Not(HasOp(op)))
+}
+
+// FixedError is a hook returning a fixed error.
+func FixedError(err error) ent.Hook {
+	return func(ent.Mutator) ent.Mutator {
+		return ent.MutateFunc(func(context.Context, ent.Mutation) (ent.Value, error) {
+			return nil, err
+		})
+	}
+}
+
+// Reject returns a hook that rejects all operations that match op.
+//
+//	func (T) Hooks() []ent.Hook {
+//		return []ent.Hook{
+//			Reject(ent.Delete|ent.Update),
+//		}
+//	}
+func Reject(op ent.Op) ent.Hook {
+	hk := FixedError(fmt.Errorf("%s operation is not allowed", op))
+	return On(hk, op)
+}
+
+// Chain acts as a list of hooks and is effectively immutable.
+// Once created, it will always hold the same set of hooks in the same order.
+type Chain struct {
+	hooks []ent.Hook
+}
+
+// NewChain creates a new chain of hooks.
+func NewChain(hooks ...ent.Hook) Chain {
+	return Chain{append([]ent.Hook(nil), hooks...)}
+}
+
+// Hook chains the list of hooks and returns the final hook.
+func (c Chain) Hook() ent.Hook {
+	return func(mutator ent.Mutator) ent.Mutator {
+		for i := len(c.hooks) - 1; i >= 0; i-- {
+			mutator = c.hooks[i](mutator)
+		}
+		return mutator
+	}
+}
+
+// Append extends a chain, adding the specified hook
+// as the last ones in the mutation flow.
+func (c Chain) Append(hooks ...ent.Hook) Chain {
+	newHooks := make([]ent.Hook, 0, len(c.hooks)+len(hooks))
+	newHooks = append(newHooks, c.hooks...)
+	newHooks = append(newHooks, hooks...)
+	return Chain{newHooks}
+}
+
+// Extend extends a chain, adding the specified chain
+// as the last ones in the mutation flow.
+func (c Chain) Extend(chain Chain) Chain {
+	return c.Append(chain.hooks...)
+}

app/core/api/repository/mysql/ent/migrate/migrate.go

@@ -0,0 +1,64 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql/schema"
+)
+
+var (
+	// WithGlobalUniqueID sets the universal ids options to the migration.
+	// If this option is enabled, ent migration will allocate a 1<<32 range
+	// for the ids of each entity (table).
+	// Note that this option cannot be applied on tables that already exist.
+	WithGlobalUniqueID = schema.WithGlobalUniqueID
+	// WithDropColumn sets the drop column option to the migration.
+	// If this option is enabled, ent migration will drop old columns
+	// that were used for both fields and edges. This defaults to false.
+	WithDropColumn = schema.WithDropColumn
+	// WithDropIndex sets the drop index option to the migration.
+	// If this option is enabled, ent migration will drop old indexes
+	// that were defined in the schema. This defaults to false.
+	// Note that unique constraints are defined using `UNIQUE INDEX`,
+	// and therefore, it's recommended to enable this option to get more
+	// flexibility in the schema changes.
+	WithDropIndex = schema.WithDropIndex
+	// WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true.
+	WithForeignKeys = schema.WithForeignKeys
+)
+
+// Schema is the API for creating, migrating and dropping a schema.
+type Schema struct {
+	drv dialect.Driver
+}
+
+// NewSchema creates a new schema client.
+func NewSchema(drv dialect.Driver) *Schema { return &Schema{drv: drv} }
+
+// Create creates all schema resources.
+func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error {
+	return Create(ctx, s, Tables, opts...)
+}
+
+// Create creates all table resources using the given schema driver.
+func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error {
+	migrate, err := schema.NewMigrate(s.drv, opts...)
+	if err != nil {
+		return fmt.Errorf("ent/migrate: %w", err)
+	}
+	return migrate.Create(ctx, tables...)
+}
+
+// WriteTo writes the schema changes to w instead of running them against the database.
+//
+//	if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil {
+//		log.Fatal(err)
+//	}
+func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error {
+	return Create(ctx, &Schema{drv: &schema.WriteDriver{Writer: w, Driver: s.drv}}, Tables, opts...)
+}

app/core/api/repository/mysql/ent/migrate/schema.go

@@ -0,0 +1,215 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/dialect/sql/schema"
+	"entgo.io/ent/schema/field"
+)
+
+var (
+	// ScaAuthPermissionRuleColumns holds the columns for the "sca_auth_permission_rule" table.
+	ScaAuthPermissionRuleColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, SchemaType: map[string]string{"mysql": "bigint(20) unsigned"}},
+		{Name: "ptype", Type: field.TypeString, Size: 100},
+		{Name: "v0", Type: field.TypeString, Size: 100},
+		{Name: "v1", Type: field.TypeString, Size: 100},
+		{Name: "v2", Type: field.TypeString, Nullable: true, Size: 100},
+		{Name: "v3", Type: field.TypeString, Nullable: true, Size: 100},
+		{Name: "v4", Type: field.TypeString, Nullable: true, Size: 100},
+		{Name: "v5", Type: field.TypeString, Nullable: true, Size: 100},
+		{Name: "sca_auth_role_sca_auth_permission_rule", Type: field.TypeInt64, Nullable: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+	}
+	// ScaAuthPermissionRuleTable holds the schema information for the "sca_auth_permission_rule" table.
+	ScaAuthPermissionRuleTable = &schema.Table{
+		Name:       "sca_auth_permission_rule",
+		Comment:    "角色权限规则表",
+		Columns:    ScaAuthPermissionRuleColumns,
+		PrimaryKey: []*schema.Column{ScaAuthPermissionRuleColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sca_auth_permission_rule_sca_auth_role_sca_auth_permission_rule",
+				Columns:    []*schema.Column{ScaAuthPermissionRuleColumns[8]},
+				RefColumns: []*schema.Column{ScaAuthRoleColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+	}
+	// ScaAuthRoleColumns holds the columns for the "sca_auth_role" table.
+	ScaAuthRoleColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, Comment: "主键ID", SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "created_at", Type: field.TypeTime, Comment: "创建时间"},
+		{Name: "updated_at", Type: field.TypeTime, Comment: "更新时间"},
+		{Name: "deleted", Type: field.TypeInt8, Nullable: true, Comment: "是否删除 0 未删除 1 已删除", Default: 0},
+		{Name: "role_name", Type: field.TypeString, Size: 32, Comment: "角色名称"},
+		{Name: "role_key", Type: field.TypeString, Size: 64, Comment: "角色关键字"},
+	}
+	// ScaAuthRoleTable holds the schema information for the "sca_auth_role" table.
+	ScaAuthRoleTable = &schema.Table{
+		Name:       "sca_auth_role",
+		Comment:    "角色表",
+		Columns:    ScaAuthRoleColumns,
+		PrimaryKey: []*schema.Column{ScaAuthRoleColumns[0]},
+	}
+	// ScaAuthUserColumns holds the columns for the "sca_auth_user" table.
+	ScaAuthUserColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, Comment: "自增ID", SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "created_at", Type: field.TypeTime, Comment: "创建时间"},
+		{Name: "updated_at", Type: field.TypeTime, Comment: "更新时间"},
+		{Name: "deleted", Type: field.TypeInt8, Nullable: true, Comment: "是否删除 0 未删除 1 已删除", Default: 0},
+		{Name: "uid", Type: field.TypeString, Unique: true, Size: 20, Comment: "唯一ID"},
+		{Name: "username", Type: field.TypeString, Nullable: true, Size: 32, Comment: "用户名"},
+		{Name: "nickname", Type: field.TypeString, Nullable: true, Size: 32, Comment: "昵称"},
+		{Name: "email", Type: field.TypeString, Nullable: true, Size: 32, Comment: "邮箱"},
+		{Name: "phone", Type: field.TypeString, Nullable: true, Size: 32, Comment: "电话"},
+		{Name: "password", Type: field.TypeString, Nullable: true, Size: 64, Comment: "密码"},
+		{Name: "gender", Type: field.TypeString, Nullable: true, Size: 32, Comment: "性别"},
+		{Name: "avatar", Type: field.TypeString, Nullable: true, Comment: "头像"},
+		{Name: "status", Type: field.TypeInt8, Nullable: true, Comment: "状态 0 正常 1 封禁", Default: 0},
+		{Name: "introduce", Type: field.TypeString, Nullable: true, Size: 255, Comment: "介绍"},
+		{Name: "blog", Type: field.TypeString, Nullable: true, Size: 30, Comment: "博客"},
+		{Name: "location", Type: field.TypeString, Nullable: true, Size: 50, Comment: "地址"},
+		{Name: "company", Type: field.TypeString, Nullable: true, Size: 50, Comment: "公司"},
+	}
+	// ScaAuthUserTable holds the schema information for the "sca_auth_user" table.
+	ScaAuthUserTable = &schema.Table{
+		Name:       "sca_auth_user",
+		Comment:    "用户表",
+		Columns:    ScaAuthUserColumns,
+		PrimaryKey: []*schema.Column{ScaAuthUserColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "scaauthuser_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserColumns[0]},
+			},
+			{
+				Name:    "scaauthuser_uid",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserColumns[4]},
+			},
+			{
+				Name:    "scaauthuser_phone",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserColumns[8]},
+			},
+		},
+	}
+	// ScaAuthUserDeviceColumns holds the columns for the "sca_auth_user_device" table.
+	ScaAuthUserDeviceColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, Comment: "主键ID", SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "created_at", Type: field.TypeTime, Comment: "创建时间"},
+		{Name: "updated_at", Type: field.TypeTime, Comment: "更新时间"},
+		{Name: "deleted", Type: field.TypeInt8, Nullable: true, Comment: "是否删除 0 未删除 1 已删除", Default: 0},
+		{Name: "user_id", Type: field.TypeString, Size: 20, Comment: "用户ID"},
+		{Name: "ip", Type: field.TypeString, Size: 20, Comment: "登录IP"},
+		{Name: "location", Type: field.TypeString, Size: 20, Comment: "地址"},
+		{Name: "agent", Type: field.TypeString, Size: 255, Comment: "设备信息"},
+		{Name: "browser", Type: field.TypeString, Size: 20, Comment: "浏览器"},
+		{Name: "operating_system", Type: field.TypeString, Size: 20, Comment: "操作系统"},
+		{Name: "browser_version", Type: field.TypeString, Size: 20, Comment: "浏览器版本"},
+		{Name: "mobile", Type: field.TypeInt, Comment: "是否为手机 0否1是"},
+		{Name: "bot", Type: field.TypeInt, Comment: "是否为bot 0否1是"},
+		{Name: "mozilla", Type: field.TypeString, Size: 10, Comment: "火狐版本"},
+		{Name: "platform", Type: field.TypeString, Size: 20, Comment: "平台"},
+		{Name: "engine_name", Type: field.TypeString, Size: 20, Comment: "引擎名称"},
+		{Name: "engine_version", Type: field.TypeString, Size: 20, Comment: "引擎版本"},
+		{Name: "sca_auth_user_sca_auth_user_device", Type: field.TypeInt64, Nullable: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+	}
+	// ScaAuthUserDeviceTable holds the schema information for the "sca_auth_user_device" table.
+	ScaAuthUserDeviceTable = &schema.Table{
+		Name:       "sca_auth_user_device",
+		Comment:    "用户设备表",
+		Columns:    ScaAuthUserDeviceColumns,
+		PrimaryKey: []*schema.Column{ScaAuthUserDeviceColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sca_auth_user_device_sca_auth_user_sca_auth_user_device",
+				Columns:    []*schema.Column{ScaAuthUserDeviceColumns[17]},
+				RefColumns: []*schema.Column{ScaAuthUserColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "scaauthuserdevice_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserDeviceColumns[0]},
+			},
+		},
+	}
+	// ScaAuthUserSocialColumns holds the columns for the "sca_auth_user_social" table.
+	ScaAuthUserSocialColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, Comment: "主键ID", SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "created_at", Type: field.TypeTime, Comment: "创建时间"},
+		{Name: "updated_at", Type: field.TypeTime, Comment: "更新时间"},
+		{Name: "deleted", Type: field.TypeInt8, Nullable: true, Comment: "是否删除 0 未删除 1 已删除", Default: 0},
+		{Name: "user_id", Type: field.TypeString, Size: 20, Comment: "用户ID"},
+		{Name: "open_id", Type: field.TypeString, Size: 50, Comment: "第三方用户的 open id"},
+		{Name: "source", Type: field.TypeString, Size: 10, Comment: "第三方用户来源"},
+		{Name: "status", Type: field.TypeInt, Comment: "状态 0正常 1 封禁", Default: 0},
+		{Name: "sca_auth_user_sca_auth_user_social", Type: field.TypeInt64, Nullable: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+	}
+	// ScaAuthUserSocialTable holds the schema information for the "sca_auth_user_social" table.
+	ScaAuthUserSocialTable = &schema.Table{
+		Name:       "sca_auth_user_social",
+		Comment:    "用户第三方登录信息",
+		Columns:    ScaAuthUserSocialColumns,
+		PrimaryKey: []*schema.Column{ScaAuthUserSocialColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sca_auth_user_social_sca_auth_user_sca_auth_user_social",
+				Columns:    []*schema.Column{ScaAuthUserSocialColumns[8]},
+				RefColumns: []*schema.Column{ScaAuthUserColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "scaauthusersocial_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserSocialColumns[0]},
+			},
+			{
+				Name:    "scaauthusersocial_user_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserSocialColumns[4]},
+			},
+			{
+				Name:    "scaauthusersocial_open_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserSocialColumns[5]},
+			},
+		},
+	}
+	// Tables holds all the tables in the schema.
+	Tables = []*schema.Table{
+		ScaAuthPermissionRuleTable,
+		ScaAuthRoleTable,
+		ScaAuthUserTable,
+		ScaAuthUserDeviceTable,
+		ScaAuthUserSocialTable,
+	}
+)
+
+func init() {
+	ScaAuthPermissionRuleTable.ForeignKeys[0].RefTable = ScaAuthRoleTable
+	ScaAuthPermissionRuleTable.Annotation = &entsql.Annotation{
+		Table: "sca_auth_permission_rule",
+	}
+	ScaAuthRoleTable.Annotation = &entsql.Annotation{
+		Table: "sca_auth_role",
+	}
+	ScaAuthUserTable.Annotation = &entsql.Annotation{
+		Table: "sca_auth_user",
+	}
+	ScaAuthUserDeviceTable.ForeignKeys[0].RefTable = ScaAuthUserTable
+	ScaAuthUserDeviceTable.Annotation = &entsql.Annotation{
+		Table: "sca_auth_user_device",
+	}
+	ScaAuthUserSocialTable.ForeignKeys[0].RefTable = ScaAuthUserTable
+	ScaAuthUserSocialTable.Annotation = &entsql.Annotation{
+		Table: "sca_auth_user_social",
+	}
+}

app/core/api/repository/mysql/ent/predicate/predicate.go

@@ -0,0 +1,22 @@
+// Code generated by ent, DO NOT EDIT.
+
+package predicate
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+// ScaAuthPermissionRule is the predicate function for scaauthpermissionrule builders.
+type ScaAuthPermissionRule func(*sql.Selector)
+
+// ScaAuthRole is the predicate function for scaauthrole builders.
+type ScaAuthRole func(*sql.Selector)
+
+// ScaAuthUser is the predicate function for scaauthuser builders.
+type ScaAuthUser func(*sql.Selector)
+
+// ScaAuthUserDevice is the predicate function for scaauthuserdevice builders.
+type ScaAuthUserDevice func(*sql.Selector)
+
+// ScaAuthUserSocial is the predicate function for scaauthusersocial builders.
+type ScaAuthUserSocial func(*sql.Selector)

app/core/api/repository/mysql/ent/privacy/privacy.go

@@ -0,0 +1,299 @@
+// Code generated by ent, DO NOT EDIT.
+
+package privacy
+
+import (
+	"context"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent"
+
+	"entgo.io/ent/entql"
+	"entgo.io/ent/privacy"
+)
+
+var (
+	// Allow may be returned by rules to indicate that the policy
+	// evaluation should terminate with allow decision.
+	Allow = privacy.Allow
+
+	// Deny may be returned by rules to indicate that the policy
+	// evaluation should terminate with deny decision.
+	Deny = privacy.Deny
+
+	// Skip may be returned by rules to indicate that the policy
+	// evaluation should continue to the next rule.
+	Skip = privacy.Skip
+)
+
+// Allowf returns a formatted wrapped Allow decision.
+func Allowf(format string, a ...any) error {
+	return privacy.Allowf(format, a...)
+}
+
+// Denyf returns a formatted wrapped Deny decision.
+func Denyf(format string, a ...any) error {
+	return privacy.Denyf(format, a...)
+}
+
+// Skipf returns a formatted wrapped Skip decision.
+func Skipf(format string, a ...any) error {
+	return privacy.Skipf(format, a...)
+}
+
+// DecisionContext creates a new context from the given parent context with
+// a policy decision attach to it.
+func DecisionContext(parent context.Context, decision error) context.Context {
+	return privacy.DecisionContext(parent, decision)
+}
+
+// DecisionFromContext retrieves the policy decision from the context.
+func DecisionFromContext(ctx context.Context) (error, bool) {
+	return privacy.DecisionFromContext(ctx)
+}
+
+type (
+	// Policy groups query and mutation policies.
+	Policy = privacy.Policy
+
+	// QueryRule defines the interface deciding whether a
+	// query is allowed and optionally modify it.
+	QueryRule = privacy.QueryRule
+	// QueryPolicy combines multiple query rules into a single policy.
+	QueryPolicy = privacy.QueryPolicy
+
+	// MutationRule defines the interface which decides whether a
+	// mutation is allowed and optionally modifies it.
+	MutationRule = privacy.MutationRule
+	// MutationPolicy combines multiple mutation rules into a single policy.
+	MutationPolicy = privacy.MutationPolicy
+	// MutationRuleFunc type is an adapter which allows the use of
+	// ordinary functions as mutation rules.
+	MutationRuleFunc = privacy.MutationRuleFunc
+
+	// QueryMutationRule is an interface which groups query and mutation rules.
+	QueryMutationRule = privacy.QueryMutationRule
+)
+
+// QueryRuleFunc type is an adapter to allow the use of
+// ordinary functions as query rules.
+type QueryRuleFunc func(context.Context, ent.Query) error
+
+// Eval returns f(ctx, q).
+func (f QueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error {
+	return f(ctx, q)
+}
+
+// AlwaysAllowRule returns a rule that returns an allow decision.
+func AlwaysAllowRule() QueryMutationRule {
+	return privacy.AlwaysAllowRule()
+}
+
+// AlwaysDenyRule returns a rule that returns a deny decision.
+func AlwaysDenyRule() QueryMutationRule {
+	return privacy.AlwaysDenyRule()
+}
+
+// ContextQueryMutationRule creates a query/mutation rule from a context eval func.
+func ContextQueryMutationRule(eval func(context.Context) error) QueryMutationRule {
+	return privacy.ContextQueryMutationRule(eval)
+}
+
+// OnMutationOperation evaluates the given rule only on a given mutation operation.
+func OnMutationOperation(rule MutationRule, op ent.Op) MutationRule {
+	return privacy.OnMutationOperation(rule, op)
+}
+
+// DenyMutationOperationRule returns a rule denying specified mutation operation.
+func DenyMutationOperationRule(op ent.Op) MutationRule {
+	rule := MutationRuleFunc(func(_ context.Context, m ent.Mutation) error {
+		return Denyf("ent/privacy: operation %s is not allowed", m.Op())
+	})
+	return OnMutationOperation(rule, op)
+}
+
+// The ScaAuthPermissionRuleQueryRuleFunc type is an adapter to allow the use of ordinary
+// functions as a query rule.
+type ScaAuthPermissionRuleQueryRuleFunc func(context.Context, *ent.ScaAuthPermissionRuleQuery) error
+
+// EvalQuery return f(ctx, q).
+func (f ScaAuthPermissionRuleQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error {
+	if q, ok := q.(*ent.ScaAuthPermissionRuleQuery); ok {
+		return f(ctx, q)
+	}
+	return Denyf("ent/privacy: unexpected query type %T, expect *ent.ScaAuthPermissionRuleQuery", q)
+}
+
+// The ScaAuthPermissionRuleMutationRuleFunc type is an adapter to allow the use of ordinary
+// functions as a mutation rule.
+type ScaAuthPermissionRuleMutationRuleFunc func(context.Context, *ent.ScaAuthPermissionRuleMutation) error
+
+// EvalMutation calls f(ctx, m).
+func (f ScaAuthPermissionRuleMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error {
+	if m, ok := m.(*ent.ScaAuthPermissionRuleMutation); ok {
+		return f(ctx, m)
+	}
+	return Denyf("ent/privacy: unexpected mutation type %T, expect *ent.ScaAuthPermissionRuleMutation", m)
+}
+
+// The ScaAuthRoleQueryRuleFunc type is an adapter to allow the use of ordinary
+// functions as a query rule.
+type ScaAuthRoleQueryRuleFunc func(context.Context, *ent.ScaAuthRoleQuery) error
+
+// EvalQuery return f(ctx, q).
+func (f ScaAuthRoleQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error {
+	if q, ok := q.(*ent.ScaAuthRoleQuery); ok {
+		return f(ctx, q)
+	}
+	return Denyf("ent/privacy: unexpected query type %T, expect *ent.ScaAuthRoleQuery", q)
+}
+
+// The ScaAuthRoleMutationRuleFunc type is an adapter to allow the use of ordinary
+// functions as a mutation rule.
+type ScaAuthRoleMutationRuleFunc func(context.Context, *ent.ScaAuthRoleMutation) error
+
+// EvalMutation calls f(ctx, m).
+func (f ScaAuthRoleMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error {
+	if m, ok := m.(*ent.ScaAuthRoleMutation); ok {
+		return f(ctx, m)
+	}
+	return Denyf("ent/privacy: unexpected mutation type %T, expect *ent.ScaAuthRoleMutation", m)
+}
+
+// The ScaAuthUserQueryRuleFunc type is an adapter to allow the use of ordinary
+// functions as a query rule.
+type ScaAuthUserQueryRuleFunc func(context.Context, *ent.ScaAuthUserQuery) error
+
+// EvalQuery return f(ctx, q).
+func (f ScaAuthUserQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error {
+	if q, ok := q.(*ent.ScaAuthUserQuery); ok {
+		return f(ctx, q)
+	}
+	return Denyf("ent/privacy: unexpected query type %T, expect *ent.ScaAuthUserQuery", q)
+}
+
+// The ScaAuthUserMutationRuleFunc type is an adapter to allow the use of ordinary
+// functions as a mutation rule.
+type ScaAuthUserMutationRuleFunc func(context.Context, *ent.ScaAuthUserMutation) error
+
+// EvalMutation calls f(ctx, m).
+func (f ScaAuthUserMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error {
+	if m, ok := m.(*ent.ScaAuthUserMutation); ok {
+		return f(ctx, m)
+	}
+	return Denyf("ent/privacy: unexpected mutation type %T, expect *ent.ScaAuthUserMutation", m)
+}
+
+// The ScaAuthUserDeviceQueryRuleFunc type is an adapter to allow the use of ordinary
+// functions as a query rule.
+type ScaAuthUserDeviceQueryRuleFunc func(context.Context, *ent.ScaAuthUserDeviceQuery) error
+
+// EvalQuery return f(ctx, q).
+func (f ScaAuthUserDeviceQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error {
+	if q, ok := q.(*ent.ScaAuthUserDeviceQuery); ok {
+		return f(ctx, q)
+	}
+	return Denyf("ent/privacy: unexpected query type %T, expect *ent.ScaAuthUserDeviceQuery", q)
+}
+
+// The ScaAuthUserDeviceMutationRuleFunc type is an adapter to allow the use of ordinary
+// functions as a mutation rule.
+type ScaAuthUserDeviceMutationRuleFunc func(context.Context, *ent.ScaAuthUserDeviceMutation) error
+
+// EvalMutation calls f(ctx, m).
+func (f ScaAuthUserDeviceMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error {
+	if m, ok := m.(*ent.ScaAuthUserDeviceMutation); ok {
+		return f(ctx, m)
+	}
+	return Denyf("ent/privacy: unexpected mutation type %T, expect *ent.ScaAuthUserDeviceMutation", m)
+}
+
+// The ScaAuthUserSocialQueryRuleFunc type is an adapter to allow the use of ordinary
+// functions as a query rule.
+type ScaAuthUserSocialQueryRuleFunc func(context.Context, *ent.ScaAuthUserSocialQuery) error
+
+// EvalQuery return f(ctx, q).
+func (f ScaAuthUserSocialQueryRuleFunc) EvalQuery(ctx context.Context, q ent.Query) error {
+	if q, ok := q.(*ent.ScaAuthUserSocialQuery); ok {
+		return f(ctx, q)
+	}
+	return Denyf("ent/privacy: unexpected query type %T, expect *ent.ScaAuthUserSocialQuery", q)
+}
+
+// The ScaAuthUserSocialMutationRuleFunc type is an adapter to allow the use of ordinary
+// functions as a mutation rule.
+type ScaAuthUserSocialMutationRuleFunc func(context.Context, *ent.ScaAuthUserSocialMutation) error
+
+// EvalMutation calls f(ctx, m).
+func (f ScaAuthUserSocialMutationRuleFunc) EvalMutation(ctx context.Context, m ent.Mutation) error {
+	if m, ok := m.(*ent.ScaAuthUserSocialMutation); ok {
+		return f(ctx, m)
+	}
+	return Denyf("ent/privacy: unexpected mutation type %T, expect *ent.ScaAuthUserSocialMutation", m)
+}
+
+type (
+	// Filter is the interface that wraps the Where function
+	// for filtering nodes in queries and mutations.
+	Filter interface {
+		// Where applies a filter on the executed query/mutation.
+		Where(entql.P)
+	}
+
+	// The FilterFunc type is an adapter that allows the use of ordinary
+	// functions as filters for query and mutation types.
+	FilterFunc func(context.Context, Filter) error
+)
+
+// EvalQuery calls f(ctx, q) if the query implements the Filter interface, otherwise it is denied.
+func (f FilterFunc) EvalQuery(ctx context.Context, q ent.Query) error {
+	fr, err := queryFilter(q)
+	if err != nil {
+		return err
+	}
+	return f(ctx, fr)
+}
+
+// EvalMutation calls f(ctx, q) if the mutation implements the Filter interface, otherwise it is denied.
+func (f FilterFunc) EvalMutation(ctx context.Context, m ent.Mutation) error {
+	fr, err := mutationFilter(m)
+	if err != nil {
+		return err
+	}
+	return f(ctx, fr)
+}
+
+var _ QueryMutationRule = FilterFunc(nil)
+
+func queryFilter(q ent.Query) (Filter, error) {
+	switch q := q.(type) {
+	case *ent.ScaAuthPermissionRuleQuery:
+		return q.Filter(), nil
+	case *ent.ScaAuthRoleQuery:
+		return q.Filter(), nil
+	case *ent.ScaAuthUserQuery:
+		return q.Filter(), nil
+	case *ent.ScaAuthUserDeviceQuery:
+		return q.Filter(), nil
+	case *ent.ScaAuthUserSocialQuery:
+		return q.Filter(), nil
+	default:
+		return nil, Denyf("ent/privacy: unexpected query type %T for query filter", q)
+	}
+}
+
+func mutationFilter(m ent.Mutation) (Filter, error) {
+	switch m := m.(type) {
+	case *ent.ScaAuthPermissionRuleMutation:
+		return m.Filter(), nil
+	case *ent.ScaAuthRoleMutation:
+		return m.Filter(), nil
+	case *ent.ScaAuthUserMutation:
+		return m.Filter(), nil
+	case *ent.ScaAuthUserDeviceMutation:
+		return m.Filter(), nil
+	case *ent.ScaAuthUserSocialMutation:
+		return m.Filter(), nil
+	default:
+		return nil, Denyf("ent/privacy: unexpected mutation type %T for mutation filter", m)
+	}
+}

app/core/api/repository/mysql/ent/runtime.go

@@ -0,0 +1,249 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/schema"
+	"time"
+)
+
+// The init function reads all schema descriptors with runtime code
+// (default values, validators, hooks and policies) and stitches it
+// to their package variables.
+func init() {
+	scaauthpermissionruleFields := schema.ScaAuthPermissionRule{}.Fields()
+	_ = scaauthpermissionruleFields
+	// scaauthpermissionruleDescPtype is the schema descriptor for ptype field.
+	scaauthpermissionruleDescPtype := scaauthpermissionruleFields[1].Descriptor()
+	// scaauthpermissionrule.PtypeValidator is a validator for the "ptype" field. It is called by the builders before save.
+	scaauthpermissionrule.PtypeValidator = scaauthpermissionruleDescPtype.Validators[0].(func(string) error)
+	// scaauthpermissionruleDescV0 is the schema descriptor for v0 field.
+	scaauthpermissionruleDescV0 := scaauthpermissionruleFields[2].Descriptor()
+	// scaauthpermissionrule.V0Validator is a validator for the "v0" field. It is called by the builders before save.
+	scaauthpermissionrule.V0Validator = scaauthpermissionruleDescV0.Validators[0].(func(string) error)
+	// scaauthpermissionruleDescV1 is the schema descriptor for v1 field.
+	scaauthpermissionruleDescV1 := scaauthpermissionruleFields[3].Descriptor()
+	// scaauthpermissionrule.V1Validator is a validator for the "v1" field. It is called by the builders before save.
+	scaauthpermissionrule.V1Validator = scaauthpermissionruleDescV1.Validators[0].(func(string) error)
+	// scaauthpermissionruleDescV2 is the schema descriptor for v2 field.
+	scaauthpermissionruleDescV2 := scaauthpermissionruleFields[4].Descriptor()
+	// scaauthpermissionrule.V2Validator is a validator for the "v2" field. It is called by the builders before save.
+	scaauthpermissionrule.V2Validator = scaauthpermissionruleDescV2.Validators[0].(func(string) error)
+	// scaauthpermissionruleDescV3 is the schema descriptor for v3 field.
+	scaauthpermissionruleDescV3 := scaauthpermissionruleFields[5].Descriptor()
+	// scaauthpermissionrule.V3Validator is a validator for the "v3" field. It is called by the builders before save.
+	scaauthpermissionrule.V3Validator = scaauthpermissionruleDescV3.Validators[0].(func(string) error)
+	// scaauthpermissionruleDescV4 is the schema descriptor for v4 field.
+	scaauthpermissionruleDescV4 := scaauthpermissionruleFields[6].Descriptor()
+	// scaauthpermissionrule.V4Validator is a validator for the "v4" field. It is called by the builders before save.
+	scaauthpermissionrule.V4Validator = scaauthpermissionruleDescV4.Validators[0].(func(string) error)
+	// scaauthpermissionruleDescV5 is the schema descriptor for v5 field.
+	scaauthpermissionruleDescV5 := scaauthpermissionruleFields[7].Descriptor()
+	// scaauthpermissionrule.V5Validator is a validator for the "v5" field. It is called by the builders before save.
+	scaauthpermissionrule.V5Validator = scaauthpermissionruleDescV5.Validators[0].(func(string) error)
+	scaauthroleMixin := schema.ScaAuthRole{}.Mixin()
+	scaauthroleMixinFields0 := scaauthroleMixin[0].Fields()
+	_ = scaauthroleMixinFields0
+	scaauthroleFields := schema.ScaAuthRole{}.Fields()
+	_ = scaauthroleFields
+	// scaauthroleDescCreatedAt is the schema descriptor for created_at field.
+	scaauthroleDescCreatedAt := scaauthroleMixinFields0[0].Descriptor()
+	// scaauthrole.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthrole.DefaultCreatedAt = scaauthroleDescCreatedAt.Default.(func() time.Time)
+	// scaauthroleDescUpdatedAt is the schema descriptor for updated_at field.
+	scaauthroleDescUpdatedAt := scaauthroleMixinFields0[1].Descriptor()
+	// scaauthrole.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	scaauthrole.DefaultUpdatedAt = scaauthroleDescUpdatedAt.Default.(func() time.Time)
+	// scaauthrole.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	scaauthrole.UpdateDefaultUpdatedAt = scaauthroleDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// scaauthroleDescDeleted is the schema descriptor for deleted field.
+	scaauthroleDescDeleted := scaauthroleMixinFields0[2].Descriptor()
+	// scaauthrole.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthrole.DefaultDeleted = scaauthroleDescDeleted.Default.(int8)
+	// scaauthrole.DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	scaauthrole.DeletedValidator = scaauthroleDescDeleted.Validators[0].(func(int8) error)
+	// scaauthroleDescRoleName is the schema descriptor for role_name field.
+	scaauthroleDescRoleName := scaauthroleFields[1].Descriptor()
+	// scaauthrole.RoleNameValidator is a validator for the "role_name" field. It is called by the builders before save.
+	scaauthrole.RoleNameValidator = scaauthroleDescRoleName.Validators[0].(func(string) error)
+	// scaauthroleDescRoleKey is the schema descriptor for role_key field.
+	scaauthroleDescRoleKey := scaauthroleFields[2].Descriptor()
+	// scaauthrole.RoleKeyValidator is a validator for the "role_key" field. It is called by the builders before save.
+	scaauthrole.RoleKeyValidator = scaauthroleDescRoleKey.Validators[0].(func(string) error)
+	scaauthuserMixin := schema.ScaAuthUser{}.Mixin()
+	scaauthuserMixinFields0 := scaauthuserMixin[0].Fields()
+	_ = scaauthuserMixinFields0
+	scaauthuserFields := schema.ScaAuthUser{}.Fields()
+	_ = scaauthuserFields
+	// scaauthuserDescCreatedAt is the schema descriptor for created_at field.
+	scaauthuserDescCreatedAt := scaauthuserMixinFields0[0].Descriptor()
+	// scaauthuser.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthuser.DefaultCreatedAt = scaauthuserDescCreatedAt.Default.(func() time.Time)
+	// scaauthuserDescUpdatedAt is the schema descriptor for updated_at field.
+	scaauthuserDescUpdatedAt := scaauthuserMixinFields0[1].Descriptor()
+	// scaauthuser.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	scaauthuser.DefaultUpdatedAt = scaauthuserDescUpdatedAt.Default.(func() time.Time)
+	// scaauthuser.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	scaauthuser.UpdateDefaultUpdatedAt = scaauthuserDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// scaauthuserDescDeleted is the schema descriptor for deleted field.
+	scaauthuserDescDeleted := scaauthuserMixinFields0[2].Descriptor()
+	// scaauthuser.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthuser.DefaultDeleted = scaauthuserDescDeleted.Default.(int8)
+	// scaauthuser.DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	scaauthuser.DeletedValidator = scaauthuserDescDeleted.Validators[0].(func(int8) error)
+	// scaauthuserDescUID is the schema descriptor for uid field.
+	scaauthuserDescUID := scaauthuserFields[1].Descriptor()
+	// scaauthuser.UIDValidator is a validator for the "uid" field. It is called by the builders before save.
+	scaauthuser.UIDValidator = scaauthuserDescUID.Validators[0].(func(string) error)
+	// scaauthuserDescUsername is the schema descriptor for username field.
+	scaauthuserDescUsername := scaauthuserFields[2].Descriptor()
+	// scaauthuser.UsernameValidator is a validator for the "username" field. It is called by the builders before save.
+	scaauthuser.UsernameValidator = scaauthuserDescUsername.Validators[0].(func(string) error)
+	// scaauthuserDescNickname is the schema descriptor for nickname field.
+	scaauthuserDescNickname := scaauthuserFields[3].Descriptor()
+	// scaauthuser.NicknameValidator is a validator for the "nickname" field. It is called by the builders before save.
+	scaauthuser.NicknameValidator = scaauthuserDescNickname.Validators[0].(func(string) error)
+	// scaauthuserDescEmail is the schema descriptor for email field.
+	scaauthuserDescEmail := scaauthuserFields[4].Descriptor()
+	// scaauthuser.EmailValidator is a validator for the "email" field. It is called by the builders before save.
+	scaauthuser.EmailValidator = scaauthuserDescEmail.Validators[0].(func(string) error)
+	// scaauthuserDescPhone is the schema descriptor for phone field.
+	scaauthuserDescPhone := scaauthuserFields[5].Descriptor()
+	// scaauthuser.PhoneValidator is a validator for the "phone" field. It is called by the builders before save.
+	scaauthuser.PhoneValidator = scaauthuserDescPhone.Validators[0].(func(string) error)
+	// scaauthuserDescPassword is the schema descriptor for password field.
+	scaauthuserDescPassword := scaauthuserFields[6].Descriptor()
+	// scaauthuser.PasswordValidator is a validator for the "password" field. It is called by the builders before save.
+	scaauthuser.PasswordValidator = scaauthuserDescPassword.Validators[0].(func(string) error)
+	// scaauthuserDescGender is the schema descriptor for gender field.
+	scaauthuserDescGender := scaauthuserFields[7].Descriptor()
+	// scaauthuser.GenderValidator is a validator for the "gender" field. It is called by the builders before save.
+	scaauthuser.GenderValidator = scaauthuserDescGender.Validators[0].(func(string) error)
+	// scaauthuserDescStatus is the schema descriptor for status field.
+	scaauthuserDescStatus := scaauthuserFields[9].Descriptor()
+	// scaauthuser.DefaultStatus holds the default value on creation for the status field.
+	scaauthuser.DefaultStatus = scaauthuserDescStatus.Default.(int8)
+	// scaauthuserDescIntroduce is the schema descriptor for introduce field.
+	scaauthuserDescIntroduce := scaauthuserFields[10].Descriptor()
+	// scaauthuser.IntroduceValidator is a validator for the "introduce" field. It is called by the builders before save.
+	scaauthuser.IntroduceValidator = scaauthuserDescIntroduce.Validators[0].(func(string) error)
+	// scaauthuserDescBlog is the schema descriptor for blog field.
+	scaauthuserDescBlog := scaauthuserFields[11].Descriptor()
+	// scaauthuser.BlogValidator is a validator for the "blog" field. It is called by the builders before save.
+	scaauthuser.BlogValidator = scaauthuserDescBlog.Validators[0].(func(string) error)
+	// scaauthuserDescLocation is the schema descriptor for location field.
+	scaauthuserDescLocation := scaauthuserFields[12].Descriptor()
+	// scaauthuser.LocationValidator is a validator for the "location" field. It is called by the builders before save.
+	scaauthuser.LocationValidator = scaauthuserDescLocation.Validators[0].(func(string) error)
+	// scaauthuserDescCompany is the schema descriptor for company field.
+	scaauthuserDescCompany := scaauthuserFields[13].Descriptor()
+	// scaauthuser.CompanyValidator is a validator for the "company" field. It is called by the builders before save.
+	scaauthuser.CompanyValidator = scaauthuserDescCompany.Validators[0].(func(string) error)
+	scaauthuserdeviceMixin := schema.ScaAuthUserDevice{}.Mixin()
+	scaauthuserdeviceMixinFields0 := scaauthuserdeviceMixin[0].Fields()
+	_ = scaauthuserdeviceMixinFields0
+	scaauthuserdeviceFields := schema.ScaAuthUserDevice{}.Fields()
+	_ = scaauthuserdeviceFields
+	// scaauthuserdeviceDescCreatedAt is the schema descriptor for created_at field.
+	scaauthuserdeviceDescCreatedAt := scaauthuserdeviceMixinFields0[0].Descriptor()
+	// scaauthuserdevice.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthuserdevice.DefaultCreatedAt = scaauthuserdeviceDescCreatedAt.Default.(func() time.Time)
+	// scaauthuserdeviceDescUpdatedAt is the schema descriptor for updated_at field.
+	scaauthuserdeviceDescUpdatedAt := scaauthuserdeviceMixinFields0[1].Descriptor()
+	// scaauthuserdevice.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	scaauthuserdevice.DefaultUpdatedAt = scaauthuserdeviceDescUpdatedAt.Default.(func() time.Time)
+	// scaauthuserdevice.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	scaauthuserdevice.UpdateDefaultUpdatedAt = scaauthuserdeviceDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// scaauthuserdeviceDescDeleted is the schema descriptor for deleted field.
+	scaauthuserdeviceDescDeleted := scaauthuserdeviceMixinFields0[2].Descriptor()
+	// scaauthuserdevice.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthuserdevice.DefaultDeleted = scaauthuserdeviceDescDeleted.Default.(int8)
+	// scaauthuserdevice.DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	scaauthuserdevice.DeletedValidator = scaauthuserdeviceDescDeleted.Validators[0].(func(int8) error)
+	// scaauthuserdeviceDescUserID is the schema descriptor for user_id field.
+	scaauthuserdeviceDescUserID := scaauthuserdeviceFields[1].Descriptor()
+	// scaauthuserdevice.UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	scaauthuserdevice.UserIDValidator = scaauthuserdeviceDescUserID.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescIP is the schema descriptor for ip field.
+	scaauthuserdeviceDescIP := scaauthuserdeviceFields[2].Descriptor()
+	// scaauthuserdevice.IPValidator is a validator for the "ip" field. It is called by the builders before save.
+	scaauthuserdevice.IPValidator = scaauthuserdeviceDescIP.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescLocation is the schema descriptor for location field.
+	scaauthuserdeviceDescLocation := scaauthuserdeviceFields[3].Descriptor()
+	// scaauthuserdevice.LocationValidator is a validator for the "location" field. It is called by the builders before save.
+	scaauthuserdevice.LocationValidator = scaauthuserdeviceDescLocation.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescAgent is the schema descriptor for agent field.
+	scaauthuserdeviceDescAgent := scaauthuserdeviceFields[4].Descriptor()
+	// scaauthuserdevice.AgentValidator is a validator for the "agent" field. It is called by the builders before save.
+	scaauthuserdevice.AgentValidator = scaauthuserdeviceDescAgent.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescBrowser is the schema descriptor for browser field.
+	scaauthuserdeviceDescBrowser := scaauthuserdeviceFields[5].Descriptor()
+	// scaauthuserdevice.BrowserValidator is a validator for the "browser" field. It is called by the builders before save.
+	scaauthuserdevice.BrowserValidator = scaauthuserdeviceDescBrowser.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescOperatingSystem is the schema descriptor for operating_system field.
+	scaauthuserdeviceDescOperatingSystem := scaauthuserdeviceFields[6].Descriptor()
+	// scaauthuserdevice.OperatingSystemValidator is a validator for the "operating_system" field. It is called by the builders before save.
+	scaauthuserdevice.OperatingSystemValidator = scaauthuserdeviceDescOperatingSystem.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescBrowserVersion is the schema descriptor for browser_version field.
+	scaauthuserdeviceDescBrowserVersion := scaauthuserdeviceFields[7].Descriptor()
+	// scaauthuserdevice.BrowserVersionValidator is a validator for the "browser_version" field. It is called by the builders before save.
+	scaauthuserdevice.BrowserVersionValidator = scaauthuserdeviceDescBrowserVersion.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescMozilla is the schema descriptor for mozilla field.
+	scaauthuserdeviceDescMozilla := scaauthuserdeviceFields[10].Descriptor()
+	// scaauthuserdevice.MozillaValidator is a validator for the "mozilla" field. It is called by the builders before save.
+	scaauthuserdevice.MozillaValidator = scaauthuserdeviceDescMozilla.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescPlatform is the schema descriptor for platform field.
+	scaauthuserdeviceDescPlatform := scaauthuserdeviceFields[11].Descriptor()
+	// scaauthuserdevice.PlatformValidator is a validator for the "platform" field. It is called by the builders before save.
+	scaauthuserdevice.PlatformValidator = scaauthuserdeviceDescPlatform.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescEngineName is the schema descriptor for engine_name field.
+	scaauthuserdeviceDescEngineName := scaauthuserdeviceFields[12].Descriptor()
+	// scaauthuserdevice.EngineNameValidator is a validator for the "engine_name" field. It is called by the builders before save.
+	scaauthuserdevice.EngineNameValidator = scaauthuserdeviceDescEngineName.Validators[0].(func(string) error)
+	// scaauthuserdeviceDescEngineVersion is the schema descriptor for engine_version field.
+	scaauthuserdeviceDescEngineVersion := scaauthuserdeviceFields[13].Descriptor()
+	// scaauthuserdevice.EngineVersionValidator is a validator for the "engine_version" field. It is called by the builders before save.
+	scaauthuserdevice.EngineVersionValidator = scaauthuserdeviceDescEngineVersion.Validators[0].(func(string) error)
+	scaauthusersocialMixin := schema.ScaAuthUserSocial{}.Mixin()
+	scaauthusersocialMixinFields0 := scaauthusersocialMixin[0].Fields()
+	_ = scaauthusersocialMixinFields0
+	scaauthusersocialFields := schema.ScaAuthUserSocial{}.Fields()
+	_ = scaauthusersocialFields
+	// scaauthusersocialDescCreatedAt is the schema descriptor for created_at field.
+	scaauthusersocialDescCreatedAt := scaauthusersocialMixinFields0[0].Descriptor()
+	// scaauthusersocial.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthusersocial.DefaultCreatedAt = scaauthusersocialDescCreatedAt.Default.(func() time.Time)
+	// scaauthusersocialDescUpdatedAt is the schema descriptor for updated_at field.
+	scaauthusersocialDescUpdatedAt := scaauthusersocialMixinFields0[1].Descriptor()
+	// scaauthusersocial.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	scaauthusersocial.DefaultUpdatedAt = scaauthusersocialDescUpdatedAt.Default.(func() time.Time)
+	// scaauthusersocial.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	scaauthusersocial.UpdateDefaultUpdatedAt = scaauthusersocialDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// scaauthusersocialDescDeleted is the schema descriptor for deleted field.
+	scaauthusersocialDescDeleted := scaauthusersocialMixinFields0[2].Descriptor()
+	// scaauthusersocial.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthusersocial.DefaultDeleted = scaauthusersocialDescDeleted.Default.(int8)
+	// scaauthusersocial.DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	scaauthusersocial.DeletedValidator = scaauthusersocialDescDeleted.Validators[0].(func(int8) error)
+	// scaauthusersocialDescUserID is the schema descriptor for user_id field.
+	scaauthusersocialDescUserID := scaauthusersocialFields[1].Descriptor()
+	// scaauthusersocial.UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	scaauthusersocial.UserIDValidator = scaauthusersocialDescUserID.Validators[0].(func(string) error)
+	// scaauthusersocialDescOpenID is the schema descriptor for open_id field.
+	scaauthusersocialDescOpenID := scaauthusersocialFields[2].Descriptor()
+	// scaauthusersocial.OpenIDValidator is a validator for the "open_id" field. It is called by the builders before save.
+	scaauthusersocial.OpenIDValidator = scaauthusersocialDescOpenID.Validators[0].(func(string) error)
+	// scaauthusersocialDescSource is the schema descriptor for source field.
+	scaauthusersocialDescSource := scaauthusersocialFields[3].Descriptor()
+	// scaauthusersocial.SourceValidator is a validator for the "source" field. It is called by the builders before save.
+	scaauthusersocial.SourceValidator = scaauthusersocialDescSource.Validators[0].(func(string) error)
+	// scaauthusersocialDescStatus is the schema descriptor for status field.
+	scaauthusersocialDescStatus := scaauthusersocialFields[4].Descriptor()
+	// scaauthusersocial.DefaultStatus holds the default value on creation for the status field.
+	scaauthusersocial.DefaultStatus = scaauthusersocialDescStatus.Default.(int)
+}

app/core/api/repository/mysql/ent/runtime/runtime.go

@@ -0,0 +1,10 @@
+// Code generated by ent, DO NOT EDIT.
+
+package runtime
+
+// The schema-stitching logic is generated in schisandra-album-cloud-microservices/app/main/api/repository/mysql/ent/runtime.go
+
+const (
+	Version = "v0.14.1"                                         // Version of ent codegen.
+	Sum     = "h1:fUERL506Pqr92EPHJqr8EYxbPioflJo6PudkrEA8a/s=" // Sum of ent codegen.
+)

app/core/api/repository/mysql/ent/scaauthpermissionrule.go

@@ -0,0 +1,229 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// 角色权限规则表
+type ScaAuthPermissionRule struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID int64 `json:"id,omitempty"`
+	// Ptype holds the value of the "ptype" field.
+	Ptype *string `json:"ptype,omitempty"`
+	// V0 holds the value of the "v0" field.
+	V0 *string `json:"v0,omitempty"`
+	// V1 holds the value of the "v1" field.
+	V1 *string `json:"v1,omitempty"`
+	// V2 holds the value of the "v2" field.
+	V2 *string `json:"v2,omitempty"`
+	// V3 holds the value of the "v3" field.
+	V3 *string `json:"v3,omitempty"`
+	// V4 holds the value of the "v4" field.
+	V4 *string `json:"v4,omitempty"`
+	// V5 holds the value of the "v5" field.
+	V5 *string `json:"v5,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ScaAuthPermissionRuleQuery when eager-loading is set.
+	Edges                                  ScaAuthPermissionRuleEdges `json:"edges"`
+	sca_auth_role_sca_auth_permission_rule *int64
+	selectValues                           sql.SelectValues
+}
+
+// ScaAuthPermissionRuleEdges holds the relations/edges for other nodes in the graph.
+type ScaAuthPermissionRuleEdges struct {
+	// ScaAuthRole holds the value of the sca_auth_role edge.
+	ScaAuthRole *ScaAuthRole `json:"sca_auth_role,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// ScaAuthRoleOrErr returns the ScaAuthRole value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e ScaAuthPermissionRuleEdges) ScaAuthRoleOrErr() (*ScaAuthRole, error) {
+	if e.ScaAuthRole != nil {
+		return e.ScaAuthRole, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: scaauthrole.Label}
+	}
+	return nil, &NotLoadedError{edge: "sca_auth_role"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ScaAuthPermissionRule) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case scaauthpermissionrule.FieldID:
+			values[i] = new(sql.NullInt64)
+		case scaauthpermissionrule.FieldPtype, scaauthpermissionrule.FieldV0, scaauthpermissionrule.FieldV1, scaauthpermissionrule.FieldV2, scaauthpermissionrule.FieldV3, scaauthpermissionrule.FieldV4, scaauthpermissionrule.FieldV5:
+			values[i] = new(sql.NullString)
+		case scaauthpermissionrule.ForeignKeys[0]: // sca_auth_role_sca_auth_permission_rule
+			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 ScaAuthPermissionRule fields.
+func (sapr *ScaAuthPermissionRule) 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 scaauthpermissionrule.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			sapr.ID = int64(value.Int64)
+		case scaauthpermissionrule.FieldPtype:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field ptype", values[i])
+			} else if value.Valid {
+				sapr.Ptype = new(string)
+				*sapr.Ptype = value.String
+			}
+		case scaauthpermissionrule.FieldV0:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field v0", values[i])
+			} else if value.Valid {
+				sapr.V0 = new(string)
+				*sapr.V0 = value.String
+			}
+		case scaauthpermissionrule.FieldV1:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field v1", values[i])
+			} else if value.Valid {
+				sapr.V1 = new(string)
+				*sapr.V1 = value.String
+			}
+		case scaauthpermissionrule.FieldV2:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field v2", values[i])
+			} else if value.Valid {
+				sapr.V2 = new(string)
+				*sapr.V2 = value.String
+			}
+		case scaauthpermissionrule.FieldV3:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field v3", values[i])
+			} else if value.Valid {
+				sapr.V3 = new(string)
+				*sapr.V3 = value.String
+			}
+		case scaauthpermissionrule.FieldV4:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field v4", values[i])
+			} else if value.Valid {
+				sapr.V4 = new(string)
+				*sapr.V4 = value.String
+			}
+		case scaauthpermissionrule.FieldV5:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field v5", values[i])
+			} else if value.Valid {
+				sapr.V5 = new(string)
+				*sapr.V5 = value.String
+			}
+		case scaauthpermissionrule.ForeignKeys[0]:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for edge-field sca_auth_role_sca_auth_permission_rule", value)
+			} else if value.Valid {
+				sapr.sca_auth_role_sca_auth_permission_rule = new(int64)
+				*sapr.sca_auth_role_sca_auth_permission_rule = int64(value.Int64)
+			}
+		default:
+			sapr.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ScaAuthPermissionRule.
+// This includes values selected through modifiers, order, etc.
+func (sapr *ScaAuthPermissionRule) Value(name string) (ent.Value, error) {
+	return sapr.selectValues.Get(name)
+}
+
+// QueryScaAuthRole queries the "sca_auth_role" edge of the ScaAuthPermissionRule entity.
+func (sapr *ScaAuthPermissionRule) QueryScaAuthRole() *ScaAuthRoleQuery {
+	return NewScaAuthPermissionRuleClient(sapr.config).QueryScaAuthRole(sapr)
+}
+
+// Update returns a builder for updating this ScaAuthPermissionRule.
+// Note that you need to call ScaAuthPermissionRule.Unwrap() before calling this method if this ScaAuthPermissionRule
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (sapr *ScaAuthPermissionRule) Update() *ScaAuthPermissionRuleUpdateOne {
+	return NewScaAuthPermissionRuleClient(sapr.config).UpdateOne(sapr)
+}
+
+// Unwrap unwraps the ScaAuthPermissionRule 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 (sapr *ScaAuthPermissionRule) Unwrap() *ScaAuthPermissionRule {
+	_tx, ok := sapr.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: ScaAuthPermissionRule is not a transactional entity")
+	}
+	sapr.config.driver = _tx.drv
+	return sapr
+}
+
+// String implements the fmt.Stringer.
+func (sapr *ScaAuthPermissionRule) String() string {
+	var builder strings.Builder
+	builder.WriteString("ScaAuthPermissionRule(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", sapr.ID))
+	if v := sapr.Ptype; v != nil {
+		builder.WriteString("ptype=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sapr.V0; v != nil {
+		builder.WriteString("v0=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sapr.V1; v != nil {
+		builder.WriteString("v1=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sapr.V2; v != nil {
+		builder.WriteString("v2=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sapr.V3; v != nil {
+		builder.WriteString("v3=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sapr.V4; v != nil {
+		builder.WriteString("v4=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sapr.V5; v != nil {
+		builder.WriteString("v5=")
+		builder.WriteString(*v)
+	}
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ScaAuthPermissionRules is a parsable slice of ScaAuthPermissionRule.
+type ScaAuthPermissionRules []*ScaAuthPermissionRule

app/core/api/repository/mysql/ent/scaauthpermissionrule/scaauthpermissionrule.go

@@ -0,0 +1,147 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthpermissionrule
+
+import (
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the scaauthpermissionrule type in the database.
+	Label = "sca_auth_permission_rule"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldPtype holds the string denoting the ptype field in the database.
+	FieldPtype = "ptype"
+	// FieldV0 holds the string denoting the v0 field in the database.
+	FieldV0 = "v0"
+	// FieldV1 holds the string denoting the v1 field in the database.
+	FieldV1 = "v1"
+	// FieldV2 holds the string denoting the v2 field in the database.
+	FieldV2 = "v2"
+	// FieldV3 holds the string denoting the v3 field in the database.
+	FieldV3 = "v3"
+	// FieldV4 holds the string denoting the v4 field in the database.
+	FieldV4 = "v4"
+	// FieldV5 holds the string denoting the v5 field in the database.
+	FieldV5 = "v5"
+	// EdgeScaAuthRole holds the string denoting the sca_auth_role edge name in mutations.
+	EdgeScaAuthRole = "sca_auth_role"
+	// Table holds the table name of the scaauthpermissionrule in the database.
+	Table = "sca_auth_permission_rule"
+	// ScaAuthRoleTable is the table that holds the sca_auth_role relation/edge.
+	ScaAuthRoleTable = "sca_auth_permission_rule"
+	// ScaAuthRoleInverseTable is the table name for the ScaAuthRole entity.
+	// It exists in this package in order to avoid circular dependency with the "scaauthrole" package.
+	ScaAuthRoleInverseTable = "sca_auth_role"
+	// ScaAuthRoleColumn is the table column denoting the sca_auth_role relation/edge.
+	ScaAuthRoleColumn = "sca_auth_role_sca_auth_permission_rule"
+)
+
+// Columns holds all SQL columns for scaauthpermissionrule fields.
+var Columns = []string{
+	FieldID,
+	FieldPtype,
+	FieldV0,
+	FieldV1,
+	FieldV2,
+	FieldV3,
+	FieldV4,
+	FieldV5,
+}
+
+// ForeignKeys holds the SQL foreign-keys that are owned by the "sca_auth_permission_rule"
+// table and are not defined as standalone fields in the schema.
+var ForeignKeys = []string{
+	"sca_auth_role_sca_auth_permission_rule",
+}
+
+// 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
+		}
+	}
+	for i := range ForeignKeys {
+		if column == ForeignKeys[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// PtypeValidator is a validator for the "ptype" field. It is called by the builders before save.
+	PtypeValidator func(string) error
+	// V0Validator is a validator for the "v0" field. It is called by the builders before save.
+	V0Validator func(string) error
+	// V1Validator is a validator for the "v1" field. It is called by the builders before save.
+	V1Validator func(string) error
+	// V2Validator is a validator for the "v2" field. It is called by the builders before save.
+	V2Validator func(string) error
+	// V3Validator is a validator for the "v3" field. It is called by the builders before save.
+	V3Validator func(string) error
+	// V4Validator is a validator for the "v4" field. It is called by the builders before save.
+	V4Validator func(string) error
+	// V5Validator is a validator for the "v5" field. It is called by the builders before save.
+	V5Validator func(string) error
+)
+
+// OrderOption defines the ordering options for the ScaAuthPermissionRule 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()
+}
+
+// ByPtype orders the results by the ptype field.
+func ByPtype(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPtype, opts...).ToFunc()
+}
+
+// ByV0 orders the results by the v0 field.
+func ByV0(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldV0, opts...).ToFunc()
+}
+
+// ByV1 orders the results by the v1 field.
+func ByV1(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldV1, opts...).ToFunc()
+}
+
+// ByV2 orders the results by the v2 field.
+func ByV2(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldV2, opts...).ToFunc()
+}
+
+// ByV3 orders the results by the v3 field.
+func ByV3(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldV3, opts...).ToFunc()
+}
+
+// ByV4 orders the results by the v4 field.
+func ByV4(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldV4, opts...).ToFunc()
+}
+
+// ByV5 orders the results by the v5 field.
+func ByV5(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldV5, opts...).ToFunc()
+}
+
+// ByScaAuthRoleField orders the results by sca_auth_role field.
+func ByScaAuthRoleField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newScaAuthRoleStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newScaAuthRoleStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ScaAuthRoleInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, ScaAuthRoleTable, ScaAuthRoleColumn),
+	)
+}

app/core/api/repository/mysql/ent/scaauthpermissionrule/where.go

@@ -0,0 +1,623 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthpermissionrule
+
+import (
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int64) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldID, id))
+}
+
+// Ptype applies equality check predicate on the "ptype" field. It's identical to PtypeEQ.
+func Ptype(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldPtype, v))
+}
+
+// V0 applies equality check predicate on the "v0" field. It's identical to V0EQ.
+func V0(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV0, v))
+}
+
+// V1 applies equality check predicate on the "v1" field. It's identical to V1EQ.
+func V1(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV1, v))
+}
+
+// V2 applies equality check predicate on the "v2" field. It's identical to V2EQ.
+func V2(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV2, v))
+}
+
+// V3 applies equality check predicate on the "v3" field. It's identical to V3EQ.
+func V3(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV3, v))
+}
+
+// V4 applies equality check predicate on the "v4" field. It's identical to V4EQ.
+func V4(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV4, v))
+}
+
+// V5 applies equality check predicate on the "v5" field. It's identical to V5EQ.
+func V5(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV5, v))
+}
+
+// PtypeEQ applies the EQ predicate on the "ptype" field.
+func PtypeEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldPtype, v))
+}
+
+// PtypeNEQ applies the NEQ predicate on the "ptype" field.
+func PtypeNEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldPtype, v))
+}
+
+// PtypeIn applies the In predicate on the "ptype" field.
+func PtypeIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldPtype, vs...))
+}
+
+// PtypeNotIn applies the NotIn predicate on the "ptype" field.
+func PtypeNotIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldPtype, vs...))
+}
+
+// PtypeGT applies the GT predicate on the "ptype" field.
+func PtypeGT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldPtype, v))
+}
+
+// PtypeGTE applies the GTE predicate on the "ptype" field.
+func PtypeGTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldPtype, v))
+}
+
+// PtypeLT applies the LT predicate on the "ptype" field.
+func PtypeLT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldPtype, v))
+}
+
+// PtypeLTE applies the LTE predicate on the "ptype" field.
+func PtypeLTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldPtype, v))
+}
+
+// PtypeContains applies the Contains predicate on the "ptype" field.
+func PtypeContains(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContains(FieldPtype, v))
+}
+
+// PtypeHasPrefix applies the HasPrefix predicate on the "ptype" field.
+func PtypeHasPrefix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasPrefix(FieldPtype, v))
+}
+
+// PtypeHasSuffix applies the HasSuffix predicate on the "ptype" field.
+func PtypeHasSuffix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasSuffix(FieldPtype, v))
+}
+
+// PtypeEqualFold applies the EqualFold predicate on the "ptype" field.
+func PtypeEqualFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEqualFold(FieldPtype, v))
+}
+
+// PtypeContainsFold applies the ContainsFold predicate on the "ptype" field.
+func PtypeContainsFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContainsFold(FieldPtype, v))
+}
+
+// V0EQ applies the EQ predicate on the "v0" field.
+func V0EQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV0, v))
+}
+
+// V0NEQ applies the NEQ predicate on the "v0" field.
+func V0NEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldV0, v))
+}
+
+// V0In applies the In predicate on the "v0" field.
+func V0In(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldV0, vs...))
+}
+
+// V0NotIn applies the NotIn predicate on the "v0" field.
+func V0NotIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldV0, vs...))
+}
+
+// V0GT applies the GT predicate on the "v0" field.
+func V0GT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldV0, v))
+}
+
+// V0GTE applies the GTE predicate on the "v0" field.
+func V0GTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldV0, v))
+}
+
+// V0LT applies the LT predicate on the "v0" field.
+func V0LT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldV0, v))
+}
+
+// V0LTE applies the LTE predicate on the "v0" field.
+func V0LTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldV0, v))
+}
+
+// V0Contains applies the Contains predicate on the "v0" field.
+func V0Contains(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContains(FieldV0, v))
+}
+
+// V0HasPrefix applies the HasPrefix predicate on the "v0" field.
+func V0HasPrefix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasPrefix(FieldV0, v))
+}
+
+// V0HasSuffix applies the HasSuffix predicate on the "v0" field.
+func V0HasSuffix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasSuffix(FieldV0, v))
+}
+
+// V0EqualFold applies the EqualFold predicate on the "v0" field.
+func V0EqualFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEqualFold(FieldV0, v))
+}
+
+// V0ContainsFold applies the ContainsFold predicate on the "v0" field.
+func V0ContainsFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContainsFold(FieldV0, v))
+}
+
+// V1EQ applies the EQ predicate on the "v1" field.
+func V1EQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV1, v))
+}
+
+// V1NEQ applies the NEQ predicate on the "v1" field.
+func V1NEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldV1, v))
+}
+
+// V1In applies the In predicate on the "v1" field.
+func V1In(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldV1, vs...))
+}
+
+// V1NotIn applies the NotIn predicate on the "v1" field.
+func V1NotIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldV1, vs...))
+}
+
+// V1GT applies the GT predicate on the "v1" field.
+func V1GT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldV1, v))
+}
+
+// V1GTE applies the GTE predicate on the "v1" field.
+func V1GTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldV1, v))
+}
+
+// V1LT applies the LT predicate on the "v1" field.
+func V1LT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldV1, v))
+}
+
+// V1LTE applies the LTE predicate on the "v1" field.
+func V1LTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldV1, v))
+}
+
+// V1Contains applies the Contains predicate on the "v1" field.
+func V1Contains(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContains(FieldV1, v))
+}
+
+// V1HasPrefix applies the HasPrefix predicate on the "v1" field.
+func V1HasPrefix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasPrefix(FieldV1, v))
+}
+
+// V1HasSuffix applies the HasSuffix predicate on the "v1" field.
+func V1HasSuffix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasSuffix(FieldV1, v))
+}
+
+// V1EqualFold applies the EqualFold predicate on the "v1" field.
+func V1EqualFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEqualFold(FieldV1, v))
+}
+
+// V1ContainsFold applies the ContainsFold predicate on the "v1" field.
+func V1ContainsFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContainsFold(FieldV1, v))
+}
+
+// V2EQ applies the EQ predicate on the "v2" field.
+func V2EQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV2, v))
+}
+
+// V2NEQ applies the NEQ predicate on the "v2" field.
+func V2NEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldV2, v))
+}
+
+// V2In applies the In predicate on the "v2" field.
+func V2In(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldV2, vs...))
+}
+
+// V2NotIn applies the NotIn predicate on the "v2" field.
+func V2NotIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldV2, vs...))
+}
+
+// V2GT applies the GT predicate on the "v2" field.
+func V2GT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldV2, v))
+}
+
+// V2GTE applies the GTE predicate on the "v2" field.
+func V2GTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldV2, v))
+}
+
+// V2LT applies the LT predicate on the "v2" field.
+func V2LT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldV2, v))
+}
+
+// V2LTE applies the LTE predicate on the "v2" field.
+func V2LTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldV2, v))
+}
+
+// V2Contains applies the Contains predicate on the "v2" field.
+func V2Contains(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContains(FieldV2, v))
+}
+
+// V2HasPrefix applies the HasPrefix predicate on the "v2" field.
+func V2HasPrefix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasPrefix(FieldV2, v))
+}
+
+// V2HasSuffix applies the HasSuffix predicate on the "v2" field.
+func V2HasSuffix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasSuffix(FieldV2, v))
+}
+
+// V2IsNil applies the IsNil predicate on the "v2" field.
+func V2IsNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIsNull(FieldV2))
+}
+
+// V2NotNil applies the NotNil predicate on the "v2" field.
+func V2NotNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotNull(FieldV2))
+}
+
+// V2EqualFold applies the EqualFold predicate on the "v2" field.
+func V2EqualFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEqualFold(FieldV2, v))
+}
+
+// V2ContainsFold applies the ContainsFold predicate on the "v2" field.
+func V2ContainsFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContainsFold(FieldV2, v))
+}
+
+// V3EQ applies the EQ predicate on the "v3" field.
+func V3EQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV3, v))
+}
+
+// V3NEQ applies the NEQ predicate on the "v3" field.
+func V3NEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldV3, v))
+}
+
+// V3In applies the In predicate on the "v3" field.
+func V3In(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldV3, vs...))
+}
+
+// V3NotIn applies the NotIn predicate on the "v3" field.
+func V3NotIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldV3, vs...))
+}
+
+// V3GT applies the GT predicate on the "v3" field.
+func V3GT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldV3, v))
+}
+
+// V3GTE applies the GTE predicate on the "v3" field.
+func V3GTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldV3, v))
+}
+
+// V3LT applies the LT predicate on the "v3" field.
+func V3LT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldV3, v))
+}
+
+// V3LTE applies the LTE predicate on the "v3" field.
+func V3LTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldV3, v))
+}
+
+// V3Contains applies the Contains predicate on the "v3" field.
+func V3Contains(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContains(FieldV3, v))
+}
+
+// V3HasPrefix applies the HasPrefix predicate on the "v3" field.
+func V3HasPrefix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasPrefix(FieldV3, v))
+}
+
+// V3HasSuffix applies the HasSuffix predicate on the "v3" field.
+func V3HasSuffix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasSuffix(FieldV3, v))
+}
+
+// V3IsNil applies the IsNil predicate on the "v3" field.
+func V3IsNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIsNull(FieldV3))
+}
+
+// V3NotNil applies the NotNil predicate on the "v3" field.
+func V3NotNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotNull(FieldV3))
+}
+
+// V3EqualFold applies the EqualFold predicate on the "v3" field.
+func V3EqualFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEqualFold(FieldV3, v))
+}
+
+// V3ContainsFold applies the ContainsFold predicate on the "v3" field.
+func V3ContainsFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContainsFold(FieldV3, v))
+}
+
+// V4EQ applies the EQ predicate on the "v4" field.
+func V4EQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV4, v))
+}
+
+// V4NEQ applies the NEQ predicate on the "v4" field.
+func V4NEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldV4, v))
+}
+
+// V4In applies the In predicate on the "v4" field.
+func V4In(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldV4, vs...))
+}
+
+// V4NotIn applies the NotIn predicate on the "v4" field.
+func V4NotIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldV4, vs...))
+}
+
+// V4GT applies the GT predicate on the "v4" field.
+func V4GT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldV4, v))
+}
+
+// V4GTE applies the GTE predicate on the "v4" field.
+func V4GTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldV4, v))
+}
+
+// V4LT applies the LT predicate on the "v4" field.
+func V4LT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldV4, v))
+}
+
+// V4LTE applies the LTE predicate on the "v4" field.
+func V4LTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldV4, v))
+}
+
+// V4Contains applies the Contains predicate on the "v4" field.
+func V4Contains(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContains(FieldV4, v))
+}
+
+// V4HasPrefix applies the HasPrefix predicate on the "v4" field.
+func V4HasPrefix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasPrefix(FieldV4, v))
+}
+
+// V4HasSuffix applies the HasSuffix predicate on the "v4" field.
+func V4HasSuffix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasSuffix(FieldV4, v))
+}
+
+// V4IsNil applies the IsNil predicate on the "v4" field.
+func V4IsNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIsNull(FieldV4))
+}
+
+// V4NotNil applies the NotNil predicate on the "v4" field.
+func V4NotNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotNull(FieldV4))
+}
+
+// V4EqualFold applies the EqualFold predicate on the "v4" field.
+func V4EqualFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEqualFold(FieldV4, v))
+}
+
+// V4ContainsFold applies the ContainsFold predicate on the "v4" field.
+func V4ContainsFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContainsFold(FieldV4, v))
+}
+
+// V5EQ applies the EQ predicate on the "v5" field.
+func V5EQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEQ(FieldV5, v))
+}
+
+// V5NEQ applies the NEQ predicate on the "v5" field.
+func V5NEQ(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNEQ(FieldV5, v))
+}
+
+// V5In applies the In predicate on the "v5" field.
+func V5In(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIn(FieldV5, vs...))
+}
+
+// V5NotIn applies the NotIn predicate on the "v5" field.
+func V5NotIn(vs ...string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotIn(FieldV5, vs...))
+}
+
+// V5GT applies the GT predicate on the "v5" field.
+func V5GT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGT(FieldV5, v))
+}
+
+// V5GTE applies the GTE predicate on the "v5" field.
+func V5GTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldGTE(FieldV5, v))
+}
+
+// V5LT applies the LT predicate on the "v5" field.
+func V5LT(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLT(FieldV5, v))
+}
+
+// V5LTE applies the LTE predicate on the "v5" field.
+func V5LTE(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldLTE(FieldV5, v))
+}
+
+// V5Contains applies the Contains predicate on the "v5" field.
+func V5Contains(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContains(FieldV5, v))
+}
+
+// V5HasPrefix applies the HasPrefix predicate on the "v5" field.
+func V5HasPrefix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasPrefix(FieldV5, v))
+}
+
+// V5HasSuffix applies the HasSuffix predicate on the "v5" field.
+func V5HasSuffix(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldHasSuffix(FieldV5, v))
+}
+
+// V5IsNil applies the IsNil predicate on the "v5" field.
+func V5IsNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldIsNull(FieldV5))
+}
+
+// V5NotNil applies the NotNil predicate on the "v5" field.
+func V5NotNil() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldNotNull(FieldV5))
+}
+
+// V5EqualFold applies the EqualFold predicate on the "v5" field.
+func V5EqualFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldEqualFold(FieldV5, v))
+}
+
+// V5ContainsFold applies the ContainsFold predicate on the "v5" field.
+func V5ContainsFold(v string) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.FieldContainsFold(FieldV5, v))
+}
+
+// HasScaAuthRole applies the HasEdge predicate on the "sca_auth_role" edge.
+func HasScaAuthRole() predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, ScaAuthRoleTable, ScaAuthRoleColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasScaAuthRoleWith applies the HasEdge predicate on the "sca_auth_role" edge with a given conditions (other predicates).
+func HasScaAuthRoleWith(preds ...predicate.ScaAuthRole) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(func(s *sql.Selector) {
+		step := newScaAuthRoleStep()
+		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.ScaAuthPermissionRule) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ScaAuthPermissionRule) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ScaAuthPermissionRule) predicate.ScaAuthPermissionRule {
+	return predicate.ScaAuthPermissionRule(sql.NotPredicates(p))
+}

app/core/api/repository/mysql/ent/scaauthpermissionrule_create.go

@@ -0,0 +1,365 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthPermissionRuleCreate is the builder for creating a ScaAuthPermissionRule entity.
+type ScaAuthPermissionRuleCreate struct {
+	config
+	mutation *ScaAuthPermissionRuleMutation
+	hooks    []Hook
+}
+
+// SetPtype sets the "ptype" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetPtype(s string) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetPtype(s)
+	return saprc
+}
+
+// SetV0 sets the "v0" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetV0(s string) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetV0(s)
+	return saprc
+}
+
+// SetV1 sets the "v1" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetV1(s string) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetV1(s)
+	return saprc
+}
+
+// SetV2 sets the "v2" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetV2(s string) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetV2(s)
+	return saprc
+}
+
+// SetNillableV2 sets the "v2" field if the given value is not nil.
+func (saprc *ScaAuthPermissionRuleCreate) SetNillableV2(s *string) *ScaAuthPermissionRuleCreate {
+	if s != nil {
+		saprc.SetV2(*s)
+	}
+	return saprc
+}
+
+// SetV3 sets the "v3" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetV3(s string) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetV3(s)
+	return saprc
+}
+
+// SetNillableV3 sets the "v3" field if the given value is not nil.
+func (saprc *ScaAuthPermissionRuleCreate) SetNillableV3(s *string) *ScaAuthPermissionRuleCreate {
+	if s != nil {
+		saprc.SetV3(*s)
+	}
+	return saprc
+}
+
+// SetV4 sets the "v4" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetV4(s string) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetV4(s)
+	return saprc
+}
+
+// SetNillableV4 sets the "v4" field if the given value is not nil.
+func (saprc *ScaAuthPermissionRuleCreate) SetNillableV4(s *string) *ScaAuthPermissionRuleCreate {
+	if s != nil {
+		saprc.SetV4(*s)
+	}
+	return saprc
+}
+
+// SetV5 sets the "v5" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetV5(s string) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetV5(s)
+	return saprc
+}
+
+// SetNillableV5 sets the "v5" field if the given value is not nil.
+func (saprc *ScaAuthPermissionRuleCreate) SetNillableV5(s *string) *ScaAuthPermissionRuleCreate {
+	if s != nil {
+		saprc.SetV5(*s)
+	}
+	return saprc
+}
+
+// SetID sets the "id" field.
+func (saprc *ScaAuthPermissionRuleCreate) SetID(i int64) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetID(i)
+	return saprc
+}
+
+// SetScaAuthRoleID sets the "sca_auth_role" edge to the ScaAuthRole entity by ID.
+func (saprc *ScaAuthPermissionRuleCreate) SetScaAuthRoleID(id int64) *ScaAuthPermissionRuleCreate {
+	saprc.mutation.SetScaAuthRoleID(id)
+	return saprc
+}
+
+// SetNillableScaAuthRoleID sets the "sca_auth_role" edge to the ScaAuthRole entity by ID if the given value is not nil.
+func (saprc *ScaAuthPermissionRuleCreate) SetNillableScaAuthRoleID(id *int64) *ScaAuthPermissionRuleCreate {
+	if id != nil {
+		saprc = saprc.SetScaAuthRoleID(*id)
+	}
+	return saprc
+}
+
+// SetScaAuthRole sets the "sca_auth_role" edge to the ScaAuthRole entity.
+func (saprc *ScaAuthPermissionRuleCreate) SetScaAuthRole(s *ScaAuthRole) *ScaAuthPermissionRuleCreate {
+	return saprc.SetScaAuthRoleID(s.ID)
+}
+
+// Mutation returns the ScaAuthPermissionRuleMutation object of the builder.
+func (saprc *ScaAuthPermissionRuleCreate) Mutation() *ScaAuthPermissionRuleMutation {
+	return saprc.mutation
+}
+
+// Save creates the ScaAuthPermissionRule in the database.
+func (saprc *ScaAuthPermissionRuleCreate) Save(ctx context.Context) (*ScaAuthPermissionRule, error) {
+	return withHooks(ctx, saprc.sqlSave, saprc.mutation, saprc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (saprc *ScaAuthPermissionRuleCreate) SaveX(ctx context.Context) *ScaAuthPermissionRule {
+	v, err := saprc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (saprc *ScaAuthPermissionRuleCreate) Exec(ctx context.Context) error {
+	_, err := saprc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saprc *ScaAuthPermissionRuleCreate) ExecX(ctx context.Context) {
+	if err := saprc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (saprc *ScaAuthPermissionRuleCreate) check() error {
+	if _, ok := saprc.mutation.Ptype(); !ok {
+		return &ValidationError{Name: "ptype", err: errors.New(`ent: missing required field "ScaAuthPermissionRule.ptype"`)}
+	}
+	if v, ok := saprc.mutation.Ptype(); ok {
+		if err := scaauthpermissionrule.PtypeValidator(v); err != nil {
+			return &ValidationError{Name: "ptype", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.ptype": %w`, err)}
+		}
+	}
+	if _, ok := saprc.mutation.V0(); !ok {
+		return &ValidationError{Name: "v0", err: errors.New(`ent: missing required field "ScaAuthPermissionRule.v0"`)}
+	}
+	if v, ok := saprc.mutation.V0(); ok {
+		if err := scaauthpermissionrule.V0Validator(v); err != nil {
+			return &ValidationError{Name: "v0", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v0": %w`, err)}
+		}
+	}
+	if _, ok := saprc.mutation.V1(); !ok {
+		return &ValidationError{Name: "v1", err: errors.New(`ent: missing required field "ScaAuthPermissionRule.v1"`)}
+	}
+	if v, ok := saprc.mutation.V1(); ok {
+		if err := scaauthpermissionrule.V1Validator(v); err != nil {
+			return &ValidationError{Name: "v1", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v1": %w`, err)}
+		}
+	}
+	if v, ok := saprc.mutation.V2(); ok {
+		if err := scaauthpermissionrule.V2Validator(v); err != nil {
+			return &ValidationError{Name: "v2", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v2": %w`, err)}
+		}
+	}
+	if v, ok := saprc.mutation.V3(); ok {
+		if err := scaauthpermissionrule.V3Validator(v); err != nil {
+			return &ValidationError{Name: "v3", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v3": %w`, err)}
+		}
+	}
+	if v, ok := saprc.mutation.V4(); ok {
+		if err := scaauthpermissionrule.V4Validator(v); err != nil {
+			return &ValidationError{Name: "v4", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v4": %w`, err)}
+		}
+	}
+	if v, ok := saprc.mutation.V5(); ok {
+		if err := scaauthpermissionrule.V5Validator(v); err != nil {
+			return &ValidationError{Name: "v5", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v5": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (saprc *ScaAuthPermissionRuleCreate) sqlSave(ctx context.Context) (*ScaAuthPermissionRule, error) {
+	if err := saprc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := saprc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, saprc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != _node.ID {
+		id := _spec.ID.Value.(int64)
+		_node.ID = int64(id)
+	}
+	saprc.mutation.id = &_node.ID
+	saprc.mutation.done = true
+	return _node, nil
+}
+
+func (saprc *ScaAuthPermissionRuleCreate) createSpec() (*ScaAuthPermissionRule, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ScaAuthPermissionRule{config: saprc.config}
+		_spec = sqlgraph.NewCreateSpec(scaauthpermissionrule.Table, sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64))
+	)
+	if id, ok := saprc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := saprc.mutation.Ptype(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldPtype, field.TypeString, value)
+		_node.Ptype = &value
+	}
+	if value, ok := saprc.mutation.V0(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV0, field.TypeString, value)
+		_node.V0 = &value
+	}
+	if value, ok := saprc.mutation.V1(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV1, field.TypeString, value)
+		_node.V1 = &value
+	}
+	if value, ok := saprc.mutation.V2(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV2, field.TypeString, value)
+		_node.V2 = &value
+	}
+	if value, ok := saprc.mutation.V3(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV3, field.TypeString, value)
+		_node.V3 = &value
+	}
+	if value, ok := saprc.mutation.V4(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV4, field.TypeString, value)
+		_node.V4 = &value
+	}
+	if value, ok := saprc.mutation.V5(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV5, field.TypeString, value)
+		_node.V5 = &value
+	}
+	if nodes := saprc.mutation.ScaAuthRoleIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthpermissionrule.ScaAuthRoleTable,
+			Columns: []string{scaauthpermissionrule.ScaAuthRoleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.sca_auth_role_sca_auth_permission_rule = &nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// ScaAuthPermissionRuleCreateBulk is the builder for creating many ScaAuthPermissionRule entities in bulk.
+type ScaAuthPermissionRuleCreateBulk struct {
+	config
+	err      error
+	builders []*ScaAuthPermissionRuleCreate
+}
+
+// Save creates the ScaAuthPermissionRule entities in the database.
+func (saprcb *ScaAuthPermissionRuleCreateBulk) Save(ctx context.Context) ([]*ScaAuthPermissionRule, error) {
+	if saprcb.err != nil {
+		return nil, saprcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(saprcb.builders))
+	nodes := make([]*ScaAuthPermissionRule, len(saprcb.builders))
+	mutators := make([]Mutator, len(saprcb.builders))
+	for i := range saprcb.builders {
+		func(i int, root context.Context) {
+			builder := saprcb.builders[i]
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ScaAuthPermissionRuleMutation)
+				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, saprcb.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, saprcb.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 && nodes[i].ID == 0 {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int64(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, saprcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (saprcb *ScaAuthPermissionRuleCreateBulk) SaveX(ctx context.Context) []*ScaAuthPermissionRule {
+	v, err := saprcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (saprcb *ScaAuthPermissionRuleCreateBulk) Exec(ctx context.Context) error {
+	_, err := saprcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saprcb *ScaAuthPermissionRuleCreateBulk) ExecX(ctx context.Context) {
+	if err := saprcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthpermissionrule_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthPermissionRuleDelete is the builder for deleting a ScaAuthPermissionRule entity.
+type ScaAuthPermissionRuleDelete struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthPermissionRuleMutation
+}
+
+// Where appends a list predicates to the ScaAuthPermissionRuleDelete builder.
+func (saprd *ScaAuthPermissionRuleDelete) Where(ps ...predicate.ScaAuthPermissionRule) *ScaAuthPermissionRuleDelete {
+	saprd.mutation.Where(ps...)
+	return saprd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (saprd *ScaAuthPermissionRuleDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, saprd.sqlExec, saprd.mutation, saprd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saprd *ScaAuthPermissionRuleDelete) ExecX(ctx context.Context) int {
+	n, err := saprd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (saprd *ScaAuthPermissionRuleDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(scaauthpermissionrule.Table, sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64))
+	if ps := saprd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, saprd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	saprd.mutation.done = true
+	return affected, err
+}
+
+// ScaAuthPermissionRuleDeleteOne is the builder for deleting a single ScaAuthPermissionRule entity.
+type ScaAuthPermissionRuleDeleteOne struct {
+	saprd *ScaAuthPermissionRuleDelete
+}
+
+// Where appends a list predicates to the ScaAuthPermissionRuleDelete builder.
+func (saprdo *ScaAuthPermissionRuleDeleteOne) Where(ps ...predicate.ScaAuthPermissionRule) *ScaAuthPermissionRuleDeleteOne {
+	saprdo.saprd.mutation.Where(ps...)
+	return saprdo
+}
+
+// Exec executes the deletion query.
+func (saprdo *ScaAuthPermissionRuleDeleteOne) Exec(ctx context.Context) error {
+	n, err := saprdo.saprd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{scaauthpermissionrule.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saprdo *ScaAuthPermissionRuleDeleteOne) ExecX(ctx context.Context) {
+	if err := saprdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthpermissionrule_query.go

@@ -0,0 +1,614 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthPermissionRuleQuery is the builder for querying ScaAuthPermissionRule entities.
+type ScaAuthPermissionRuleQuery struct {
+	config
+	ctx             *QueryContext
+	order           []scaauthpermissionrule.OrderOption
+	inters          []Interceptor
+	predicates      []predicate.ScaAuthPermissionRule
+	withScaAuthRole *ScaAuthRoleQuery
+	withFKs         bool
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ScaAuthPermissionRuleQuery builder.
+func (saprq *ScaAuthPermissionRuleQuery) Where(ps ...predicate.ScaAuthPermissionRule) *ScaAuthPermissionRuleQuery {
+	saprq.predicates = append(saprq.predicates, ps...)
+	return saprq
+}
+
+// Limit the number of records to be returned by this query.
+func (saprq *ScaAuthPermissionRuleQuery) Limit(limit int) *ScaAuthPermissionRuleQuery {
+	saprq.ctx.Limit = &limit
+	return saprq
+}
+
+// Offset to start from.
+func (saprq *ScaAuthPermissionRuleQuery) Offset(offset int) *ScaAuthPermissionRuleQuery {
+	saprq.ctx.Offset = &offset
+	return saprq
+}
+
+// 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 (saprq *ScaAuthPermissionRuleQuery) Unique(unique bool) *ScaAuthPermissionRuleQuery {
+	saprq.ctx.Unique = &unique
+	return saprq
+}
+
+// Order specifies how the records should be ordered.
+func (saprq *ScaAuthPermissionRuleQuery) Order(o ...scaauthpermissionrule.OrderOption) *ScaAuthPermissionRuleQuery {
+	saprq.order = append(saprq.order, o...)
+	return saprq
+}
+
+// QueryScaAuthRole chains the current query on the "sca_auth_role" edge.
+func (saprq *ScaAuthPermissionRuleQuery) QueryScaAuthRole() *ScaAuthRoleQuery {
+	query := (&ScaAuthRoleClient{config: saprq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := saprq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := saprq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(scaauthpermissionrule.Table, scaauthpermissionrule.FieldID, selector),
+			sqlgraph.To(scaauthrole.Table, scaauthrole.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, scaauthpermissionrule.ScaAuthRoleTable, scaauthpermissionrule.ScaAuthRoleColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(saprq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first ScaAuthPermissionRule entity from the query.
+// Returns a *NotFoundError when no ScaAuthPermissionRule was found.
+func (saprq *ScaAuthPermissionRuleQuery) First(ctx context.Context) (*ScaAuthPermissionRule, error) {
+	nodes, err := saprq.Limit(1).All(setContextOp(ctx, saprq.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{scaauthpermissionrule.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (saprq *ScaAuthPermissionRuleQuery) FirstX(ctx context.Context) *ScaAuthPermissionRule {
+	node, err := saprq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ScaAuthPermissionRule ID from the query.
+// Returns a *NotFoundError when no ScaAuthPermissionRule ID was found.
+func (saprq *ScaAuthPermissionRuleQuery) FirstID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = saprq.Limit(1).IDs(setContextOp(ctx, saprq.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{scaauthpermissionrule.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (saprq *ScaAuthPermissionRuleQuery) FirstIDX(ctx context.Context) int64 {
+	id, err := saprq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ScaAuthPermissionRule entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ScaAuthPermissionRule entity is found.
+// Returns a *NotFoundError when no ScaAuthPermissionRule entities are found.
+func (saprq *ScaAuthPermissionRuleQuery) Only(ctx context.Context) (*ScaAuthPermissionRule, error) {
+	nodes, err := saprq.Limit(2).All(setContextOp(ctx, saprq.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{scaauthpermissionrule.Label}
+	default:
+		return nil, &NotSingularError{scaauthpermissionrule.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (saprq *ScaAuthPermissionRuleQuery) OnlyX(ctx context.Context) *ScaAuthPermissionRule {
+	node, err := saprq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ScaAuthPermissionRule ID in the query.
+// Returns a *NotSingularError when more than one ScaAuthPermissionRule ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (saprq *ScaAuthPermissionRuleQuery) OnlyID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = saprq.Limit(2).IDs(setContextOp(ctx, saprq.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{scaauthpermissionrule.Label}
+	default:
+		err = &NotSingularError{scaauthpermissionrule.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (saprq *ScaAuthPermissionRuleQuery) OnlyIDX(ctx context.Context) int64 {
+	id, err := saprq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ScaAuthPermissionRules.
+func (saprq *ScaAuthPermissionRuleQuery) All(ctx context.Context) ([]*ScaAuthPermissionRule, error) {
+	ctx = setContextOp(ctx, saprq.ctx, ent.OpQueryAll)
+	if err := saprq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ScaAuthPermissionRule, *ScaAuthPermissionRuleQuery]()
+	return withInterceptors[[]*ScaAuthPermissionRule](ctx, saprq, qr, saprq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (saprq *ScaAuthPermissionRuleQuery) AllX(ctx context.Context) []*ScaAuthPermissionRule {
+	nodes, err := saprq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ScaAuthPermissionRule IDs.
+func (saprq *ScaAuthPermissionRuleQuery) IDs(ctx context.Context) (ids []int64, err error) {
+	if saprq.ctx.Unique == nil && saprq.path != nil {
+		saprq.Unique(true)
+	}
+	ctx = setContextOp(ctx, saprq.ctx, ent.OpQueryIDs)
+	if err = saprq.Select(scaauthpermissionrule.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (saprq *ScaAuthPermissionRuleQuery) IDsX(ctx context.Context) []int64 {
+	ids, err := saprq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (saprq *ScaAuthPermissionRuleQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, saprq.ctx, ent.OpQueryCount)
+	if err := saprq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, saprq, querierCount[*ScaAuthPermissionRuleQuery](), saprq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (saprq *ScaAuthPermissionRuleQuery) CountX(ctx context.Context) int {
+	count, err := saprq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (saprq *ScaAuthPermissionRuleQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, saprq.ctx, ent.OpQueryExist)
+	switch _, err := saprq.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 (saprq *ScaAuthPermissionRuleQuery) ExistX(ctx context.Context) bool {
+	exist, err := saprq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ScaAuthPermissionRuleQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (saprq *ScaAuthPermissionRuleQuery) Clone() *ScaAuthPermissionRuleQuery {
+	if saprq == nil {
+		return nil
+	}
+	return &ScaAuthPermissionRuleQuery{
+		config:          saprq.config,
+		ctx:             saprq.ctx.Clone(),
+		order:           append([]scaauthpermissionrule.OrderOption{}, saprq.order...),
+		inters:          append([]Interceptor{}, saprq.inters...),
+		predicates:      append([]predicate.ScaAuthPermissionRule{}, saprq.predicates...),
+		withScaAuthRole: saprq.withScaAuthRole.Clone(),
+		// clone intermediate query.
+		sql:  saprq.sql.Clone(),
+		path: saprq.path,
+	}
+}
+
+// WithScaAuthRole tells the query-builder to eager-load the nodes that are connected to
+// the "sca_auth_role" edge. The optional arguments are used to configure the query builder of the edge.
+func (saprq *ScaAuthPermissionRuleQuery) WithScaAuthRole(opts ...func(*ScaAuthRoleQuery)) *ScaAuthPermissionRuleQuery {
+	query := (&ScaAuthRoleClient{config: saprq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	saprq.withScaAuthRole = query
+	return saprq
+}
+
+// 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 {
+//		Ptype string `json:"ptype,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthPermissionRule.Query().
+//		GroupBy(scaauthpermissionrule.FieldPtype).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (saprq *ScaAuthPermissionRuleQuery) GroupBy(field string, fields ...string) *ScaAuthPermissionRuleGroupBy {
+	saprq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ScaAuthPermissionRuleGroupBy{build: saprq}
+	grbuild.flds = &saprq.ctx.Fields
+	grbuild.label = scaauthpermissionrule.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 {
+//		Ptype string `json:"ptype,omitempty"`
+//	}
+//
+//	client.ScaAuthPermissionRule.Query().
+//		Select(scaauthpermissionrule.FieldPtype).
+//		Scan(ctx, &v)
+func (saprq *ScaAuthPermissionRuleQuery) Select(fields ...string) *ScaAuthPermissionRuleSelect {
+	saprq.ctx.Fields = append(saprq.ctx.Fields, fields...)
+	sbuild := &ScaAuthPermissionRuleSelect{ScaAuthPermissionRuleQuery: saprq}
+	sbuild.label = scaauthpermissionrule.Label
+	sbuild.flds, sbuild.scan = &saprq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ScaAuthPermissionRuleSelect configured with the given aggregations.
+func (saprq *ScaAuthPermissionRuleQuery) Aggregate(fns ...AggregateFunc) *ScaAuthPermissionRuleSelect {
+	return saprq.Select().Aggregate(fns...)
+}
+
+func (saprq *ScaAuthPermissionRuleQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range saprq.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, saprq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range saprq.ctx.Fields {
+		if !scaauthpermissionrule.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if saprq.path != nil {
+		prev, err := saprq.path(ctx)
+		if err != nil {
+			return err
+		}
+		saprq.sql = prev
+	}
+	return nil
+}
+
+func (saprq *ScaAuthPermissionRuleQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ScaAuthPermissionRule, error) {
+	var (
+		nodes       = []*ScaAuthPermissionRule{}
+		withFKs     = saprq.withFKs
+		_spec       = saprq.querySpec()
+		loadedTypes = [1]bool{
+			saprq.withScaAuthRole != nil,
+		}
+	)
+	if saprq.withScaAuthRole != nil {
+		withFKs = true
+	}
+	if withFKs {
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthpermissionrule.ForeignKeys...)
+	}
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ScaAuthPermissionRule).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ScaAuthPermissionRule{config: saprq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, saprq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := saprq.withScaAuthRole; query != nil {
+		if err := saprq.loadScaAuthRole(ctx, query, nodes, nil,
+			func(n *ScaAuthPermissionRule, e *ScaAuthRole) { n.Edges.ScaAuthRole = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (saprq *ScaAuthPermissionRuleQuery) loadScaAuthRole(ctx context.Context, query *ScaAuthRoleQuery, nodes []*ScaAuthPermissionRule, init func(*ScaAuthPermissionRule), assign func(*ScaAuthPermissionRule, *ScaAuthRole)) error {
+	ids := make([]int64, 0, len(nodes))
+	nodeids := make(map[int64][]*ScaAuthPermissionRule)
+	for i := range nodes {
+		if nodes[i].sca_auth_role_sca_auth_permission_rule == nil {
+			continue
+		}
+		fk := *nodes[i].sca_auth_role_sca_auth_permission_rule
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(scaauthrole.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 "sca_auth_role_sca_auth_permission_rule" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (saprq *ScaAuthPermissionRuleQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := saprq.querySpec()
+	_spec.Node.Columns = saprq.ctx.Fields
+	if len(saprq.ctx.Fields) > 0 {
+		_spec.Unique = saprq.ctx.Unique != nil && *saprq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, saprq.driver, _spec)
+}
+
+func (saprq *ScaAuthPermissionRuleQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(scaauthpermissionrule.Table, scaauthpermissionrule.Columns, sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64))
+	_spec.From = saprq.sql
+	if unique := saprq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if saprq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := saprq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthpermissionrule.FieldID)
+		for i := range fields {
+			if fields[i] != scaauthpermissionrule.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := saprq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := saprq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := saprq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := saprq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (saprq *ScaAuthPermissionRuleQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(saprq.driver.Dialect())
+	t1 := builder.Table(scaauthpermissionrule.Table)
+	columns := saprq.ctx.Fields
+	if len(columns) == 0 {
+		columns = scaauthpermissionrule.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if saprq.sql != nil {
+		selector = saprq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if saprq.ctx.Unique != nil && *saprq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range saprq.predicates {
+		p(selector)
+	}
+	for _, p := range saprq.order {
+		p(selector)
+	}
+	if offset := saprq.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 := saprq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ScaAuthPermissionRuleGroupBy is the group-by builder for ScaAuthPermissionRule entities.
+type ScaAuthPermissionRuleGroupBy struct {
+	selector
+	build *ScaAuthPermissionRuleQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (saprgb *ScaAuthPermissionRuleGroupBy) Aggregate(fns ...AggregateFunc) *ScaAuthPermissionRuleGroupBy {
+	saprgb.fns = append(saprgb.fns, fns...)
+	return saprgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (saprgb *ScaAuthPermissionRuleGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, saprgb.build.ctx, ent.OpQueryGroupBy)
+	if err := saprgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthPermissionRuleQuery, *ScaAuthPermissionRuleGroupBy](ctx, saprgb.build, saprgb, saprgb.build.inters, v)
+}
+
+func (saprgb *ScaAuthPermissionRuleGroupBy) sqlScan(ctx context.Context, root *ScaAuthPermissionRuleQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(saprgb.fns))
+	for _, fn := range saprgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*saprgb.flds)+len(saprgb.fns))
+		for _, f := range *saprgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*saprgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := saprgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ScaAuthPermissionRuleSelect is the builder for selecting fields of ScaAuthPermissionRule entities.
+type ScaAuthPermissionRuleSelect struct {
+	*ScaAuthPermissionRuleQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (saprs *ScaAuthPermissionRuleSelect) Aggregate(fns ...AggregateFunc) *ScaAuthPermissionRuleSelect {
+	saprs.fns = append(saprs.fns, fns...)
+	return saprs
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (saprs *ScaAuthPermissionRuleSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, saprs.ctx, ent.OpQuerySelect)
+	if err := saprs.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthPermissionRuleQuery, *ScaAuthPermissionRuleSelect](ctx, saprs.ScaAuthPermissionRuleQuery, saprs, saprs.inters, v)
+}
+
+func (saprs *ScaAuthPermissionRuleSelect) sqlScan(ctx context.Context, root *ScaAuthPermissionRuleQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(saprs.fns))
+	for _, fn := range saprs.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*saprs.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 := saprs.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

app/core/api/repository/mysql/ent/scaauthpermissionrule_update.go

@@ -0,0 +1,680 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthPermissionRuleUpdate is the builder for updating ScaAuthPermissionRule entities.
+type ScaAuthPermissionRuleUpdate struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthPermissionRuleMutation
+}
+
+// Where appends a list predicates to the ScaAuthPermissionRuleUpdate builder.
+func (sapru *ScaAuthPermissionRuleUpdate) Where(ps ...predicate.ScaAuthPermissionRule) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.Where(ps...)
+	return sapru
+}
+
+// SetPtype sets the "ptype" field.
+func (sapru *ScaAuthPermissionRuleUpdate) SetPtype(s string) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetPtype(s)
+	return sapru
+}
+
+// SetNillablePtype sets the "ptype" field if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillablePtype(s *string) *ScaAuthPermissionRuleUpdate {
+	if s != nil {
+		sapru.SetPtype(*s)
+	}
+	return sapru
+}
+
+// SetV0 sets the "v0" field.
+func (sapru *ScaAuthPermissionRuleUpdate) SetV0(s string) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetV0(s)
+	return sapru
+}
+
+// SetNillableV0 sets the "v0" field if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillableV0(s *string) *ScaAuthPermissionRuleUpdate {
+	if s != nil {
+		sapru.SetV0(*s)
+	}
+	return sapru
+}
+
+// SetV1 sets the "v1" field.
+func (sapru *ScaAuthPermissionRuleUpdate) SetV1(s string) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetV1(s)
+	return sapru
+}
+
+// SetNillableV1 sets the "v1" field if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillableV1(s *string) *ScaAuthPermissionRuleUpdate {
+	if s != nil {
+		sapru.SetV1(*s)
+	}
+	return sapru
+}
+
+// SetV2 sets the "v2" field.
+func (sapru *ScaAuthPermissionRuleUpdate) SetV2(s string) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetV2(s)
+	return sapru
+}
+
+// SetNillableV2 sets the "v2" field if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillableV2(s *string) *ScaAuthPermissionRuleUpdate {
+	if s != nil {
+		sapru.SetV2(*s)
+	}
+	return sapru
+}
+
+// ClearV2 clears the value of the "v2" field.
+func (sapru *ScaAuthPermissionRuleUpdate) ClearV2() *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.ClearV2()
+	return sapru
+}
+
+// SetV3 sets the "v3" field.
+func (sapru *ScaAuthPermissionRuleUpdate) SetV3(s string) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetV3(s)
+	return sapru
+}
+
+// SetNillableV3 sets the "v3" field if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillableV3(s *string) *ScaAuthPermissionRuleUpdate {
+	if s != nil {
+		sapru.SetV3(*s)
+	}
+	return sapru
+}
+
+// ClearV3 clears the value of the "v3" field.
+func (sapru *ScaAuthPermissionRuleUpdate) ClearV3() *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.ClearV3()
+	return sapru
+}
+
+// SetV4 sets the "v4" field.
+func (sapru *ScaAuthPermissionRuleUpdate) SetV4(s string) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetV4(s)
+	return sapru
+}
+
+// SetNillableV4 sets the "v4" field if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillableV4(s *string) *ScaAuthPermissionRuleUpdate {
+	if s != nil {
+		sapru.SetV4(*s)
+	}
+	return sapru
+}
+
+// ClearV4 clears the value of the "v4" field.
+func (sapru *ScaAuthPermissionRuleUpdate) ClearV4() *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.ClearV4()
+	return sapru
+}
+
+// SetV5 sets the "v5" field.
+func (sapru *ScaAuthPermissionRuleUpdate) SetV5(s string) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetV5(s)
+	return sapru
+}
+
+// SetNillableV5 sets the "v5" field if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillableV5(s *string) *ScaAuthPermissionRuleUpdate {
+	if s != nil {
+		sapru.SetV5(*s)
+	}
+	return sapru
+}
+
+// ClearV5 clears the value of the "v5" field.
+func (sapru *ScaAuthPermissionRuleUpdate) ClearV5() *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.ClearV5()
+	return sapru
+}
+
+// SetScaAuthRoleID sets the "sca_auth_role" edge to the ScaAuthRole entity by ID.
+func (sapru *ScaAuthPermissionRuleUpdate) SetScaAuthRoleID(id int64) *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.SetScaAuthRoleID(id)
+	return sapru
+}
+
+// SetNillableScaAuthRoleID sets the "sca_auth_role" edge to the ScaAuthRole entity by ID if the given value is not nil.
+func (sapru *ScaAuthPermissionRuleUpdate) SetNillableScaAuthRoleID(id *int64) *ScaAuthPermissionRuleUpdate {
+	if id != nil {
+		sapru = sapru.SetScaAuthRoleID(*id)
+	}
+	return sapru
+}
+
+// SetScaAuthRole sets the "sca_auth_role" edge to the ScaAuthRole entity.
+func (sapru *ScaAuthPermissionRuleUpdate) SetScaAuthRole(s *ScaAuthRole) *ScaAuthPermissionRuleUpdate {
+	return sapru.SetScaAuthRoleID(s.ID)
+}
+
+// Mutation returns the ScaAuthPermissionRuleMutation object of the builder.
+func (sapru *ScaAuthPermissionRuleUpdate) Mutation() *ScaAuthPermissionRuleMutation {
+	return sapru.mutation
+}
+
+// ClearScaAuthRole clears the "sca_auth_role" edge to the ScaAuthRole entity.
+func (sapru *ScaAuthPermissionRuleUpdate) ClearScaAuthRole() *ScaAuthPermissionRuleUpdate {
+	sapru.mutation.ClearScaAuthRole()
+	return sapru
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (sapru *ScaAuthPermissionRuleUpdate) Save(ctx context.Context) (int, error) {
+	return withHooks(ctx, sapru.sqlSave, sapru.mutation, sapru.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (sapru *ScaAuthPermissionRuleUpdate) SaveX(ctx context.Context) int {
+	affected, err := sapru.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (sapru *ScaAuthPermissionRuleUpdate) Exec(ctx context.Context) error {
+	_, err := sapru.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sapru *ScaAuthPermissionRuleUpdate) ExecX(ctx context.Context) {
+	if err := sapru.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sapru *ScaAuthPermissionRuleUpdate) check() error {
+	if v, ok := sapru.mutation.Ptype(); ok {
+		if err := scaauthpermissionrule.PtypeValidator(v); err != nil {
+			return &ValidationError{Name: "ptype", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.ptype": %w`, err)}
+		}
+	}
+	if v, ok := sapru.mutation.V0(); ok {
+		if err := scaauthpermissionrule.V0Validator(v); err != nil {
+			return &ValidationError{Name: "v0", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v0": %w`, err)}
+		}
+	}
+	if v, ok := sapru.mutation.V1(); ok {
+		if err := scaauthpermissionrule.V1Validator(v); err != nil {
+			return &ValidationError{Name: "v1", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v1": %w`, err)}
+		}
+	}
+	if v, ok := sapru.mutation.V2(); ok {
+		if err := scaauthpermissionrule.V2Validator(v); err != nil {
+			return &ValidationError{Name: "v2", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v2": %w`, err)}
+		}
+	}
+	if v, ok := sapru.mutation.V3(); ok {
+		if err := scaauthpermissionrule.V3Validator(v); err != nil {
+			return &ValidationError{Name: "v3", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v3": %w`, err)}
+		}
+	}
+	if v, ok := sapru.mutation.V4(); ok {
+		if err := scaauthpermissionrule.V4Validator(v); err != nil {
+			return &ValidationError{Name: "v4", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v4": %w`, err)}
+		}
+	}
+	if v, ok := sapru.mutation.V5(); ok {
+		if err := scaauthpermissionrule.V5Validator(v); err != nil {
+			return &ValidationError{Name: "v5", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v5": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (sapru *ScaAuthPermissionRuleUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := sapru.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthpermissionrule.Table, scaauthpermissionrule.Columns, sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64))
+	if ps := sapru.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := sapru.mutation.Ptype(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldPtype, field.TypeString, value)
+	}
+	if value, ok := sapru.mutation.V0(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV0, field.TypeString, value)
+	}
+	if value, ok := sapru.mutation.V1(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV1, field.TypeString, value)
+	}
+	if value, ok := sapru.mutation.V2(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV2, field.TypeString, value)
+	}
+	if sapru.mutation.V2Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV2, field.TypeString)
+	}
+	if value, ok := sapru.mutation.V3(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV3, field.TypeString, value)
+	}
+	if sapru.mutation.V3Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV3, field.TypeString)
+	}
+	if value, ok := sapru.mutation.V4(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV4, field.TypeString, value)
+	}
+	if sapru.mutation.V4Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV4, field.TypeString)
+	}
+	if value, ok := sapru.mutation.V5(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV5, field.TypeString, value)
+	}
+	if sapru.mutation.V5Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV5, field.TypeString)
+	}
+	if sapru.mutation.ScaAuthRoleCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthpermissionrule.ScaAuthRoleTable,
+			Columns: []string{scaauthpermissionrule.ScaAuthRoleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := sapru.mutation.ScaAuthRoleIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthpermissionrule.ScaAuthRoleTable,
+			Columns: []string{scaauthpermissionrule.ScaAuthRoleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64),
+			},
+		}
+		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, sapru.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthpermissionrule.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	sapru.mutation.done = true
+	return n, nil
+}
+
+// ScaAuthPermissionRuleUpdateOne is the builder for updating a single ScaAuthPermissionRule entity.
+type ScaAuthPermissionRuleUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *ScaAuthPermissionRuleMutation
+}
+
+// SetPtype sets the "ptype" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetPtype(s string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetPtype(s)
+	return sapruo
+}
+
+// SetNillablePtype sets the "ptype" field if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillablePtype(s *string) *ScaAuthPermissionRuleUpdateOne {
+	if s != nil {
+		sapruo.SetPtype(*s)
+	}
+	return sapruo
+}
+
+// SetV0 sets the "v0" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetV0(s string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetV0(s)
+	return sapruo
+}
+
+// SetNillableV0 sets the "v0" field if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillableV0(s *string) *ScaAuthPermissionRuleUpdateOne {
+	if s != nil {
+		sapruo.SetV0(*s)
+	}
+	return sapruo
+}
+
+// SetV1 sets the "v1" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetV1(s string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetV1(s)
+	return sapruo
+}
+
+// SetNillableV1 sets the "v1" field if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillableV1(s *string) *ScaAuthPermissionRuleUpdateOne {
+	if s != nil {
+		sapruo.SetV1(*s)
+	}
+	return sapruo
+}
+
+// SetV2 sets the "v2" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetV2(s string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetV2(s)
+	return sapruo
+}
+
+// SetNillableV2 sets the "v2" field if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillableV2(s *string) *ScaAuthPermissionRuleUpdateOne {
+	if s != nil {
+		sapruo.SetV2(*s)
+	}
+	return sapruo
+}
+
+// ClearV2 clears the value of the "v2" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) ClearV2() *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.ClearV2()
+	return sapruo
+}
+
+// SetV3 sets the "v3" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetV3(s string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetV3(s)
+	return sapruo
+}
+
+// SetNillableV3 sets the "v3" field if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillableV3(s *string) *ScaAuthPermissionRuleUpdateOne {
+	if s != nil {
+		sapruo.SetV3(*s)
+	}
+	return sapruo
+}
+
+// ClearV3 clears the value of the "v3" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) ClearV3() *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.ClearV3()
+	return sapruo
+}
+
+// SetV4 sets the "v4" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetV4(s string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetV4(s)
+	return sapruo
+}
+
+// SetNillableV4 sets the "v4" field if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillableV4(s *string) *ScaAuthPermissionRuleUpdateOne {
+	if s != nil {
+		sapruo.SetV4(*s)
+	}
+	return sapruo
+}
+
+// ClearV4 clears the value of the "v4" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) ClearV4() *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.ClearV4()
+	return sapruo
+}
+
+// SetV5 sets the "v5" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetV5(s string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetV5(s)
+	return sapruo
+}
+
+// SetNillableV5 sets the "v5" field if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillableV5(s *string) *ScaAuthPermissionRuleUpdateOne {
+	if s != nil {
+		sapruo.SetV5(*s)
+	}
+	return sapruo
+}
+
+// ClearV5 clears the value of the "v5" field.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) ClearV5() *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.ClearV5()
+	return sapruo
+}
+
+// SetScaAuthRoleID sets the "sca_auth_role" edge to the ScaAuthRole entity by ID.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetScaAuthRoleID(id int64) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.SetScaAuthRoleID(id)
+	return sapruo
+}
+
+// SetNillableScaAuthRoleID sets the "sca_auth_role" edge to the ScaAuthRole entity by ID if the given value is not nil.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetNillableScaAuthRoleID(id *int64) *ScaAuthPermissionRuleUpdateOne {
+	if id != nil {
+		sapruo = sapruo.SetScaAuthRoleID(*id)
+	}
+	return sapruo
+}
+
+// SetScaAuthRole sets the "sca_auth_role" edge to the ScaAuthRole entity.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SetScaAuthRole(s *ScaAuthRole) *ScaAuthPermissionRuleUpdateOne {
+	return sapruo.SetScaAuthRoleID(s.ID)
+}
+
+// Mutation returns the ScaAuthPermissionRuleMutation object of the builder.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) Mutation() *ScaAuthPermissionRuleMutation {
+	return sapruo.mutation
+}
+
+// ClearScaAuthRole clears the "sca_auth_role" edge to the ScaAuthRole entity.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) ClearScaAuthRole() *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.ClearScaAuthRole()
+	return sapruo
+}
+
+// Where appends a list predicates to the ScaAuthPermissionRuleUpdate builder.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) Where(ps ...predicate.ScaAuthPermissionRule) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.mutation.Where(ps...)
+	return sapruo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) Select(field string, fields ...string) *ScaAuthPermissionRuleUpdateOne {
+	sapruo.fields = append([]string{field}, fields...)
+	return sapruo
+}
+
+// Save executes the query and returns the updated ScaAuthPermissionRule entity.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) Save(ctx context.Context) (*ScaAuthPermissionRule, error) {
+	return withHooks(ctx, sapruo.sqlSave, sapruo.mutation, sapruo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) SaveX(ctx context.Context) *ScaAuthPermissionRule {
+	node, err := sapruo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) Exec(ctx context.Context) error {
+	_, err := sapruo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) ExecX(ctx context.Context) {
+	if err := sapruo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sapruo *ScaAuthPermissionRuleUpdateOne) check() error {
+	if v, ok := sapruo.mutation.Ptype(); ok {
+		if err := scaauthpermissionrule.PtypeValidator(v); err != nil {
+			return &ValidationError{Name: "ptype", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.ptype": %w`, err)}
+		}
+	}
+	if v, ok := sapruo.mutation.V0(); ok {
+		if err := scaauthpermissionrule.V0Validator(v); err != nil {
+			return &ValidationError{Name: "v0", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v0": %w`, err)}
+		}
+	}
+	if v, ok := sapruo.mutation.V1(); ok {
+		if err := scaauthpermissionrule.V1Validator(v); err != nil {
+			return &ValidationError{Name: "v1", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v1": %w`, err)}
+		}
+	}
+	if v, ok := sapruo.mutation.V2(); ok {
+		if err := scaauthpermissionrule.V2Validator(v); err != nil {
+			return &ValidationError{Name: "v2", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v2": %w`, err)}
+		}
+	}
+	if v, ok := sapruo.mutation.V3(); ok {
+		if err := scaauthpermissionrule.V3Validator(v); err != nil {
+			return &ValidationError{Name: "v3", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v3": %w`, err)}
+		}
+	}
+	if v, ok := sapruo.mutation.V4(); ok {
+		if err := scaauthpermissionrule.V4Validator(v); err != nil {
+			return &ValidationError{Name: "v4", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v4": %w`, err)}
+		}
+	}
+	if v, ok := sapruo.mutation.V5(); ok {
+		if err := scaauthpermissionrule.V5Validator(v); err != nil {
+			return &ValidationError{Name: "v5", err: fmt.Errorf(`ent: validator failed for field "ScaAuthPermissionRule.v5": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (sapruo *ScaAuthPermissionRuleUpdateOne) sqlSave(ctx context.Context) (_node *ScaAuthPermissionRule, err error) {
+	if err := sapruo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthpermissionrule.Table, scaauthpermissionrule.Columns, sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64))
+	id, ok := sapruo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ScaAuthPermissionRule.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := sapruo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthpermissionrule.FieldID)
+		for _, f := range fields {
+			if !scaauthpermissionrule.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != scaauthpermissionrule.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := sapruo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := sapruo.mutation.Ptype(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldPtype, field.TypeString, value)
+	}
+	if value, ok := sapruo.mutation.V0(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV0, field.TypeString, value)
+	}
+	if value, ok := sapruo.mutation.V1(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV1, field.TypeString, value)
+	}
+	if value, ok := sapruo.mutation.V2(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV2, field.TypeString, value)
+	}
+	if sapruo.mutation.V2Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV2, field.TypeString)
+	}
+	if value, ok := sapruo.mutation.V3(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV3, field.TypeString, value)
+	}
+	if sapruo.mutation.V3Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV3, field.TypeString)
+	}
+	if value, ok := sapruo.mutation.V4(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV4, field.TypeString, value)
+	}
+	if sapruo.mutation.V4Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV4, field.TypeString)
+	}
+	if value, ok := sapruo.mutation.V5(); ok {
+		_spec.SetField(scaauthpermissionrule.FieldV5, field.TypeString, value)
+	}
+	if sapruo.mutation.V5Cleared() {
+		_spec.ClearField(scaauthpermissionrule.FieldV5, field.TypeString)
+	}
+	if sapruo.mutation.ScaAuthRoleCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthpermissionrule.ScaAuthRoleTable,
+			Columns: []string{scaauthpermissionrule.ScaAuthRoleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := sapruo.mutation.ScaAuthRoleIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthpermissionrule.ScaAuthRoleTable,
+			Columns: []string{scaauthpermissionrule.ScaAuthRoleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &ScaAuthPermissionRule{config: sapruo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, sapruo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthpermissionrule.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	sapruo.mutation.done = true
+	return _node, nil
+}

app/core/api/repository/mysql/ent/scaauthrole.go

@@ -0,0 +1,177 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// 角色表
+type ScaAuthRole struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 主键ID
+	ID int64 `json:"id,omitempty"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// 是否删除 0 未删除 1 已删除
+	Deleted int8 `json:"deleted,omitempty"`
+	// 角色名称
+	RoleName string `json:"role_name,omitempty"`
+	// 角色关键字
+	RoleKey string `json:"role_key,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ScaAuthRoleQuery when eager-loading is set.
+	Edges        ScaAuthRoleEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// ScaAuthRoleEdges holds the relations/edges for other nodes in the graph.
+type ScaAuthRoleEdges struct {
+	// ScaAuthPermissionRule holds the value of the sca_auth_permission_rule edge.
+	ScaAuthPermissionRule []*ScaAuthPermissionRule `json:"sca_auth_permission_rule,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// ScaAuthPermissionRuleOrErr returns the ScaAuthPermissionRule value or an error if the edge
+// was not loaded in eager-loading.
+func (e ScaAuthRoleEdges) ScaAuthPermissionRuleOrErr() ([]*ScaAuthPermissionRule, error) {
+	if e.loadedTypes[0] {
+		return e.ScaAuthPermissionRule, nil
+	}
+	return nil, &NotLoadedError{edge: "sca_auth_permission_rule"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ScaAuthRole) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case scaauthrole.FieldID, scaauthrole.FieldDeleted:
+			values[i] = new(sql.NullInt64)
+		case scaauthrole.FieldRoleName, scaauthrole.FieldRoleKey:
+			values[i] = new(sql.NullString)
+		case scaauthrole.FieldCreatedAt, scaauthrole.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the ScaAuthRole fields.
+func (sar *ScaAuthRole) 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 scaauthrole.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			sar.ID = int64(value.Int64)
+		case scaauthrole.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				sar.CreatedAt = value.Time
+			}
+		case scaauthrole.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				sar.UpdatedAt = value.Time
+			}
+		case scaauthrole.FieldDeleted:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field deleted", values[i])
+			} else if value.Valid {
+				sar.Deleted = int8(value.Int64)
+			}
+		case scaauthrole.FieldRoleName:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field role_name", values[i])
+			} else if value.Valid {
+				sar.RoleName = value.String
+			}
+		case scaauthrole.FieldRoleKey:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field role_key", values[i])
+			} else if value.Valid {
+				sar.RoleKey = value.String
+			}
+		default:
+			sar.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ScaAuthRole.
+// This includes values selected through modifiers, order, etc.
+func (sar *ScaAuthRole) Value(name string) (ent.Value, error) {
+	return sar.selectValues.Get(name)
+}
+
+// QueryScaAuthPermissionRule queries the "sca_auth_permission_rule" edge of the ScaAuthRole entity.
+func (sar *ScaAuthRole) QueryScaAuthPermissionRule() *ScaAuthPermissionRuleQuery {
+	return NewScaAuthRoleClient(sar.config).QueryScaAuthPermissionRule(sar)
+}
+
+// Update returns a builder for updating this ScaAuthRole.
+// Note that you need to call ScaAuthRole.Unwrap() before calling this method if this ScaAuthRole
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (sar *ScaAuthRole) Update() *ScaAuthRoleUpdateOne {
+	return NewScaAuthRoleClient(sar.config).UpdateOne(sar)
+}
+
+// Unwrap unwraps the ScaAuthRole 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 (sar *ScaAuthRole) Unwrap() *ScaAuthRole {
+	_tx, ok := sar.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: ScaAuthRole is not a transactional entity")
+	}
+	sar.config.driver = _tx.drv
+	return sar
+}
+
+// String implements the fmt.Stringer.
+func (sar *ScaAuthRole) String() string {
+	var builder strings.Builder
+	builder.WriteString("ScaAuthRole(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", sar.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(sar.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(sar.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", sar.Deleted))
+	builder.WriteString(", ")
+	builder.WriteString("role_name=")
+	builder.WriteString(sar.RoleName)
+	builder.WriteString(", ")
+	builder.WriteString("role_key=")
+	builder.WriteString(sar.RoleKey)
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ScaAuthRoles is a parsable slice of ScaAuthRole.
+type ScaAuthRoles []*ScaAuthRole

app/core/api/repository/mysql/ent/scaauthrole/scaauthrole.go

@@ -0,0 +1,129 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthrole
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the scaauthrole type in the database.
+	Label = "sca_auth_role"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// FieldRoleName holds the string denoting the role_name field in the database.
+	FieldRoleName = "role_name"
+	// FieldRoleKey holds the string denoting the role_key field in the database.
+	FieldRoleKey = "role_key"
+	// EdgeScaAuthPermissionRule holds the string denoting the sca_auth_permission_rule edge name in mutations.
+	EdgeScaAuthPermissionRule = "sca_auth_permission_rule"
+	// Table holds the table name of the scaauthrole in the database.
+	Table = "sca_auth_role"
+	// ScaAuthPermissionRuleTable is the table that holds the sca_auth_permission_rule relation/edge.
+	ScaAuthPermissionRuleTable = "sca_auth_permission_rule"
+	// ScaAuthPermissionRuleInverseTable is the table name for the ScaAuthPermissionRule entity.
+	// It exists in this package in order to avoid circular dependency with the "scaauthpermissionrule" package.
+	ScaAuthPermissionRuleInverseTable = "sca_auth_permission_rule"
+	// ScaAuthPermissionRuleColumn is the table column denoting the sca_auth_permission_rule relation/edge.
+	ScaAuthPermissionRuleColumn = "sca_auth_role_sca_auth_permission_rule"
+)
+
+// Columns holds all SQL columns for scaauthrole fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldDeleted,
+	FieldRoleName,
+	FieldRoleKey,
+}
+
+// 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
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted int8
+	// DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	DeletedValidator func(int8) error
+	// RoleNameValidator is a validator for the "role_name" field. It is called by the builders before save.
+	RoleNameValidator func(string) error
+	// RoleKeyValidator is a validator for the "role_key" field. It is called by the builders before save.
+	RoleKeyValidator func(string) error
+)
+
+// OrderOption defines the ordering options for the ScaAuthRole 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, opts...).ToFunc()
+}
+
+// ByRoleName orders the results by the role_name field.
+func ByRoleName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRoleName, opts...).ToFunc()
+}
+
+// ByRoleKey orders the results by the role_key field.
+func ByRoleKey(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRoleKey, opts...).ToFunc()
+}
+
+// ByScaAuthPermissionRuleCount orders the results by sca_auth_permission_rule count.
+func ByScaAuthPermissionRuleCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newScaAuthPermissionRuleStep(), opts...)
+	}
+}
+
+// ByScaAuthPermissionRule orders the results by sca_auth_permission_rule terms.
+func ByScaAuthPermissionRule(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newScaAuthPermissionRuleStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+func newScaAuthPermissionRuleStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ScaAuthPermissionRuleInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, ScaAuthPermissionRuleTable, ScaAuthPermissionRuleColumn),
+	)
+}

app/core/api/repository/mysql/ent/scaauthrole/where.go

@@ -0,0 +1,379 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthrole
+
+import (
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int64) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Deleted applies equality check predicate on the "deleted" field. It's identical to DeletedEQ.
+func Deleted(v int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldDeleted, v))
+}
+
+// RoleName applies equality check predicate on the "role_name" field. It's identical to RoleNameEQ.
+func RoleName(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldRoleName, v))
+}
+
+// RoleKey applies equality check predicate on the "role_key" field. It's identical to RoleKeyEQ.
+func RoleKey(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldRoleKey, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// DeletedEQ applies the EQ predicate on the "deleted" field.
+func DeletedEQ(v int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldDeleted, v))
+}
+
+// DeletedNEQ applies the NEQ predicate on the "deleted" field.
+func DeletedNEQ(v int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldDeleted, v))
+}
+
+// DeletedIn applies the In predicate on the "deleted" field.
+func DeletedIn(vs ...int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldDeleted, vs...))
+}
+
+// DeletedNotIn applies the NotIn predicate on the "deleted" field.
+func DeletedNotIn(vs ...int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldDeleted, vs...))
+}
+
+// DeletedGT applies the GT predicate on the "deleted" field.
+func DeletedGT(v int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldDeleted, v))
+}
+
+// DeletedGTE applies the GTE predicate on the "deleted" field.
+func DeletedGTE(v int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldDeleted, v))
+}
+
+// DeletedLT applies the LT predicate on the "deleted" field.
+func DeletedLT(v int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldDeleted, v))
+}
+
+// DeletedLTE applies the LTE predicate on the "deleted" field.
+func DeletedLTE(v int8) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldDeleted, v))
+}
+
+// DeletedIsNil applies the IsNil predicate on the "deleted" field.
+func DeletedIsNil() predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIsNull(FieldDeleted))
+}
+
+// DeletedNotNil applies the NotNil predicate on the "deleted" field.
+func DeletedNotNil() predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotNull(FieldDeleted))
+}
+
+// RoleNameEQ applies the EQ predicate on the "role_name" field.
+func RoleNameEQ(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldRoleName, v))
+}
+
+// RoleNameNEQ applies the NEQ predicate on the "role_name" field.
+func RoleNameNEQ(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldRoleName, v))
+}
+
+// RoleNameIn applies the In predicate on the "role_name" field.
+func RoleNameIn(vs ...string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldRoleName, vs...))
+}
+
+// RoleNameNotIn applies the NotIn predicate on the "role_name" field.
+func RoleNameNotIn(vs ...string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldRoleName, vs...))
+}
+
+// RoleNameGT applies the GT predicate on the "role_name" field.
+func RoleNameGT(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldRoleName, v))
+}
+
+// RoleNameGTE applies the GTE predicate on the "role_name" field.
+func RoleNameGTE(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldRoleName, v))
+}
+
+// RoleNameLT applies the LT predicate on the "role_name" field.
+func RoleNameLT(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldRoleName, v))
+}
+
+// RoleNameLTE applies the LTE predicate on the "role_name" field.
+func RoleNameLTE(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldRoleName, v))
+}
+
+// RoleNameContains applies the Contains predicate on the "role_name" field.
+func RoleNameContains(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldContains(FieldRoleName, v))
+}
+
+// RoleNameHasPrefix applies the HasPrefix predicate on the "role_name" field.
+func RoleNameHasPrefix(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldHasPrefix(FieldRoleName, v))
+}
+
+// RoleNameHasSuffix applies the HasSuffix predicate on the "role_name" field.
+func RoleNameHasSuffix(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldHasSuffix(FieldRoleName, v))
+}
+
+// RoleNameEqualFold applies the EqualFold predicate on the "role_name" field.
+func RoleNameEqualFold(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEqualFold(FieldRoleName, v))
+}
+
+// RoleNameContainsFold applies the ContainsFold predicate on the "role_name" field.
+func RoleNameContainsFold(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldContainsFold(FieldRoleName, v))
+}
+
+// RoleKeyEQ applies the EQ predicate on the "role_key" field.
+func RoleKeyEQ(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldRoleKey, v))
+}
+
+// RoleKeyNEQ applies the NEQ predicate on the "role_key" field.
+func RoleKeyNEQ(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldRoleKey, v))
+}
+
+// RoleKeyIn applies the In predicate on the "role_key" field.
+func RoleKeyIn(vs ...string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldRoleKey, vs...))
+}
+
+// RoleKeyNotIn applies the NotIn predicate on the "role_key" field.
+func RoleKeyNotIn(vs ...string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldRoleKey, vs...))
+}
+
+// RoleKeyGT applies the GT predicate on the "role_key" field.
+func RoleKeyGT(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldRoleKey, v))
+}
+
+// RoleKeyGTE applies the GTE predicate on the "role_key" field.
+func RoleKeyGTE(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldRoleKey, v))
+}
+
+// RoleKeyLT applies the LT predicate on the "role_key" field.
+func RoleKeyLT(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldRoleKey, v))
+}
+
+// RoleKeyLTE applies the LTE predicate on the "role_key" field.
+func RoleKeyLTE(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldRoleKey, v))
+}
+
+// RoleKeyContains applies the Contains predicate on the "role_key" field.
+func RoleKeyContains(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldContains(FieldRoleKey, v))
+}
+
+// RoleKeyHasPrefix applies the HasPrefix predicate on the "role_key" field.
+func RoleKeyHasPrefix(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldHasPrefix(FieldRoleKey, v))
+}
+
+// RoleKeyHasSuffix applies the HasSuffix predicate on the "role_key" field.
+func RoleKeyHasSuffix(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldHasSuffix(FieldRoleKey, v))
+}
+
+// RoleKeyEqualFold applies the EqualFold predicate on the "role_key" field.
+func RoleKeyEqualFold(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEqualFold(FieldRoleKey, v))
+}
+
+// RoleKeyContainsFold applies the ContainsFold predicate on the "role_key" field.
+func RoleKeyContainsFold(v string) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldContainsFold(FieldRoleKey, v))
+}
+
+// HasScaAuthPermissionRule applies the HasEdge predicate on the "sca_auth_permission_rule" edge.
+func HasScaAuthPermissionRule() predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, ScaAuthPermissionRuleTable, ScaAuthPermissionRuleColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasScaAuthPermissionRuleWith applies the HasEdge predicate on the "sca_auth_permission_rule" edge with a given conditions (other predicates).
+func HasScaAuthPermissionRuleWith(preds ...predicate.ScaAuthPermissionRule) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(func(s *sql.Selector) {
+		step := newScaAuthPermissionRuleStep()
+		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.ScaAuthRole) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ScaAuthRole) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ScaAuthRole) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.NotPredicates(p))
+}

app/core/api/repository/mysql/ent/scaauthrole_create.go

@@ -0,0 +1,334 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthRoleCreate is the builder for creating a ScaAuthRole entity.
+type ScaAuthRoleCreate struct {
+	config
+	mutation *ScaAuthRoleMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (sarc *ScaAuthRoleCreate) SetCreatedAt(t time.Time) *ScaAuthRoleCreate {
+	sarc.mutation.SetCreatedAt(t)
+	return sarc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (sarc *ScaAuthRoleCreate) SetNillableCreatedAt(t *time.Time) *ScaAuthRoleCreate {
+	if t != nil {
+		sarc.SetCreatedAt(*t)
+	}
+	return sarc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (sarc *ScaAuthRoleCreate) SetUpdatedAt(t time.Time) *ScaAuthRoleCreate {
+	sarc.mutation.SetUpdatedAt(t)
+	return sarc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (sarc *ScaAuthRoleCreate) SetNillableUpdatedAt(t *time.Time) *ScaAuthRoleCreate {
+	if t != nil {
+		sarc.SetUpdatedAt(*t)
+	}
+	return sarc
+}
+
+// SetDeleted sets the "deleted" field.
+func (sarc *ScaAuthRoleCreate) SetDeleted(i int8) *ScaAuthRoleCreate {
+	sarc.mutation.SetDeleted(i)
+	return sarc
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sarc *ScaAuthRoleCreate) SetNillableDeleted(i *int8) *ScaAuthRoleCreate {
+	if i != nil {
+		sarc.SetDeleted(*i)
+	}
+	return sarc
+}
+
+// SetRoleName sets the "role_name" field.
+func (sarc *ScaAuthRoleCreate) SetRoleName(s string) *ScaAuthRoleCreate {
+	sarc.mutation.SetRoleName(s)
+	return sarc
+}
+
+// SetRoleKey sets the "role_key" field.
+func (sarc *ScaAuthRoleCreate) SetRoleKey(s string) *ScaAuthRoleCreate {
+	sarc.mutation.SetRoleKey(s)
+	return sarc
+}
+
+// SetID sets the "id" field.
+func (sarc *ScaAuthRoleCreate) SetID(i int64) *ScaAuthRoleCreate {
+	sarc.mutation.SetID(i)
+	return sarc
+}
+
+// AddScaAuthPermissionRuleIDs adds the "sca_auth_permission_rule" edge to the ScaAuthPermissionRule entity by IDs.
+func (sarc *ScaAuthRoleCreate) AddScaAuthPermissionRuleIDs(ids ...int64) *ScaAuthRoleCreate {
+	sarc.mutation.AddScaAuthPermissionRuleIDs(ids...)
+	return sarc
+}
+
+// AddScaAuthPermissionRule adds the "sca_auth_permission_rule" edges to the ScaAuthPermissionRule entity.
+func (sarc *ScaAuthRoleCreate) AddScaAuthPermissionRule(s ...*ScaAuthPermissionRule) *ScaAuthRoleCreate {
+	ids := make([]int64, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return sarc.AddScaAuthPermissionRuleIDs(ids...)
+}
+
+// Mutation returns the ScaAuthRoleMutation object of the builder.
+func (sarc *ScaAuthRoleCreate) Mutation() *ScaAuthRoleMutation {
+	return sarc.mutation
+}
+
+// Save creates the ScaAuthRole in the database.
+func (sarc *ScaAuthRoleCreate) Save(ctx context.Context) (*ScaAuthRole, error) {
+	sarc.defaults()
+	return withHooks(ctx, sarc.sqlSave, sarc.mutation, sarc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (sarc *ScaAuthRoleCreate) SaveX(ctx context.Context) *ScaAuthRole {
+	v, err := sarc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (sarc *ScaAuthRoleCreate) Exec(ctx context.Context) error {
+	_, err := sarc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sarc *ScaAuthRoleCreate) ExecX(ctx context.Context) {
+	if err := sarc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sarc *ScaAuthRoleCreate) defaults() {
+	if _, ok := sarc.mutation.CreatedAt(); !ok {
+		v := scaauthrole.DefaultCreatedAt()
+		sarc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := sarc.mutation.UpdatedAt(); !ok {
+		v := scaauthrole.DefaultUpdatedAt()
+		sarc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := sarc.mutation.Deleted(); !ok {
+		v := scaauthrole.DefaultDeleted
+		sarc.mutation.SetDeleted(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sarc *ScaAuthRoleCreate) check() error {
+	if _, ok := sarc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "ScaAuthRole.created_at"`)}
+	}
+	if _, ok := sarc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "ScaAuthRole.updated_at"`)}
+	}
+	if v, ok := sarc.mutation.Deleted(); ok {
+		if err := scaauthrole.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.deleted": %w`, err)}
+		}
+	}
+	if _, ok := sarc.mutation.RoleName(); !ok {
+		return &ValidationError{Name: "role_name", err: errors.New(`ent: missing required field "ScaAuthRole.role_name"`)}
+	}
+	if v, ok := sarc.mutation.RoleName(); ok {
+		if err := scaauthrole.RoleNameValidator(v); err != nil {
+			return &ValidationError{Name: "role_name", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.role_name": %w`, err)}
+		}
+	}
+	if _, ok := sarc.mutation.RoleKey(); !ok {
+		return &ValidationError{Name: "role_key", err: errors.New(`ent: missing required field "ScaAuthRole.role_key"`)}
+	}
+	if v, ok := sarc.mutation.RoleKey(); ok {
+		if err := scaauthrole.RoleKeyValidator(v); err != nil {
+			return &ValidationError{Name: "role_key", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.role_key": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (sarc *ScaAuthRoleCreate) sqlSave(ctx context.Context) (*ScaAuthRole, error) {
+	if err := sarc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := sarc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, sarc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != _node.ID {
+		id := _spec.ID.Value.(int64)
+		_node.ID = int64(id)
+	}
+	sarc.mutation.id = &_node.ID
+	sarc.mutation.done = true
+	return _node, nil
+}
+
+func (sarc *ScaAuthRoleCreate) createSpec() (*ScaAuthRole, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ScaAuthRole{config: sarc.config}
+		_spec = sqlgraph.NewCreateSpec(scaauthrole.Table, sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64))
+	)
+	if id, ok := sarc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := sarc.mutation.CreatedAt(); ok {
+		_spec.SetField(scaauthrole.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := sarc.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthrole.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := sarc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthrole.FieldDeleted, field.TypeInt8, value)
+		_node.Deleted = value
+	}
+	if value, ok := sarc.mutation.RoleName(); ok {
+		_spec.SetField(scaauthrole.FieldRoleName, field.TypeString, value)
+		_node.RoleName = value
+	}
+	if value, ok := sarc.mutation.RoleKey(); ok {
+		_spec.SetField(scaauthrole.FieldRoleKey, field.TypeString, value)
+		_node.RoleKey = value
+	}
+	if nodes := sarc.mutation.ScaAuthPermissionRuleIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// ScaAuthRoleCreateBulk is the builder for creating many ScaAuthRole entities in bulk.
+type ScaAuthRoleCreateBulk struct {
+	config
+	err      error
+	builders []*ScaAuthRoleCreate
+}
+
+// Save creates the ScaAuthRole entities in the database.
+func (sarcb *ScaAuthRoleCreateBulk) Save(ctx context.Context) ([]*ScaAuthRole, error) {
+	if sarcb.err != nil {
+		return nil, sarcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(sarcb.builders))
+	nodes := make([]*ScaAuthRole, len(sarcb.builders))
+	mutators := make([]Mutator, len(sarcb.builders))
+	for i := range sarcb.builders {
+		func(i int, root context.Context) {
+			builder := sarcb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ScaAuthRoleMutation)
+				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, sarcb.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, sarcb.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 && nodes[i].ID == 0 {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int64(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, sarcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (sarcb *ScaAuthRoleCreateBulk) SaveX(ctx context.Context) []*ScaAuthRole {
+	v, err := sarcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (sarcb *ScaAuthRoleCreateBulk) Exec(ctx context.Context) error {
+	_, err := sarcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sarcb *ScaAuthRoleCreateBulk) ExecX(ctx context.Context) {
+	if err := sarcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthrole_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthRoleDelete is the builder for deleting a ScaAuthRole entity.
+type ScaAuthRoleDelete struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthRoleMutation
+}
+
+// Where appends a list predicates to the ScaAuthRoleDelete builder.
+func (sard *ScaAuthRoleDelete) Where(ps ...predicate.ScaAuthRole) *ScaAuthRoleDelete {
+	sard.mutation.Where(ps...)
+	return sard
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (sard *ScaAuthRoleDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, sard.sqlExec, sard.mutation, sard.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sard *ScaAuthRoleDelete) ExecX(ctx context.Context) int {
+	n, err := sard.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (sard *ScaAuthRoleDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(scaauthrole.Table, sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64))
+	if ps := sard.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, sard.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	sard.mutation.done = true
+	return affected, err
+}
+
+// ScaAuthRoleDeleteOne is the builder for deleting a single ScaAuthRole entity.
+type ScaAuthRoleDeleteOne struct {
+	sard *ScaAuthRoleDelete
+}
+
+// Where appends a list predicates to the ScaAuthRoleDelete builder.
+func (sardo *ScaAuthRoleDeleteOne) Where(ps ...predicate.ScaAuthRole) *ScaAuthRoleDeleteOne {
+	sardo.sard.mutation.Where(ps...)
+	return sardo
+}
+
+// Exec executes the deletion query.
+func (sardo *ScaAuthRoleDeleteOne) Exec(ctx context.Context) error {
+	n, err := sardo.sard.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{scaauthrole.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sardo *ScaAuthRoleDeleteOne) ExecX(ctx context.Context) {
+	if err := sardo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthrole_query.go

@@ -0,0 +1,609 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"database/sql/driver"
+	"fmt"
+	"math"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthRoleQuery is the builder for querying ScaAuthRole entities.
+type ScaAuthRoleQuery struct {
+	config
+	ctx                       *QueryContext
+	order                     []scaauthrole.OrderOption
+	inters                    []Interceptor
+	predicates                []predicate.ScaAuthRole
+	withScaAuthPermissionRule *ScaAuthPermissionRuleQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ScaAuthRoleQuery builder.
+func (sarq *ScaAuthRoleQuery) Where(ps ...predicate.ScaAuthRole) *ScaAuthRoleQuery {
+	sarq.predicates = append(sarq.predicates, ps...)
+	return sarq
+}
+
+// Limit the number of records to be returned by this query.
+func (sarq *ScaAuthRoleQuery) Limit(limit int) *ScaAuthRoleQuery {
+	sarq.ctx.Limit = &limit
+	return sarq
+}
+
+// Offset to start from.
+func (sarq *ScaAuthRoleQuery) Offset(offset int) *ScaAuthRoleQuery {
+	sarq.ctx.Offset = &offset
+	return sarq
+}
+
+// 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 (sarq *ScaAuthRoleQuery) Unique(unique bool) *ScaAuthRoleQuery {
+	sarq.ctx.Unique = &unique
+	return sarq
+}
+
+// Order specifies how the records should be ordered.
+func (sarq *ScaAuthRoleQuery) Order(o ...scaauthrole.OrderOption) *ScaAuthRoleQuery {
+	sarq.order = append(sarq.order, o...)
+	return sarq
+}
+
+// QueryScaAuthPermissionRule chains the current query on the "sca_auth_permission_rule" edge.
+func (sarq *ScaAuthRoleQuery) QueryScaAuthPermissionRule() *ScaAuthPermissionRuleQuery {
+	query := (&ScaAuthPermissionRuleClient{config: sarq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := sarq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := sarq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(scaauthrole.Table, scaauthrole.FieldID, selector),
+			sqlgraph.To(scaauthpermissionrule.Table, scaauthpermissionrule.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, scaauthrole.ScaAuthPermissionRuleTable, scaauthrole.ScaAuthPermissionRuleColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(sarq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first ScaAuthRole entity from the query.
+// Returns a *NotFoundError when no ScaAuthRole was found.
+func (sarq *ScaAuthRoleQuery) First(ctx context.Context) (*ScaAuthRole, error) {
+	nodes, err := sarq.Limit(1).All(setContextOp(ctx, sarq.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{scaauthrole.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (sarq *ScaAuthRoleQuery) FirstX(ctx context.Context) *ScaAuthRole {
+	node, err := sarq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ScaAuthRole ID from the query.
+// Returns a *NotFoundError when no ScaAuthRole ID was found.
+func (sarq *ScaAuthRoleQuery) FirstID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = sarq.Limit(1).IDs(setContextOp(ctx, sarq.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{scaauthrole.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (sarq *ScaAuthRoleQuery) FirstIDX(ctx context.Context) int64 {
+	id, err := sarq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ScaAuthRole entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ScaAuthRole entity is found.
+// Returns a *NotFoundError when no ScaAuthRole entities are found.
+func (sarq *ScaAuthRoleQuery) Only(ctx context.Context) (*ScaAuthRole, error) {
+	nodes, err := sarq.Limit(2).All(setContextOp(ctx, sarq.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{scaauthrole.Label}
+	default:
+		return nil, &NotSingularError{scaauthrole.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (sarq *ScaAuthRoleQuery) OnlyX(ctx context.Context) *ScaAuthRole {
+	node, err := sarq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ScaAuthRole ID in the query.
+// Returns a *NotSingularError when more than one ScaAuthRole ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (sarq *ScaAuthRoleQuery) OnlyID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = sarq.Limit(2).IDs(setContextOp(ctx, sarq.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{scaauthrole.Label}
+	default:
+		err = &NotSingularError{scaauthrole.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (sarq *ScaAuthRoleQuery) OnlyIDX(ctx context.Context) int64 {
+	id, err := sarq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ScaAuthRoles.
+func (sarq *ScaAuthRoleQuery) All(ctx context.Context) ([]*ScaAuthRole, error) {
+	ctx = setContextOp(ctx, sarq.ctx, ent.OpQueryAll)
+	if err := sarq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ScaAuthRole, *ScaAuthRoleQuery]()
+	return withInterceptors[[]*ScaAuthRole](ctx, sarq, qr, sarq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (sarq *ScaAuthRoleQuery) AllX(ctx context.Context) []*ScaAuthRole {
+	nodes, err := sarq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ScaAuthRole IDs.
+func (sarq *ScaAuthRoleQuery) IDs(ctx context.Context) (ids []int64, err error) {
+	if sarq.ctx.Unique == nil && sarq.path != nil {
+		sarq.Unique(true)
+	}
+	ctx = setContextOp(ctx, sarq.ctx, ent.OpQueryIDs)
+	if err = sarq.Select(scaauthrole.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (sarq *ScaAuthRoleQuery) IDsX(ctx context.Context) []int64 {
+	ids, err := sarq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (sarq *ScaAuthRoleQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, sarq.ctx, ent.OpQueryCount)
+	if err := sarq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, sarq, querierCount[*ScaAuthRoleQuery](), sarq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (sarq *ScaAuthRoleQuery) CountX(ctx context.Context) int {
+	count, err := sarq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (sarq *ScaAuthRoleQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, sarq.ctx, ent.OpQueryExist)
+	switch _, err := sarq.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 (sarq *ScaAuthRoleQuery) ExistX(ctx context.Context) bool {
+	exist, err := sarq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ScaAuthRoleQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (sarq *ScaAuthRoleQuery) Clone() *ScaAuthRoleQuery {
+	if sarq == nil {
+		return nil
+	}
+	return &ScaAuthRoleQuery{
+		config:                    sarq.config,
+		ctx:                       sarq.ctx.Clone(),
+		order:                     append([]scaauthrole.OrderOption{}, sarq.order...),
+		inters:                    append([]Interceptor{}, sarq.inters...),
+		predicates:                append([]predicate.ScaAuthRole{}, sarq.predicates...),
+		withScaAuthPermissionRule: sarq.withScaAuthPermissionRule.Clone(),
+		// clone intermediate query.
+		sql:  sarq.sql.Clone(),
+		path: sarq.path,
+	}
+}
+
+// WithScaAuthPermissionRule tells the query-builder to eager-load the nodes that are connected to
+// the "sca_auth_permission_rule" edge. The optional arguments are used to configure the query builder of the edge.
+func (sarq *ScaAuthRoleQuery) WithScaAuthPermissionRule(opts ...func(*ScaAuthPermissionRuleQuery)) *ScaAuthRoleQuery {
+	query := (&ScaAuthPermissionRuleClient{config: sarq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	sarq.withScaAuthPermissionRule = query
+	return sarq
+}
+
+// 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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthRole.Query().
+//		GroupBy(scaauthrole.FieldCreatedAt).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (sarq *ScaAuthRoleQuery) GroupBy(field string, fields ...string) *ScaAuthRoleGroupBy {
+	sarq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ScaAuthRoleGroupBy{build: sarq}
+	grbuild.flds = &sarq.ctx.Fields
+	grbuild.label = scaauthrole.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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//	}
+//
+//	client.ScaAuthRole.Query().
+//		Select(scaauthrole.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (sarq *ScaAuthRoleQuery) Select(fields ...string) *ScaAuthRoleSelect {
+	sarq.ctx.Fields = append(sarq.ctx.Fields, fields...)
+	sbuild := &ScaAuthRoleSelect{ScaAuthRoleQuery: sarq}
+	sbuild.label = scaauthrole.Label
+	sbuild.flds, sbuild.scan = &sarq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ScaAuthRoleSelect configured with the given aggregations.
+func (sarq *ScaAuthRoleQuery) Aggregate(fns ...AggregateFunc) *ScaAuthRoleSelect {
+	return sarq.Select().Aggregate(fns...)
+}
+
+func (sarq *ScaAuthRoleQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range sarq.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, sarq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range sarq.ctx.Fields {
+		if !scaauthrole.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if sarq.path != nil {
+		prev, err := sarq.path(ctx)
+		if err != nil {
+			return err
+		}
+		sarq.sql = prev
+	}
+	return nil
+}
+
+func (sarq *ScaAuthRoleQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ScaAuthRole, error) {
+	var (
+		nodes       = []*ScaAuthRole{}
+		_spec       = sarq.querySpec()
+		loadedTypes = [1]bool{
+			sarq.withScaAuthPermissionRule != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ScaAuthRole).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ScaAuthRole{config: sarq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, sarq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := sarq.withScaAuthPermissionRule; query != nil {
+		if err := sarq.loadScaAuthPermissionRule(ctx, query, nodes,
+			func(n *ScaAuthRole) { n.Edges.ScaAuthPermissionRule = []*ScaAuthPermissionRule{} },
+			func(n *ScaAuthRole, e *ScaAuthPermissionRule) {
+				n.Edges.ScaAuthPermissionRule = append(n.Edges.ScaAuthPermissionRule, e)
+			}); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (sarq *ScaAuthRoleQuery) loadScaAuthPermissionRule(ctx context.Context, query *ScaAuthPermissionRuleQuery, nodes []*ScaAuthRole, init func(*ScaAuthRole), assign func(*ScaAuthRole, *ScaAuthPermissionRule)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[int64]*ScaAuthRole)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	query.withFKs = true
+	query.Where(predicate.ScaAuthPermissionRule(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(scaauthrole.ScaAuthPermissionRuleColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.sca_auth_role_sca_auth_permission_rule
+		if fk == nil {
+			return fmt.Errorf(`foreign-key "sca_auth_role_sca_auth_permission_rule" is nil for node %v`, n.ID)
+		}
+		node, ok := nodeids[*fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "sca_auth_role_sca_auth_permission_rule" returned %v for node %v`, *fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+
+func (sarq *ScaAuthRoleQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := sarq.querySpec()
+	_spec.Node.Columns = sarq.ctx.Fields
+	if len(sarq.ctx.Fields) > 0 {
+		_spec.Unique = sarq.ctx.Unique != nil && *sarq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, sarq.driver, _spec)
+}
+
+func (sarq *ScaAuthRoleQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(scaauthrole.Table, scaauthrole.Columns, sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64))
+	_spec.From = sarq.sql
+	if unique := sarq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if sarq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := sarq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthrole.FieldID)
+		for i := range fields {
+			if fields[i] != scaauthrole.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := sarq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := sarq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := sarq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := sarq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (sarq *ScaAuthRoleQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(sarq.driver.Dialect())
+	t1 := builder.Table(scaauthrole.Table)
+	columns := sarq.ctx.Fields
+	if len(columns) == 0 {
+		columns = scaauthrole.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if sarq.sql != nil {
+		selector = sarq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if sarq.ctx.Unique != nil && *sarq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range sarq.predicates {
+		p(selector)
+	}
+	for _, p := range sarq.order {
+		p(selector)
+	}
+	if offset := sarq.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 := sarq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ScaAuthRoleGroupBy is the group-by builder for ScaAuthRole entities.
+type ScaAuthRoleGroupBy struct {
+	selector
+	build *ScaAuthRoleQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (sargb *ScaAuthRoleGroupBy) Aggregate(fns ...AggregateFunc) *ScaAuthRoleGroupBy {
+	sargb.fns = append(sargb.fns, fns...)
+	return sargb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (sargb *ScaAuthRoleGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, sargb.build.ctx, ent.OpQueryGroupBy)
+	if err := sargb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthRoleQuery, *ScaAuthRoleGroupBy](ctx, sargb.build, sargb, sargb.build.inters, v)
+}
+
+func (sargb *ScaAuthRoleGroupBy) sqlScan(ctx context.Context, root *ScaAuthRoleQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(sargb.fns))
+	for _, fn := range sargb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*sargb.flds)+len(sargb.fns))
+		for _, f := range *sargb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*sargb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := sargb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ScaAuthRoleSelect is the builder for selecting fields of ScaAuthRole entities.
+type ScaAuthRoleSelect struct {
+	*ScaAuthRoleQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (sars *ScaAuthRoleSelect) Aggregate(fns ...AggregateFunc) *ScaAuthRoleSelect {
+	sars.fns = append(sars.fns, fns...)
+	return sars
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (sars *ScaAuthRoleSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, sars.ctx, ent.OpQuerySelect)
+	if err := sars.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthRoleQuery, *ScaAuthRoleSelect](ctx, sars.ScaAuthRoleQuery, sars, sars.inters, v)
+}
+
+func (sars *ScaAuthRoleSelect) sqlScan(ctx context.Context, root *ScaAuthRoleQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(sars.fns))
+	for _, fn := range sars.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*sars.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 := sars.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

app/core/api/repository/mysql/ent/scaauthrole_update.go

@@ -0,0 +1,561 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthrole"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthRoleUpdate is the builder for updating ScaAuthRole entities.
+type ScaAuthRoleUpdate struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthRoleMutation
+}
+
+// Where appends a list predicates to the ScaAuthRoleUpdate builder.
+func (saru *ScaAuthRoleUpdate) Where(ps ...predicate.ScaAuthRole) *ScaAuthRoleUpdate {
+	saru.mutation.Where(ps...)
+	return saru
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (saru *ScaAuthRoleUpdate) SetUpdatedAt(t time.Time) *ScaAuthRoleUpdate {
+	saru.mutation.SetUpdatedAt(t)
+	return saru
+}
+
+// SetDeleted sets the "deleted" field.
+func (saru *ScaAuthRoleUpdate) SetDeleted(i int8) *ScaAuthRoleUpdate {
+	saru.mutation.ResetDeleted()
+	saru.mutation.SetDeleted(i)
+	return saru
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (saru *ScaAuthRoleUpdate) SetNillableDeleted(i *int8) *ScaAuthRoleUpdate {
+	if i != nil {
+		saru.SetDeleted(*i)
+	}
+	return saru
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (saru *ScaAuthRoleUpdate) AddDeleted(i int8) *ScaAuthRoleUpdate {
+	saru.mutation.AddDeleted(i)
+	return saru
+}
+
+// ClearDeleted clears the value of the "deleted" field.
+func (saru *ScaAuthRoleUpdate) ClearDeleted() *ScaAuthRoleUpdate {
+	saru.mutation.ClearDeleted()
+	return saru
+}
+
+// SetRoleName sets the "role_name" field.
+func (saru *ScaAuthRoleUpdate) SetRoleName(s string) *ScaAuthRoleUpdate {
+	saru.mutation.SetRoleName(s)
+	return saru
+}
+
+// SetNillableRoleName sets the "role_name" field if the given value is not nil.
+func (saru *ScaAuthRoleUpdate) SetNillableRoleName(s *string) *ScaAuthRoleUpdate {
+	if s != nil {
+		saru.SetRoleName(*s)
+	}
+	return saru
+}
+
+// SetRoleKey sets the "role_key" field.
+func (saru *ScaAuthRoleUpdate) SetRoleKey(s string) *ScaAuthRoleUpdate {
+	saru.mutation.SetRoleKey(s)
+	return saru
+}
+
+// SetNillableRoleKey sets the "role_key" field if the given value is not nil.
+func (saru *ScaAuthRoleUpdate) SetNillableRoleKey(s *string) *ScaAuthRoleUpdate {
+	if s != nil {
+		saru.SetRoleKey(*s)
+	}
+	return saru
+}
+
+// AddScaAuthPermissionRuleIDs adds the "sca_auth_permission_rule" edge to the ScaAuthPermissionRule entity by IDs.
+func (saru *ScaAuthRoleUpdate) AddScaAuthPermissionRuleIDs(ids ...int64) *ScaAuthRoleUpdate {
+	saru.mutation.AddScaAuthPermissionRuleIDs(ids...)
+	return saru
+}
+
+// AddScaAuthPermissionRule adds the "sca_auth_permission_rule" edges to the ScaAuthPermissionRule entity.
+func (saru *ScaAuthRoleUpdate) AddScaAuthPermissionRule(s ...*ScaAuthPermissionRule) *ScaAuthRoleUpdate {
+	ids := make([]int64, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return saru.AddScaAuthPermissionRuleIDs(ids...)
+}
+
+// Mutation returns the ScaAuthRoleMutation object of the builder.
+func (saru *ScaAuthRoleUpdate) Mutation() *ScaAuthRoleMutation {
+	return saru.mutation
+}
+
+// ClearScaAuthPermissionRule clears all "sca_auth_permission_rule" edges to the ScaAuthPermissionRule entity.
+func (saru *ScaAuthRoleUpdate) ClearScaAuthPermissionRule() *ScaAuthRoleUpdate {
+	saru.mutation.ClearScaAuthPermissionRule()
+	return saru
+}
+
+// RemoveScaAuthPermissionRuleIDs removes the "sca_auth_permission_rule" edge to ScaAuthPermissionRule entities by IDs.
+func (saru *ScaAuthRoleUpdate) RemoveScaAuthPermissionRuleIDs(ids ...int64) *ScaAuthRoleUpdate {
+	saru.mutation.RemoveScaAuthPermissionRuleIDs(ids...)
+	return saru
+}
+
+// RemoveScaAuthPermissionRule removes "sca_auth_permission_rule" edges to ScaAuthPermissionRule entities.
+func (saru *ScaAuthRoleUpdate) RemoveScaAuthPermissionRule(s ...*ScaAuthPermissionRule) *ScaAuthRoleUpdate {
+	ids := make([]int64, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return saru.RemoveScaAuthPermissionRuleIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (saru *ScaAuthRoleUpdate) Save(ctx context.Context) (int, error) {
+	saru.defaults()
+	return withHooks(ctx, saru.sqlSave, saru.mutation, saru.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (saru *ScaAuthRoleUpdate) SaveX(ctx context.Context) int {
+	affected, err := saru.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (saru *ScaAuthRoleUpdate) Exec(ctx context.Context) error {
+	_, err := saru.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saru *ScaAuthRoleUpdate) ExecX(ctx context.Context) {
+	if err := saru.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (saru *ScaAuthRoleUpdate) defaults() {
+	if _, ok := saru.mutation.UpdatedAt(); !ok {
+		v := scaauthrole.UpdateDefaultUpdatedAt()
+		saru.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (saru *ScaAuthRoleUpdate) check() error {
+	if v, ok := saru.mutation.Deleted(); ok {
+		if err := scaauthrole.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.deleted": %w`, err)}
+		}
+	}
+	if v, ok := saru.mutation.RoleName(); ok {
+		if err := scaauthrole.RoleNameValidator(v); err != nil {
+			return &ValidationError{Name: "role_name", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.role_name": %w`, err)}
+		}
+	}
+	if v, ok := saru.mutation.RoleKey(); ok {
+		if err := scaauthrole.RoleKeyValidator(v); err != nil {
+			return &ValidationError{Name: "role_key", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.role_key": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (saru *ScaAuthRoleUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := saru.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthrole.Table, scaauthrole.Columns, sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64))
+	if ps := saru.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := saru.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthrole.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := saru.mutation.Deleted(); ok {
+		_spec.SetField(scaauthrole.FieldDeleted, field.TypeInt8, value)
+	}
+	if value, ok := saru.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthrole.FieldDeleted, field.TypeInt8, value)
+	}
+	if saru.mutation.DeletedCleared() {
+		_spec.ClearField(scaauthrole.FieldDeleted, field.TypeInt8)
+	}
+	if value, ok := saru.mutation.RoleName(); ok {
+		_spec.SetField(scaauthrole.FieldRoleName, field.TypeString, value)
+	}
+	if value, ok := saru.mutation.RoleKey(); ok {
+		_spec.SetField(scaauthrole.FieldRoleKey, field.TypeString, value)
+	}
+	if saru.mutation.ScaAuthPermissionRuleCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := saru.mutation.RemovedScaAuthPermissionRuleIDs(); len(nodes) > 0 && !saru.mutation.ScaAuthPermissionRuleCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := saru.mutation.ScaAuthPermissionRuleIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64),
+			},
+		}
+		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, saru.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthrole.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	saru.mutation.done = true
+	return n, nil
+}
+
+// ScaAuthRoleUpdateOne is the builder for updating a single ScaAuthRole entity.
+type ScaAuthRoleUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *ScaAuthRoleMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (saruo *ScaAuthRoleUpdateOne) SetUpdatedAt(t time.Time) *ScaAuthRoleUpdateOne {
+	saruo.mutation.SetUpdatedAt(t)
+	return saruo
+}
+
+// SetDeleted sets the "deleted" field.
+func (saruo *ScaAuthRoleUpdateOne) SetDeleted(i int8) *ScaAuthRoleUpdateOne {
+	saruo.mutation.ResetDeleted()
+	saruo.mutation.SetDeleted(i)
+	return saruo
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (saruo *ScaAuthRoleUpdateOne) SetNillableDeleted(i *int8) *ScaAuthRoleUpdateOne {
+	if i != nil {
+		saruo.SetDeleted(*i)
+	}
+	return saruo
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (saruo *ScaAuthRoleUpdateOne) AddDeleted(i int8) *ScaAuthRoleUpdateOne {
+	saruo.mutation.AddDeleted(i)
+	return saruo
+}
+
+// ClearDeleted clears the value of the "deleted" field.
+func (saruo *ScaAuthRoleUpdateOne) ClearDeleted() *ScaAuthRoleUpdateOne {
+	saruo.mutation.ClearDeleted()
+	return saruo
+}
+
+// SetRoleName sets the "role_name" field.
+func (saruo *ScaAuthRoleUpdateOne) SetRoleName(s string) *ScaAuthRoleUpdateOne {
+	saruo.mutation.SetRoleName(s)
+	return saruo
+}
+
+// SetNillableRoleName sets the "role_name" field if the given value is not nil.
+func (saruo *ScaAuthRoleUpdateOne) SetNillableRoleName(s *string) *ScaAuthRoleUpdateOne {
+	if s != nil {
+		saruo.SetRoleName(*s)
+	}
+	return saruo
+}
+
+// SetRoleKey sets the "role_key" field.
+func (saruo *ScaAuthRoleUpdateOne) SetRoleKey(s string) *ScaAuthRoleUpdateOne {
+	saruo.mutation.SetRoleKey(s)
+	return saruo
+}
+
+// SetNillableRoleKey sets the "role_key" field if the given value is not nil.
+func (saruo *ScaAuthRoleUpdateOne) SetNillableRoleKey(s *string) *ScaAuthRoleUpdateOne {
+	if s != nil {
+		saruo.SetRoleKey(*s)
+	}
+	return saruo
+}
+
+// AddScaAuthPermissionRuleIDs adds the "sca_auth_permission_rule" edge to the ScaAuthPermissionRule entity by IDs.
+func (saruo *ScaAuthRoleUpdateOne) AddScaAuthPermissionRuleIDs(ids ...int64) *ScaAuthRoleUpdateOne {
+	saruo.mutation.AddScaAuthPermissionRuleIDs(ids...)
+	return saruo
+}
+
+// AddScaAuthPermissionRule adds the "sca_auth_permission_rule" edges to the ScaAuthPermissionRule entity.
+func (saruo *ScaAuthRoleUpdateOne) AddScaAuthPermissionRule(s ...*ScaAuthPermissionRule) *ScaAuthRoleUpdateOne {
+	ids := make([]int64, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return saruo.AddScaAuthPermissionRuleIDs(ids...)
+}
+
+// Mutation returns the ScaAuthRoleMutation object of the builder.
+func (saruo *ScaAuthRoleUpdateOne) Mutation() *ScaAuthRoleMutation {
+	return saruo.mutation
+}
+
+// ClearScaAuthPermissionRule clears all "sca_auth_permission_rule" edges to the ScaAuthPermissionRule entity.
+func (saruo *ScaAuthRoleUpdateOne) ClearScaAuthPermissionRule() *ScaAuthRoleUpdateOne {
+	saruo.mutation.ClearScaAuthPermissionRule()
+	return saruo
+}
+
+// RemoveScaAuthPermissionRuleIDs removes the "sca_auth_permission_rule" edge to ScaAuthPermissionRule entities by IDs.
+func (saruo *ScaAuthRoleUpdateOne) RemoveScaAuthPermissionRuleIDs(ids ...int64) *ScaAuthRoleUpdateOne {
+	saruo.mutation.RemoveScaAuthPermissionRuleIDs(ids...)
+	return saruo
+}
+
+// RemoveScaAuthPermissionRule removes "sca_auth_permission_rule" edges to ScaAuthPermissionRule entities.
+func (saruo *ScaAuthRoleUpdateOne) RemoveScaAuthPermissionRule(s ...*ScaAuthPermissionRule) *ScaAuthRoleUpdateOne {
+	ids := make([]int64, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return saruo.RemoveScaAuthPermissionRuleIDs(ids...)
+}
+
+// Where appends a list predicates to the ScaAuthRoleUpdate builder.
+func (saruo *ScaAuthRoleUpdateOne) Where(ps ...predicate.ScaAuthRole) *ScaAuthRoleUpdateOne {
+	saruo.mutation.Where(ps...)
+	return saruo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (saruo *ScaAuthRoleUpdateOne) Select(field string, fields ...string) *ScaAuthRoleUpdateOne {
+	saruo.fields = append([]string{field}, fields...)
+	return saruo
+}
+
+// Save executes the query and returns the updated ScaAuthRole entity.
+func (saruo *ScaAuthRoleUpdateOne) Save(ctx context.Context) (*ScaAuthRole, error) {
+	saruo.defaults()
+	return withHooks(ctx, saruo.sqlSave, saruo.mutation, saruo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (saruo *ScaAuthRoleUpdateOne) SaveX(ctx context.Context) *ScaAuthRole {
+	node, err := saruo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (saruo *ScaAuthRoleUpdateOne) Exec(ctx context.Context) error {
+	_, err := saruo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saruo *ScaAuthRoleUpdateOne) ExecX(ctx context.Context) {
+	if err := saruo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (saruo *ScaAuthRoleUpdateOne) defaults() {
+	if _, ok := saruo.mutation.UpdatedAt(); !ok {
+		v := scaauthrole.UpdateDefaultUpdatedAt()
+		saruo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (saruo *ScaAuthRoleUpdateOne) check() error {
+	if v, ok := saruo.mutation.Deleted(); ok {
+		if err := scaauthrole.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.deleted": %w`, err)}
+		}
+	}
+	if v, ok := saruo.mutation.RoleName(); ok {
+		if err := scaauthrole.RoleNameValidator(v); err != nil {
+			return &ValidationError{Name: "role_name", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.role_name": %w`, err)}
+		}
+	}
+	if v, ok := saruo.mutation.RoleKey(); ok {
+		if err := scaauthrole.RoleKeyValidator(v); err != nil {
+			return &ValidationError{Name: "role_key", err: fmt.Errorf(`ent: validator failed for field "ScaAuthRole.role_key": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (saruo *ScaAuthRoleUpdateOne) sqlSave(ctx context.Context) (_node *ScaAuthRole, err error) {
+	if err := saruo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthrole.Table, scaauthrole.Columns, sqlgraph.NewFieldSpec(scaauthrole.FieldID, field.TypeInt64))
+	id, ok := saruo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ScaAuthRole.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := saruo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthrole.FieldID)
+		for _, f := range fields {
+			if !scaauthrole.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != scaauthrole.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := saruo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := saruo.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthrole.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := saruo.mutation.Deleted(); ok {
+		_spec.SetField(scaauthrole.FieldDeleted, field.TypeInt8, value)
+	}
+	if value, ok := saruo.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthrole.FieldDeleted, field.TypeInt8, value)
+	}
+	if saruo.mutation.DeletedCleared() {
+		_spec.ClearField(scaauthrole.FieldDeleted, field.TypeInt8)
+	}
+	if value, ok := saruo.mutation.RoleName(); ok {
+		_spec.SetField(scaauthrole.FieldRoleName, field.TypeString, value)
+	}
+	if value, ok := saruo.mutation.RoleKey(); ok {
+		_spec.SetField(scaauthrole.FieldRoleKey, field.TypeString, value)
+	}
+	if saruo.mutation.ScaAuthPermissionRuleCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := saruo.mutation.RemovedScaAuthPermissionRuleIDs(); len(nodes) > 0 && !saruo.mutation.ScaAuthPermissionRuleCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := saruo.mutation.ScaAuthPermissionRuleIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthrole.ScaAuthPermissionRuleTable,
+			Columns: []string{scaauthrole.ScaAuthPermissionRuleColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthpermissionrule.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &ScaAuthRole{config: saruo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, saruo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthrole.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	saruo.mutation.done = true
+	return _node, nil
+}

app/core/api/repository/mysql/ent/scaauthuser.go

@@ -0,0 +1,322 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// 用户表
+type ScaAuthUser struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 自增ID
+	ID int64 `json:"id,omitempty"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// 是否删除 0 未删除 1 已删除
+	Deleted int8 `json:"deleted,omitempty"`
+	// 唯一ID
+	UID string `json:"uid,omitempty"`
+	// 用户名
+	Username string `json:"username,omitempty"`
+	// 昵称
+	Nickname string `json:"nickname,omitempty"`
+	// 邮箱
+	Email string `json:"email,omitempty"`
+	// 电话
+	Phone string `json:"phone,omitempty"`
+	// 密码
+	Password string `json:"-"`
+	// 性别
+	Gender string `json:"gender,omitempty"`
+	// 头像
+	Avatar string `json:"avatar,omitempty"`
+	// 状态 0 正常 1 封禁
+	Status int8 `json:"status,omitempty"`
+	// 介绍
+	Introduce string `json:"introduce,omitempty"`
+	// 博客
+	Blog *string `json:"blog,omitempty"`
+	// 地址
+	Location *string `json:"location,omitempty"`
+	// 公司
+	Company *string `json:"company,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ScaAuthUserQuery when eager-loading is set.
+	Edges        ScaAuthUserEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// ScaAuthUserEdges holds the relations/edges for other nodes in the graph.
+type ScaAuthUserEdges struct {
+	// ScaAuthUserSocial holds the value of the sca_auth_user_social edge.
+	ScaAuthUserSocial []*ScaAuthUserSocial `json:"sca_auth_user_social,omitempty"`
+	// ScaAuthUserDevice holds the value of the sca_auth_user_device edge.
+	ScaAuthUserDevice []*ScaAuthUserDevice `json:"sca_auth_user_device,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [2]bool
+}
+
+// ScaAuthUserSocialOrErr returns the ScaAuthUserSocial value or an error if the edge
+// was not loaded in eager-loading.
+func (e ScaAuthUserEdges) ScaAuthUserSocialOrErr() ([]*ScaAuthUserSocial, error) {
+	if e.loadedTypes[0] {
+		return e.ScaAuthUserSocial, nil
+	}
+	return nil, &NotLoadedError{edge: "sca_auth_user_social"}
+}
+
+// ScaAuthUserDeviceOrErr returns the ScaAuthUserDevice value or an error if the edge
+// was not loaded in eager-loading.
+func (e ScaAuthUserEdges) ScaAuthUserDeviceOrErr() ([]*ScaAuthUserDevice, error) {
+	if e.loadedTypes[1] {
+		return e.ScaAuthUserDevice, nil
+	}
+	return nil, &NotLoadedError{edge: "sca_auth_user_device"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ScaAuthUser) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case scaauthuser.FieldID, scaauthuser.FieldDeleted, scaauthuser.FieldStatus:
+			values[i] = new(sql.NullInt64)
+		case scaauthuser.FieldUID, scaauthuser.FieldUsername, scaauthuser.FieldNickname, scaauthuser.FieldEmail, scaauthuser.FieldPhone, scaauthuser.FieldPassword, scaauthuser.FieldGender, scaauthuser.FieldAvatar, scaauthuser.FieldIntroduce, scaauthuser.FieldBlog, scaauthuser.FieldLocation, scaauthuser.FieldCompany:
+			values[i] = new(sql.NullString)
+		case scaauthuser.FieldCreatedAt, scaauthuser.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the ScaAuthUser fields.
+func (sau *ScaAuthUser) 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 scaauthuser.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			sau.ID = int64(value.Int64)
+		case scaauthuser.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				sau.CreatedAt = value.Time
+			}
+		case scaauthuser.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				sau.UpdatedAt = value.Time
+			}
+		case scaauthuser.FieldDeleted:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field deleted", values[i])
+			} else if value.Valid {
+				sau.Deleted = int8(value.Int64)
+			}
+		case scaauthuser.FieldUID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field uid", values[i])
+			} else if value.Valid {
+				sau.UID = value.String
+			}
+		case scaauthuser.FieldUsername:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field username", values[i])
+			} else if value.Valid {
+				sau.Username = value.String
+			}
+		case scaauthuser.FieldNickname:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field nickname", values[i])
+			} else if value.Valid {
+				sau.Nickname = value.String
+			}
+		case scaauthuser.FieldEmail:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field email", values[i])
+			} else if value.Valid {
+				sau.Email = value.String
+			}
+		case scaauthuser.FieldPhone:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field phone", values[i])
+			} else if value.Valid {
+				sau.Phone = value.String
+			}
+		case scaauthuser.FieldPassword:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field password", values[i])
+			} else if value.Valid {
+				sau.Password = value.String
+			}
+		case scaauthuser.FieldGender:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field gender", values[i])
+			} else if value.Valid {
+				sau.Gender = value.String
+			}
+		case scaauthuser.FieldAvatar:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field avatar", values[i])
+			} else if value.Valid {
+				sau.Avatar = value.String
+			}
+		case scaauthuser.FieldStatus:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field status", values[i])
+			} else if value.Valid {
+				sau.Status = int8(value.Int64)
+			}
+		case scaauthuser.FieldIntroduce:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field introduce", values[i])
+			} else if value.Valid {
+				sau.Introduce = value.String
+			}
+		case scaauthuser.FieldBlog:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field blog", values[i])
+			} else if value.Valid {
+				sau.Blog = new(string)
+				*sau.Blog = value.String
+			}
+		case scaauthuser.FieldLocation:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field location", values[i])
+			} else if value.Valid {
+				sau.Location = new(string)
+				*sau.Location = value.String
+			}
+		case scaauthuser.FieldCompany:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field company", values[i])
+			} else if value.Valid {
+				sau.Company = new(string)
+				*sau.Company = value.String
+			}
+		default:
+			sau.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ScaAuthUser.
+// This includes values selected through modifiers, order, etc.
+func (sau *ScaAuthUser) Value(name string) (ent.Value, error) {
+	return sau.selectValues.Get(name)
+}
+
+// QueryScaAuthUserSocial queries the "sca_auth_user_social" edge of the ScaAuthUser entity.
+func (sau *ScaAuthUser) QueryScaAuthUserSocial() *ScaAuthUserSocialQuery {
+	return NewScaAuthUserClient(sau.config).QueryScaAuthUserSocial(sau)
+}
+
+// QueryScaAuthUserDevice queries the "sca_auth_user_device" edge of the ScaAuthUser entity.
+func (sau *ScaAuthUser) QueryScaAuthUserDevice() *ScaAuthUserDeviceQuery {
+	return NewScaAuthUserClient(sau.config).QueryScaAuthUserDevice(sau)
+}
+
+// Update returns a builder for updating this ScaAuthUser.
+// Note that you need to call ScaAuthUser.Unwrap() before calling this method if this ScaAuthUser
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (sau *ScaAuthUser) Update() *ScaAuthUserUpdateOne {
+	return NewScaAuthUserClient(sau.config).UpdateOne(sau)
+}
+
+// Unwrap unwraps the ScaAuthUser 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 (sau *ScaAuthUser) Unwrap() *ScaAuthUser {
+	_tx, ok := sau.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: ScaAuthUser is not a transactional entity")
+	}
+	sau.config.driver = _tx.drv
+	return sau
+}
+
+// String implements the fmt.Stringer.
+func (sau *ScaAuthUser) String() string {
+	var builder strings.Builder
+	builder.WriteString("ScaAuthUser(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", sau.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(sau.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(sau.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", sau.Deleted))
+	builder.WriteString(", ")
+	builder.WriteString("uid=")
+	builder.WriteString(sau.UID)
+	builder.WriteString(", ")
+	builder.WriteString("username=")
+	builder.WriteString(sau.Username)
+	builder.WriteString(", ")
+	builder.WriteString("nickname=")
+	builder.WriteString(sau.Nickname)
+	builder.WriteString(", ")
+	builder.WriteString("email=")
+	builder.WriteString(sau.Email)
+	builder.WriteString(", ")
+	builder.WriteString("phone=")
+	builder.WriteString(sau.Phone)
+	builder.WriteString(", ")
+	builder.WriteString("password=<sensitive>")
+	builder.WriteString(", ")
+	builder.WriteString("gender=")
+	builder.WriteString(sau.Gender)
+	builder.WriteString(", ")
+	builder.WriteString("avatar=")
+	builder.WriteString(sau.Avatar)
+	builder.WriteString(", ")
+	builder.WriteString("status=")
+	builder.WriteString(fmt.Sprintf("%v", sau.Status))
+	builder.WriteString(", ")
+	builder.WriteString("introduce=")
+	builder.WriteString(sau.Introduce)
+	builder.WriteString(", ")
+	if v := sau.Blog; v != nil {
+		builder.WriteString("blog=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sau.Location; v != nil {
+		builder.WriteString("location=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	if v := sau.Company; v != nil {
+		builder.WriteString("company=")
+		builder.WriteString(*v)
+	}
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ScaAuthUsers is a parsable slice of ScaAuthUser.
+type ScaAuthUsers []*ScaAuthUser

app/core/api/repository/mysql/ent/scaauthuser/scaauthuser.go

@@ -0,0 +1,267 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthuser
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the scaauthuser type in the database.
+	Label = "sca_auth_user"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// FieldUID holds the string denoting the uid field in the database.
+	FieldUID = "uid"
+	// FieldUsername holds the string denoting the username field in the database.
+	FieldUsername = "username"
+	// FieldNickname holds the string denoting the nickname field in the database.
+	FieldNickname = "nickname"
+	// FieldEmail holds the string denoting the email field in the database.
+	FieldEmail = "email"
+	// FieldPhone holds the string denoting the phone field in the database.
+	FieldPhone = "phone"
+	// FieldPassword holds the string denoting the password field in the database.
+	FieldPassword = "password"
+	// FieldGender holds the string denoting the gender field in the database.
+	FieldGender = "gender"
+	// FieldAvatar holds the string denoting the avatar field in the database.
+	FieldAvatar = "avatar"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldIntroduce holds the string denoting the introduce field in the database.
+	FieldIntroduce = "introduce"
+	// FieldBlog holds the string denoting the blog field in the database.
+	FieldBlog = "blog"
+	// FieldLocation holds the string denoting the location field in the database.
+	FieldLocation = "location"
+	// FieldCompany holds the string denoting the company field in the database.
+	FieldCompany = "company"
+	// EdgeScaAuthUserSocial holds the string denoting the sca_auth_user_social edge name in mutations.
+	EdgeScaAuthUserSocial = "sca_auth_user_social"
+	// EdgeScaAuthUserDevice holds the string denoting the sca_auth_user_device edge name in mutations.
+	EdgeScaAuthUserDevice = "sca_auth_user_device"
+	// Table holds the table name of the scaauthuser in the database.
+	Table = "sca_auth_user"
+	// ScaAuthUserSocialTable is the table that holds the sca_auth_user_social relation/edge.
+	ScaAuthUserSocialTable = "sca_auth_user_social"
+	// ScaAuthUserSocialInverseTable is the table name for the ScaAuthUserSocial entity.
+	// It exists in this package in order to avoid circular dependency with the "scaauthusersocial" package.
+	ScaAuthUserSocialInverseTable = "sca_auth_user_social"
+	// ScaAuthUserSocialColumn is the table column denoting the sca_auth_user_social relation/edge.
+	ScaAuthUserSocialColumn = "sca_auth_user_sca_auth_user_social"
+	// ScaAuthUserDeviceTable is the table that holds the sca_auth_user_device relation/edge.
+	ScaAuthUserDeviceTable = "sca_auth_user_device"
+	// ScaAuthUserDeviceInverseTable is the table name for the ScaAuthUserDevice entity.
+	// It exists in this package in order to avoid circular dependency with the "scaauthuserdevice" package.
+	ScaAuthUserDeviceInverseTable = "sca_auth_user_device"
+	// ScaAuthUserDeviceColumn is the table column denoting the sca_auth_user_device relation/edge.
+	ScaAuthUserDeviceColumn = "sca_auth_user_sca_auth_user_device"
+)
+
+// Columns holds all SQL columns for scaauthuser fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldDeleted,
+	FieldUID,
+	FieldUsername,
+	FieldNickname,
+	FieldEmail,
+	FieldPhone,
+	FieldPassword,
+	FieldGender,
+	FieldAvatar,
+	FieldStatus,
+	FieldIntroduce,
+	FieldBlog,
+	FieldLocation,
+	FieldCompany,
+}
+
+// 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
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted int8
+	// DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	DeletedValidator func(int8) error
+	// UIDValidator is a validator for the "uid" field. It is called by the builders before save.
+	UIDValidator func(string) error
+	// UsernameValidator is a validator for the "username" field. It is called by the builders before save.
+	UsernameValidator func(string) error
+	// NicknameValidator is a validator for the "nickname" field. It is called by the builders before save.
+	NicknameValidator func(string) error
+	// EmailValidator is a validator for the "email" field. It is called by the builders before save.
+	EmailValidator func(string) error
+	// PhoneValidator is a validator for the "phone" field. It is called by the builders before save.
+	PhoneValidator func(string) error
+	// PasswordValidator is a validator for the "password" field. It is called by the builders before save.
+	PasswordValidator func(string) error
+	// GenderValidator is a validator for the "gender" field. It is called by the builders before save.
+	GenderValidator func(string) error
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus int8
+	// IntroduceValidator is a validator for the "introduce" field. It is called by the builders before save.
+	IntroduceValidator func(string) error
+	// BlogValidator is a validator for the "blog" field. It is called by the builders before save.
+	BlogValidator func(string) error
+	// LocationValidator is a validator for the "location" field. It is called by the builders before save.
+	LocationValidator func(string) error
+	// CompanyValidator is a validator for the "company" field. It is called by the builders before save.
+	CompanyValidator func(string) error
+)
+
+// OrderOption defines the ordering options for the ScaAuthUser 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, opts...).ToFunc()
+}
+
+// ByUID orders the results by the uid field.
+func ByUID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUID, opts...).ToFunc()
+}
+
+// ByUsername orders the results by the username field.
+func ByUsername(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUsername, opts...).ToFunc()
+}
+
+// ByNickname orders the results by the nickname field.
+func ByNickname(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldNickname, opts...).ToFunc()
+}
+
+// ByEmail orders the results by the email field.
+func ByEmail(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldEmail, opts...).ToFunc()
+}
+
+// ByPhone orders the results by the phone field.
+func ByPhone(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPhone, opts...).ToFunc()
+}
+
+// ByPassword orders the results by the password field.
+func ByPassword(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPassword, opts...).ToFunc()
+}
+
+// ByGender orders the results by the gender field.
+func ByGender(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldGender, opts...).ToFunc()
+}
+
+// ByAvatar orders the results by the avatar field.
+func ByAvatar(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAvatar, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByIntroduce orders the results by the introduce field.
+func ByIntroduce(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIntroduce, opts...).ToFunc()
+}
+
+// ByBlog orders the results by the blog field.
+func ByBlog(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBlog, opts...).ToFunc()
+}
+
+// ByLocation orders the results by the location field.
+func ByLocation(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLocation, opts...).ToFunc()
+}
+
+// ByCompany orders the results by the company field.
+func ByCompany(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCompany, opts...).ToFunc()
+}
+
+// ByScaAuthUserSocialCount orders the results by sca_auth_user_social count.
+func ByScaAuthUserSocialCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newScaAuthUserSocialStep(), opts...)
+	}
+}
+
+// ByScaAuthUserSocial orders the results by sca_auth_user_social terms.
+func ByScaAuthUserSocial(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newScaAuthUserSocialStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+
+// ByScaAuthUserDeviceCount orders the results by sca_auth_user_device count.
+func ByScaAuthUserDeviceCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newScaAuthUserDeviceStep(), opts...)
+	}
+}
+
+// ByScaAuthUserDevice orders the results by sca_auth_user_device terms.
+func ByScaAuthUserDevice(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newScaAuthUserDeviceStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+func newScaAuthUserSocialStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ScaAuthUserSocialInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, ScaAuthUserSocialTable, ScaAuthUserSocialColumn),
+	)
+}
+func newScaAuthUserDeviceStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ScaAuthUserDeviceInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, ScaAuthUserDeviceTable, ScaAuthUserDeviceColumn),
+	)
+}

app/core/api/repository/mysql/ent/scaauthuser_create.go

@@ -0,0 +1,618 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserCreate is the builder for creating a ScaAuthUser entity.
+type ScaAuthUserCreate struct {
+	config
+	mutation *ScaAuthUserMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (sauc *ScaAuthUserCreate) SetCreatedAt(t time.Time) *ScaAuthUserCreate {
+	sauc.mutation.SetCreatedAt(t)
+	return sauc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableCreatedAt(t *time.Time) *ScaAuthUserCreate {
+	if t != nil {
+		sauc.SetCreatedAt(*t)
+	}
+	return sauc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (sauc *ScaAuthUserCreate) SetUpdatedAt(t time.Time) *ScaAuthUserCreate {
+	sauc.mutation.SetUpdatedAt(t)
+	return sauc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableUpdatedAt(t *time.Time) *ScaAuthUserCreate {
+	if t != nil {
+		sauc.SetUpdatedAt(*t)
+	}
+	return sauc
+}
+
+// SetDeleted sets the "deleted" field.
+func (sauc *ScaAuthUserCreate) SetDeleted(i int8) *ScaAuthUserCreate {
+	sauc.mutation.SetDeleted(i)
+	return sauc
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableDeleted(i *int8) *ScaAuthUserCreate {
+	if i != nil {
+		sauc.SetDeleted(*i)
+	}
+	return sauc
+}
+
+// SetUID sets the "uid" field.
+func (sauc *ScaAuthUserCreate) SetUID(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetUID(s)
+	return sauc
+}
+
+// SetUsername sets the "username" field.
+func (sauc *ScaAuthUserCreate) SetUsername(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetUsername(s)
+	return sauc
+}
+
+// SetNillableUsername sets the "username" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableUsername(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetUsername(*s)
+	}
+	return sauc
+}
+
+// SetNickname sets the "nickname" field.
+func (sauc *ScaAuthUserCreate) SetNickname(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetNickname(s)
+	return sauc
+}
+
+// SetNillableNickname sets the "nickname" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableNickname(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetNickname(*s)
+	}
+	return sauc
+}
+
+// SetEmail sets the "email" field.
+func (sauc *ScaAuthUserCreate) SetEmail(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetEmail(s)
+	return sauc
+}
+
+// SetNillableEmail sets the "email" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableEmail(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetEmail(*s)
+	}
+	return sauc
+}
+
+// SetPhone sets the "phone" field.
+func (sauc *ScaAuthUserCreate) SetPhone(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetPhone(s)
+	return sauc
+}
+
+// SetNillablePhone sets the "phone" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillablePhone(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetPhone(*s)
+	}
+	return sauc
+}
+
+// SetPassword sets the "password" field.
+func (sauc *ScaAuthUserCreate) SetPassword(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetPassword(s)
+	return sauc
+}
+
+// SetNillablePassword sets the "password" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillablePassword(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetPassword(*s)
+	}
+	return sauc
+}
+
+// SetGender sets the "gender" field.
+func (sauc *ScaAuthUserCreate) SetGender(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetGender(s)
+	return sauc
+}
+
+// SetNillableGender sets the "gender" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableGender(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetGender(*s)
+	}
+	return sauc
+}
+
+// SetAvatar sets the "avatar" field.
+func (sauc *ScaAuthUserCreate) SetAvatar(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetAvatar(s)
+	return sauc
+}
+
+// SetNillableAvatar sets the "avatar" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableAvatar(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetAvatar(*s)
+	}
+	return sauc
+}
+
+// SetStatus sets the "status" field.
+func (sauc *ScaAuthUserCreate) SetStatus(i int8) *ScaAuthUserCreate {
+	sauc.mutation.SetStatus(i)
+	return sauc
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableStatus(i *int8) *ScaAuthUserCreate {
+	if i != nil {
+		sauc.SetStatus(*i)
+	}
+	return sauc
+}
+
+// SetIntroduce sets the "introduce" field.
+func (sauc *ScaAuthUserCreate) SetIntroduce(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetIntroduce(s)
+	return sauc
+}
+
+// SetNillableIntroduce sets the "introduce" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableIntroduce(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetIntroduce(*s)
+	}
+	return sauc
+}
+
+// SetBlog sets the "blog" field.
+func (sauc *ScaAuthUserCreate) SetBlog(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetBlog(s)
+	return sauc
+}
+
+// SetNillableBlog sets the "blog" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableBlog(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetBlog(*s)
+	}
+	return sauc
+}
+
+// SetLocation sets the "location" field.
+func (sauc *ScaAuthUserCreate) SetLocation(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetLocation(s)
+	return sauc
+}
+
+// SetNillableLocation sets the "location" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableLocation(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetLocation(*s)
+	}
+	return sauc
+}
+
+// SetCompany sets the "company" field.
+func (sauc *ScaAuthUserCreate) SetCompany(s string) *ScaAuthUserCreate {
+	sauc.mutation.SetCompany(s)
+	return sauc
+}
+
+// SetNillableCompany sets the "company" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableCompany(s *string) *ScaAuthUserCreate {
+	if s != nil {
+		sauc.SetCompany(*s)
+	}
+	return sauc
+}
+
+// SetID sets the "id" field.
+func (sauc *ScaAuthUserCreate) SetID(i int64) *ScaAuthUserCreate {
+	sauc.mutation.SetID(i)
+	return sauc
+}
+
+// AddScaAuthUserSocialIDs adds the "sca_auth_user_social" edge to the ScaAuthUserSocial entity by IDs.
+func (sauc *ScaAuthUserCreate) AddScaAuthUserSocialIDs(ids ...int64) *ScaAuthUserCreate {
+	sauc.mutation.AddScaAuthUserSocialIDs(ids...)
+	return sauc
+}
+
+// AddScaAuthUserSocial adds the "sca_auth_user_social" edges to the ScaAuthUserSocial entity.
+func (sauc *ScaAuthUserCreate) AddScaAuthUserSocial(s ...*ScaAuthUserSocial) *ScaAuthUserCreate {
+	ids := make([]int64, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return sauc.AddScaAuthUserSocialIDs(ids...)
+}
+
+// AddScaAuthUserDeviceIDs adds the "sca_auth_user_device" edge to the ScaAuthUserDevice entity by IDs.
+func (sauc *ScaAuthUserCreate) AddScaAuthUserDeviceIDs(ids ...int64) *ScaAuthUserCreate {
+	sauc.mutation.AddScaAuthUserDeviceIDs(ids...)
+	return sauc
+}
+
+// AddScaAuthUserDevice adds the "sca_auth_user_device" edges to the ScaAuthUserDevice entity.
+func (sauc *ScaAuthUserCreate) AddScaAuthUserDevice(s ...*ScaAuthUserDevice) *ScaAuthUserCreate {
+	ids := make([]int64, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return sauc.AddScaAuthUserDeviceIDs(ids...)
+}
+
+// Mutation returns the ScaAuthUserMutation object of the builder.
+func (sauc *ScaAuthUserCreate) Mutation() *ScaAuthUserMutation {
+	return sauc.mutation
+}
+
+// Save creates the ScaAuthUser in the database.
+func (sauc *ScaAuthUserCreate) Save(ctx context.Context) (*ScaAuthUser, error) {
+	sauc.defaults()
+	return withHooks(ctx, sauc.sqlSave, sauc.mutation, sauc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (sauc *ScaAuthUserCreate) SaveX(ctx context.Context) *ScaAuthUser {
+	v, err := sauc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (sauc *ScaAuthUserCreate) Exec(ctx context.Context) error {
+	_, err := sauc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sauc *ScaAuthUserCreate) ExecX(ctx context.Context) {
+	if err := sauc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sauc *ScaAuthUserCreate) defaults() {
+	if _, ok := sauc.mutation.CreatedAt(); !ok {
+		v := scaauthuser.DefaultCreatedAt()
+		sauc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := sauc.mutation.UpdatedAt(); !ok {
+		v := scaauthuser.DefaultUpdatedAt()
+		sauc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := sauc.mutation.Deleted(); !ok {
+		v := scaauthuser.DefaultDeleted
+		sauc.mutation.SetDeleted(v)
+	}
+	if _, ok := sauc.mutation.Status(); !ok {
+		v := scaauthuser.DefaultStatus
+		sauc.mutation.SetStatus(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sauc *ScaAuthUserCreate) check() error {
+	if _, ok := sauc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "ScaAuthUser.created_at"`)}
+	}
+	if _, ok := sauc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "ScaAuthUser.updated_at"`)}
+	}
+	if v, ok := sauc.mutation.Deleted(); ok {
+		if err := scaauthuser.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.deleted": %w`, err)}
+		}
+	}
+	if _, ok := sauc.mutation.UID(); !ok {
+		return &ValidationError{Name: "uid", err: errors.New(`ent: missing required field "ScaAuthUser.uid"`)}
+	}
+	if v, ok := sauc.mutation.UID(); ok {
+		if err := scaauthuser.UIDValidator(v); err != nil {
+			return &ValidationError{Name: "uid", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.uid": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Username(); ok {
+		if err := scaauthuser.UsernameValidator(v); err != nil {
+			return &ValidationError{Name: "username", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.username": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Nickname(); ok {
+		if err := scaauthuser.NicknameValidator(v); err != nil {
+			return &ValidationError{Name: "nickname", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.nickname": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Email(); ok {
+		if err := scaauthuser.EmailValidator(v); err != nil {
+			return &ValidationError{Name: "email", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.email": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Phone(); ok {
+		if err := scaauthuser.PhoneValidator(v); err != nil {
+			return &ValidationError{Name: "phone", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.phone": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Password(); ok {
+		if err := scaauthuser.PasswordValidator(v); err != nil {
+			return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.password": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Gender(); ok {
+		if err := scaauthuser.GenderValidator(v); err != nil {
+			return &ValidationError{Name: "gender", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.gender": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Introduce(); ok {
+		if err := scaauthuser.IntroduceValidator(v); err != nil {
+			return &ValidationError{Name: "introduce", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.introduce": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Blog(); ok {
+		if err := scaauthuser.BlogValidator(v); err != nil {
+			return &ValidationError{Name: "blog", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.blog": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Location(); ok {
+		if err := scaauthuser.LocationValidator(v); err != nil {
+			return &ValidationError{Name: "location", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.location": %w`, err)}
+		}
+	}
+	if v, ok := sauc.mutation.Company(); ok {
+		if err := scaauthuser.CompanyValidator(v); err != nil {
+			return &ValidationError{Name: "company", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUser.company": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (sauc *ScaAuthUserCreate) sqlSave(ctx context.Context) (*ScaAuthUser, error) {
+	if err := sauc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := sauc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, sauc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != _node.ID {
+		id := _spec.ID.Value.(int64)
+		_node.ID = int64(id)
+	}
+	sauc.mutation.id = &_node.ID
+	sauc.mutation.done = true
+	return _node, nil
+}
+
+func (sauc *ScaAuthUserCreate) createSpec() (*ScaAuthUser, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ScaAuthUser{config: sauc.config}
+		_spec = sqlgraph.NewCreateSpec(scaauthuser.Table, sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64))
+	)
+	if id, ok := sauc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := sauc.mutation.CreatedAt(); ok {
+		_spec.SetField(scaauthuser.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := sauc.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthuser.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := sauc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthuser.FieldDeleted, field.TypeInt8, value)
+		_node.Deleted = value
+	}
+	if value, ok := sauc.mutation.UID(); ok {
+		_spec.SetField(scaauthuser.FieldUID, field.TypeString, value)
+		_node.UID = value
+	}
+	if value, ok := sauc.mutation.Username(); ok {
+		_spec.SetField(scaauthuser.FieldUsername, field.TypeString, value)
+		_node.Username = value
+	}
+	if value, ok := sauc.mutation.Nickname(); ok {
+		_spec.SetField(scaauthuser.FieldNickname, field.TypeString, value)
+		_node.Nickname = value
+	}
+	if value, ok := sauc.mutation.Email(); ok {
+		_spec.SetField(scaauthuser.FieldEmail, field.TypeString, value)
+		_node.Email = value
+	}
+	if value, ok := sauc.mutation.Phone(); ok {
+		_spec.SetField(scaauthuser.FieldPhone, field.TypeString, value)
+		_node.Phone = value
+	}
+	if value, ok := sauc.mutation.Password(); ok {
+		_spec.SetField(scaauthuser.FieldPassword, field.TypeString, value)
+		_node.Password = value
+	}
+	if value, ok := sauc.mutation.Gender(); ok {
+		_spec.SetField(scaauthuser.FieldGender, field.TypeString, value)
+		_node.Gender = value
+	}
+	if value, ok := sauc.mutation.Avatar(); ok {
+		_spec.SetField(scaauthuser.FieldAvatar, field.TypeString, value)
+		_node.Avatar = value
+	}
+	if value, ok := sauc.mutation.Status(); ok {
+		_spec.SetField(scaauthuser.FieldStatus, field.TypeInt8, value)
+		_node.Status = value
+	}
+	if value, ok := sauc.mutation.Introduce(); ok {
+		_spec.SetField(scaauthuser.FieldIntroduce, field.TypeString, value)
+		_node.Introduce = value
+	}
+	if value, ok := sauc.mutation.Blog(); ok {
+		_spec.SetField(scaauthuser.FieldBlog, field.TypeString, value)
+		_node.Blog = &value
+	}
+	if value, ok := sauc.mutation.Location(); ok {
+		_spec.SetField(scaauthuser.FieldLocation, field.TypeString, value)
+		_node.Location = &value
+	}
+	if value, ok := sauc.mutation.Company(); ok {
+		_spec.SetField(scaauthuser.FieldCompany, field.TypeString, value)
+		_node.Company = &value
+	}
+	if nodes := sauc.mutation.ScaAuthUserSocialIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthuser.ScaAuthUserSocialTable,
+			Columns: []string{scaauthuser.ScaAuthUserSocialColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthusersocial.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	if nodes := sauc.mutation.ScaAuthUserDeviceIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   scaauthuser.ScaAuthUserDeviceTable,
+			Columns: []string{scaauthuser.ScaAuthUserDeviceColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthuserdevice.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// ScaAuthUserCreateBulk is the builder for creating many ScaAuthUser entities in bulk.
+type ScaAuthUserCreateBulk struct {
+	config
+	err      error
+	builders []*ScaAuthUserCreate
+}
+
+// Save creates the ScaAuthUser entities in the database.
+func (saucb *ScaAuthUserCreateBulk) Save(ctx context.Context) ([]*ScaAuthUser, error) {
+	if saucb.err != nil {
+		return nil, saucb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(saucb.builders))
+	nodes := make([]*ScaAuthUser, len(saucb.builders))
+	mutators := make([]Mutator, len(saucb.builders))
+	for i := range saucb.builders {
+		func(i int, root context.Context) {
+			builder := saucb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ScaAuthUserMutation)
+				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, saucb.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, saucb.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 && nodes[i].ID == 0 {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int64(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, saucb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (saucb *ScaAuthUserCreateBulk) SaveX(ctx context.Context) []*ScaAuthUser {
+	v, err := saucb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (saucb *ScaAuthUserCreateBulk) Exec(ctx context.Context) error {
+	_, err := saucb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saucb *ScaAuthUserCreateBulk) ExecX(ctx context.Context) {
+	if err := saucb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthuser_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserDelete is the builder for deleting a ScaAuthUser entity.
+type ScaAuthUserDelete struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthUserMutation
+}
+
+// Where appends a list predicates to the ScaAuthUserDelete builder.
+func (saud *ScaAuthUserDelete) Where(ps ...predicate.ScaAuthUser) *ScaAuthUserDelete {
+	saud.mutation.Where(ps...)
+	return saud
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (saud *ScaAuthUserDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, saud.sqlExec, saud.mutation, saud.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saud *ScaAuthUserDelete) ExecX(ctx context.Context) int {
+	n, err := saud.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (saud *ScaAuthUserDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(scaauthuser.Table, sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64))
+	if ps := saud.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, saud.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	saud.mutation.done = true
+	return affected, err
+}
+
+// ScaAuthUserDeleteOne is the builder for deleting a single ScaAuthUser entity.
+type ScaAuthUserDeleteOne struct {
+	saud *ScaAuthUserDelete
+}
+
+// Where appends a list predicates to the ScaAuthUserDelete builder.
+func (saudo *ScaAuthUserDeleteOne) Where(ps ...predicate.ScaAuthUser) *ScaAuthUserDeleteOne {
+	saudo.saud.mutation.Where(ps...)
+	return saudo
+}
+
+// Exec executes the deletion query.
+func (saudo *ScaAuthUserDeleteOne) Exec(ctx context.Context) error {
+	n, err := saudo.saud.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{scaauthuser.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saudo *ScaAuthUserDeleteOne) ExecX(ctx context.Context) {
+	if err := saudo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthuser_query.go

@@ -0,0 +1,686 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"database/sql/driver"
+	"fmt"
+	"math"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserQuery is the builder for querying ScaAuthUser entities.
+type ScaAuthUserQuery struct {
+	config
+	ctx                   *QueryContext
+	order                 []scaauthuser.OrderOption
+	inters                []Interceptor
+	predicates            []predicate.ScaAuthUser
+	withScaAuthUserSocial *ScaAuthUserSocialQuery
+	withScaAuthUserDevice *ScaAuthUserDeviceQuery
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ScaAuthUserQuery builder.
+func (sauq *ScaAuthUserQuery) Where(ps ...predicate.ScaAuthUser) *ScaAuthUserQuery {
+	sauq.predicates = append(sauq.predicates, ps...)
+	return sauq
+}
+
+// Limit the number of records to be returned by this query.
+func (sauq *ScaAuthUserQuery) Limit(limit int) *ScaAuthUserQuery {
+	sauq.ctx.Limit = &limit
+	return sauq
+}
+
+// Offset to start from.
+func (sauq *ScaAuthUserQuery) Offset(offset int) *ScaAuthUserQuery {
+	sauq.ctx.Offset = &offset
+	return sauq
+}
+
+// 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 (sauq *ScaAuthUserQuery) Unique(unique bool) *ScaAuthUserQuery {
+	sauq.ctx.Unique = &unique
+	return sauq
+}
+
+// Order specifies how the records should be ordered.
+func (sauq *ScaAuthUserQuery) Order(o ...scaauthuser.OrderOption) *ScaAuthUserQuery {
+	sauq.order = append(sauq.order, o...)
+	return sauq
+}
+
+// QueryScaAuthUserSocial chains the current query on the "sca_auth_user_social" edge.
+func (sauq *ScaAuthUserQuery) QueryScaAuthUserSocial() *ScaAuthUserSocialQuery {
+	query := (&ScaAuthUserSocialClient{config: sauq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := sauq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := sauq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(scaauthuser.Table, scaauthuser.FieldID, selector),
+			sqlgraph.To(scaauthusersocial.Table, scaauthusersocial.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, scaauthuser.ScaAuthUserSocialTable, scaauthuser.ScaAuthUserSocialColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(sauq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// QueryScaAuthUserDevice chains the current query on the "sca_auth_user_device" edge.
+func (sauq *ScaAuthUserQuery) QueryScaAuthUserDevice() *ScaAuthUserDeviceQuery {
+	query := (&ScaAuthUserDeviceClient{config: sauq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := sauq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := sauq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(scaauthuser.Table, scaauthuser.FieldID, selector),
+			sqlgraph.To(scaauthuserdevice.Table, scaauthuserdevice.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, scaauthuser.ScaAuthUserDeviceTable, scaauthuser.ScaAuthUserDeviceColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(sauq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first ScaAuthUser entity from the query.
+// Returns a *NotFoundError when no ScaAuthUser was found.
+func (sauq *ScaAuthUserQuery) First(ctx context.Context) (*ScaAuthUser, error) {
+	nodes, err := sauq.Limit(1).All(setContextOp(ctx, sauq.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{scaauthuser.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (sauq *ScaAuthUserQuery) FirstX(ctx context.Context) *ScaAuthUser {
+	node, err := sauq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ScaAuthUser ID from the query.
+// Returns a *NotFoundError when no ScaAuthUser ID was found.
+func (sauq *ScaAuthUserQuery) FirstID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = sauq.Limit(1).IDs(setContextOp(ctx, sauq.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{scaauthuser.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (sauq *ScaAuthUserQuery) FirstIDX(ctx context.Context) int64 {
+	id, err := sauq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ScaAuthUser entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ScaAuthUser entity is found.
+// Returns a *NotFoundError when no ScaAuthUser entities are found.
+func (sauq *ScaAuthUserQuery) Only(ctx context.Context) (*ScaAuthUser, error) {
+	nodes, err := sauq.Limit(2).All(setContextOp(ctx, sauq.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{scaauthuser.Label}
+	default:
+		return nil, &NotSingularError{scaauthuser.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (sauq *ScaAuthUserQuery) OnlyX(ctx context.Context) *ScaAuthUser {
+	node, err := sauq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ScaAuthUser ID in the query.
+// Returns a *NotSingularError when more than one ScaAuthUser ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (sauq *ScaAuthUserQuery) OnlyID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = sauq.Limit(2).IDs(setContextOp(ctx, sauq.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{scaauthuser.Label}
+	default:
+		err = &NotSingularError{scaauthuser.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (sauq *ScaAuthUserQuery) OnlyIDX(ctx context.Context) int64 {
+	id, err := sauq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ScaAuthUsers.
+func (sauq *ScaAuthUserQuery) All(ctx context.Context) ([]*ScaAuthUser, error) {
+	ctx = setContextOp(ctx, sauq.ctx, ent.OpQueryAll)
+	if err := sauq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ScaAuthUser, *ScaAuthUserQuery]()
+	return withInterceptors[[]*ScaAuthUser](ctx, sauq, qr, sauq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (sauq *ScaAuthUserQuery) AllX(ctx context.Context) []*ScaAuthUser {
+	nodes, err := sauq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ScaAuthUser IDs.
+func (sauq *ScaAuthUserQuery) IDs(ctx context.Context) (ids []int64, err error) {
+	if sauq.ctx.Unique == nil && sauq.path != nil {
+		sauq.Unique(true)
+	}
+	ctx = setContextOp(ctx, sauq.ctx, ent.OpQueryIDs)
+	if err = sauq.Select(scaauthuser.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (sauq *ScaAuthUserQuery) IDsX(ctx context.Context) []int64 {
+	ids, err := sauq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (sauq *ScaAuthUserQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, sauq.ctx, ent.OpQueryCount)
+	if err := sauq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, sauq, querierCount[*ScaAuthUserQuery](), sauq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (sauq *ScaAuthUserQuery) CountX(ctx context.Context) int {
+	count, err := sauq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (sauq *ScaAuthUserQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, sauq.ctx, ent.OpQueryExist)
+	switch _, err := sauq.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 (sauq *ScaAuthUserQuery) ExistX(ctx context.Context) bool {
+	exist, err := sauq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ScaAuthUserQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (sauq *ScaAuthUserQuery) Clone() *ScaAuthUserQuery {
+	if sauq == nil {
+		return nil
+	}
+	return &ScaAuthUserQuery{
+		config:                sauq.config,
+		ctx:                   sauq.ctx.Clone(),
+		order:                 append([]scaauthuser.OrderOption{}, sauq.order...),
+		inters:                append([]Interceptor{}, sauq.inters...),
+		predicates:            append([]predicate.ScaAuthUser{}, sauq.predicates...),
+		withScaAuthUserSocial: sauq.withScaAuthUserSocial.Clone(),
+		withScaAuthUserDevice: sauq.withScaAuthUserDevice.Clone(),
+		// clone intermediate query.
+		sql:  sauq.sql.Clone(),
+		path: sauq.path,
+	}
+}
+
+// WithScaAuthUserSocial tells the query-builder to eager-load the nodes that are connected to
+// the "sca_auth_user_social" edge. The optional arguments are used to configure the query builder of the edge.
+func (sauq *ScaAuthUserQuery) WithScaAuthUserSocial(opts ...func(*ScaAuthUserSocialQuery)) *ScaAuthUserQuery {
+	query := (&ScaAuthUserSocialClient{config: sauq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	sauq.withScaAuthUserSocial = query
+	return sauq
+}
+
+// WithScaAuthUserDevice tells the query-builder to eager-load the nodes that are connected to
+// the "sca_auth_user_device" edge. The optional arguments are used to configure the query builder of the edge.
+func (sauq *ScaAuthUserQuery) WithScaAuthUserDevice(opts ...func(*ScaAuthUserDeviceQuery)) *ScaAuthUserQuery {
+	query := (&ScaAuthUserDeviceClient{config: sauq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	sauq.withScaAuthUserDevice = query
+	return sauq
+}
+
+// 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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthUser.Query().
+//		GroupBy(scaauthuser.FieldCreatedAt).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (sauq *ScaAuthUserQuery) GroupBy(field string, fields ...string) *ScaAuthUserGroupBy {
+	sauq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ScaAuthUserGroupBy{build: sauq}
+	grbuild.flds = &sauq.ctx.Fields
+	grbuild.label = scaauthuser.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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//	}
+//
+//	client.ScaAuthUser.Query().
+//		Select(scaauthuser.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (sauq *ScaAuthUserQuery) Select(fields ...string) *ScaAuthUserSelect {
+	sauq.ctx.Fields = append(sauq.ctx.Fields, fields...)
+	sbuild := &ScaAuthUserSelect{ScaAuthUserQuery: sauq}
+	sbuild.label = scaauthuser.Label
+	sbuild.flds, sbuild.scan = &sauq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ScaAuthUserSelect configured with the given aggregations.
+func (sauq *ScaAuthUserQuery) Aggregate(fns ...AggregateFunc) *ScaAuthUserSelect {
+	return sauq.Select().Aggregate(fns...)
+}
+
+func (sauq *ScaAuthUserQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range sauq.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, sauq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range sauq.ctx.Fields {
+		if !scaauthuser.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if sauq.path != nil {
+		prev, err := sauq.path(ctx)
+		if err != nil {
+			return err
+		}
+		sauq.sql = prev
+	}
+	return nil
+}
+
+func (sauq *ScaAuthUserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ScaAuthUser, error) {
+	var (
+		nodes       = []*ScaAuthUser{}
+		_spec       = sauq.querySpec()
+		loadedTypes = [2]bool{
+			sauq.withScaAuthUserSocial != nil,
+			sauq.withScaAuthUserDevice != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ScaAuthUser).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ScaAuthUser{config: sauq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, sauq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := sauq.withScaAuthUserSocial; query != nil {
+		if err := sauq.loadScaAuthUserSocial(ctx, query, nodes,
+			func(n *ScaAuthUser) { n.Edges.ScaAuthUserSocial = []*ScaAuthUserSocial{} },
+			func(n *ScaAuthUser, e *ScaAuthUserSocial) {
+				n.Edges.ScaAuthUserSocial = append(n.Edges.ScaAuthUserSocial, e)
+			}); err != nil {
+			return nil, err
+		}
+	}
+	if query := sauq.withScaAuthUserDevice; query != nil {
+		if err := sauq.loadScaAuthUserDevice(ctx, query, nodes,
+			func(n *ScaAuthUser) { n.Edges.ScaAuthUserDevice = []*ScaAuthUserDevice{} },
+			func(n *ScaAuthUser, e *ScaAuthUserDevice) {
+				n.Edges.ScaAuthUserDevice = append(n.Edges.ScaAuthUserDevice, e)
+			}); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (sauq *ScaAuthUserQuery) loadScaAuthUserSocial(ctx context.Context, query *ScaAuthUserSocialQuery, nodes []*ScaAuthUser, init func(*ScaAuthUser), assign func(*ScaAuthUser, *ScaAuthUserSocial)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[int64]*ScaAuthUser)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	query.withFKs = true
+	query.Where(predicate.ScaAuthUserSocial(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(scaauthuser.ScaAuthUserSocialColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.sca_auth_user_sca_auth_user_social
+		if fk == nil {
+			return fmt.Errorf(`foreign-key "sca_auth_user_sca_auth_user_social" is nil for node %v`, n.ID)
+		}
+		node, ok := nodeids[*fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "sca_auth_user_sca_auth_user_social" returned %v for node %v`, *fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+func (sauq *ScaAuthUserQuery) loadScaAuthUserDevice(ctx context.Context, query *ScaAuthUserDeviceQuery, nodes []*ScaAuthUser, init func(*ScaAuthUser), assign func(*ScaAuthUser, *ScaAuthUserDevice)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[int64]*ScaAuthUser)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	query.withFKs = true
+	query.Where(predicate.ScaAuthUserDevice(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(scaauthuser.ScaAuthUserDeviceColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.sca_auth_user_sca_auth_user_device
+		if fk == nil {
+			return fmt.Errorf(`foreign-key "sca_auth_user_sca_auth_user_device" is nil for node %v`, n.ID)
+		}
+		node, ok := nodeids[*fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "sca_auth_user_sca_auth_user_device" returned %v for node %v`, *fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+
+func (sauq *ScaAuthUserQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := sauq.querySpec()
+	_spec.Node.Columns = sauq.ctx.Fields
+	if len(sauq.ctx.Fields) > 0 {
+		_spec.Unique = sauq.ctx.Unique != nil && *sauq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, sauq.driver, _spec)
+}
+
+func (sauq *ScaAuthUserQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(scaauthuser.Table, scaauthuser.Columns, sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64))
+	_spec.From = sauq.sql
+	if unique := sauq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if sauq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := sauq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthuser.FieldID)
+		for i := range fields {
+			if fields[i] != scaauthuser.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := sauq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := sauq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := sauq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := sauq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (sauq *ScaAuthUserQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(sauq.driver.Dialect())
+	t1 := builder.Table(scaauthuser.Table)
+	columns := sauq.ctx.Fields
+	if len(columns) == 0 {
+		columns = scaauthuser.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if sauq.sql != nil {
+		selector = sauq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if sauq.ctx.Unique != nil && *sauq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range sauq.predicates {
+		p(selector)
+	}
+	for _, p := range sauq.order {
+		p(selector)
+	}
+	if offset := sauq.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 := sauq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ScaAuthUserGroupBy is the group-by builder for ScaAuthUser entities.
+type ScaAuthUserGroupBy struct {
+	selector
+	build *ScaAuthUserQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (saugb *ScaAuthUserGroupBy) Aggregate(fns ...AggregateFunc) *ScaAuthUserGroupBy {
+	saugb.fns = append(saugb.fns, fns...)
+	return saugb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (saugb *ScaAuthUserGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, saugb.build.ctx, ent.OpQueryGroupBy)
+	if err := saugb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthUserQuery, *ScaAuthUserGroupBy](ctx, saugb.build, saugb, saugb.build.inters, v)
+}
+
+func (saugb *ScaAuthUserGroupBy) sqlScan(ctx context.Context, root *ScaAuthUserQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(saugb.fns))
+	for _, fn := range saugb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*saugb.flds)+len(saugb.fns))
+		for _, f := range *saugb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*saugb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := saugb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ScaAuthUserSelect is the builder for selecting fields of ScaAuthUser entities.
+type ScaAuthUserSelect struct {
+	*ScaAuthUserQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (saus *ScaAuthUserSelect) Aggregate(fns ...AggregateFunc) *ScaAuthUserSelect {
+	saus.fns = append(saus.fns, fns...)
+	return saus
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (saus *ScaAuthUserSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, saus.ctx, ent.OpQuerySelect)
+	if err := saus.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthUserQuery, *ScaAuthUserSelect](ctx, saus.ScaAuthUserQuery, saus, saus.inters, v)
+}
+
+func (saus *ScaAuthUserSelect) sqlScan(ctx context.Context, root *ScaAuthUserQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(saus.fns))
+	for _, fn := range saus.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*saus.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 := saus.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

app/core/api/repository/mysql/ent/scaauthuserdevice.go

@@ -0,0 +1,311 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// 用户设备表
+type ScaAuthUserDevice struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 主键ID
+	ID int64 `json:"id,omitempty"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// 是否删除 0 未删除 1 已删除
+	Deleted int8 `json:"deleted,omitempty"`
+	// 用户ID
+	UserID string `json:"user_id,omitempty"`
+	// 登录IP
+	IP string `json:"ip,omitempty"`
+	// 地址
+	Location string `json:"location,omitempty"`
+	// 设备信息
+	Agent string `json:"agent,omitempty"`
+	// 浏览器
+	Browser string `json:"browser,omitempty"`
+	// 操作系统
+	OperatingSystem string `json:"operating_system,omitempty"`
+	// 浏览器版本
+	BrowserVersion string `json:"browser_version,omitempty"`
+	// 是否为手机 0否1是
+	Mobile int `json:"mobile,omitempty"`
+	// 是否为bot 0否1是
+	Bot int `json:"bot,omitempty"`
+	// 火狐版本
+	Mozilla string `json:"mozilla,omitempty"`
+	// 平台
+	Platform string `json:"platform,omitempty"`
+	// 引擎名称
+	EngineName string `json:"engine_name,omitempty"`
+	// 引擎版本
+	EngineVersion string `json:"engine_version,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ScaAuthUserDeviceQuery when eager-loading is set.
+	Edges                              ScaAuthUserDeviceEdges `json:"edges"`
+	sca_auth_user_sca_auth_user_device *int64
+	selectValues                       sql.SelectValues
+}
+
+// ScaAuthUserDeviceEdges holds the relations/edges for other nodes in the graph.
+type ScaAuthUserDeviceEdges struct {
+	// ScaAuthUser holds the value of the sca_auth_user edge.
+	ScaAuthUser *ScaAuthUser `json:"sca_auth_user,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// ScaAuthUserOrErr returns the ScaAuthUser value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e ScaAuthUserDeviceEdges) ScaAuthUserOrErr() (*ScaAuthUser, error) {
+	if e.ScaAuthUser != nil {
+		return e.ScaAuthUser, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: scaauthuser.Label}
+	}
+	return nil, &NotLoadedError{edge: "sca_auth_user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ScaAuthUserDevice) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case scaauthuserdevice.FieldID, scaauthuserdevice.FieldDeleted, scaauthuserdevice.FieldMobile, scaauthuserdevice.FieldBot:
+			values[i] = new(sql.NullInt64)
+		case scaauthuserdevice.FieldUserID, scaauthuserdevice.FieldIP, scaauthuserdevice.FieldLocation, scaauthuserdevice.FieldAgent, scaauthuserdevice.FieldBrowser, scaauthuserdevice.FieldOperatingSystem, scaauthuserdevice.FieldBrowserVersion, scaauthuserdevice.FieldMozilla, scaauthuserdevice.FieldPlatform, scaauthuserdevice.FieldEngineName, scaauthuserdevice.FieldEngineVersion:
+			values[i] = new(sql.NullString)
+		case scaauthuserdevice.FieldCreatedAt, scaauthuserdevice.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		case scaauthuserdevice.ForeignKeys[0]: // sca_auth_user_sca_auth_user_device
+			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 ScaAuthUserDevice fields.
+func (saud *ScaAuthUserDevice) 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 scaauthuserdevice.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			saud.ID = int64(value.Int64)
+		case scaauthuserdevice.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				saud.CreatedAt = value.Time
+			}
+		case scaauthuserdevice.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				saud.UpdatedAt = value.Time
+			}
+		case scaauthuserdevice.FieldDeleted:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field deleted", values[i])
+			} else if value.Valid {
+				saud.Deleted = int8(value.Int64)
+			}
+		case scaauthuserdevice.FieldUserID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				saud.UserID = value.String
+			}
+		case scaauthuserdevice.FieldIP:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field ip", values[i])
+			} else if value.Valid {
+				saud.IP = value.String
+			}
+		case scaauthuserdevice.FieldLocation:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field location", values[i])
+			} else if value.Valid {
+				saud.Location = value.String
+			}
+		case scaauthuserdevice.FieldAgent:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field agent", values[i])
+			} else if value.Valid {
+				saud.Agent = value.String
+			}
+		case scaauthuserdevice.FieldBrowser:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field browser", values[i])
+			} else if value.Valid {
+				saud.Browser = value.String
+			}
+		case scaauthuserdevice.FieldOperatingSystem:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field operating_system", values[i])
+			} else if value.Valid {
+				saud.OperatingSystem = value.String
+			}
+		case scaauthuserdevice.FieldBrowserVersion:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field browser_version", values[i])
+			} else if value.Valid {
+				saud.BrowserVersion = value.String
+			}
+		case scaauthuserdevice.FieldMobile:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field mobile", values[i])
+			} else if value.Valid {
+				saud.Mobile = int(value.Int64)
+			}
+		case scaauthuserdevice.FieldBot:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field bot", values[i])
+			} else if value.Valid {
+				saud.Bot = int(value.Int64)
+			}
+		case scaauthuserdevice.FieldMozilla:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field mozilla", values[i])
+			} else if value.Valid {
+				saud.Mozilla = value.String
+			}
+		case scaauthuserdevice.FieldPlatform:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field platform", values[i])
+			} else if value.Valid {
+				saud.Platform = value.String
+			}
+		case scaauthuserdevice.FieldEngineName:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field engine_name", values[i])
+			} else if value.Valid {
+				saud.EngineName = value.String
+			}
+		case scaauthuserdevice.FieldEngineVersion:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field engine_version", values[i])
+			} else if value.Valid {
+				saud.EngineVersion = value.String
+			}
+		case scaauthuserdevice.ForeignKeys[0]:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for edge-field sca_auth_user_sca_auth_user_device", value)
+			} else if value.Valid {
+				saud.sca_auth_user_sca_auth_user_device = new(int64)
+				*saud.sca_auth_user_sca_auth_user_device = int64(value.Int64)
+			}
+		default:
+			saud.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ScaAuthUserDevice.
+// This includes values selected through modifiers, order, etc.
+func (saud *ScaAuthUserDevice) Value(name string) (ent.Value, error) {
+	return saud.selectValues.Get(name)
+}
+
+// QueryScaAuthUser queries the "sca_auth_user" edge of the ScaAuthUserDevice entity.
+func (saud *ScaAuthUserDevice) QueryScaAuthUser() *ScaAuthUserQuery {
+	return NewScaAuthUserDeviceClient(saud.config).QueryScaAuthUser(saud)
+}
+
+// Update returns a builder for updating this ScaAuthUserDevice.
+// Note that you need to call ScaAuthUserDevice.Unwrap() before calling this method if this ScaAuthUserDevice
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (saud *ScaAuthUserDevice) Update() *ScaAuthUserDeviceUpdateOne {
+	return NewScaAuthUserDeviceClient(saud.config).UpdateOne(saud)
+}
+
+// Unwrap unwraps the ScaAuthUserDevice 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 (saud *ScaAuthUserDevice) Unwrap() *ScaAuthUserDevice {
+	_tx, ok := saud.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: ScaAuthUserDevice is not a transactional entity")
+	}
+	saud.config.driver = _tx.drv
+	return saud
+}
+
+// String implements the fmt.Stringer.
+func (saud *ScaAuthUserDevice) String() string {
+	var builder strings.Builder
+	builder.WriteString("ScaAuthUserDevice(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", saud.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(saud.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(saud.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", saud.Deleted))
+	builder.WriteString(", ")
+	builder.WriteString("user_id=")
+	builder.WriteString(saud.UserID)
+	builder.WriteString(", ")
+	builder.WriteString("ip=")
+	builder.WriteString(saud.IP)
+	builder.WriteString(", ")
+	builder.WriteString("location=")
+	builder.WriteString(saud.Location)
+	builder.WriteString(", ")
+	builder.WriteString("agent=")
+	builder.WriteString(saud.Agent)
+	builder.WriteString(", ")
+	builder.WriteString("browser=")
+	builder.WriteString(saud.Browser)
+	builder.WriteString(", ")
+	builder.WriteString("operating_system=")
+	builder.WriteString(saud.OperatingSystem)
+	builder.WriteString(", ")
+	builder.WriteString("browser_version=")
+	builder.WriteString(saud.BrowserVersion)
+	builder.WriteString(", ")
+	builder.WriteString("mobile=")
+	builder.WriteString(fmt.Sprintf("%v", saud.Mobile))
+	builder.WriteString(", ")
+	builder.WriteString("bot=")
+	builder.WriteString(fmt.Sprintf("%v", saud.Bot))
+	builder.WriteString(", ")
+	builder.WriteString("mozilla=")
+	builder.WriteString(saud.Mozilla)
+	builder.WriteString(", ")
+	builder.WriteString("platform=")
+	builder.WriteString(saud.Platform)
+	builder.WriteString(", ")
+	builder.WriteString("engine_name=")
+	builder.WriteString(saud.EngineName)
+	builder.WriteString(", ")
+	builder.WriteString("engine_version=")
+	builder.WriteString(saud.EngineVersion)
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ScaAuthUserDevices is a parsable slice of ScaAuthUserDevice.
+type ScaAuthUserDevices []*ScaAuthUserDevice

app/core/api/repository/mysql/ent/scaauthuserdevice/scaauthuserdevice.go

@@ -0,0 +1,239 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthuserdevice
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the scaauthuserdevice type in the database.
+	Label = "sca_auth_user_device"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldIP holds the string denoting the ip field in the database.
+	FieldIP = "ip"
+	// FieldLocation holds the string denoting the location field in the database.
+	FieldLocation = "location"
+	// FieldAgent holds the string denoting the agent field in the database.
+	FieldAgent = "agent"
+	// FieldBrowser holds the string denoting the browser field in the database.
+	FieldBrowser = "browser"
+	// FieldOperatingSystem holds the string denoting the operating_system field in the database.
+	FieldOperatingSystem = "operating_system"
+	// FieldBrowserVersion holds the string denoting the browser_version field in the database.
+	FieldBrowserVersion = "browser_version"
+	// FieldMobile holds the string denoting the mobile field in the database.
+	FieldMobile = "mobile"
+	// FieldBot holds the string denoting the bot field in the database.
+	FieldBot = "bot"
+	// FieldMozilla holds the string denoting the mozilla field in the database.
+	FieldMozilla = "mozilla"
+	// FieldPlatform holds the string denoting the platform field in the database.
+	FieldPlatform = "platform"
+	// FieldEngineName holds the string denoting the engine_name field in the database.
+	FieldEngineName = "engine_name"
+	// FieldEngineVersion holds the string denoting the engine_version field in the database.
+	FieldEngineVersion = "engine_version"
+	// EdgeScaAuthUser holds the string denoting the sca_auth_user edge name in mutations.
+	EdgeScaAuthUser = "sca_auth_user"
+	// Table holds the table name of the scaauthuserdevice in the database.
+	Table = "sca_auth_user_device"
+	// ScaAuthUserTable is the table that holds the sca_auth_user relation/edge.
+	ScaAuthUserTable = "sca_auth_user_device"
+	// ScaAuthUserInverseTable is the table name for the ScaAuthUser entity.
+	// It exists in this package in order to avoid circular dependency with the "scaauthuser" package.
+	ScaAuthUserInverseTable = "sca_auth_user"
+	// ScaAuthUserColumn is the table column denoting the sca_auth_user relation/edge.
+	ScaAuthUserColumn = "sca_auth_user_sca_auth_user_device"
+)
+
+// Columns holds all SQL columns for scaauthuserdevice fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldDeleted,
+	FieldUserID,
+	FieldIP,
+	FieldLocation,
+	FieldAgent,
+	FieldBrowser,
+	FieldOperatingSystem,
+	FieldBrowserVersion,
+	FieldMobile,
+	FieldBot,
+	FieldMozilla,
+	FieldPlatform,
+	FieldEngineName,
+	FieldEngineVersion,
+}
+
+// ForeignKeys holds the SQL foreign-keys that are owned by the "sca_auth_user_device"
+// table and are not defined as standalone fields in the schema.
+var ForeignKeys = []string{
+	"sca_auth_user_sca_auth_user_device",
+}
+
+// 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
+		}
+	}
+	for i := range ForeignKeys {
+		if column == ForeignKeys[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted int8
+	// DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	DeletedValidator func(int8) error
+	// UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	UserIDValidator func(string) error
+	// IPValidator is a validator for the "ip" field. It is called by the builders before save.
+	IPValidator func(string) error
+	// LocationValidator is a validator for the "location" field. It is called by the builders before save.
+	LocationValidator func(string) error
+	// AgentValidator is a validator for the "agent" field. It is called by the builders before save.
+	AgentValidator func(string) error
+	// BrowserValidator is a validator for the "browser" field. It is called by the builders before save.
+	BrowserValidator func(string) error
+	// OperatingSystemValidator is a validator for the "operating_system" field. It is called by the builders before save.
+	OperatingSystemValidator func(string) error
+	// BrowserVersionValidator is a validator for the "browser_version" field. It is called by the builders before save.
+	BrowserVersionValidator func(string) error
+	// MozillaValidator is a validator for the "mozilla" field. It is called by the builders before save.
+	MozillaValidator func(string) error
+	// PlatformValidator is a validator for the "platform" field. It is called by the builders before save.
+	PlatformValidator func(string) error
+	// EngineNameValidator is a validator for the "engine_name" field. It is called by the builders before save.
+	EngineNameValidator func(string) error
+	// EngineVersionValidator is a validator for the "engine_version" field. It is called by the builders before save.
+	EngineVersionValidator func(string) error
+)
+
+// OrderOption defines the ordering options for the ScaAuthUserDevice 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByIP orders the results by the ip field.
+func ByIP(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIP, opts...).ToFunc()
+}
+
+// ByLocation orders the results by the location field.
+func ByLocation(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLocation, opts...).ToFunc()
+}
+
+// ByAgent orders the results by the agent field.
+func ByAgent(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAgent, opts...).ToFunc()
+}
+
+// ByBrowser orders the results by the browser field.
+func ByBrowser(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBrowser, opts...).ToFunc()
+}
+
+// ByOperatingSystem orders the results by the operating_system field.
+func ByOperatingSystem(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOperatingSystem, opts...).ToFunc()
+}
+
+// ByBrowserVersion orders the results by the browser_version field.
+func ByBrowserVersion(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBrowserVersion, opts...).ToFunc()
+}
+
+// ByMobile orders the results by the mobile field.
+func ByMobile(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMobile, opts...).ToFunc()
+}
+
+// ByBot orders the results by the bot field.
+func ByBot(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBot, opts...).ToFunc()
+}
+
+// ByMozilla orders the results by the mozilla field.
+func ByMozilla(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMozilla, opts...).ToFunc()
+}
+
+// ByPlatform orders the results by the platform field.
+func ByPlatform(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPlatform, opts...).ToFunc()
+}
+
+// ByEngineName orders the results by the engine_name field.
+func ByEngineName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldEngineName, opts...).ToFunc()
+}
+
+// ByEngineVersion orders the results by the engine_version field.
+func ByEngineVersion(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldEngineVersion, opts...).ToFunc()
+}
+
+// ByScaAuthUserField orders the results by sca_auth_user field.
+func ByScaAuthUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newScaAuthUserStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newScaAuthUserStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ScaAuthUserInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, ScaAuthUserTable, ScaAuthUserColumn),
+	)
+}

app/core/api/repository/mysql/ent/scaauthuserdevice_create.go

@@ -0,0 +1,527 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserDeviceCreate is the builder for creating a ScaAuthUserDevice entity.
+type ScaAuthUserDeviceCreate struct {
+	config
+	mutation *ScaAuthUserDeviceMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (saudc *ScaAuthUserDeviceCreate) SetCreatedAt(t time.Time) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetCreatedAt(t)
+	return saudc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (saudc *ScaAuthUserDeviceCreate) SetNillableCreatedAt(t *time.Time) *ScaAuthUserDeviceCreate {
+	if t != nil {
+		saudc.SetCreatedAt(*t)
+	}
+	return saudc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (saudc *ScaAuthUserDeviceCreate) SetUpdatedAt(t time.Time) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetUpdatedAt(t)
+	return saudc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (saudc *ScaAuthUserDeviceCreate) SetNillableUpdatedAt(t *time.Time) *ScaAuthUserDeviceCreate {
+	if t != nil {
+		saudc.SetUpdatedAt(*t)
+	}
+	return saudc
+}
+
+// SetDeleted sets the "deleted" field.
+func (saudc *ScaAuthUserDeviceCreate) SetDeleted(i int8) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetDeleted(i)
+	return saudc
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (saudc *ScaAuthUserDeviceCreate) SetNillableDeleted(i *int8) *ScaAuthUserDeviceCreate {
+	if i != nil {
+		saudc.SetDeleted(*i)
+	}
+	return saudc
+}
+
+// SetUserID sets the "user_id" field.
+func (saudc *ScaAuthUserDeviceCreate) SetUserID(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetUserID(s)
+	return saudc
+}
+
+// SetIP sets the "ip" field.
+func (saudc *ScaAuthUserDeviceCreate) SetIP(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetIP(s)
+	return saudc
+}
+
+// SetLocation sets the "location" field.
+func (saudc *ScaAuthUserDeviceCreate) SetLocation(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetLocation(s)
+	return saudc
+}
+
+// SetAgent sets the "agent" field.
+func (saudc *ScaAuthUserDeviceCreate) SetAgent(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetAgent(s)
+	return saudc
+}
+
+// SetBrowser sets the "browser" field.
+func (saudc *ScaAuthUserDeviceCreate) SetBrowser(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetBrowser(s)
+	return saudc
+}
+
+// SetOperatingSystem sets the "operating_system" field.
+func (saudc *ScaAuthUserDeviceCreate) SetOperatingSystem(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetOperatingSystem(s)
+	return saudc
+}
+
+// SetBrowserVersion sets the "browser_version" field.
+func (saudc *ScaAuthUserDeviceCreate) SetBrowserVersion(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetBrowserVersion(s)
+	return saudc
+}
+
+// SetMobile sets the "mobile" field.
+func (saudc *ScaAuthUserDeviceCreate) SetMobile(i int) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetMobile(i)
+	return saudc
+}
+
+// SetBot sets the "bot" field.
+func (saudc *ScaAuthUserDeviceCreate) SetBot(i int) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetBot(i)
+	return saudc
+}
+
+// SetMozilla sets the "mozilla" field.
+func (saudc *ScaAuthUserDeviceCreate) SetMozilla(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetMozilla(s)
+	return saudc
+}
+
+// SetPlatform sets the "platform" field.
+func (saudc *ScaAuthUserDeviceCreate) SetPlatform(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetPlatform(s)
+	return saudc
+}
+
+// SetEngineName sets the "engine_name" field.
+func (saudc *ScaAuthUserDeviceCreate) SetEngineName(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetEngineName(s)
+	return saudc
+}
+
+// SetEngineVersion sets the "engine_version" field.
+func (saudc *ScaAuthUserDeviceCreate) SetEngineVersion(s string) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetEngineVersion(s)
+	return saudc
+}
+
+// SetID sets the "id" field.
+func (saudc *ScaAuthUserDeviceCreate) SetID(i int64) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetID(i)
+	return saudc
+}
+
+// SetScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID.
+func (saudc *ScaAuthUserDeviceCreate) SetScaAuthUserID(id int64) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetScaAuthUserID(id)
+	return saudc
+}
+
+// SetNillableScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID if the given value is not nil.
+func (saudc *ScaAuthUserDeviceCreate) SetNillableScaAuthUserID(id *int64) *ScaAuthUserDeviceCreate {
+	if id != nil {
+		saudc = saudc.SetScaAuthUserID(*id)
+	}
+	return saudc
+}
+
+// SetScaAuthUser sets the "sca_auth_user" edge to the ScaAuthUser entity.
+func (saudc *ScaAuthUserDeviceCreate) SetScaAuthUser(s *ScaAuthUser) *ScaAuthUserDeviceCreate {
+	return saudc.SetScaAuthUserID(s.ID)
+}
+
+// Mutation returns the ScaAuthUserDeviceMutation object of the builder.
+func (saudc *ScaAuthUserDeviceCreate) Mutation() *ScaAuthUserDeviceMutation {
+	return saudc.mutation
+}
+
+// Save creates the ScaAuthUserDevice in the database.
+func (saudc *ScaAuthUserDeviceCreate) Save(ctx context.Context) (*ScaAuthUserDevice, error) {
+	saudc.defaults()
+	return withHooks(ctx, saudc.sqlSave, saudc.mutation, saudc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (saudc *ScaAuthUserDeviceCreate) SaveX(ctx context.Context) *ScaAuthUserDevice {
+	v, err := saudc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (saudc *ScaAuthUserDeviceCreate) Exec(ctx context.Context) error {
+	_, err := saudc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saudc *ScaAuthUserDeviceCreate) ExecX(ctx context.Context) {
+	if err := saudc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (saudc *ScaAuthUserDeviceCreate) defaults() {
+	if _, ok := saudc.mutation.CreatedAt(); !ok {
+		v := scaauthuserdevice.DefaultCreatedAt()
+		saudc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := saudc.mutation.UpdatedAt(); !ok {
+		v := scaauthuserdevice.DefaultUpdatedAt()
+		saudc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := saudc.mutation.Deleted(); !ok {
+		v := scaauthuserdevice.DefaultDeleted
+		saudc.mutation.SetDeleted(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (saudc *ScaAuthUserDeviceCreate) check() error {
+	if _, ok := saudc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "ScaAuthUserDevice.created_at"`)}
+	}
+	if _, ok := saudc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "ScaAuthUserDevice.updated_at"`)}
+	}
+	if v, ok := saudc.mutation.Deleted(); ok {
+		if err := scaauthuserdevice.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.deleted": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`ent: missing required field "ScaAuthUserDevice.user_id"`)}
+	}
+	if v, ok := saudc.mutation.UserID(); ok {
+		if err := scaauthuserdevice.UserIDValidator(v); err != nil {
+			return &ValidationError{Name: "user_id", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.user_id": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.IP(); !ok {
+		return &ValidationError{Name: "ip", err: errors.New(`ent: missing required field "ScaAuthUserDevice.ip"`)}
+	}
+	if v, ok := saudc.mutation.IP(); ok {
+		if err := scaauthuserdevice.IPValidator(v); err != nil {
+			return &ValidationError{Name: "ip", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.ip": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.Location(); !ok {
+		return &ValidationError{Name: "location", err: errors.New(`ent: missing required field "ScaAuthUserDevice.location"`)}
+	}
+	if v, ok := saudc.mutation.Location(); ok {
+		if err := scaauthuserdevice.LocationValidator(v); err != nil {
+			return &ValidationError{Name: "location", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.location": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.Agent(); !ok {
+		return &ValidationError{Name: "agent", err: errors.New(`ent: missing required field "ScaAuthUserDevice.agent"`)}
+	}
+	if v, ok := saudc.mutation.Agent(); ok {
+		if err := scaauthuserdevice.AgentValidator(v); err != nil {
+			return &ValidationError{Name: "agent", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.agent": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.Browser(); !ok {
+		return &ValidationError{Name: "browser", err: errors.New(`ent: missing required field "ScaAuthUserDevice.browser"`)}
+	}
+	if v, ok := saudc.mutation.Browser(); ok {
+		if err := scaauthuserdevice.BrowserValidator(v); err != nil {
+			return &ValidationError{Name: "browser", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.browser": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.OperatingSystem(); !ok {
+		return &ValidationError{Name: "operating_system", err: errors.New(`ent: missing required field "ScaAuthUserDevice.operating_system"`)}
+	}
+	if v, ok := saudc.mutation.OperatingSystem(); ok {
+		if err := scaauthuserdevice.OperatingSystemValidator(v); err != nil {
+			return &ValidationError{Name: "operating_system", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.operating_system": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.BrowserVersion(); !ok {
+		return &ValidationError{Name: "browser_version", err: errors.New(`ent: missing required field "ScaAuthUserDevice.browser_version"`)}
+	}
+	if v, ok := saudc.mutation.BrowserVersion(); ok {
+		if err := scaauthuserdevice.BrowserVersionValidator(v); err != nil {
+			return &ValidationError{Name: "browser_version", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.browser_version": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.Mobile(); !ok {
+		return &ValidationError{Name: "mobile", err: errors.New(`ent: missing required field "ScaAuthUserDevice.mobile"`)}
+	}
+	if _, ok := saudc.mutation.Bot(); !ok {
+		return &ValidationError{Name: "bot", err: errors.New(`ent: missing required field "ScaAuthUserDevice.bot"`)}
+	}
+	if _, ok := saudc.mutation.Mozilla(); !ok {
+		return &ValidationError{Name: "mozilla", err: errors.New(`ent: missing required field "ScaAuthUserDevice.mozilla"`)}
+	}
+	if v, ok := saudc.mutation.Mozilla(); ok {
+		if err := scaauthuserdevice.MozillaValidator(v); err != nil {
+			return &ValidationError{Name: "mozilla", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.mozilla": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.Platform(); !ok {
+		return &ValidationError{Name: "platform", err: errors.New(`ent: missing required field "ScaAuthUserDevice.platform"`)}
+	}
+	if v, ok := saudc.mutation.Platform(); ok {
+		if err := scaauthuserdevice.PlatformValidator(v); err != nil {
+			return &ValidationError{Name: "platform", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.platform": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.EngineName(); !ok {
+		return &ValidationError{Name: "engine_name", err: errors.New(`ent: missing required field "ScaAuthUserDevice.engine_name"`)}
+	}
+	if v, ok := saudc.mutation.EngineName(); ok {
+		if err := scaauthuserdevice.EngineNameValidator(v); err != nil {
+			return &ValidationError{Name: "engine_name", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.engine_name": %w`, err)}
+		}
+	}
+	if _, ok := saudc.mutation.EngineVersion(); !ok {
+		return &ValidationError{Name: "engine_version", err: errors.New(`ent: missing required field "ScaAuthUserDevice.engine_version"`)}
+	}
+	if v, ok := saudc.mutation.EngineVersion(); ok {
+		if err := scaauthuserdevice.EngineVersionValidator(v); err != nil {
+			return &ValidationError{Name: "engine_version", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserDevice.engine_version": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (saudc *ScaAuthUserDeviceCreate) sqlSave(ctx context.Context) (*ScaAuthUserDevice, error) {
+	if err := saudc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := saudc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, saudc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != _node.ID {
+		id := _spec.ID.Value.(int64)
+		_node.ID = int64(id)
+	}
+	saudc.mutation.id = &_node.ID
+	saudc.mutation.done = true
+	return _node, nil
+}
+
+func (saudc *ScaAuthUserDeviceCreate) createSpec() (*ScaAuthUserDevice, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ScaAuthUserDevice{config: saudc.config}
+		_spec = sqlgraph.NewCreateSpec(scaauthuserdevice.Table, sqlgraph.NewFieldSpec(scaauthuserdevice.FieldID, field.TypeInt64))
+	)
+	if id, ok := saudc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := saudc.mutation.CreatedAt(); ok {
+		_spec.SetField(scaauthuserdevice.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := saudc.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthuserdevice.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := saudc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthuserdevice.FieldDeleted, field.TypeInt8, value)
+		_node.Deleted = value
+	}
+	if value, ok := saudc.mutation.UserID(); ok {
+		_spec.SetField(scaauthuserdevice.FieldUserID, field.TypeString, value)
+		_node.UserID = value
+	}
+	if value, ok := saudc.mutation.IP(); ok {
+		_spec.SetField(scaauthuserdevice.FieldIP, field.TypeString, value)
+		_node.IP = value
+	}
+	if value, ok := saudc.mutation.Location(); ok {
+		_spec.SetField(scaauthuserdevice.FieldLocation, field.TypeString, value)
+		_node.Location = value
+	}
+	if value, ok := saudc.mutation.Agent(); ok {
+		_spec.SetField(scaauthuserdevice.FieldAgent, field.TypeString, value)
+		_node.Agent = value
+	}
+	if value, ok := saudc.mutation.Browser(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBrowser, field.TypeString, value)
+		_node.Browser = value
+	}
+	if value, ok := saudc.mutation.OperatingSystem(); ok {
+		_spec.SetField(scaauthuserdevice.FieldOperatingSystem, field.TypeString, value)
+		_node.OperatingSystem = value
+	}
+	if value, ok := saudc.mutation.BrowserVersion(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBrowserVersion, field.TypeString, value)
+		_node.BrowserVersion = value
+	}
+	if value, ok := saudc.mutation.Mobile(); ok {
+		_spec.SetField(scaauthuserdevice.FieldMobile, field.TypeInt, value)
+		_node.Mobile = value
+	}
+	if value, ok := saudc.mutation.Bot(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBot, field.TypeInt, value)
+		_node.Bot = value
+	}
+	if value, ok := saudc.mutation.Mozilla(); ok {
+		_spec.SetField(scaauthuserdevice.FieldMozilla, field.TypeString, value)
+		_node.Mozilla = value
+	}
+	if value, ok := saudc.mutation.Platform(); ok {
+		_spec.SetField(scaauthuserdevice.FieldPlatform, field.TypeString, value)
+		_node.Platform = value
+	}
+	if value, ok := saudc.mutation.EngineName(); ok {
+		_spec.SetField(scaauthuserdevice.FieldEngineName, field.TypeString, value)
+		_node.EngineName = value
+	}
+	if value, ok := saudc.mutation.EngineVersion(); ok {
+		_spec.SetField(scaauthuserdevice.FieldEngineVersion, field.TypeString, value)
+		_node.EngineVersion = value
+	}
+	if nodes := saudc.mutation.ScaAuthUserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthuserdevice.ScaAuthUserTable,
+			Columns: []string{scaauthuserdevice.ScaAuthUserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.sca_auth_user_sca_auth_user_device = &nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// ScaAuthUserDeviceCreateBulk is the builder for creating many ScaAuthUserDevice entities in bulk.
+type ScaAuthUserDeviceCreateBulk struct {
+	config
+	err      error
+	builders []*ScaAuthUserDeviceCreate
+}
+
+// Save creates the ScaAuthUserDevice entities in the database.
+func (saudcb *ScaAuthUserDeviceCreateBulk) Save(ctx context.Context) ([]*ScaAuthUserDevice, error) {
+	if saudcb.err != nil {
+		return nil, saudcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(saudcb.builders))
+	nodes := make([]*ScaAuthUserDevice, len(saudcb.builders))
+	mutators := make([]Mutator, len(saudcb.builders))
+	for i := range saudcb.builders {
+		func(i int, root context.Context) {
+			builder := saudcb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ScaAuthUserDeviceMutation)
+				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, saudcb.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, saudcb.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 && nodes[i].ID == 0 {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int64(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, saudcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (saudcb *ScaAuthUserDeviceCreateBulk) SaveX(ctx context.Context) []*ScaAuthUserDevice {
+	v, err := saudcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (saudcb *ScaAuthUserDeviceCreateBulk) Exec(ctx context.Context) error {
+	_, err := saudcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saudcb *ScaAuthUserDeviceCreateBulk) ExecX(ctx context.Context) {
+	if err := saudcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthuserdevice_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserDeviceDelete is the builder for deleting a ScaAuthUserDevice entity.
+type ScaAuthUserDeviceDelete struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthUserDeviceMutation
+}
+
+// Where appends a list predicates to the ScaAuthUserDeviceDelete builder.
+func (saudd *ScaAuthUserDeviceDelete) Where(ps ...predicate.ScaAuthUserDevice) *ScaAuthUserDeviceDelete {
+	saudd.mutation.Where(ps...)
+	return saudd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (saudd *ScaAuthUserDeviceDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, saudd.sqlExec, saudd.mutation, saudd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saudd *ScaAuthUserDeviceDelete) ExecX(ctx context.Context) int {
+	n, err := saudd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (saudd *ScaAuthUserDeviceDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(scaauthuserdevice.Table, sqlgraph.NewFieldSpec(scaauthuserdevice.FieldID, field.TypeInt64))
+	if ps := saudd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, saudd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	saudd.mutation.done = true
+	return affected, err
+}
+
+// ScaAuthUserDeviceDeleteOne is the builder for deleting a single ScaAuthUserDevice entity.
+type ScaAuthUserDeviceDeleteOne struct {
+	saudd *ScaAuthUserDeviceDelete
+}
+
+// Where appends a list predicates to the ScaAuthUserDeviceDelete builder.
+func (sauddo *ScaAuthUserDeviceDeleteOne) Where(ps ...predicate.ScaAuthUserDevice) *ScaAuthUserDeviceDeleteOne {
+	sauddo.saudd.mutation.Where(ps...)
+	return sauddo
+}
+
+// Exec executes the deletion query.
+func (sauddo *ScaAuthUserDeviceDeleteOne) Exec(ctx context.Context) error {
+	n, err := sauddo.saudd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{scaauthuserdevice.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sauddo *ScaAuthUserDeviceDeleteOne) ExecX(ctx context.Context) {
+	if err := sauddo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthuserdevice_query.go

@@ -0,0 +1,614 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuserdevice"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserDeviceQuery is the builder for querying ScaAuthUserDevice entities.
+type ScaAuthUserDeviceQuery struct {
+	config
+	ctx             *QueryContext
+	order           []scaauthuserdevice.OrderOption
+	inters          []Interceptor
+	predicates      []predicate.ScaAuthUserDevice
+	withScaAuthUser *ScaAuthUserQuery
+	withFKs         bool
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ScaAuthUserDeviceQuery builder.
+func (saudq *ScaAuthUserDeviceQuery) Where(ps ...predicate.ScaAuthUserDevice) *ScaAuthUserDeviceQuery {
+	saudq.predicates = append(saudq.predicates, ps...)
+	return saudq
+}
+
+// Limit the number of records to be returned by this query.
+func (saudq *ScaAuthUserDeviceQuery) Limit(limit int) *ScaAuthUserDeviceQuery {
+	saudq.ctx.Limit = &limit
+	return saudq
+}
+
+// Offset to start from.
+func (saudq *ScaAuthUserDeviceQuery) Offset(offset int) *ScaAuthUserDeviceQuery {
+	saudq.ctx.Offset = &offset
+	return saudq
+}
+
+// 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 (saudq *ScaAuthUserDeviceQuery) Unique(unique bool) *ScaAuthUserDeviceQuery {
+	saudq.ctx.Unique = &unique
+	return saudq
+}
+
+// Order specifies how the records should be ordered.
+func (saudq *ScaAuthUserDeviceQuery) Order(o ...scaauthuserdevice.OrderOption) *ScaAuthUserDeviceQuery {
+	saudq.order = append(saudq.order, o...)
+	return saudq
+}
+
+// QueryScaAuthUser chains the current query on the "sca_auth_user" edge.
+func (saudq *ScaAuthUserDeviceQuery) QueryScaAuthUser() *ScaAuthUserQuery {
+	query := (&ScaAuthUserClient{config: saudq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := saudq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := saudq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(scaauthuserdevice.Table, scaauthuserdevice.FieldID, selector),
+			sqlgraph.To(scaauthuser.Table, scaauthuser.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, scaauthuserdevice.ScaAuthUserTable, scaauthuserdevice.ScaAuthUserColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(saudq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first ScaAuthUserDevice entity from the query.
+// Returns a *NotFoundError when no ScaAuthUserDevice was found.
+func (saudq *ScaAuthUserDeviceQuery) First(ctx context.Context) (*ScaAuthUserDevice, error) {
+	nodes, err := saudq.Limit(1).All(setContextOp(ctx, saudq.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{scaauthuserdevice.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (saudq *ScaAuthUserDeviceQuery) FirstX(ctx context.Context) *ScaAuthUserDevice {
+	node, err := saudq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ScaAuthUserDevice ID from the query.
+// Returns a *NotFoundError when no ScaAuthUserDevice ID was found.
+func (saudq *ScaAuthUserDeviceQuery) FirstID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = saudq.Limit(1).IDs(setContextOp(ctx, saudq.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{scaauthuserdevice.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (saudq *ScaAuthUserDeviceQuery) FirstIDX(ctx context.Context) int64 {
+	id, err := saudq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ScaAuthUserDevice entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ScaAuthUserDevice entity is found.
+// Returns a *NotFoundError when no ScaAuthUserDevice entities are found.
+func (saudq *ScaAuthUserDeviceQuery) Only(ctx context.Context) (*ScaAuthUserDevice, error) {
+	nodes, err := saudq.Limit(2).All(setContextOp(ctx, saudq.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{scaauthuserdevice.Label}
+	default:
+		return nil, &NotSingularError{scaauthuserdevice.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (saudq *ScaAuthUserDeviceQuery) OnlyX(ctx context.Context) *ScaAuthUserDevice {
+	node, err := saudq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ScaAuthUserDevice ID in the query.
+// Returns a *NotSingularError when more than one ScaAuthUserDevice ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (saudq *ScaAuthUserDeviceQuery) OnlyID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = saudq.Limit(2).IDs(setContextOp(ctx, saudq.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{scaauthuserdevice.Label}
+	default:
+		err = &NotSingularError{scaauthuserdevice.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (saudq *ScaAuthUserDeviceQuery) OnlyIDX(ctx context.Context) int64 {
+	id, err := saudq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ScaAuthUserDevices.
+func (saudq *ScaAuthUserDeviceQuery) All(ctx context.Context) ([]*ScaAuthUserDevice, error) {
+	ctx = setContextOp(ctx, saudq.ctx, ent.OpQueryAll)
+	if err := saudq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ScaAuthUserDevice, *ScaAuthUserDeviceQuery]()
+	return withInterceptors[[]*ScaAuthUserDevice](ctx, saudq, qr, saudq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (saudq *ScaAuthUserDeviceQuery) AllX(ctx context.Context) []*ScaAuthUserDevice {
+	nodes, err := saudq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ScaAuthUserDevice IDs.
+func (saudq *ScaAuthUserDeviceQuery) IDs(ctx context.Context) (ids []int64, err error) {
+	if saudq.ctx.Unique == nil && saudq.path != nil {
+		saudq.Unique(true)
+	}
+	ctx = setContextOp(ctx, saudq.ctx, ent.OpQueryIDs)
+	if err = saudq.Select(scaauthuserdevice.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (saudq *ScaAuthUserDeviceQuery) IDsX(ctx context.Context) []int64 {
+	ids, err := saudq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (saudq *ScaAuthUserDeviceQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, saudq.ctx, ent.OpQueryCount)
+	if err := saudq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, saudq, querierCount[*ScaAuthUserDeviceQuery](), saudq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (saudq *ScaAuthUserDeviceQuery) CountX(ctx context.Context) int {
+	count, err := saudq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (saudq *ScaAuthUserDeviceQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, saudq.ctx, ent.OpQueryExist)
+	switch _, err := saudq.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 (saudq *ScaAuthUserDeviceQuery) ExistX(ctx context.Context) bool {
+	exist, err := saudq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ScaAuthUserDeviceQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (saudq *ScaAuthUserDeviceQuery) Clone() *ScaAuthUserDeviceQuery {
+	if saudq == nil {
+		return nil
+	}
+	return &ScaAuthUserDeviceQuery{
+		config:          saudq.config,
+		ctx:             saudq.ctx.Clone(),
+		order:           append([]scaauthuserdevice.OrderOption{}, saudq.order...),
+		inters:          append([]Interceptor{}, saudq.inters...),
+		predicates:      append([]predicate.ScaAuthUserDevice{}, saudq.predicates...),
+		withScaAuthUser: saudq.withScaAuthUser.Clone(),
+		// clone intermediate query.
+		sql:  saudq.sql.Clone(),
+		path: saudq.path,
+	}
+}
+
+// WithScaAuthUser tells the query-builder to eager-load the nodes that are connected to
+// the "sca_auth_user" edge. The optional arguments are used to configure the query builder of the edge.
+func (saudq *ScaAuthUserDeviceQuery) WithScaAuthUser(opts ...func(*ScaAuthUserQuery)) *ScaAuthUserDeviceQuery {
+	query := (&ScaAuthUserClient{config: saudq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	saudq.withScaAuthUser = query
+	return saudq
+}
+
+// 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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthUserDevice.Query().
+//		GroupBy(scaauthuserdevice.FieldCreatedAt).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (saudq *ScaAuthUserDeviceQuery) GroupBy(field string, fields ...string) *ScaAuthUserDeviceGroupBy {
+	saudq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ScaAuthUserDeviceGroupBy{build: saudq}
+	grbuild.flds = &saudq.ctx.Fields
+	grbuild.label = scaauthuserdevice.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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//	}
+//
+//	client.ScaAuthUserDevice.Query().
+//		Select(scaauthuserdevice.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (saudq *ScaAuthUserDeviceQuery) Select(fields ...string) *ScaAuthUserDeviceSelect {
+	saudq.ctx.Fields = append(saudq.ctx.Fields, fields...)
+	sbuild := &ScaAuthUserDeviceSelect{ScaAuthUserDeviceQuery: saudq}
+	sbuild.label = scaauthuserdevice.Label
+	sbuild.flds, sbuild.scan = &saudq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ScaAuthUserDeviceSelect configured with the given aggregations.
+func (saudq *ScaAuthUserDeviceQuery) Aggregate(fns ...AggregateFunc) *ScaAuthUserDeviceSelect {
+	return saudq.Select().Aggregate(fns...)
+}
+
+func (saudq *ScaAuthUserDeviceQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range saudq.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, saudq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range saudq.ctx.Fields {
+		if !scaauthuserdevice.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if saudq.path != nil {
+		prev, err := saudq.path(ctx)
+		if err != nil {
+			return err
+		}
+		saudq.sql = prev
+	}
+	return nil
+}
+
+func (saudq *ScaAuthUserDeviceQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ScaAuthUserDevice, error) {
+	var (
+		nodes       = []*ScaAuthUserDevice{}
+		withFKs     = saudq.withFKs
+		_spec       = saudq.querySpec()
+		loadedTypes = [1]bool{
+			saudq.withScaAuthUser != nil,
+		}
+	)
+	if saudq.withScaAuthUser != nil {
+		withFKs = true
+	}
+	if withFKs {
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthuserdevice.ForeignKeys...)
+	}
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ScaAuthUserDevice).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ScaAuthUserDevice{config: saudq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, saudq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := saudq.withScaAuthUser; query != nil {
+		if err := saudq.loadScaAuthUser(ctx, query, nodes, nil,
+			func(n *ScaAuthUserDevice, e *ScaAuthUser) { n.Edges.ScaAuthUser = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (saudq *ScaAuthUserDeviceQuery) loadScaAuthUser(ctx context.Context, query *ScaAuthUserQuery, nodes []*ScaAuthUserDevice, init func(*ScaAuthUserDevice), assign func(*ScaAuthUserDevice, *ScaAuthUser)) error {
+	ids := make([]int64, 0, len(nodes))
+	nodeids := make(map[int64][]*ScaAuthUserDevice)
+	for i := range nodes {
+		if nodes[i].sca_auth_user_sca_auth_user_device == nil {
+			continue
+		}
+		fk := *nodes[i].sca_auth_user_sca_auth_user_device
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(scaauthuser.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 "sca_auth_user_sca_auth_user_device" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (saudq *ScaAuthUserDeviceQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := saudq.querySpec()
+	_spec.Node.Columns = saudq.ctx.Fields
+	if len(saudq.ctx.Fields) > 0 {
+		_spec.Unique = saudq.ctx.Unique != nil && *saudq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, saudq.driver, _spec)
+}
+
+func (saudq *ScaAuthUserDeviceQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(scaauthuserdevice.Table, scaauthuserdevice.Columns, sqlgraph.NewFieldSpec(scaauthuserdevice.FieldID, field.TypeInt64))
+	_spec.From = saudq.sql
+	if unique := saudq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if saudq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := saudq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthuserdevice.FieldID)
+		for i := range fields {
+			if fields[i] != scaauthuserdevice.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := saudq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := saudq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := saudq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := saudq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (saudq *ScaAuthUserDeviceQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(saudq.driver.Dialect())
+	t1 := builder.Table(scaauthuserdevice.Table)
+	columns := saudq.ctx.Fields
+	if len(columns) == 0 {
+		columns = scaauthuserdevice.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if saudq.sql != nil {
+		selector = saudq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if saudq.ctx.Unique != nil && *saudq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range saudq.predicates {
+		p(selector)
+	}
+	for _, p := range saudq.order {
+		p(selector)
+	}
+	if offset := saudq.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 := saudq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ScaAuthUserDeviceGroupBy is the group-by builder for ScaAuthUserDevice entities.
+type ScaAuthUserDeviceGroupBy struct {
+	selector
+	build *ScaAuthUserDeviceQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (saudgb *ScaAuthUserDeviceGroupBy) Aggregate(fns ...AggregateFunc) *ScaAuthUserDeviceGroupBy {
+	saudgb.fns = append(saudgb.fns, fns...)
+	return saudgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (saudgb *ScaAuthUserDeviceGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, saudgb.build.ctx, ent.OpQueryGroupBy)
+	if err := saudgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthUserDeviceQuery, *ScaAuthUserDeviceGroupBy](ctx, saudgb.build, saudgb, saudgb.build.inters, v)
+}
+
+func (saudgb *ScaAuthUserDeviceGroupBy) sqlScan(ctx context.Context, root *ScaAuthUserDeviceQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(saudgb.fns))
+	for _, fn := range saudgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*saudgb.flds)+len(saudgb.fns))
+		for _, f := range *saudgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*saudgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := saudgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ScaAuthUserDeviceSelect is the builder for selecting fields of ScaAuthUserDevice entities.
+type ScaAuthUserDeviceSelect struct {
+	*ScaAuthUserDeviceQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (sauds *ScaAuthUserDeviceSelect) Aggregate(fns ...AggregateFunc) *ScaAuthUserDeviceSelect {
+	sauds.fns = append(sauds.fns, fns...)
+	return sauds
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (sauds *ScaAuthUserDeviceSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, sauds.ctx, ent.OpQuerySelect)
+	if err := sauds.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthUserDeviceQuery, *ScaAuthUserDeviceSelect](ctx, sauds.ScaAuthUserDeviceQuery, sauds, sauds.inters, v)
+}
+
+func (sauds *ScaAuthUserDeviceSelect) sqlScan(ctx context.Context, root *ScaAuthUserDeviceQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(sauds.fns))
+	for _, fn := range sauds.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*sauds.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 := sauds.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

app/core/api/repository/mysql/ent/scaauthusersocial.go

@@ -0,0 +1,212 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// 用户第三方登录信息
+type ScaAuthUserSocial struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 主键ID
+	ID int64 `json:"id,omitempty"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// 是否删除 0 未删除 1 已删除
+	Deleted int8 `json:"deleted,omitempty"`
+	// 用户ID
+	UserID string `json:"user_id,omitempty"`
+	// 第三方用户的 open id
+	OpenID string `json:"open_id,omitempty"`
+	// 第三方用户来源
+	Source string `json:"source,omitempty"`
+	// 状态 0正常 1 封禁
+	Status int `json:"status,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ScaAuthUserSocialQuery when eager-loading is set.
+	Edges                              ScaAuthUserSocialEdges `json:"edges"`
+	sca_auth_user_sca_auth_user_social *int64
+	selectValues                       sql.SelectValues
+}
+
+// ScaAuthUserSocialEdges holds the relations/edges for other nodes in the graph.
+type ScaAuthUserSocialEdges struct {
+	// ScaAuthUser holds the value of the sca_auth_user edge.
+	ScaAuthUser *ScaAuthUser `json:"sca_auth_user,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// ScaAuthUserOrErr returns the ScaAuthUser value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e ScaAuthUserSocialEdges) ScaAuthUserOrErr() (*ScaAuthUser, error) {
+	if e.ScaAuthUser != nil {
+		return e.ScaAuthUser, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: scaauthuser.Label}
+	}
+	return nil, &NotLoadedError{edge: "sca_auth_user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ScaAuthUserSocial) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case scaauthusersocial.FieldID, scaauthusersocial.FieldDeleted, scaauthusersocial.FieldStatus:
+			values[i] = new(sql.NullInt64)
+		case scaauthusersocial.FieldUserID, scaauthusersocial.FieldOpenID, scaauthusersocial.FieldSource:
+			values[i] = new(sql.NullString)
+		case scaauthusersocial.FieldCreatedAt, scaauthusersocial.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		case scaauthusersocial.ForeignKeys[0]: // sca_auth_user_sca_auth_user_social
+			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 ScaAuthUserSocial fields.
+func (saus *ScaAuthUserSocial) 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 scaauthusersocial.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			saus.ID = int64(value.Int64)
+		case scaauthusersocial.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				saus.CreatedAt = value.Time
+			}
+		case scaauthusersocial.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				saus.UpdatedAt = value.Time
+			}
+		case scaauthusersocial.FieldDeleted:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field deleted", values[i])
+			} else if value.Valid {
+				saus.Deleted = int8(value.Int64)
+			}
+		case scaauthusersocial.FieldUserID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				saus.UserID = value.String
+			}
+		case scaauthusersocial.FieldOpenID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field open_id", values[i])
+			} else if value.Valid {
+				saus.OpenID = value.String
+			}
+		case scaauthusersocial.FieldSource:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field source", values[i])
+			} else if value.Valid {
+				saus.Source = value.String
+			}
+		case scaauthusersocial.FieldStatus:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field status", values[i])
+			} else if value.Valid {
+				saus.Status = int(value.Int64)
+			}
+		case scaauthusersocial.ForeignKeys[0]:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for edge-field sca_auth_user_sca_auth_user_social", value)
+			} else if value.Valid {
+				saus.sca_auth_user_sca_auth_user_social = new(int64)
+				*saus.sca_auth_user_sca_auth_user_social = int64(value.Int64)
+			}
+		default:
+			saus.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ScaAuthUserSocial.
+// This includes values selected through modifiers, order, etc.
+func (saus *ScaAuthUserSocial) Value(name string) (ent.Value, error) {
+	return saus.selectValues.Get(name)
+}
+
+// QueryScaAuthUser queries the "sca_auth_user" edge of the ScaAuthUserSocial entity.
+func (saus *ScaAuthUserSocial) QueryScaAuthUser() *ScaAuthUserQuery {
+	return NewScaAuthUserSocialClient(saus.config).QueryScaAuthUser(saus)
+}
+
+// Update returns a builder for updating this ScaAuthUserSocial.
+// Note that you need to call ScaAuthUserSocial.Unwrap() before calling this method if this ScaAuthUserSocial
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (saus *ScaAuthUserSocial) Update() *ScaAuthUserSocialUpdateOne {
+	return NewScaAuthUserSocialClient(saus.config).UpdateOne(saus)
+}
+
+// Unwrap unwraps the ScaAuthUserSocial 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 (saus *ScaAuthUserSocial) Unwrap() *ScaAuthUserSocial {
+	_tx, ok := saus.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: ScaAuthUserSocial is not a transactional entity")
+	}
+	saus.config.driver = _tx.drv
+	return saus
+}
+
+// String implements the fmt.Stringer.
+func (saus *ScaAuthUserSocial) String() string {
+	var builder strings.Builder
+	builder.WriteString("ScaAuthUserSocial(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", saus.ID))
+	builder.WriteString("created_at=")
+	builder.WriteString(saus.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(saus.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", saus.Deleted))
+	builder.WriteString(", ")
+	builder.WriteString("user_id=")
+	builder.WriteString(saus.UserID)
+	builder.WriteString(", ")
+	builder.WriteString("open_id=")
+	builder.WriteString(saus.OpenID)
+	builder.WriteString(", ")
+	builder.WriteString("source=")
+	builder.WriteString(saus.Source)
+	builder.WriteString(", ")
+	builder.WriteString("status=")
+	builder.WriteString(fmt.Sprintf("%v", saus.Status))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ScaAuthUserSocials is a parsable slice of ScaAuthUserSocial.
+type ScaAuthUserSocials []*ScaAuthUserSocial

app/core/api/repository/mysql/ent/scaauthusersocial/scaauthusersocial.go

@@ -0,0 +1,153 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthusersocial
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the scaauthusersocial type in the database.
+	Label = "sca_auth_user_social"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldOpenID holds the string denoting the open_id field in the database.
+	FieldOpenID = "open_id"
+	// FieldSource holds the string denoting the source field in the database.
+	FieldSource = "source"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// EdgeScaAuthUser holds the string denoting the sca_auth_user edge name in mutations.
+	EdgeScaAuthUser = "sca_auth_user"
+	// Table holds the table name of the scaauthusersocial in the database.
+	Table = "sca_auth_user_social"
+	// ScaAuthUserTable is the table that holds the sca_auth_user relation/edge.
+	ScaAuthUserTable = "sca_auth_user_social"
+	// ScaAuthUserInverseTable is the table name for the ScaAuthUser entity.
+	// It exists in this package in order to avoid circular dependency with the "scaauthuser" package.
+	ScaAuthUserInverseTable = "sca_auth_user"
+	// ScaAuthUserColumn is the table column denoting the sca_auth_user relation/edge.
+	ScaAuthUserColumn = "sca_auth_user_sca_auth_user_social"
+)
+
+// Columns holds all SQL columns for scaauthusersocial fields.
+var Columns = []string{
+	FieldID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+	FieldDeleted,
+	FieldUserID,
+	FieldOpenID,
+	FieldSource,
+	FieldStatus,
+}
+
+// ForeignKeys holds the SQL foreign-keys that are owned by the "sca_auth_user_social"
+// table and are not defined as standalone fields in the schema.
+var ForeignKeys = []string{
+	"sca_auth_user_sca_auth_user_social",
+}
+
+// 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
+		}
+	}
+	for i := range ForeignKeys {
+		if column == ForeignKeys[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted int8
+	// DeletedValidator is a validator for the "deleted" field. It is called by the builders before save.
+	DeletedValidator func(int8) error
+	// UserIDValidator is a validator for the "user_id" field. It is called by the builders before save.
+	UserIDValidator func(string) error
+	// OpenIDValidator is a validator for the "open_id" field. It is called by the builders before save.
+	OpenIDValidator func(string) error
+	// SourceValidator is a validator for the "source" field. It is called by the builders before save.
+	SourceValidator func(string) error
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus int
+)
+
+// OrderOption defines the ordering options for the ScaAuthUserSocial 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByOpenID orders the results by the open_id field.
+func ByOpenID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOpenID, opts...).ToFunc()
+}
+
+// BySource orders the results by the source field.
+func BySource(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSource, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByScaAuthUserField orders the results by sca_auth_user field.
+func ByScaAuthUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newScaAuthUserStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newScaAuthUserStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ScaAuthUserInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, ScaAuthUserTable, ScaAuthUserColumn),
+	)
+}

app/core/api/repository/mysql/ent/scaauthusersocial/where.go

@@ -0,0 +1,494 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthusersocial
+
+import (
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int64) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldID, id))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// Deleted applies equality check predicate on the "deleted" field. It's identical to DeletedEQ.
+func Deleted(v int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldDeleted, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldUserID, v))
+}
+
+// OpenID applies equality check predicate on the "open_id" field. It's identical to OpenIDEQ.
+func OpenID(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldOpenID, v))
+}
+
+// Source applies equality check predicate on the "source" field. It's identical to SourceEQ.
+func Source(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldSource, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldStatus, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// DeletedEQ applies the EQ predicate on the "deleted" field.
+func DeletedEQ(v int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldDeleted, v))
+}
+
+// DeletedNEQ applies the NEQ predicate on the "deleted" field.
+func DeletedNEQ(v int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldDeleted, v))
+}
+
+// DeletedIn applies the In predicate on the "deleted" field.
+func DeletedIn(vs ...int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldDeleted, vs...))
+}
+
+// DeletedNotIn applies the NotIn predicate on the "deleted" field.
+func DeletedNotIn(vs ...int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldDeleted, vs...))
+}
+
+// DeletedGT applies the GT predicate on the "deleted" field.
+func DeletedGT(v int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldDeleted, v))
+}
+
+// DeletedGTE applies the GTE predicate on the "deleted" field.
+func DeletedGTE(v int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldDeleted, v))
+}
+
+// DeletedLT applies the LT predicate on the "deleted" field.
+func DeletedLT(v int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldDeleted, v))
+}
+
+// DeletedLTE applies the LTE predicate on the "deleted" field.
+func DeletedLTE(v int8) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldDeleted, v))
+}
+
+// DeletedIsNil applies the IsNil predicate on the "deleted" field.
+func DeletedIsNil() predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIsNull(FieldDeleted))
+}
+
+// DeletedNotNil applies the NotNil predicate on the "deleted" field.
+func DeletedNotNil() predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotNull(FieldDeleted))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// UserIDGT applies the GT predicate on the "user_id" field.
+func UserIDGT(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldUserID, v))
+}
+
+// UserIDGTE applies the GTE predicate on the "user_id" field.
+func UserIDGTE(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldUserID, v))
+}
+
+// UserIDLT applies the LT predicate on the "user_id" field.
+func UserIDLT(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldUserID, v))
+}
+
+// UserIDLTE applies the LTE predicate on the "user_id" field.
+func UserIDLTE(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldUserID, v))
+}
+
+// UserIDContains applies the Contains predicate on the "user_id" field.
+func UserIDContains(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldContains(FieldUserID, v))
+}
+
+// UserIDHasPrefix applies the HasPrefix predicate on the "user_id" field.
+func UserIDHasPrefix(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldHasPrefix(FieldUserID, v))
+}
+
+// UserIDHasSuffix applies the HasSuffix predicate on the "user_id" field.
+func UserIDHasSuffix(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldHasSuffix(FieldUserID, v))
+}
+
+// UserIDEqualFold applies the EqualFold predicate on the "user_id" field.
+func UserIDEqualFold(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEqualFold(FieldUserID, v))
+}
+
+// UserIDContainsFold applies the ContainsFold predicate on the "user_id" field.
+func UserIDContainsFold(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldContainsFold(FieldUserID, v))
+}
+
+// OpenIDEQ applies the EQ predicate on the "open_id" field.
+func OpenIDEQ(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldOpenID, v))
+}
+
+// OpenIDNEQ applies the NEQ predicate on the "open_id" field.
+func OpenIDNEQ(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldOpenID, v))
+}
+
+// OpenIDIn applies the In predicate on the "open_id" field.
+func OpenIDIn(vs ...string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldOpenID, vs...))
+}
+
+// OpenIDNotIn applies the NotIn predicate on the "open_id" field.
+func OpenIDNotIn(vs ...string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldOpenID, vs...))
+}
+
+// OpenIDGT applies the GT predicate on the "open_id" field.
+func OpenIDGT(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldOpenID, v))
+}
+
+// OpenIDGTE applies the GTE predicate on the "open_id" field.
+func OpenIDGTE(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldOpenID, v))
+}
+
+// OpenIDLT applies the LT predicate on the "open_id" field.
+func OpenIDLT(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldOpenID, v))
+}
+
+// OpenIDLTE applies the LTE predicate on the "open_id" field.
+func OpenIDLTE(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldOpenID, v))
+}
+
+// OpenIDContains applies the Contains predicate on the "open_id" field.
+func OpenIDContains(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldContains(FieldOpenID, v))
+}
+
+// OpenIDHasPrefix applies the HasPrefix predicate on the "open_id" field.
+func OpenIDHasPrefix(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldHasPrefix(FieldOpenID, v))
+}
+
+// OpenIDHasSuffix applies the HasSuffix predicate on the "open_id" field.
+func OpenIDHasSuffix(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldHasSuffix(FieldOpenID, v))
+}
+
+// OpenIDEqualFold applies the EqualFold predicate on the "open_id" field.
+func OpenIDEqualFold(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEqualFold(FieldOpenID, v))
+}
+
+// OpenIDContainsFold applies the ContainsFold predicate on the "open_id" field.
+func OpenIDContainsFold(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldContainsFold(FieldOpenID, v))
+}
+
+// SourceEQ applies the EQ predicate on the "source" field.
+func SourceEQ(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldSource, v))
+}
+
+// SourceNEQ applies the NEQ predicate on the "source" field.
+func SourceNEQ(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldSource, v))
+}
+
+// SourceIn applies the In predicate on the "source" field.
+func SourceIn(vs ...string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldSource, vs...))
+}
+
+// SourceNotIn applies the NotIn predicate on the "source" field.
+func SourceNotIn(vs ...string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldSource, vs...))
+}
+
+// SourceGT applies the GT predicate on the "source" field.
+func SourceGT(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldSource, v))
+}
+
+// SourceGTE applies the GTE predicate on the "source" field.
+func SourceGTE(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldSource, v))
+}
+
+// SourceLT applies the LT predicate on the "source" field.
+func SourceLT(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldSource, v))
+}
+
+// SourceLTE applies the LTE predicate on the "source" field.
+func SourceLTE(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldSource, v))
+}
+
+// SourceContains applies the Contains predicate on the "source" field.
+func SourceContains(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldContains(FieldSource, v))
+}
+
+// SourceHasPrefix applies the HasPrefix predicate on the "source" field.
+func SourceHasPrefix(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldHasPrefix(FieldSource, v))
+}
+
+// SourceHasSuffix applies the HasSuffix predicate on the "source" field.
+func SourceHasSuffix(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldHasSuffix(FieldSource, v))
+}
+
+// SourceEqualFold applies the EqualFold predicate on the "source" field.
+func SourceEqualFold(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEqualFold(FieldSource, v))
+}
+
+// SourceContainsFold applies the ContainsFold predicate on the "source" field.
+func SourceContainsFold(v string) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldContainsFold(FieldSource, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldStatus, v))
+}
+
+// HasScaAuthUser applies the HasEdge predicate on the "sca_auth_user" edge.
+func HasScaAuthUser() predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, ScaAuthUserTable, ScaAuthUserColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasScaAuthUserWith applies the HasEdge predicate on the "sca_auth_user" edge with a given conditions (other predicates).
+func HasScaAuthUserWith(preds ...predicate.ScaAuthUser) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(func(s *sql.Selector) {
+		step := newScaAuthUserStep()
+		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.ScaAuthUserSocial) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ScaAuthUserSocial) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ScaAuthUserSocial) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.NotPredicates(p))
+}

app/core/api/repository/mysql/ent/scaauthusersocial_create.go

@@ -0,0 +1,382 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserSocialCreate is the builder for creating a ScaAuthUserSocial entity.
+type ScaAuthUserSocialCreate struct {
+	config
+	mutation *ScaAuthUserSocialMutation
+	hooks    []Hook
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (sausc *ScaAuthUserSocialCreate) SetCreatedAt(t time.Time) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetCreatedAt(t)
+	return sausc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (sausc *ScaAuthUserSocialCreate) SetNillableCreatedAt(t *time.Time) *ScaAuthUserSocialCreate {
+	if t != nil {
+		sausc.SetCreatedAt(*t)
+	}
+	return sausc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (sausc *ScaAuthUserSocialCreate) SetUpdatedAt(t time.Time) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetUpdatedAt(t)
+	return sausc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (sausc *ScaAuthUserSocialCreate) SetNillableUpdatedAt(t *time.Time) *ScaAuthUserSocialCreate {
+	if t != nil {
+		sausc.SetUpdatedAt(*t)
+	}
+	return sausc
+}
+
+// SetDeleted sets the "deleted" field.
+func (sausc *ScaAuthUserSocialCreate) SetDeleted(i int8) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetDeleted(i)
+	return sausc
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sausc *ScaAuthUserSocialCreate) SetNillableDeleted(i *int8) *ScaAuthUserSocialCreate {
+	if i != nil {
+		sausc.SetDeleted(*i)
+	}
+	return sausc
+}
+
+// SetUserID sets the "user_id" field.
+func (sausc *ScaAuthUserSocialCreate) SetUserID(s string) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetUserID(s)
+	return sausc
+}
+
+// SetOpenID sets the "open_id" field.
+func (sausc *ScaAuthUserSocialCreate) SetOpenID(s string) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetOpenID(s)
+	return sausc
+}
+
+// SetSource sets the "source" field.
+func (sausc *ScaAuthUserSocialCreate) SetSource(s string) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetSource(s)
+	return sausc
+}
+
+// SetStatus sets the "status" field.
+func (sausc *ScaAuthUserSocialCreate) SetStatus(i int) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetStatus(i)
+	return sausc
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (sausc *ScaAuthUserSocialCreate) SetNillableStatus(i *int) *ScaAuthUserSocialCreate {
+	if i != nil {
+		sausc.SetStatus(*i)
+	}
+	return sausc
+}
+
+// SetID sets the "id" field.
+func (sausc *ScaAuthUserSocialCreate) SetID(i int64) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetID(i)
+	return sausc
+}
+
+// SetScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID.
+func (sausc *ScaAuthUserSocialCreate) SetScaAuthUserID(id int64) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetScaAuthUserID(id)
+	return sausc
+}
+
+// SetNillableScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID if the given value is not nil.
+func (sausc *ScaAuthUserSocialCreate) SetNillableScaAuthUserID(id *int64) *ScaAuthUserSocialCreate {
+	if id != nil {
+		sausc = sausc.SetScaAuthUserID(*id)
+	}
+	return sausc
+}
+
+// SetScaAuthUser sets the "sca_auth_user" edge to the ScaAuthUser entity.
+func (sausc *ScaAuthUserSocialCreate) SetScaAuthUser(s *ScaAuthUser) *ScaAuthUserSocialCreate {
+	return sausc.SetScaAuthUserID(s.ID)
+}
+
+// Mutation returns the ScaAuthUserSocialMutation object of the builder.
+func (sausc *ScaAuthUserSocialCreate) Mutation() *ScaAuthUserSocialMutation {
+	return sausc.mutation
+}
+
+// Save creates the ScaAuthUserSocial in the database.
+func (sausc *ScaAuthUserSocialCreate) Save(ctx context.Context) (*ScaAuthUserSocial, error) {
+	sausc.defaults()
+	return withHooks(ctx, sausc.sqlSave, sausc.mutation, sausc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (sausc *ScaAuthUserSocialCreate) SaveX(ctx context.Context) *ScaAuthUserSocial {
+	v, err := sausc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (sausc *ScaAuthUserSocialCreate) Exec(ctx context.Context) error {
+	_, err := sausc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sausc *ScaAuthUserSocialCreate) ExecX(ctx context.Context) {
+	if err := sausc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sausc *ScaAuthUserSocialCreate) defaults() {
+	if _, ok := sausc.mutation.CreatedAt(); !ok {
+		v := scaauthusersocial.DefaultCreatedAt()
+		sausc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := sausc.mutation.UpdatedAt(); !ok {
+		v := scaauthusersocial.DefaultUpdatedAt()
+		sausc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := sausc.mutation.Deleted(); !ok {
+		v := scaauthusersocial.DefaultDeleted
+		sausc.mutation.SetDeleted(v)
+	}
+	if _, ok := sausc.mutation.Status(); !ok {
+		v := scaauthusersocial.DefaultStatus
+		sausc.mutation.SetStatus(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sausc *ScaAuthUserSocialCreate) check() error {
+	if _, ok := sausc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "ScaAuthUserSocial.created_at"`)}
+	}
+	if _, ok := sausc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "ScaAuthUserSocial.updated_at"`)}
+	}
+	if v, ok := sausc.mutation.Deleted(); ok {
+		if err := scaauthusersocial.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.deleted": %w`, err)}
+		}
+	}
+	if _, ok := sausc.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`ent: missing required field "ScaAuthUserSocial.user_id"`)}
+	}
+	if v, ok := sausc.mutation.UserID(); ok {
+		if err := scaauthusersocial.UserIDValidator(v); err != nil {
+			return &ValidationError{Name: "user_id", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.user_id": %w`, err)}
+		}
+	}
+	if _, ok := sausc.mutation.OpenID(); !ok {
+		return &ValidationError{Name: "open_id", err: errors.New(`ent: missing required field "ScaAuthUserSocial.open_id"`)}
+	}
+	if v, ok := sausc.mutation.OpenID(); ok {
+		if err := scaauthusersocial.OpenIDValidator(v); err != nil {
+			return &ValidationError{Name: "open_id", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.open_id": %w`, err)}
+		}
+	}
+	if _, ok := sausc.mutation.Source(); !ok {
+		return &ValidationError{Name: "source", err: errors.New(`ent: missing required field "ScaAuthUserSocial.source"`)}
+	}
+	if v, ok := sausc.mutation.Source(); ok {
+		if err := scaauthusersocial.SourceValidator(v); err != nil {
+			return &ValidationError{Name: "source", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.source": %w`, err)}
+		}
+	}
+	if _, ok := sausc.mutation.Status(); !ok {
+		return &ValidationError{Name: "status", err: errors.New(`ent: missing required field "ScaAuthUserSocial.status"`)}
+	}
+	return nil
+}
+
+func (sausc *ScaAuthUserSocialCreate) sqlSave(ctx context.Context) (*ScaAuthUserSocial, error) {
+	if err := sausc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := sausc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, sausc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != _node.ID {
+		id := _spec.ID.Value.(int64)
+		_node.ID = int64(id)
+	}
+	sausc.mutation.id = &_node.ID
+	sausc.mutation.done = true
+	return _node, nil
+}
+
+func (sausc *ScaAuthUserSocialCreate) createSpec() (*ScaAuthUserSocial, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ScaAuthUserSocial{config: sausc.config}
+		_spec = sqlgraph.NewCreateSpec(scaauthusersocial.Table, sqlgraph.NewFieldSpec(scaauthusersocial.FieldID, field.TypeInt64))
+	)
+	if id, ok := sausc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := sausc.mutation.CreatedAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := sausc.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := sausc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthusersocial.FieldDeleted, field.TypeInt8, value)
+		_node.Deleted = value
+	}
+	if value, ok := sausc.mutation.UserID(); ok {
+		_spec.SetField(scaauthusersocial.FieldUserID, field.TypeString, value)
+		_node.UserID = value
+	}
+	if value, ok := sausc.mutation.OpenID(); ok {
+		_spec.SetField(scaauthusersocial.FieldOpenID, field.TypeString, value)
+		_node.OpenID = value
+	}
+	if value, ok := sausc.mutation.Source(); ok {
+		_spec.SetField(scaauthusersocial.FieldSource, field.TypeString, value)
+		_node.Source = value
+	}
+	if value, ok := sausc.mutation.Status(); ok {
+		_spec.SetField(scaauthusersocial.FieldStatus, field.TypeInt, value)
+		_node.Status = value
+	}
+	if nodes := sausc.mutation.ScaAuthUserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthusersocial.ScaAuthUserTable,
+			Columns: []string{scaauthusersocial.ScaAuthUserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.sca_auth_user_sca_auth_user_social = &nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// ScaAuthUserSocialCreateBulk is the builder for creating many ScaAuthUserSocial entities in bulk.
+type ScaAuthUserSocialCreateBulk struct {
+	config
+	err      error
+	builders []*ScaAuthUserSocialCreate
+}
+
+// Save creates the ScaAuthUserSocial entities in the database.
+func (sauscb *ScaAuthUserSocialCreateBulk) Save(ctx context.Context) ([]*ScaAuthUserSocial, error) {
+	if sauscb.err != nil {
+		return nil, sauscb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(sauscb.builders))
+	nodes := make([]*ScaAuthUserSocial, len(sauscb.builders))
+	mutators := make([]Mutator, len(sauscb.builders))
+	for i := range sauscb.builders {
+		func(i int, root context.Context) {
+			builder := sauscb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ScaAuthUserSocialMutation)
+				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, sauscb.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, sauscb.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 && nodes[i].ID == 0 {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int64(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, sauscb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (sauscb *ScaAuthUserSocialCreateBulk) SaveX(ctx context.Context) []*ScaAuthUserSocial {
+	v, err := sauscb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (sauscb *ScaAuthUserSocialCreateBulk) Exec(ctx context.Context) error {
+	_, err := sauscb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sauscb *ScaAuthUserSocialCreateBulk) ExecX(ctx context.Context) {
+	if err := sauscb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthusersocial_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserSocialDelete is the builder for deleting a ScaAuthUserSocial entity.
+type ScaAuthUserSocialDelete struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthUserSocialMutation
+}
+
+// Where appends a list predicates to the ScaAuthUserSocialDelete builder.
+func (sausd *ScaAuthUserSocialDelete) Where(ps ...predicate.ScaAuthUserSocial) *ScaAuthUserSocialDelete {
+	sausd.mutation.Where(ps...)
+	return sausd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (sausd *ScaAuthUserSocialDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, sausd.sqlExec, sausd.mutation, sausd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sausd *ScaAuthUserSocialDelete) ExecX(ctx context.Context) int {
+	n, err := sausd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (sausd *ScaAuthUserSocialDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(scaauthusersocial.Table, sqlgraph.NewFieldSpec(scaauthusersocial.FieldID, field.TypeInt64))
+	if ps := sausd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, sausd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	sausd.mutation.done = true
+	return affected, err
+}
+
+// ScaAuthUserSocialDeleteOne is the builder for deleting a single ScaAuthUserSocial entity.
+type ScaAuthUserSocialDeleteOne struct {
+	sausd *ScaAuthUserSocialDelete
+}
+
+// Where appends a list predicates to the ScaAuthUserSocialDelete builder.
+func (sausdo *ScaAuthUserSocialDeleteOne) Where(ps ...predicate.ScaAuthUserSocial) *ScaAuthUserSocialDeleteOne {
+	sausdo.sausd.mutation.Where(ps...)
+	return sausdo
+}
+
+// Exec executes the deletion query.
+func (sausdo *ScaAuthUserSocialDeleteOne) Exec(ctx context.Context) error {
+	n, err := sausdo.sausd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{scaauthusersocial.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sausdo *ScaAuthUserSocialDeleteOne) ExecX(ctx context.Context) {
+	if err := sausdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/core/api/repository/mysql/ent/scaauthusersocial_query.go

@@ -0,0 +1,614 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserSocialQuery is the builder for querying ScaAuthUserSocial entities.
+type ScaAuthUserSocialQuery struct {
+	config
+	ctx             *QueryContext
+	order           []scaauthusersocial.OrderOption
+	inters          []Interceptor
+	predicates      []predicate.ScaAuthUserSocial
+	withScaAuthUser *ScaAuthUserQuery
+	withFKs         bool
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ScaAuthUserSocialQuery builder.
+func (sausq *ScaAuthUserSocialQuery) Where(ps ...predicate.ScaAuthUserSocial) *ScaAuthUserSocialQuery {
+	sausq.predicates = append(sausq.predicates, ps...)
+	return sausq
+}
+
+// Limit the number of records to be returned by this query.
+func (sausq *ScaAuthUserSocialQuery) Limit(limit int) *ScaAuthUserSocialQuery {
+	sausq.ctx.Limit = &limit
+	return sausq
+}
+
+// Offset to start from.
+func (sausq *ScaAuthUserSocialQuery) Offset(offset int) *ScaAuthUserSocialQuery {
+	sausq.ctx.Offset = &offset
+	return sausq
+}
+
+// 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 (sausq *ScaAuthUserSocialQuery) Unique(unique bool) *ScaAuthUserSocialQuery {
+	sausq.ctx.Unique = &unique
+	return sausq
+}
+
+// Order specifies how the records should be ordered.
+func (sausq *ScaAuthUserSocialQuery) Order(o ...scaauthusersocial.OrderOption) *ScaAuthUserSocialQuery {
+	sausq.order = append(sausq.order, o...)
+	return sausq
+}
+
+// QueryScaAuthUser chains the current query on the "sca_auth_user" edge.
+func (sausq *ScaAuthUserSocialQuery) QueryScaAuthUser() *ScaAuthUserQuery {
+	query := (&ScaAuthUserClient{config: sausq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := sausq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := sausq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(scaauthusersocial.Table, scaauthusersocial.FieldID, selector),
+			sqlgraph.To(scaauthuser.Table, scaauthuser.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, scaauthusersocial.ScaAuthUserTable, scaauthusersocial.ScaAuthUserColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(sausq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first ScaAuthUserSocial entity from the query.
+// Returns a *NotFoundError when no ScaAuthUserSocial was found.
+func (sausq *ScaAuthUserSocialQuery) First(ctx context.Context) (*ScaAuthUserSocial, error) {
+	nodes, err := sausq.Limit(1).All(setContextOp(ctx, sausq.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{scaauthusersocial.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (sausq *ScaAuthUserSocialQuery) FirstX(ctx context.Context) *ScaAuthUserSocial {
+	node, err := sausq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ScaAuthUserSocial ID from the query.
+// Returns a *NotFoundError when no ScaAuthUserSocial ID was found.
+func (sausq *ScaAuthUserSocialQuery) FirstID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = sausq.Limit(1).IDs(setContextOp(ctx, sausq.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{scaauthusersocial.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (sausq *ScaAuthUserSocialQuery) FirstIDX(ctx context.Context) int64 {
+	id, err := sausq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ScaAuthUserSocial entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ScaAuthUserSocial entity is found.
+// Returns a *NotFoundError when no ScaAuthUserSocial entities are found.
+func (sausq *ScaAuthUserSocialQuery) Only(ctx context.Context) (*ScaAuthUserSocial, error) {
+	nodes, err := sausq.Limit(2).All(setContextOp(ctx, sausq.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{scaauthusersocial.Label}
+	default:
+		return nil, &NotSingularError{scaauthusersocial.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (sausq *ScaAuthUserSocialQuery) OnlyX(ctx context.Context) *ScaAuthUserSocial {
+	node, err := sausq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ScaAuthUserSocial ID in the query.
+// Returns a *NotSingularError when more than one ScaAuthUserSocial ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (sausq *ScaAuthUserSocialQuery) OnlyID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = sausq.Limit(2).IDs(setContextOp(ctx, sausq.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{scaauthusersocial.Label}
+	default:
+		err = &NotSingularError{scaauthusersocial.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (sausq *ScaAuthUserSocialQuery) OnlyIDX(ctx context.Context) int64 {
+	id, err := sausq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ScaAuthUserSocials.
+func (sausq *ScaAuthUserSocialQuery) All(ctx context.Context) ([]*ScaAuthUserSocial, error) {
+	ctx = setContextOp(ctx, sausq.ctx, ent.OpQueryAll)
+	if err := sausq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ScaAuthUserSocial, *ScaAuthUserSocialQuery]()
+	return withInterceptors[[]*ScaAuthUserSocial](ctx, sausq, qr, sausq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (sausq *ScaAuthUserSocialQuery) AllX(ctx context.Context) []*ScaAuthUserSocial {
+	nodes, err := sausq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ScaAuthUserSocial IDs.
+func (sausq *ScaAuthUserSocialQuery) IDs(ctx context.Context) (ids []int64, err error) {
+	if sausq.ctx.Unique == nil && sausq.path != nil {
+		sausq.Unique(true)
+	}
+	ctx = setContextOp(ctx, sausq.ctx, ent.OpQueryIDs)
+	if err = sausq.Select(scaauthusersocial.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (sausq *ScaAuthUserSocialQuery) IDsX(ctx context.Context) []int64 {
+	ids, err := sausq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (sausq *ScaAuthUserSocialQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, sausq.ctx, ent.OpQueryCount)
+	if err := sausq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, sausq, querierCount[*ScaAuthUserSocialQuery](), sausq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (sausq *ScaAuthUserSocialQuery) CountX(ctx context.Context) int {
+	count, err := sausq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (sausq *ScaAuthUserSocialQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, sausq.ctx, ent.OpQueryExist)
+	switch _, err := sausq.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 (sausq *ScaAuthUserSocialQuery) ExistX(ctx context.Context) bool {
+	exist, err := sausq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ScaAuthUserSocialQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (sausq *ScaAuthUserSocialQuery) Clone() *ScaAuthUserSocialQuery {
+	if sausq == nil {
+		return nil
+	}
+	return &ScaAuthUserSocialQuery{
+		config:          sausq.config,
+		ctx:             sausq.ctx.Clone(),
+		order:           append([]scaauthusersocial.OrderOption{}, sausq.order...),
+		inters:          append([]Interceptor{}, sausq.inters...),
+		predicates:      append([]predicate.ScaAuthUserSocial{}, sausq.predicates...),
+		withScaAuthUser: sausq.withScaAuthUser.Clone(),
+		// clone intermediate query.
+		sql:  sausq.sql.Clone(),
+		path: sausq.path,
+	}
+}
+
+// WithScaAuthUser tells the query-builder to eager-load the nodes that are connected to
+// the "sca_auth_user" edge. The optional arguments are used to configure the query builder of the edge.
+func (sausq *ScaAuthUserSocialQuery) WithScaAuthUser(opts ...func(*ScaAuthUserQuery)) *ScaAuthUserSocialQuery {
+	query := (&ScaAuthUserClient{config: sausq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	sausq.withScaAuthUser = query
+	return sausq
+}
+
+// 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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthUserSocial.Query().
+//		GroupBy(scaauthusersocial.FieldCreatedAt).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (sausq *ScaAuthUserSocialQuery) GroupBy(field string, fields ...string) *ScaAuthUserSocialGroupBy {
+	sausq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ScaAuthUserSocialGroupBy{build: sausq}
+	grbuild.flds = &sausq.ctx.Fields
+	grbuild.label = scaauthusersocial.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 {
+//		CreatedAt time.Time `json:"created_at,omitempty"`
+//	}
+//
+//	client.ScaAuthUserSocial.Query().
+//		Select(scaauthusersocial.FieldCreatedAt).
+//		Scan(ctx, &v)
+func (sausq *ScaAuthUserSocialQuery) Select(fields ...string) *ScaAuthUserSocialSelect {
+	sausq.ctx.Fields = append(sausq.ctx.Fields, fields...)
+	sbuild := &ScaAuthUserSocialSelect{ScaAuthUserSocialQuery: sausq}
+	sbuild.label = scaauthusersocial.Label
+	sbuild.flds, sbuild.scan = &sausq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ScaAuthUserSocialSelect configured with the given aggregations.
+func (sausq *ScaAuthUserSocialQuery) Aggregate(fns ...AggregateFunc) *ScaAuthUserSocialSelect {
+	return sausq.Select().Aggregate(fns...)
+}
+
+func (sausq *ScaAuthUserSocialQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range sausq.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, sausq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range sausq.ctx.Fields {
+		if !scaauthusersocial.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if sausq.path != nil {
+		prev, err := sausq.path(ctx)
+		if err != nil {
+			return err
+		}
+		sausq.sql = prev
+	}
+	return nil
+}
+
+func (sausq *ScaAuthUserSocialQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ScaAuthUserSocial, error) {
+	var (
+		nodes       = []*ScaAuthUserSocial{}
+		withFKs     = sausq.withFKs
+		_spec       = sausq.querySpec()
+		loadedTypes = [1]bool{
+			sausq.withScaAuthUser != nil,
+		}
+	)
+	if sausq.withScaAuthUser != nil {
+		withFKs = true
+	}
+	if withFKs {
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthusersocial.ForeignKeys...)
+	}
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ScaAuthUserSocial).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ScaAuthUserSocial{config: sausq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, sausq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := sausq.withScaAuthUser; query != nil {
+		if err := sausq.loadScaAuthUser(ctx, query, nodes, nil,
+			func(n *ScaAuthUserSocial, e *ScaAuthUser) { n.Edges.ScaAuthUser = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (sausq *ScaAuthUserSocialQuery) loadScaAuthUser(ctx context.Context, query *ScaAuthUserQuery, nodes []*ScaAuthUserSocial, init func(*ScaAuthUserSocial), assign func(*ScaAuthUserSocial, *ScaAuthUser)) error {
+	ids := make([]int64, 0, len(nodes))
+	nodeids := make(map[int64][]*ScaAuthUserSocial)
+	for i := range nodes {
+		if nodes[i].sca_auth_user_sca_auth_user_social == nil {
+			continue
+		}
+		fk := *nodes[i].sca_auth_user_sca_auth_user_social
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(scaauthuser.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 "sca_auth_user_sca_auth_user_social" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (sausq *ScaAuthUserSocialQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := sausq.querySpec()
+	_spec.Node.Columns = sausq.ctx.Fields
+	if len(sausq.ctx.Fields) > 0 {
+		_spec.Unique = sausq.ctx.Unique != nil && *sausq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, sausq.driver, _spec)
+}
+
+func (sausq *ScaAuthUserSocialQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(scaauthusersocial.Table, scaauthusersocial.Columns, sqlgraph.NewFieldSpec(scaauthusersocial.FieldID, field.TypeInt64))
+	_spec.From = sausq.sql
+	if unique := sausq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if sausq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := sausq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthusersocial.FieldID)
+		for i := range fields {
+			if fields[i] != scaauthusersocial.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := sausq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := sausq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := sausq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := sausq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (sausq *ScaAuthUserSocialQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(sausq.driver.Dialect())
+	t1 := builder.Table(scaauthusersocial.Table)
+	columns := sausq.ctx.Fields
+	if len(columns) == 0 {
+		columns = scaauthusersocial.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if sausq.sql != nil {
+		selector = sausq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if sausq.ctx.Unique != nil && *sausq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range sausq.predicates {
+		p(selector)
+	}
+	for _, p := range sausq.order {
+		p(selector)
+	}
+	if offset := sausq.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 := sausq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ScaAuthUserSocialGroupBy is the group-by builder for ScaAuthUserSocial entities.
+type ScaAuthUserSocialGroupBy struct {
+	selector
+	build *ScaAuthUserSocialQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (sausgb *ScaAuthUserSocialGroupBy) Aggregate(fns ...AggregateFunc) *ScaAuthUserSocialGroupBy {
+	sausgb.fns = append(sausgb.fns, fns...)
+	return sausgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (sausgb *ScaAuthUserSocialGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, sausgb.build.ctx, ent.OpQueryGroupBy)
+	if err := sausgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthUserSocialQuery, *ScaAuthUserSocialGroupBy](ctx, sausgb.build, sausgb, sausgb.build.inters, v)
+}
+
+func (sausgb *ScaAuthUserSocialGroupBy) sqlScan(ctx context.Context, root *ScaAuthUserSocialQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(sausgb.fns))
+	for _, fn := range sausgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*sausgb.flds)+len(sausgb.fns))
+		for _, f := range *sausgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*sausgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := sausgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ScaAuthUserSocialSelect is the builder for selecting fields of ScaAuthUserSocial entities.
+type ScaAuthUserSocialSelect struct {
+	*ScaAuthUserSocialQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (sauss *ScaAuthUserSocialSelect) Aggregate(fns ...AggregateFunc) *ScaAuthUserSocialSelect {
+	sauss.fns = append(sauss.fns, fns...)
+	return sauss
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (sauss *ScaAuthUserSocialSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, sauss.ctx, ent.OpQuerySelect)
+	if err := sauss.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ScaAuthUserSocialQuery, *ScaAuthUserSocialSelect](ctx, sauss.ScaAuthUserSocialQuery, sauss, sauss.inters, v)
+}
+
+func (sauss *ScaAuthUserSocialSelect) sqlScan(ctx context.Context, root *ScaAuthUserSocialQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(sauss.fns))
+	for _, fn := range sauss.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*sauss.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 := sauss.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

app/core/api/repository/mysql/ent/scaauthusersocial_update.go

@@ -0,0 +1,605 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/predicate"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent/scaauthusersocial"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserSocialUpdate is the builder for updating ScaAuthUserSocial entities.
+type ScaAuthUserSocialUpdate struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthUserSocialMutation
+}
+
+// Where appends a list predicates to the ScaAuthUserSocialUpdate builder.
+func (sausu *ScaAuthUserSocialUpdate) Where(ps ...predicate.ScaAuthUserSocial) *ScaAuthUserSocialUpdate {
+	sausu.mutation.Where(ps...)
+	return sausu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (sausu *ScaAuthUserSocialUpdate) SetUpdatedAt(t time.Time) *ScaAuthUserSocialUpdate {
+	sausu.mutation.SetUpdatedAt(t)
+	return sausu
+}
+
+// SetDeleted sets the "deleted" field.
+func (sausu *ScaAuthUserSocialUpdate) SetDeleted(i int8) *ScaAuthUserSocialUpdate {
+	sausu.mutation.ResetDeleted()
+	sausu.mutation.SetDeleted(i)
+	return sausu
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sausu *ScaAuthUserSocialUpdate) SetNillableDeleted(i *int8) *ScaAuthUserSocialUpdate {
+	if i != nil {
+		sausu.SetDeleted(*i)
+	}
+	return sausu
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (sausu *ScaAuthUserSocialUpdate) AddDeleted(i int8) *ScaAuthUserSocialUpdate {
+	sausu.mutation.AddDeleted(i)
+	return sausu
+}
+
+// ClearDeleted clears the value of the "deleted" field.
+func (sausu *ScaAuthUserSocialUpdate) ClearDeleted() *ScaAuthUserSocialUpdate {
+	sausu.mutation.ClearDeleted()
+	return sausu
+}
+
+// SetUserID sets the "user_id" field.
+func (sausu *ScaAuthUserSocialUpdate) SetUserID(s string) *ScaAuthUserSocialUpdate {
+	sausu.mutation.SetUserID(s)
+	return sausu
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (sausu *ScaAuthUserSocialUpdate) SetNillableUserID(s *string) *ScaAuthUserSocialUpdate {
+	if s != nil {
+		sausu.SetUserID(*s)
+	}
+	return sausu
+}
+
+// SetOpenID sets the "open_id" field.
+func (sausu *ScaAuthUserSocialUpdate) SetOpenID(s string) *ScaAuthUserSocialUpdate {
+	sausu.mutation.SetOpenID(s)
+	return sausu
+}
+
+// SetNillableOpenID sets the "open_id" field if the given value is not nil.
+func (sausu *ScaAuthUserSocialUpdate) SetNillableOpenID(s *string) *ScaAuthUserSocialUpdate {
+	if s != nil {
+		sausu.SetOpenID(*s)
+	}
+	return sausu
+}
+
+// SetSource sets the "source" field.
+func (sausu *ScaAuthUserSocialUpdate) SetSource(s string) *ScaAuthUserSocialUpdate {
+	sausu.mutation.SetSource(s)
+	return sausu
+}
+
+// SetNillableSource sets the "source" field if the given value is not nil.
+func (sausu *ScaAuthUserSocialUpdate) SetNillableSource(s *string) *ScaAuthUserSocialUpdate {
+	if s != nil {
+		sausu.SetSource(*s)
+	}
+	return sausu
+}
+
+// SetStatus sets the "status" field.
+func (sausu *ScaAuthUserSocialUpdate) SetStatus(i int) *ScaAuthUserSocialUpdate {
+	sausu.mutation.ResetStatus()
+	sausu.mutation.SetStatus(i)
+	return sausu
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (sausu *ScaAuthUserSocialUpdate) SetNillableStatus(i *int) *ScaAuthUserSocialUpdate {
+	if i != nil {
+		sausu.SetStatus(*i)
+	}
+	return sausu
+}
+
+// AddStatus adds i to the "status" field.
+func (sausu *ScaAuthUserSocialUpdate) AddStatus(i int) *ScaAuthUserSocialUpdate {
+	sausu.mutation.AddStatus(i)
+	return sausu
+}
+
+// SetScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID.
+func (sausu *ScaAuthUserSocialUpdate) SetScaAuthUserID(id int64) *ScaAuthUserSocialUpdate {
+	sausu.mutation.SetScaAuthUserID(id)
+	return sausu
+}
+
+// SetNillableScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID if the given value is not nil.
+func (sausu *ScaAuthUserSocialUpdate) SetNillableScaAuthUserID(id *int64) *ScaAuthUserSocialUpdate {
+	if id != nil {
+		sausu = sausu.SetScaAuthUserID(*id)
+	}
+	return sausu
+}
+
+// SetScaAuthUser sets the "sca_auth_user" edge to the ScaAuthUser entity.
+func (sausu *ScaAuthUserSocialUpdate) SetScaAuthUser(s *ScaAuthUser) *ScaAuthUserSocialUpdate {
+	return sausu.SetScaAuthUserID(s.ID)
+}
+
+// Mutation returns the ScaAuthUserSocialMutation object of the builder.
+func (sausu *ScaAuthUserSocialUpdate) Mutation() *ScaAuthUserSocialMutation {
+	return sausu.mutation
+}
+
+// ClearScaAuthUser clears the "sca_auth_user" edge to the ScaAuthUser entity.
+func (sausu *ScaAuthUserSocialUpdate) ClearScaAuthUser() *ScaAuthUserSocialUpdate {
+	sausu.mutation.ClearScaAuthUser()
+	return sausu
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (sausu *ScaAuthUserSocialUpdate) Save(ctx context.Context) (int, error) {
+	sausu.defaults()
+	return withHooks(ctx, sausu.sqlSave, sausu.mutation, sausu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (sausu *ScaAuthUserSocialUpdate) SaveX(ctx context.Context) int {
+	affected, err := sausu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (sausu *ScaAuthUserSocialUpdate) Exec(ctx context.Context) error {
+	_, err := sausu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sausu *ScaAuthUserSocialUpdate) ExecX(ctx context.Context) {
+	if err := sausu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sausu *ScaAuthUserSocialUpdate) defaults() {
+	if _, ok := sausu.mutation.UpdatedAt(); !ok {
+		v := scaauthusersocial.UpdateDefaultUpdatedAt()
+		sausu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sausu *ScaAuthUserSocialUpdate) check() error {
+	if v, ok := sausu.mutation.Deleted(); ok {
+		if err := scaauthusersocial.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.deleted": %w`, err)}
+		}
+	}
+	if v, ok := sausu.mutation.UserID(); ok {
+		if err := scaauthusersocial.UserIDValidator(v); err != nil {
+			return &ValidationError{Name: "user_id", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.user_id": %w`, err)}
+		}
+	}
+	if v, ok := sausu.mutation.OpenID(); ok {
+		if err := scaauthusersocial.OpenIDValidator(v); err != nil {
+			return &ValidationError{Name: "open_id", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.open_id": %w`, err)}
+		}
+	}
+	if v, ok := sausu.mutation.Source(); ok {
+		if err := scaauthusersocial.SourceValidator(v); err != nil {
+			return &ValidationError{Name: "source", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.source": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (sausu *ScaAuthUserSocialUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := sausu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthusersocial.Table, scaauthusersocial.Columns, sqlgraph.NewFieldSpec(scaauthusersocial.FieldID, field.TypeInt64))
+	if ps := sausu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := sausu.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := sausu.mutation.Deleted(); ok {
+		_spec.SetField(scaauthusersocial.FieldDeleted, field.TypeInt8, value)
+	}
+	if value, ok := sausu.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthusersocial.FieldDeleted, field.TypeInt8, value)
+	}
+	if sausu.mutation.DeletedCleared() {
+		_spec.ClearField(scaauthusersocial.FieldDeleted, field.TypeInt8)
+	}
+	if value, ok := sausu.mutation.UserID(); ok {
+		_spec.SetField(scaauthusersocial.FieldUserID, field.TypeString, value)
+	}
+	if value, ok := sausu.mutation.OpenID(); ok {
+		_spec.SetField(scaauthusersocial.FieldOpenID, field.TypeString, value)
+	}
+	if value, ok := sausu.mutation.Source(); ok {
+		_spec.SetField(scaauthusersocial.FieldSource, field.TypeString, value)
+	}
+	if value, ok := sausu.mutation.Status(); ok {
+		_spec.SetField(scaauthusersocial.FieldStatus, field.TypeInt, value)
+	}
+	if value, ok := sausu.mutation.AddedStatus(); ok {
+		_spec.AddField(scaauthusersocial.FieldStatus, field.TypeInt, value)
+	}
+	if sausu.mutation.ScaAuthUserCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthusersocial.ScaAuthUserTable,
+			Columns: []string{scaauthusersocial.ScaAuthUserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := sausu.mutation.ScaAuthUserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthusersocial.ScaAuthUserTable,
+			Columns: []string{scaauthusersocial.ScaAuthUserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64),
+			},
+		}
+		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, sausu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthusersocial.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	sausu.mutation.done = true
+	return n, nil
+}
+
+// ScaAuthUserSocialUpdateOne is the builder for updating a single ScaAuthUserSocial entity.
+type ScaAuthUserSocialUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *ScaAuthUserSocialMutation
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetUpdatedAt(t time.Time) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.SetUpdatedAt(t)
+	return sausuo
+}
+
+// SetDeleted sets the "deleted" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetDeleted(i int8) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.ResetDeleted()
+	sausuo.mutation.SetDeleted(i)
+	return sausuo
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetNillableDeleted(i *int8) *ScaAuthUserSocialUpdateOne {
+	if i != nil {
+		sausuo.SetDeleted(*i)
+	}
+	return sausuo
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) AddDeleted(i int8) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.AddDeleted(i)
+	return sausuo
+}
+
+// ClearDeleted clears the value of the "deleted" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) ClearDeleted() *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.ClearDeleted()
+	return sausuo
+}
+
+// SetUserID sets the "user_id" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetUserID(s string) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.SetUserID(s)
+	return sausuo
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetNillableUserID(s *string) *ScaAuthUserSocialUpdateOne {
+	if s != nil {
+		sausuo.SetUserID(*s)
+	}
+	return sausuo
+}
+
+// SetOpenID sets the "open_id" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetOpenID(s string) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.SetOpenID(s)
+	return sausuo
+}
+
+// SetNillableOpenID sets the "open_id" field if the given value is not nil.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetNillableOpenID(s *string) *ScaAuthUserSocialUpdateOne {
+	if s != nil {
+		sausuo.SetOpenID(*s)
+	}
+	return sausuo
+}
+
+// SetSource sets the "source" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetSource(s string) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.SetSource(s)
+	return sausuo
+}
+
+// SetNillableSource sets the "source" field if the given value is not nil.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetNillableSource(s *string) *ScaAuthUserSocialUpdateOne {
+	if s != nil {
+		sausuo.SetSource(*s)
+	}
+	return sausuo
+}
+
+// SetStatus sets the "status" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetStatus(i int) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.ResetStatus()
+	sausuo.mutation.SetStatus(i)
+	return sausuo
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetNillableStatus(i *int) *ScaAuthUserSocialUpdateOne {
+	if i != nil {
+		sausuo.SetStatus(*i)
+	}
+	return sausuo
+}
+
+// AddStatus adds i to the "status" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) AddStatus(i int) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.AddStatus(i)
+	return sausuo
+}
+
+// SetScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetScaAuthUserID(id int64) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.SetScaAuthUserID(id)
+	return sausuo
+}
+
+// SetNillableScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID if the given value is not nil.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetNillableScaAuthUserID(id *int64) *ScaAuthUserSocialUpdateOne {
+	if id != nil {
+		sausuo = sausuo.SetScaAuthUserID(*id)
+	}
+	return sausuo
+}
+
+// SetScaAuthUser sets the "sca_auth_user" edge to the ScaAuthUser entity.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetScaAuthUser(s *ScaAuthUser) *ScaAuthUserSocialUpdateOne {
+	return sausuo.SetScaAuthUserID(s.ID)
+}
+
+// Mutation returns the ScaAuthUserSocialMutation object of the builder.
+func (sausuo *ScaAuthUserSocialUpdateOne) Mutation() *ScaAuthUserSocialMutation {
+	return sausuo.mutation
+}
+
+// ClearScaAuthUser clears the "sca_auth_user" edge to the ScaAuthUser entity.
+func (sausuo *ScaAuthUserSocialUpdateOne) ClearScaAuthUser() *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.ClearScaAuthUser()
+	return sausuo
+}
+
+// Where appends a list predicates to the ScaAuthUserSocialUpdate builder.
+func (sausuo *ScaAuthUserSocialUpdateOne) Where(ps ...predicate.ScaAuthUserSocial) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.Where(ps...)
+	return sausuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (sausuo *ScaAuthUserSocialUpdateOne) Select(field string, fields ...string) *ScaAuthUserSocialUpdateOne {
+	sausuo.fields = append([]string{field}, fields...)
+	return sausuo
+}
+
+// Save executes the query and returns the updated ScaAuthUserSocial entity.
+func (sausuo *ScaAuthUserSocialUpdateOne) Save(ctx context.Context) (*ScaAuthUserSocial, error) {
+	sausuo.defaults()
+	return withHooks(ctx, sausuo.sqlSave, sausuo.mutation, sausuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (sausuo *ScaAuthUserSocialUpdateOne) SaveX(ctx context.Context) *ScaAuthUserSocial {
+	node, err := sausuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (sausuo *ScaAuthUserSocialUpdateOne) Exec(ctx context.Context) error {
+	_, err := sausuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sausuo *ScaAuthUserSocialUpdateOne) ExecX(ctx context.Context) {
+	if err := sausuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sausuo *ScaAuthUserSocialUpdateOne) defaults() {
+	if _, ok := sausuo.mutation.UpdatedAt(); !ok {
+		v := scaauthusersocial.UpdateDefaultUpdatedAt()
+		sausuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sausuo *ScaAuthUserSocialUpdateOne) check() error {
+	if v, ok := sausuo.mutation.Deleted(); ok {
+		if err := scaauthusersocial.DeletedValidator(v); err != nil {
+			return &ValidationError{Name: "deleted", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.deleted": %w`, err)}
+		}
+	}
+	if v, ok := sausuo.mutation.UserID(); ok {
+		if err := scaauthusersocial.UserIDValidator(v); err != nil {
+			return &ValidationError{Name: "user_id", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.user_id": %w`, err)}
+		}
+	}
+	if v, ok := sausuo.mutation.OpenID(); ok {
+		if err := scaauthusersocial.OpenIDValidator(v); err != nil {
+			return &ValidationError{Name: "open_id", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.open_id": %w`, err)}
+		}
+	}
+	if v, ok := sausuo.mutation.Source(); ok {
+		if err := scaauthusersocial.SourceValidator(v); err != nil {
+			return &ValidationError{Name: "source", err: fmt.Errorf(`ent: validator failed for field "ScaAuthUserSocial.source": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (sausuo *ScaAuthUserSocialUpdateOne) sqlSave(ctx context.Context) (_node *ScaAuthUserSocial, err error) {
+	if err := sausuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthusersocial.Table, scaauthusersocial.Columns, sqlgraph.NewFieldSpec(scaauthusersocial.FieldID, field.TypeInt64))
+	id, ok := sausuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ScaAuthUserSocial.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := sausuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthusersocial.FieldID)
+		for _, f := range fields {
+			if !scaauthusersocial.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != scaauthusersocial.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := sausuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := sausuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if value, ok := sausuo.mutation.Deleted(); ok {
+		_spec.SetField(scaauthusersocial.FieldDeleted, field.TypeInt8, value)
+	}
+	if value, ok := sausuo.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthusersocial.FieldDeleted, field.TypeInt8, value)
+	}
+	if sausuo.mutation.DeletedCleared() {
+		_spec.ClearField(scaauthusersocial.FieldDeleted, field.TypeInt8)
+	}
+	if value, ok := sausuo.mutation.UserID(); ok {
+		_spec.SetField(scaauthusersocial.FieldUserID, field.TypeString, value)
+	}
+	if value, ok := sausuo.mutation.OpenID(); ok {
+		_spec.SetField(scaauthusersocial.FieldOpenID, field.TypeString, value)
+	}
+	if value, ok := sausuo.mutation.Source(); ok {
+		_spec.SetField(scaauthusersocial.FieldSource, field.TypeString, value)
+	}
+	if value, ok := sausuo.mutation.Status(); ok {
+		_spec.SetField(scaauthusersocial.FieldStatus, field.TypeInt, value)
+	}
+	if value, ok := sausuo.mutation.AddedStatus(); ok {
+		_spec.AddField(scaauthusersocial.FieldStatus, field.TypeInt, value)
+	}
+	if sausuo.mutation.ScaAuthUserCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthusersocial.ScaAuthUserTable,
+			Columns: []string{scaauthusersocial.ScaAuthUserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := sausuo.mutation.ScaAuthUserIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   scaauthusersocial.ScaAuthUserTable,
+			Columns: []string{scaauthusersocial.ScaAuthUserColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(scaauthuser.FieldID, field.TypeInt64),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &ScaAuthUserSocial{config: sausuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, sausuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthusersocial.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	sausuo.mutation.done = true
+	return _node, nil
+}

app/core/api/repository/mysql/ent/tx.go

@@ -0,0 +1,222 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"sync"
+
+	"entgo.io/ent/dialect"
+)
+
+// Tx is a transactional client that is created by calling Client.Tx().
+type Tx struct {
+	config
+	// ScaAuthPermissionRule is the client for interacting with the ScaAuthPermissionRule builders.
+	ScaAuthPermissionRule *ScaAuthPermissionRuleClient
+	// ScaAuthRole is the client for interacting with the ScaAuthRole builders.
+	ScaAuthRole *ScaAuthRoleClient
+	// ScaAuthUser is the client for interacting with the ScaAuthUser builders.
+	ScaAuthUser *ScaAuthUserClient
+	// ScaAuthUserDevice is the client for interacting with the ScaAuthUserDevice builders.
+	ScaAuthUserDevice *ScaAuthUserDeviceClient
+	// ScaAuthUserSocial is the client for interacting with the ScaAuthUserSocial builders.
+	ScaAuthUserSocial *ScaAuthUserSocialClient
+
+	// lazily loaded.
+	client     *Client
+	clientOnce sync.Once
+	// ctx lives for the life of the transaction. It is
+	// the same context used by the underlying connection.
+	ctx context.Context
+}
+
+type (
+	// Committer is the interface that wraps the Commit method.
+	Committer interface {
+		Commit(context.Context, *Tx) error
+	}
+
+	// The CommitFunc type is an adapter to allow the use of ordinary
+	// function as a Committer. If f is a function with the appropriate
+	// signature, CommitFunc(f) is a Committer that calls f.
+	CommitFunc func(context.Context, *Tx) error
+
+	// CommitHook defines the "commit middleware". A function that gets a Committer
+	// and returns a Committer. For example:
+	//
+	//	hook := func(next ent.Committer) ent.Committer {
+	//		return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
+	//			// Do some stuff before.
+	//			if err := next.Commit(ctx, tx); err != nil {
+	//				return err
+	//			}
+	//			// Do some stuff after.
+	//			return nil
+	//		})
+	//	}
+	//
+	CommitHook func(Committer) Committer
+)
+
+// Commit calls f(ctx, m).
+func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error {
+	return f(ctx, tx)
+}
+
+// Commit commits the transaction.
+func (tx *Tx) Commit() error {
+	txDriver := tx.config.driver.(*txDriver)
+	var fn Committer = CommitFunc(func(context.Context, *Tx) error {
+		return txDriver.tx.Commit()
+	})
+	txDriver.mu.Lock()
+	hooks := append([]CommitHook(nil), txDriver.onCommit...)
+	txDriver.mu.Unlock()
+	for i := len(hooks) - 1; i >= 0; i-- {
+		fn = hooks[i](fn)
+	}
+	return fn.Commit(tx.ctx, tx)
+}
+
+// OnCommit adds a hook to call on commit.
+func (tx *Tx) OnCommit(f CommitHook) {
+	txDriver := tx.config.driver.(*txDriver)
+	txDriver.mu.Lock()
+	txDriver.onCommit = append(txDriver.onCommit, f)
+	txDriver.mu.Unlock()
+}
+
+type (
+	// Rollbacker is the interface that wraps the Rollback method.
+	Rollbacker interface {
+		Rollback(context.Context, *Tx) error
+	}
+
+	// The RollbackFunc type is an adapter to allow the use of ordinary
+	// function as a Rollbacker. If f is a function with the appropriate
+	// signature, RollbackFunc(f) is a Rollbacker that calls f.
+	RollbackFunc func(context.Context, *Tx) error
+
+	// RollbackHook defines the "rollback middleware". A function that gets a Rollbacker
+	// and returns a Rollbacker. For example:
+	//
+	//	hook := func(next ent.Rollbacker) ent.Rollbacker {
+	//		return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
+	//			// Do some stuff before.
+	//			if err := next.Rollback(ctx, tx); err != nil {
+	//				return err
+	//			}
+	//			// Do some stuff after.
+	//			return nil
+	//		})
+	//	}
+	//
+	RollbackHook func(Rollbacker) Rollbacker
+)
+
+// Rollback calls f(ctx, m).
+func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error {
+	return f(ctx, tx)
+}
+
+// Rollback rollbacks the transaction.
+func (tx *Tx) Rollback() error {
+	txDriver := tx.config.driver.(*txDriver)
+	var fn Rollbacker = RollbackFunc(func(context.Context, *Tx) error {
+		return txDriver.tx.Rollback()
+	})
+	txDriver.mu.Lock()
+	hooks := append([]RollbackHook(nil), txDriver.onRollback...)
+	txDriver.mu.Unlock()
+	for i := len(hooks) - 1; i >= 0; i-- {
+		fn = hooks[i](fn)
+	}
+	return fn.Rollback(tx.ctx, tx)
+}
+
+// OnRollback adds a hook to call on rollback.
+func (tx *Tx) OnRollback(f RollbackHook) {
+	txDriver := tx.config.driver.(*txDriver)
+	txDriver.mu.Lock()
+	txDriver.onRollback = append(txDriver.onRollback, f)
+	txDriver.mu.Unlock()
+}
+
+// Client returns a Client that binds to current transaction.
+func (tx *Tx) Client() *Client {
+	tx.clientOnce.Do(func() {
+		tx.client = &Client{config: tx.config}
+		tx.client.init()
+	})
+	return tx.client
+}
+
+func (tx *Tx) init() {
+	tx.ScaAuthPermissionRule = NewScaAuthPermissionRuleClient(tx.config)
+	tx.ScaAuthRole = NewScaAuthRoleClient(tx.config)
+	tx.ScaAuthUser = NewScaAuthUserClient(tx.config)
+	tx.ScaAuthUserDevice = NewScaAuthUserDeviceClient(tx.config)
+	tx.ScaAuthUserSocial = NewScaAuthUserSocialClient(tx.config)
+}
+
+// txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation.
+// The idea is to support transactions without adding any extra code to the builders.
+// When a builder calls to driver.Tx(), it gets the same dialect.Tx instance.
+// Commit and Rollback are nop for the internal builders and the user must call one
+// of them in order to commit or rollback the transaction.
+//
+// If a closed transaction is embedded in one of the generated entities, and the entity
+// applies a query, for example: ScaAuthPermissionRule.QueryXXX(), the query will be executed
+// through the driver which created this transaction.
+//
+// Note that txDriver is not goroutine safe.
+type txDriver struct {
+	// the driver we started the transaction from.
+	drv dialect.Driver
+	// tx is the underlying transaction.
+	tx dialect.Tx
+	// completion hooks.
+	mu         sync.Mutex
+	onCommit   []CommitHook
+	onRollback []RollbackHook
+}
+
+// newTx creates a new transactional driver.
+func newTx(ctx context.Context, drv dialect.Driver) (*txDriver, error) {
+	tx, err := drv.Tx(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &txDriver{tx: tx, drv: drv}, nil
+}
+
+// Tx returns the transaction wrapper (txDriver) to avoid Commit or Rollback calls
+// from the internal builders. Should be called only by the internal builders.
+func (tx *txDriver) Tx(context.Context) (dialect.Tx, error) { return tx, nil }
+
+// Dialect returns the dialect of the driver we started the transaction from.
+func (tx *txDriver) Dialect() string { return tx.drv.Dialect() }
+
+// Close is a nop close.
+func (*txDriver) Close() error { return nil }
+
+// Commit is a nop commit for the internal builders.
+// User must call `Tx.Commit` in order to commit the transaction.
+func (*txDriver) Commit() error { return nil }
+
+// Rollback is a nop rollback for the internal builders.
+// User must call `Tx.Rollback` in order to rollback the transaction.
+func (*txDriver) Rollback() error { return nil }
+
+// Exec calls tx.Exec.
+func (tx *txDriver) Exec(ctx context.Context, query string, args, v any) error {
+	return tx.tx.Exec(ctx, query, args, v)
+}
+
+// Query calls tx.Query.
+func (tx *txDriver) Query(ctx context.Context, query string, args, v any) error {
+	return tx.tx.Query(ctx, query, args, v)
+}
+
+var _ dialect.Driver = (*txDriver)(nil)

app/core/api/repository/mysql/generate.go

@@ -0,0 +1,3 @@
+package mysql
+
+//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature privacy,entql --target ./ent ./schema

app/core/api/repository/mysql/init.go

@@ -0,0 +1,35 @@
+package mysql
+
+import (
+	"context"
+	"database/sql"
+	"log"
+	"time"
+
+	entsql "entgo.io/ent/dialect/sql"
+	_ "github.com/go-sql-driver/mysql"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/ent"
+)
+
+func NewMySQL(url string) *ent.Client {
+	var db *sql.DB
+	db, err := sql.Open("mysql", url)
+
+	if err != nil {
+		log.Panicf("failed to connect to database: %v", err)
+		return nil
+	}
+	db.SetMaxOpenConns(100)
+	db.SetMaxIdleConns(10)
+	db.SetConnMaxLifetime(time.Hour)
+	drv := entsql.OpenDB("mysql", db)
+	client := ent.NewClient(ent.Driver(drv), ent.Debug())
+
+	defer client.Close()
+
+	if err = client.Schema.Create(context.Background()); err != nil {
+		log.Panicf("failed creating schema resources: %v", err)
+	}
+	return client
+}

app/core/api/repository/mysql/schema/mixin/default_mixin.go

@@ -0,0 +1,31 @@
+package mixin
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/mixin"
+)
+
+type DefaultMixin struct {
+	mixin.Schema
+}
+
+func (DefaultMixin) Fields() []ent.Field {
+	return []ent.Field{
+		field.Time("created_at").
+			Immutable().
+			Default(time.Now).
+			Comment("创建时间"),
+		field.Time("updated_at").
+			Default(time.Now).
+			Comment("更新时间").
+			UpdateDefault(time.Now),
+		field.Int8("deleted").
+			Default(0).
+			Max(1).
+			Optional().
+			Comment("是否删除 0 未删除 1 已删除"),
+	}
+}

app/core/api/repository/mysql/schema/sca_auth_permission_rule.go

@@ -0,0 +1,73 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthPermissionRule holds the schema definition for the ScaAuthPermissionRule entity.
+type ScaAuthPermissionRule struct {
+	ent.Schema
+}
+
+// Fields of the ScaAuthPermissionRule.
+func (ScaAuthPermissionRule) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int64("id").
+			SchemaType(map[string]string{
+				dialect.MySQL: "bigint(20) unsigned",
+			}).
+			Unique(),
+		field.String("ptype").
+			MaxLen(100).
+			Nillable(),
+		field.String("v0").
+			MaxLen(100).
+			Nillable(),
+		field.String("v1").
+			MaxLen(100).
+			Nillable(),
+		field.String("v2").
+			MaxLen(100).
+			Optional().
+			Nillable(),
+		field.String("v3").
+			MaxLen(100).
+			Optional().
+			Nillable(),
+		field.String("v4").
+			MaxLen(100).
+			Optional().
+			Nillable(),
+		field.String("v5").
+			MaxLen(100).
+			Optional().
+			Nillable().Annotations(
+			entsql.WithComments(true),
+		),
+	}
+}
+
+// Edges of the ScaAuthPermissionRule.
+func (ScaAuthPermissionRule) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("sca_auth_role", ScaAuthRole.Type).
+			Ref("sca_auth_permission_rule").
+			Unique(),
+	}
+}
+
+// Annotations of the ScaAuthPermissionRule.
+func (ScaAuthPermissionRule) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.WithComments(true),
+		schema.Comment("角色权限规则表"),
+		entsql.Annotation{
+			Table: "sca_auth_permission_rule",
+		},
+	}
+}

app/core/api/repository/mysql/schema/sca_auth_role.go

@@ -0,0 +1,67 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/schema/mixin"
+)
+
+// ScaAuthRole holds the schema definition for the ScaAuthRole entity.
+type ScaAuthRole struct {
+	ent.Schema
+}
+
+func (ScaAuthRole) Mixin() []ent.Mixin {
+	return []ent.Mixin{
+		mixin.DefaultMixin{},
+	}
+}
+
+// Fields of the ScaAuthRole.
+func (ScaAuthRole) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int64("id").
+			SchemaType(map[string]string{
+				dialect.MySQL: "bigint(20)",
+			}).
+			Unique().
+			Comment("主键ID"),
+		field.String("role_name").
+			MaxLen(32).
+			Comment("角色名称"),
+		field.String("role_key").
+			MaxLen(64).
+			Comment("角色关键字").
+			Annotations(
+				entsql.WithComments(true),
+			),
+	}
+}
+
+// Edges of the ScaAuthRole.
+func (ScaAuthRole) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.To("sca_auth_permission_rule", ScaAuthPermissionRule.Type),
+	}
+}
+
+// Indexes of the ScaAuthRole.
+func (ScaAuthRole) Indexes() []ent.Index {
+	return nil
+}
+
+// Annotations of the ScaAuthRole.
+func (ScaAuthRole) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.WithComments(true),
+		schema.Comment("角色表"),
+		entsql.Annotation{
+			Table: "sca_auth_role",
+		},
+	}
+}

app/core/api/repository/mysql/schema/sca_auth_user.go

@@ -0,0 +1,125 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/schema/mixin"
+)
+
+// ScaAuthUser holds the schema definition for the ScaAuthUser entity.
+type ScaAuthUser struct {
+	ent.Schema
+}
+
+func (ScaAuthUser) Mixin() []ent.Mixin {
+	return []ent.Mixin{
+		mixin.DefaultMixin{},
+	}
+}
+
+// Fields of the ScaAuthUser.
+func (ScaAuthUser) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int64("id").
+			SchemaType(map[string]string{
+				dialect.MySQL: "bigint(20)",
+			}).
+			Unique().
+			Comment("自增ID"),
+		field.String("uid").
+			MaxLen(20).
+			Unique().
+			Comment("唯一ID"),
+		field.String("username").
+			MaxLen(32).
+			Optional().
+			Comment("用户名"),
+		field.String("nickname").
+			MaxLen(32).
+			Optional().
+			Comment("昵称"),
+		field.String("email").
+			MaxLen(32).
+			Optional().
+			Comment("邮箱"),
+		field.String("phone").
+			MaxLen(32).
+			Optional().
+			Comment("电话"),
+		field.String("password").
+			MaxLen(64).
+			Optional().
+			Sensitive().
+			Comment("密码"),
+		field.String("gender").
+			MaxLen(32).
+			Optional().
+			Comment("性别"),
+		field.String("avatar").
+			Optional().
+			Comment("头像"),
+		field.Int8("status").
+			Default(0).
+			Optional().
+			Comment("状态 0 正常 1 封禁"),
+		field.String("introduce").
+			MaxLen(255).
+			Optional().
+			Comment("介绍"),
+		field.String("blog").
+			MaxLen(30).
+			Nillable().
+			Optional().
+			Comment("博客"),
+		field.String("location").
+			MaxLen(50).
+			Nillable().
+			Optional().
+			Comment("地址"),
+		field.String("company").
+			MaxLen(50).
+			Nillable().
+			Optional().
+			Comment("公司").
+			Annotations(
+				entsql.WithComments(true),
+			),
+	}
+}
+
+// Edges of the ScaAuthUser.
+func (ScaAuthUser) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.To("sca_auth_user_social", ScaAuthUserSocial.Type),
+		edge.To("sca_auth_user_device", ScaAuthUserDevice.Type),
+	}
+}
+
+// Indexes of the ScaAuthUser.
+func (ScaAuthUser) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id").
+			Unique(),
+		index.Fields("uid").
+			Unique(),
+		index.Fields("phone").
+			Unique(),
+	}
+}
+
+// Annotations of the ScaAuthUser.
+func (ScaAuthUser) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.WithComments(true),
+		schema.Comment("用户表"),
+		entsql.Annotation{
+			Table: "sca_auth_user",
+		},
+	}
+}

app/core/api/repository/mysql/schema/sca_auth_user_device.go

@@ -0,0 +1,103 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/schema/mixin"
+)
+
+// ScaAuthUserDevice holds the schema definition for the ScaAuthUserDevice entity.
+type ScaAuthUserDevice struct {
+	ent.Schema
+}
+
+func (ScaAuthUserDevice) Mixin() []ent.Mixin {
+	return []ent.Mixin{
+		mixin.DefaultMixin{},
+	}
+}
+
+// Fields of the ScaAuthUserDevice.
+func (ScaAuthUserDevice) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int64("id").
+			SchemaType(map[string]string{
+				dialect.MySQL: "bigint(20)",
+			}).
+			Unique().
+			Comment("主键ID"),
+		field.String("user_id").
+			MaxLen(20).
+			Comment("用户ID"),
+		field.String("ip").
+			MaxLen(20).
+			Comment("登录IP"),
+		field.String("location").
+			MaxLen(20).
+			Comment("地址"),
+		field.String("agent").
+			MaxLen(255).
+			Comment("设备信息"),
+		field.String("browser").
+			MaxLen(20).
+			Comment("浏览器"),
+		field.String("operating_system").
+			MaxLen(20).
+			Comment("操作系统"),
+		field.String("browser_version").
+			MaxLen(20).
+			Comment("浏览器版本"),
+		field.Int("mobile").
+			Comment("是否为手机 0否1是"),
+		field.Int("bot").
+			Comment("是否为bot 0否1是"),
+		field.String("mozilla").
+			MaxLen(10).
+			Comment("火狐版本"),
+		field.String("platform").
+			MaxLen(20).
+			Comment("平台"),
+		field.String("engine_name").
+			MaxLen(20).
+			Comment("引擎名称"),
+		field.String("engine_version").
+			MaxLen(20).
+			Comment("引擎版本").Annotations(
+			entsql.WithComments(true),
+		),
+	}
+}
+
+// Edges of the ScaAuthUserDevice.
+func (ScaAuthUserDevice) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("sca_auth_user", ScaAuthUser.Type).
+			Ref("sca_auth_user_device").
+			Unique(),
+	}
+}
+
+// Indexes of the ScaAuthUserDevice.
+func (ScaAuthUserDevice) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id").
+			Unique(),
+	}
+}
+
+// Annotations of the ScaAuthUserDevice.
+func (ScaAuthUserDevice) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.WithComments(true),
+		schema.Comment("用户设备表"),
+		entsql.Annotation{
+			Table: "sca_auth_user_device",
+		},
+	}
+}

app/core/api/repository/mysql/schema/sca_auth_user_social.go

@@ -0,0 +1,82 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/schema/mixin"
+)
+
+// ScaAuthUserSocial holds the schema definition for the ScaAuthUserSocial entity.
+type ScaAuthUserSocial struct {
+	ent.Schema
+}
+
+func (ScaAuthUserSocial) Mixin() []ent.Mixin {
+	return []ent.Mixin{
+		mixin.DefaultMixin{},
+	}
+}
+
+// Fields of the ScaAuthUserSocial.
+func (ScaAuthUserSocial) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int64("id").
+			SchemaType(map[string]string{
+				dialect.MySQL: "bigint(20)",
+			}).
+			Unique().
+			Comment("主键ID"),
+		field.String("user_id").
+			MaxLen(20).
+			Comment("用户ID"),
+		field.String("open_id").
+			MaxLen(50).
+			Comment("第三方用户的 open id"),
+		field.String("source").
+			MaxLen(10).
+			Comment("第三方用户来源"),
+		field.Int("status").
+			Default(0).
+			Comment("状态 0正常 1 封禁").Annotations(
+			entsql.WithComments(true),
+		),
+	}
+}
+
+// Edges of the ScaAuthUserSocial.
+func (ScaAuthUserSocial) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("sca_auth_user", ScaAuthUser.Type).
+			Ref("sca_auth_user_social").
+			Unique(),
+	}
+}
+
+// Indexes of the ScaAuthUserSocial.
+func (ScaAuthUserSocial) Indexes() []ent.Index {
+	return []ent.Index{
+		index.Fields("id").
+			Unique(),
+		index.Fields("user_id").
+			Unique(),
+		index.Fields("open_id").
+			Unique(),
+	}
+}
+
+// Annotations of the ScaAuthUserSocial.
+func (ScaAuthUserSocial) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.WithComments(true),
+		schema.Comment("用户第三方登录信息"),
+		entsql.Annotation{
+			Table: "sca_auth_user_social",
+		},
+	}
+}