🎉 init

.gitignore

@@ -0,0 +1,106 @@
+### GoLand+all template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Go template
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/schisandra-album-cloud-microservices.iml" filepath="$PROJECT_DIR$/.idea/schisandra-album-cloud-microservices.iml" />
+    </modules>
+  </component>
+</project>

.idea/schisandra-album-cloud-microservices.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

app/auth/auth.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: I18nMiddleware,SecurityHeadersMiddleware // 注册中间件
+	MaxConns:   true // 是否开启最大连接数限制
+	Recover:    true // 是否开启自动恢复
+)
+service auth {
+	// 账户登录
+	@handler accountLogin
+	post /login (AccountLoginRequest) returns (LoginResponse)
+
+	// 手机号登录
+	@handler phoneLogin
+	post /phone_login (PhoneLoginRequest) returns (LoginResponse)
+
+	// 重置密码
+	@handler resetPassword
+	post /reset_password (ResetPasswordRequest) returns (string)
+}
+

app/auth/auth.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+
+	"schisandra-album-cloud-microservices/app/auth/internal/config"
+	"schisandra-album-cloud-microservices/app/auth/internal/handler"
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+
+	"github.com/zeromicro/go-zero/core/conf"
+	"github.com/zeromicro/go-zero/rest"
+)
+
+var configFile = flag.String("f", "etc/auth.yaml", "the config file")
+
+func main() {
+	flag.Parse()
+
+	var c config.Config
+	conf.MustLoad(*configFile, &c)
+
+	server := rest.MustNewServer(c.RestConf, rest.WithCustomCors(func(header http.Header) {
+		header.Set("Access-Control-Allow-Origin", "*")
+		header.Add("Access-Control-Allow-Headers", "UserHeader1, UserHeader2")
+		header.Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, PATCH")
+		header.Set("Access-Control-Expose-Headers", "Content-Length, Content-Type")
+	}, nil, "*"))
+	defer server.Stop()
+
+	ctx := svc.NewServiceContext(c)
+	handler.RegisterHandlers(server, ctx)
+
+	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
+	server.Start()
+}

app/auth/etc/auth.yaml

@@ -0,0 +1,5 @@
+Name: auth
+Host: 0.0.0.0
+Port: 8888
+Mysql:
+  Dsn: root:1611@tcp(localhost:3306)/schisandra-cloud-album?charset=utf8mb4&parseTime=True&loc=Local

app/auth/internal/config/config.go

@@ -0,0 +1,10 @@
+package config
+
+import "github.com/zeromicro/go-zero/rest"
+
+type Config struct {
+	rest.RestConf
+	Mysql struct {
+		Dsn string
+	}
+}

app/auth/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/auth/internal/handler/user"
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+
+	"github.com/zeromicro/go-zero/rest"
+)
+
+func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
+	server.AddRoutes(
+		rest.WithMiddlewares(
+			[]rest.Middleware{serverCtx.I18nMiddleware, 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/auth/internal/handler/user/account_login_handler.go

@@ -0,0 +1,28 @@
+package user
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"schisandra-album-cloud-microservices/app/auth/internal/logic/user"
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/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/auth/internal/handler/user/phone_login_handler.go

@@ -0,0 +1,28 @@
+package user
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"schisandra-album-cloud-microservices/app/auth/internal/logic/user"
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/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/auth/internal/handler/user/reset_password_handler.go

@@ -0,0 +1,28 @@
+package user
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"schisandra-album-cloud-microservices/app/auth/internal/logic/user"
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/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/auth/internal/logic/user/account_login_logic.go

@@ -0,0 +1,30 @@
+package user
+
+import (
+	"context"
+
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/internal/types"
+
+	"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
+
+	return
+}

app/auth/internal/logic/user/phone_login_logic.go

@@ -0,0 +1,30 @@
+package user
+
+import (
+	"context"
+
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+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/auth/internal/logic/user/reset_password_logic.go

@@ -0,0 +1,30 @@
+package user
+
+import (
+	"context"
+
+	"schisandra-album-cloud-microservices/app/auth/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+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/auth/internal/middleware/i18n_middleware.go

@@ -0,0 +1,19 @@
+package middleware
+
+import "net/http"
+
+type I18nMiddleware struct {
+}
+
+func NewI18nMiddleware() *I18nMiddleware {
+	return &I18nMiddleware{}
+}
+
+func (m *I18nMiddleware) Handle(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// TODO generate middleware implement function, delete after code implementation
+
+		// Passthrough to next handler if need
+		next(w, r)
+	}
+}

app/auth/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/auth/internal/svc/service_context.go

@@ -0,0 +1,26 @@
+package svc
+
+import (
+	"github.com/zeromicro/go-zero/rest"
+
+	"schisandra-album-cloud-microservices/app/auth/internal/config"
+	"schisandra-album-cloud-microservices/app/auth/internal/middleware"
+	"schisandra-album-cloud-microservices/common/core"
+	"schisandra-album-cloud-microservices/common/ent/gen/entschema"
+)
+
+type ServiceContext struct {
+	Config                    config.Config
+	I18nMiddleware            rest.Middleware
+	SecurityHeadersMiddleware rest.Middleware
+	DB                        *entschema.Client
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	return &ServiceContext{
+		Config:                    c,
+		I18nMiddleware:            middleware.NewI18nMiddleware().Handle,
+		SecurityHeadersMiddleware: middleware.NewSecurityHeadersMiddleware().Handle,
+		DB:                        core.InitMySQL(c.Mysql.Dsn),
+	}
+}

app/auth/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"`
+}

common/core/mysql.go

@@ -0,0 +1,32 @@
+package core
+
+import (
+	"context"
+	"database/sql"
+	"log"
+
+	entsql "entgo.io/ent/dialect/sql"
+	_ "github.com/go-sql-driver/mysql"
+
+	"schisandra-album-cloud-microservices/common/ent"
+)
+
+func InitMySQL(url string) *ent.Client {
+	var db *sql.DB
+	db, err := sql.Open("mysql", url)
+
+	if err != nil {
+		return nil
+	}
+	db.SetMaxOpenConns(100)
+	db.SetMaxIdleConns(50)
+	drv := entsql.OpenDB("mysql", db)
+	client := ent.NewClient(ent.Driver(drv))
+
+	defer client.Close()
+
+	if err = client.Schema.Create(context.Background()); err != nil {
+		log.Fatalf("failed creating schema resources: %v", err)
+	}
+	return client
+}

common/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/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/ent/scaauthrole"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/common/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)

common/ent/enttest/enttest.go

@@ -0,0 +1,85 @@
+// Code generated by ent, DO NOT EDIT.
+
+package enttest
+
+import (
+	"context"
+
+	"schisandra-album-cloud-microservices/common/ent"
+	// required by schema hooks.
+	_ "schisandra-album-cloud-microservices/common/ent/runtime"
+
+	"schisandra-album-cloud-microservices/common/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()
+	}
+}

common/ent/generate.go

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

common/ent/hook/hook.go

@@ -0,0 +1,246 @@
+// Code generated by ent, DO NOT EDIT.
+
+package hook
+
+import (
+	"context"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/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...)
+}

common/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...)
+}

common/ent/migrate/schema.go

@@ -0,0 +1,184 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"entgo.io/ent/dialect/sql/schema"
+	"entgo.io/ent/schema/field"
+)
+
+var (
+	// ScaAuthPermissionRulesColumns holds the columns for the "sca_auth_permission_rules" table.
+	ScaAuthPermissionRulesColumns = []*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)"}},
+	}
+	// ScaAuthPermissionRulesTable holds the schema information for the "sca_auth_permission_rules" table.
+	ScaAuthPermissionRulesTable = &schema.Table{
+		Name:       "sca_auth_permission_rules",
+		Columns:    ScaAuthPermissionRulesColumns,
+		PrimaryKey: []*schema.Column{ScaAuthPermissionRulesColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sca_auth_permission_rules_sca_auth_roles_sca_auth_permission_rule",
+				Columns:    []*schema.Column{ScaAuthPermissionRulesColumns[8]},
+				RefColumns: []*schema.Column{ScaAuthRolesColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+	}
+	// ScaAuthRolesColumns holds the columns for the "sca_auth_roles" table.
+	ScaAuthRolesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "role_name", Type: field.TypeString, Size: 32},
+		{Name: "role_key", Type: field.TypeString, Size: 64},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "update_at", Type: field.TypeTime},
+		{Name: "deleted", Type: field.TypeInt, Default: 0},
+	}
+	// ScaAuthRolesTable holds the schema information for the "sca_auth_roles" table.
+	ScaAuthRolesTable = &schema.Table{
+		Name:       "sca_auth_roles",
+		Columns:    ScaAuthRolesColumns,
+		PrimaryKey: []*schema.Column{ScaAuthRolesColumns[0]},
+	}
+	// ScaAuthUsersColumns holds the columns for the "sca_auth_users" table.
+	ScaAuthUsersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "uid", Type: field.TypeString, Unique: true, Size: 20},
+		{Name: "username", Type: field.TypeString, Nullable: true, Size: 32},
+		{Name: "nickname", Type: field.TypeString, Nullable: true, Size: 32},
+		{Name: "email", Type: field.TypeString, Nullable: true, Size: 32},
+		{Name: "phone", Type: field.TypeString, Nullable: true, Size: 32},
+		{Name: "password", Type: field.TypeString, Nullable: true, Size: 64},
+		{Name: "gender", Type: field.TypeString, Nullable: true, Size: 32},
+		{Name: "avatar", Type: field.TypeString, Nullable: true},
+		{Name: "status", Type: field.TypeInt8, Nullable: true, Default: 0},
+		{Name: "introduce", Type: field.TypeString, Nullable: true, Size: 255},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "update_at", Type: field.TypeTime, Nullable: true},
+		{Name: "deleted", Type: field.TypeInt8, Default: 0},
+		{Name: "blog", Type: field.TypeString, Nullable: true, Size: 30},
+		{Name: "location", Type: field.TypeString, Nullable: true, Size: 50},
+		{Name: "company", Type: field.TypeString, Nullable: true, Size: 50},
+	}
+	// ScaAuthUsersTable holds the schema information for the "sca_auth_users" table.
+	ScaAuthUsersTable = &schema.Table{
+		Name:       "sca_auth_users",
+		Columns:    ScaAuthUsersColumns,
+		PrimaryKey: []*schema.Column{ScaAuthUsersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "scaauthuser_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUsersColumns[0]},
+			},
+			{
+				Name:    "scaauthuser_uid",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUsersColumns[1]},
+			},
+			{
+				Name:    "scaauthuser_phone",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUsersColumns[5]},
+			},
+		},
+	}
+	// ScaAuthUserDevicesColumns holds the columns for the "sca_auth_user_devices" table.
+	ScaAuthUserDevicesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "user_id", Type: field.TypeString, Size: 20},
+		{Name: "ip", Type: field.TypeString, Size: 20},
+		{Name: "location", Type: field.TypeString, Size: 20},
+		{Name: "agent", Type: field.TypeString, Size: 255},
+		{Name: "created_at", Type: field.TypeTime, Nullable: true},
+		{Name: "update_at", Type: field.TypeTime},
+		{Name: "deleted", Type: field.TypeInt, Default: 0},
+		{Name: "browser", Type: field.TypeString, Size: 20},
+		{Name: "operating_system", Type: field.TypeString, Size: 20},
+		{Name: "browser_version", Type: field.TypeString, Size: 20},
+		{Name: "mobile", Type: field.TypeInt},
+		{Name: "bot", Type: field.TypeInt},
+		{Name: "mozilla", Type: field.TypeString, Size: 10},
+		{Name: "platform", Type: field.TypeString, Size: 20},
+		{Name: "engine_name", Type: field.TypeString, Size: 20},
+		{Name: "engine_version", Type: field.TypeString, Size: 20},
+		{Name: "sca_auth_user_sca_auth_user_device", Type: field.TypeInt64, Nullable: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+	}
+	// ScaAuthUserDevicesTable holds the schema information for the "sca_auth_user_devices" table.
+	ScaAuthUserDevicesTable = &schema.Table{
+		Name:       "sca_auth_user_devices",
+		Columns:    ScaAuthUserDevicesColumns,
+		PrimaryKey: []*schema.Column{ScaAuthUserDevicesColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sca_auth_user_devices_sca_auth_users_sca_auth_user_device",
+				Columns:    []*schema.Column{ScaAuthUserDevicesColumns[17]},
+				RefColumns: []*schema.Column{ScaAuthUsersColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "scaauthuserdevice_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserDevicesColumns[0]},
+			},
+		},
+	}
+	// ScaAuthUserSocialsColumns holds the columns for the "sca_auth_user_socials" table.
+	ScaAuthUserSocialsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+		{Name: "user_id", Type: field.TypeString, Size: 20},
+		{Name: "open_id", Type: field.TypeString, Size: 50},
+		{Name: "source", Type: field.TypeString, Size: 10},
+		{Name: "status", Type: field.TypeInt, Default: 0},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "update_at", Type: field.TypeTime, Nullable: true},
+		{Name: "deleted", Type: field.TypeInt, Default: 0},
+		{Name: "sca_auth_user_sca_auth_user_social", Type: field.TypeInt64, Nullable: true, SchemaType: map[string]string{"mysql": "bigint(20)"}},
+	}
+	// ScaAuthUserSocialsTable holds the schema information for the "sca_auth_user_socials" table.
+	ScaAuthUserSocialsTable = &schema.Table{
+		Name:       "sca_auth_user_socials",
+		Columns:    ScaAuthUserSocialsColumns,
+		PrimaryKey: []*schema.Column{ScaAuthUserSocialsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sca_auth_user_socials_sca_auth_users_sca_auth_user_social",
+				Columns:    []*schema.Column{ScaAuthUserSocialsColumns[8]},
+				RefColumns: []*schema.Column{ScaAuthUsersColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+		Indexes: []*schema.Index{
+			{
+				Name:    "scaauthusersocial_id_user_id_open_id",
+				Unique:  true,
+				Columns: []*schema.Column{ScaAuthUserSocialsColumns[0], ScaAuthUserSocialsColumns[1], ScaAuthUserSocialsColumns[2]},
+			},
+		},
+	}
+	// Tables holds all the tables in the schema.
+	Tables = []*schema.Table{
+		ScaAuthPermissionRulesTable,
+		ScaAuthRolesTable,
+		ScaAuthUsersTable,
+		ScaAuthUserDevicesTable,
+		ScaAuthUserSocialsTable,
+	}
+)
+
+func init() {
+	ScaAuthPermissionRulesTable.ForeignKeys[0].RefTable = ScaAuthRolesTable
+	ScaAuthUserDevicesTable.ForeignKeys[0].RefTable = ScaAuthUsersTable
+	ScaAuthUserSocialsTable.ForeignKeys[0].RefTable = ScaAuthUsersTable
+}

common/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)

common/ent/runtime.go

@@ -0,0 +1,229 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"schisandra-album-cloud-microservices/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/ent/scaauthrole"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/common/ent/scaauthusersocial"
+	"schisandra-album-cloud-microservices/common/ent/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)
+	scaauthroleFields := schema.ScaAuthRole{}.Fields()
+	_ = scaauthroleFields
+	// 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)
+	// scaauthroleDescCreatedAt is the schema descriptor for created_at field.
+	scaauthroleDescCreatedAt := scaauthroleFields[3].Descriptor()
+	// scaauthrole.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthrole.DefaultCreatedAt = scaauthroleDescCreatedAt.Default.(func() time.Time)
+	// scaauthroleDescUpdateAt is the schema descriptor for update_at field.
+	scaauthroleDescUpdateAt := scaauthroleFields[4].Descriptor()
+	// scaauthrole.DefaultUpdateAt holds the default value on creation for the update_at field.
+	scaauthrole.DefaultUpdateAt = scaauthroleDescUpdateAt.Default.(func() time.Time)
+	// scaauthrole.UpdateDefaultUpdateAt holds the default value on update for the update_at field.
+	scaauthrole.UpdateDefaultUpdateAt = scaauthroleDescUpdateAt.UpdateDefault.(func() time.Time)
+	// scaauthroleDescDeleted is the schema descriptor for deleted field.
+	scaauthroleDescDeleted := scaauthroleFields[5].Descriptor()
+	// scaauthrole.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthrole.DefaultDeleted = scaauthroleDescDeleted.Default.(int)
+	scaauthuserFields := schema.ScaAuthUser{}.Fields()
+	_ = scaauthuserFields
+	// 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)
+	// scaauthuserDescCreatedAt is the schema descriptor for created_at field.
+	scaauthuserDescCreatedAt := scaauthuserFields[11].Descriptor()
+	// scaauthuser.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthuser.DefaultCreatedAt = scaauthuserDescCreatedAt.Default.(func() time.Time)
+	// scaauthuserDescUpdateAt is the schema descriptor for update_at field.
+	scaauthuserDescUpdateAt := scaauthuserFields[12].Descriptor()
+	// scaauthuser.DefaultUpdateAt holds the default value on creation for the update_at field.
+	scaauthuser.DefaultUpdateAt = scaauthuserDescUpdateAt.Default.(func() time.Time)
+	// scaauthuser.UpdateDefaultUpdateAt holds the default value on update for the update_at field.
+	scaauthuser.UpdateDefaultUpdateAt = scaauthuserDescUpdateAt.UpdateDefault.(func() time.Time)
+	// scaauthuserDescDeleted is the schema descriptor for deleted field.
+	scaauthuserDescDeleted := scaauthuserFields[13].Descriptor()
+	// scaauthuser.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthuser.DefaultDeleted = scaauthuserDescDeleted.Default.(int8)
+	// scaauthuserDescBlog is the schema descriptor for blog field.
+	scaauthuserDescBlog := scaauthuserFields[14].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[15].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[16].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)
+	scaauthuserdeviceFields := schema.ScaAuthUserDevice{}.Fields()
+	_ = scaauthuserdeviceFields
+	// 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)
+	// scaauthuserdeviceDescCreatedAt is the schema descriptor for created_at field.
+	scaauthuserdeviceDescCreatedAt := scaauthuserdeviceFields[5].Descriptor()
+	// scaauthuserdevice.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthuserdevice.DefaultCreatedAt = scaauthuserdeviceDescCreatedAt.Default.(func() time.Time)
+	// scaauthuserdeviceDescUpdateAt is the schema descriptor for update_at field.
+	scaauthuserdeviceDescUpdateAt := scaauthuserdeviceFields[6].Descriptor()
+	// scaauthuserdevice.DefaultUpdateAt holds the default value on creation for the update_at field.
+	scaauthuserdevice.DefaultUpdateAt = scaauthuserdeviceDescUpdateAt.Default.(func() time.Time)
+	// scaauthuserdevice.UpdateDefaultUpdateAt holds the default value on update for the update_at field.
+	scaauthuserdevice.UpdateDefaultUpdateAt = scaauthuserdeviceDescUpdateAt.UpdateDefault.(func() time.Time)
+	// scaauthuserdeviceDescDeleted is the schema descriptor for deleted field.
+	scaauthuserdeviceDescDeleted := scaauthuserdeviceFields[7].Descriptor()
+	// scaauthuserdevice.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthuserdevice.DefaultDeleted = scaauthuserdeviceDescDeleted.Default.(int)
+	// scaauthuserdeviceDescBrowser is the schema descriptor for browser field.
+	scaauthuserdeviceDescBrowser := scaauthuserdeviceFields[8].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[9].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[10].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[13].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[14].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[15].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[16].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)
+	scaauthusersocialFields := schema.ScaAuthUserSocial{}.Fields()
+	_ = scaauthusersocialFields
+	// 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)
+	// scaauthusersocialDescCreatedAt is the schema descriptor for created_at field.
+	scaauthusersocialDescCreatedAt := scaauthusersocialFields[5].Descriptor()
+	// scaauthusersocial.DefaultCreatedAt holds the default value on creation for the created_at field.
+	scaauthusersocial.DefaultCreatedAt = scaauthusersocialDescCreatedAt.Default.(func() time.Time)
+	// scaauthusersocialDescUpdateAt is the schema descriptor for update_at field.
+	scaauthusersocialDescUpdateAt := scaauthusersocialFields[6].Descriptor()
+	// scaauthusersocial.DefaultUpdateAt holds the default value on creation for the update_at field.
+	scaauthusersocial.DefaultUpdateAt = scaauthusersocialDescUpdateAt.Default.(func() time.Time)
+	// scaauthusersocial.UpdateDefaultUpdateAt holds the default value on update for the update_at field.
+	scaauthusersocial.UpdateDefaultUpdateAt = scaauthusersocialDescUpdateAt.UpdateDefault.(func() time.Time)
+	// scaauthusersocialDescDeleted is the schema descriptor for deleted field.
+	scaauthusersocialDescDeleted := scaauthusersocialFields[7].Descriptor()
+	// scaauthusersocial.DefaultDeleted holds the default value on creation for the deleted field.
+	scaauthusersocial.DefaultDeleted = scaauthusersocialDescDeleted.Default.(int)
+}

common/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/common/ent/runtime.go
+
+const (
+	Version = "v0.14.1"                                         // Version of ent codegen.
+	Sum     = "h1:fUERL506Pqr92EPHJqr8EYxbPioflJo6PudkrEA8a/s=" // Sum of ent codegen.
+)

common/ent/scaauthpermissionrule.go

@@ -0,0 +1,229 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/ent/scaauthrole"
+	"strings"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// ScaAuthPermissionRule is the model entity for the ScaAuthPermissionRule schema.
+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

common/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_rules"
+	// ScaAuthRoleTable is the table that holds the sca_auth_role relation/edge.
+	ScaAuthRoleTable = "sca_auth_permission_rules"
+	// 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_roles"
+	// 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_rules"
+// 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),
+	)
+}

common/ent/scaauthpermissionrule/where.go

@@ -0,0 +1,623 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthpermissionrule
+
+import (
+	"schisandra-album-cloud-microservices/common/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))
+}

common/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/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/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)
+	}
+}

common/ent/scaauthpermissionrule_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/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)
+	}
+}

common/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/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/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)
+}

common/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/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/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
+}

common/ent/scaauthrole.go

@@ -0,0 +1,177 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthrole"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// ScaAuthRole is the model entity for the ScaAuthRole schema.
+type ScaAuthRole struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 主键ID
+	ID int64 `json:"id,omitempty"`
+	// 角色名称
+	RoleName string `json:"role_name,omitempty"`
+	// 角色关键字
+	RoleKey string `json:"role_key,omitempty"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdateAt time.Time `json:"update_at,omitempty"`
+	// 是否删除 0 未删除 1已删除
+	Deleted int `json:"deleted,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.FieldUpdateAt:
+			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.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
+			}
+		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.FieldUpdateAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field update_at", values[i])
+			} else if value.Valid {
+				sar.UpdateAt = 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 = int(value.Int64)
+			}
+		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("role_name=")
+	builder.WriteString(sar.RoleName)
+	builder.WriteString(", ")
+	builder.WriteString("role_key=")
+	builder.WriteString(sar.RoleKey)
+	builder.WriteString(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(sar.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("update_at=")
+	builder.WriteString(sar.UpdateAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", sar.Deleted))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ScaAuthRoles is a parsable slice of ScaAuthRole.
+type ScaAuthRoles []*ScaAuthRole

common/ent/scaauthrole/scaauthrole.go

@@ -0,0 +1,127 @@
+// 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"
+	// 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"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdateAt holds the string denoting the update_at field in the database.
+	FieldUpdateAt = "update_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// 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_roles"
+	// ScaAuthPermissionRuleTable is the table that holds the sca_auth_permission_rule relation/edge.
+	ScaAuthPermissionRuleTable = "sca_auth_permission_rules"
+	// 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_rules"
+	// 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,
+	FieldRoleName,
+	FieldRoleKey,
+	FieldCreatedAt,
+	FieldUpdateAt,
+	FieldDeleted,
+}
+
+// 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 (
+	// 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
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdateAt holds the default value on creation for the "update_at" field.
+	DefaultUpdateAt func() time.Time
+	// UpdateDefaultUpdateAt holds the default value on update for the "update_at" field.
+	UpdateDefaultUpdateAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted int
+)
+
+// 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()
+}
+
+// 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdateAt orders the results by the update_at field.
+func ByUpdateAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdateAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, 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),
+	)
+}

common/ent/scaauthrole/where.go

@@ -0,0 +1,369 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthrole
+
+import (
+	"schisandra-album-cloud-microservices/common/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))
+}
+
+// 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))
+}
+
+// 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))
+}
+
+// UpdateAt applies equality check predicate on the "update_at" field. It's identical to UpdateAtEQ.
+func UpdateAt(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldUpdateAt, v))
+}
+
+// Deleted applies equality check predicate on the "deleted" field. It's identical to DeletedEQ.
+func Deleted(v int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldDeleted, v))
+}
+
+// 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))
+}
+
+// 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))
+}
+
+// UpdateAtEQ applies the EQ predicate on the "update_at" field.
+func UpdateAtEQ(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldUpdateAt, v))
+}
+
+// UpdateAtNEQ applies the NEQ predicate on the "update_at" field.
+func UpdateAtNEQ(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldUpdateAt, v))
+}
+
+// UpdateAtIn applies the In predicate on the "update_at" field.
+func UpdateAtIn(vs ...time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldUpdateAt, vs...))
+}
+
+// UpdateAtNotIn applies the NotIn predicate on the "update_at" field.
+func UpdateAtNotIn(vs ...time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldUpdateAt, vs...))
+}
+
+// UpdateAtGT applies the GT predicate on the "update_at" field.
+func UpdateAtGT(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldUpdateAt, v))
+}
+
+// UpdateAtGTE applies the GTE predicate on the "update_at" field.
+func UpdateAtGTE(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldUpdateAt, v))
+}
+
+// UpdateAtLT applies the LT predicate on the "update_at" field.
+func UpdateAtLT(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldUpdateAt, v))
+}
+
+// UpdateAtLTE applies the LTE predicate on the "update_at" field.
+func UpdateAtLTE(v time.Time) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldUpdateAt, v))
+}
+
+// DeletedEQ applies the EQ predicate on the "deleted" field.
+func DeletedEQ(v int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldEQ(FieldDeleted, v))
+}
+
+// DeletedNEQ applies the NEQ predicate on the "deleted" field.
+func DeletedNEQ(v int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNEQ(FieldDeleted, v))
+}
+
+// DeletedIn applies the In predicate on the "deleted" field.
+func DeletedIn(vs ...int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldIn(FieldDeleted, vs...))
+}
+
+// DeletedNotIn applies the NotIn predicate on the "deleted" field.
+func DeletedNotIn(vs ...int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldNotIn(FieldDeleted, vs...))
+}
+
+// DeletedGT applies the GT predicate on the "deleted" field.
+func DeletedGT(v int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGT(FieldDeleted, v))
+}
+
+// DeletedGTE applies the GTE predicate on the "deleted" field.
+func DeletedGTE(v int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldGTE(FieldDeleted, v))
+}
+
+// DeletedLT applies the LT predicate on the "deleted" field.
+func DeletedLT(v int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLT(FieldDeleted, v))
+}
+
+// DeletedLTE applies the LTE predicate on the "deleted" field.
+func DeletedLTE(v int) predicate.ScaAuthRole {
+	return predicate.ScaAuthRole(sql.FieldLTE(FieldDeleted, 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))
+}

common/ent/scaauthrole_create.go

@@ -0,0 +1,332 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/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
+}
+
+// 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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (sarc *ScaAuthRoleCreate) SetUpdateAt(t time.Time) *ScaAuthRoleCreate {
+	sarc.mutation.SetUpdateAt(t)
+	return sarc
+}
+
+// SetNillableUpdateAt sets the "update_at" field if the given value is not nil.
+func (sarc *ScaAuthRoleCreate) SetNillableUpdateAt(t *time.Time) *ScaAuthRoleCreate {
+	if t != nil {
+		sarc.SetUpdateAt(*t)
+	}
+	return sarc
+}
+
+// SetDeleted sets the "deleted" field.
+func (sarc *ScaAuthRoleCreate) SetDeleted(i int) *ScaAuthRoleCreate {
+	sarc.mutation.SetDeleted(i)
+	return sarc
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sarc *ScaAuthRoleCreate) SetNillableDeleted(i *int) *ScaAuthRoleCreate {
+	if i != nil {
+		sarc.SetDeleted(*i)
+	}
+	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.UpdateAt(); !ok {
+		v := scaauthrole.DefaultUpdateAt()
+		sarc.mutation.SetUpdateAt(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.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)}
+		}
+	}
+	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.UpdateAt(); !ok {
+		return &ValidationError{Name: "update_at", err: errors.New(`ent: missing required field "ScaAuthRole.update_at"`)}
+	}
+	if _, ok := sarc.mutation.Deleted(); !ok {
+		return &ValidationError{Name: "deleted", err: errors.New(`ent: missing required field "ScaAuthRole.deleted"`)}
+	}
+	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.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 value, ok := sarc.mutation.CreatedAt(); ok {
+		_spec.SetField(scaauthrole.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := sarc.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthrole.FieldUpdateAt, field.TypeTime, value)
+		_node.UpdateAt = value
+	}
+	if value, ok := sarc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthrole.FieldDeleted, field.TypeInt, value)
+		_node.Deleted = 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)
+	}
+}

common/ent/scaauthrole_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/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)
+	}
+}

common/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/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/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 {
+//		RoleName string `json:"role_name,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthRole.Query().
+//		GroupBy(scaauthrole.FieldRoleName).
+//		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 {
+//		RoleName string `json:"role_name,omitempty"`
+//	}
+//
+//	client.ScaAuthRole.Query().
+//		Select(scaauthrole.FieldRoleName).
+//		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)
+}

common/ent/scaauthrole_update.go

@@ -0,0 +1,533 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthpermissionrule"
+	"schisandra-album-cloud-microservices/common/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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (saru *ScaAuthRoleUpdate) SetUpdateAt(t time.Time) *ScaAuthRoleUpdate {
+	saru.mutation.SetUpdateAt(t)
+	return saru
+}
+
+// SetDeleted sets the "deleted" field.
+func (saru *ScaAuthRoleUpdate) SetDeleted(i int) *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 *int) *ScaAuthRoleUpdate {
+	if i != nil {
+		saru.SetDeleted(*i)
+	}
+	return saru
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (saru *ScaAuthRoleUpdate) AddDeleted(i int) *ScaAuthRoleUpdate {
+	saru.mutation.AddDeleted(i)
+	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.UpdateAt(); !ok {
+		v := scaauthrole.UpdateDefaultUpdateAt()
+		saru.mutation.SetUpdateAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (saru *ScaAuthRoleUpdate) check() error {
+	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.RoleName(); ok {
+		_spec.SetField(scaauthrole.FieldRoleName, field.TypeString, value)
+	}
+	if value, ok := saru.mutation.RoleKey(); ok {
+		_spec.SetField(scaauthrole.FieldRoleKey, field.TypeString, value)
+	}
+	if value, ok := saru.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthrole.FieldUpdateAt, field.TypeTime, value)
+	}
+	if value, ok := saru.mutation.Deleted(); ok {
+		_spec.SetField(scaauthrole.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := saru.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthrole.FieldDeleted, field.TypeInt, 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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (saruo *ScaAuthRoleUpdateOne) SetUpdateAt(t time.Time) *ScaAuthRoleUpdateOne {
+	saruo.mutation.SetUpdateAt(t)
+	return saruo
+}
+
+// SetDeleted sets the "deleted" field.
+func (saruo *ScaAuthRoleUpdateOne) SetDeleted(i int) *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 *int) *ScaAuthRoleUpdateOne {
+	if i != nil {
+		saruo.SetDeleted(*i)
+	}
+	return saruo
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (saruo *ScaAuthRoleUpdateOne) AddDeleted(i int) *ScaAuthRoleUpdateOne {
+	saruo.mutation.AddDeleted(i)
+	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.UpdateAt(); !ok {
+		v := scaauthrole.UpdateDefaultUpdateAt()
+		saruo.mutation.SetUpdateAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (saruo *ScaAuthRoleUpdateOne) check() error {
+	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.RoleName(); ok {
+		_spec.SetField(scaauthrole.FieldRoleName, field.TypeString, value)
+	}
+	if value, ok := saruo.mutation.RoleKey(); ok {
+		_spec.SetField(scaauthrole.FieldRoleKey, field.TypeString, value)
+	}
+	if value, ok := saruo.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthrole.FieldUpdateAt, field.TypeTime, value)
+	}
+	if value, ok := saruo.mutation.Deleted(); ok {
+		_spec.SetField(scaauthrole.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := saruo.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthrole.FieldDeleted, field.TypeInt, 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
+}

common/ent/scaauthuser.go

@@ -0,0 +1,325 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// ScaAuthUser is the model entity for the ScaAuthUser schema.
+type ScaAuthUser struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 自增ID
+	ID int64 `json:"id,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"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdateAt *time.Time `json:"update_at,omitempty"`
+	// 是否删除 0 未删除 1 已删除
+	Deleted int8 `json:"deleted,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.FieldStatus, scaauthuser.FieldDeleted:
+			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.FieldUpdateAt:
+			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.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.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.FieldUpdateAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field update_at", values[i])
+			} else if value.Valid {
+				sau.UpdateAt = new(time.Time)
+				*sau.UpdateAt = 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.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("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(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(sau.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	if v := sau.UpdateAt; v != nil {
+		builder.WriteString("update_at=")
+		builder.WriteString(v.Format(time.ANSIC))
+	}
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", sau.Deleted))
+	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

common/ent/scaauthuser/scaauthuser.go

@@ -0,0 +1,265 @@
+// 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"
+	// 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"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdateAt holds the string denoting the update_at field in the database.
+	FieldUpdateAt = "update_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// 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_users"
+	// ScaAuthUserSocialTable is the table that holds the sca_auth_user_social relation/edge.
+	ScaAuthUserSocialTable = "sca_auth_user_socials"
+	// 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_socials"
+	// 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_devices"
+	// 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_devices"
+	// 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,
+	FieldUID,
+	FieldUsername,
+	FieldNickname,
+	FieldEmail,
+	FieldPhone,
+	FieldPassword,
+	FieldGender,
+	FieldAvatar,
+	FieldStatus,
+	FieldIntroduce,
+	FieldCreatedAt,
+	FieldUpdateAt,
+	FieldDeleted,
+	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 (
+	// 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
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdateAt holds the default value on creation for the "update_at" field.
+	DefaultUpdateAt func() time.Time
+	// UpdateDefaultUpdateAt holds the default value on update for the "update_at" field.
+	UpdateDefaultUpdateAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted int8
+	// 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()
+}
+
+// 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdateAt orders the results by the update_at field.
+func ByUpdateAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdateAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, 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),
+	)
+}

common/ent/scaauthuser_create.go

@@ -0,0 +1,613 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/common/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
+}
+
+// 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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (sauc *ScaAuthUserCreate) SetUpdateAt(t time.Time) *ScaAuthUserCreate {
+	sauc.mutation.SetUpdateAt(t)
+	return sauc
+}
+
+// SetNillableUpdateAt sets the "update_at" field if the given value is not nil.
+func (sauc *ScaAuthUserCreate) SetNillableUpdateAt(t *time.Time) *ScaAuthUserCreate {
+	if t != nil {
+		sauc.SetUpdateAt(*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
+}
+
+// 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.Status(); !ok {
+		v := scaauthuser.DefaultStatus
+		sauc.mutation.SetStatus(v)
+	}
+	if _, ok := sauc.mutation.CreatedAt(); !ok {
+		v := scaauthuser.DefaultCreatedAt()
+		sauc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := sauc.mutation.UpdateAt(); !ok {
+		v := scaauthuser.DefaultUpdateAt()
+		sauc.mutation.SetUpdateAt(v)
+	}
+	if _, ok := sauc.mutation.Deleted(); !ok {
+		v := scaauthuser.DefaultDeleted
+		sauc.mutation.SetDeleted(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sauc *ScaAuthUserCreate) check() error {
+	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 _, ok := sauc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "ScaAuthUser.created_at"`)}
+	}
+	if _, ok := sauc.mutation.Deleted(); !ok {
+		return &ValidationError{Name: "deleted", err: errors.New(`ent: missing required field "ScaAuthUser.deleted"`)}
+	}
+	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.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.CreatedAt(); ok {
+		_spec.SetField(scaauthuser.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := sauc.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthuser.FieldUpdateAt, field.TypeTime, value)
+		_node.UpdateAt = &value
+	}
+	if value, ok := sauc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthuser.FieldDeleted, field.TypeInt8, value)
+		_node.Deleted = 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)
+	}
+}

common/ent/scaauthuser_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/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)
+	}
+}

common/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/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuserdevice"
+	"schisandra-album-cloud-microservices/common/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 {
+//		UID string `json:"uid,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthUser.Query().
+//		GroupBy(scaauthuser.FieldUID).
+//		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 {
+//		UID string `json:"uid,omitempty"`
+//	}
+//
+//	client.ScaAuthUser.Query().
+//		Select(scaauthuser.FieldUID).
+//		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)
+}

common/ent/scaauthuserdevice.go

@@ -0,0 +1,314 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuserdevice"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// ScaAuthUserDevice is the model entity for the ScaAuthUserDevice schema.
+type ScaAuthUserDevice struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 主键ID
+	ID int64 `json:"id,omitempty"`
+	// 用户ID
+	UserID string `json:"user_id,omitempty"`
+	// 登录IP
+	IP string `json:"ip,omitempty"`
+	// 地址
+	Location string `json:"location,omitempty"`
+	// 设备信息
+	Agent string `json:"agent,omitempty"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdateAt *time.Time `json:"update_at,omitempty"`
+	// 是否删除
+	Deleted int `json:"deleted,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.FieldUpdateAt:
+			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.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.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.FieldUpdateAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field update_at", values[i])
+			} else if value.Valid {
+				saud.UpdateAt = new(time.Time)
+				*saud.UpdateAt = 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 = int(value.Int64)
+			}
+		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("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("created_at=")
+	builder.WriteString(saud.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	if v := saud.UpdateAt; v != nil {
+		builder.WriteString("update_at=")
+		builder.WriteString(v.Format(time.ANSIC))
+	}
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", saud.Deleted))
+	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

common/ent/scaauthuserdevice/scaauthuserdevice.go

@@ -0,0 +1,237 @@
+// 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"
+	// 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"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdateAt holds the string denoting the update_at field in the database.
+	FieldUpdateAt = "update_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// 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_devices"
+	// ScaAuthUserTable is the table that holds the sca_auth_user relation/edge.
+	ScaAuthUserTable = "sca_auth_user_devices"
+	// 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_users"
+	// 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,
+	FieldUserID,
+	FieldIP,
+	FieldLocation,
+	FieldAgent,
+	FieldCreatedAt,
+	FieldUpdateAt,
+	FieldDeleted,
+	FieldBrowser,
+	FieldOperatingSystem,
+	FieldBrowserVersion,
+	FieldMobile,
+	FieldBot,
+	FieldMozilla,
+	FieldPlatform,
+	FieldEngineName,
+	FieldEngineVersion,
+}
+
+// ForeignKeys holds the SQL foreign-keys that are owned by the "sca_auth_user_devices"
+// 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 (
+	// 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
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdateAt holds the default value on creation for the "update_at" field.
+	DefaultUpdateAt func() time.Time
+	// UpdateDefaultUpdateAt holds the default value on update for the "update_at" field.
+	UpdateDefaultUpdateAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted int
+	// 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()
+}
+
+// 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdateAt orders the results by the update_at field.
+func ByUpdateAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdateAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, 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),
+	)
+}

common/ent/scaauthuserdevice_create.go

@@ -0,0 +1,522 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/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
+}
+
+// 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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (saudc *ScaAuthUserDeviceCreate) SetUpdateAt(t time.Time) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetUpdateAt(t)
+	return saudc
+}
+
+// SetNillableUpdateAt sets the "update_at" field if the given value is not nil.
+func (saudc *ScaAuthUserDeviceCreate) SetNillableUpdateAt(t *time.Time) *ScaAuthUserDeviceCreate {
+	if t != nil {
+		saudc.SetUpdateAt(*t)
+	}
+	return saudc
+}
+
+// SetDeleted sets the "deleted" field.
+func (saudc *ScaAuthUserDeviceCreate) SetDeleted(i int) *ScaAuthUserDeviceCreate {
+	saudc.mutation.SetDeleted(i)
+	return saudc
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (saudc *ScaAuthUserDeviceCreate) SetNillableDeleted(i *int) *ScaAuthUserDeviceCreate {
+	if i != nil {
+		saudc.SetDeleted(*i)
+	}
+	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.UpdateAt(); !ok {
+		v := scaauthuserdevice.DefaultUpdateAt()
+		saudc.mutation.SetUpdateAt(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.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.UpdateAt(); !ok {
+		return &ValidationError{Name: "update_at", err: errors.New(`ent: missing required field "ScaAuthUserDevice.update_at"`)}
+	}
+	if _, ok := saudc.mutation.Deleted(); !ok {
+		return &ValidationError{Name: "deleted", err: errors.New(`ent: missing required field "ScaAuthUserDevice.deleted"`)}
+	}
+	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.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.CreatedAt(); ok {
+		_spec.SetField(scaauthuserdevice.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := saudc.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthuserdevice.FieldUpdateAt, field.TypeTime, value)
+		_node.UpdateAt = &value
+	}
+	if value, ok := saudc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthuserdevice.FieldDeleted, field.TypeInt, value)
+		_node.Deleted = 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)
+	}
+}

common/ent/scaauthuserdevice_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/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)
+	}
+}

common/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/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/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 {
+//		UserID string `json:"user_id,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthUserDevice.Query().
+//		GroupBy(scaauthuserdevice.FieldUserID).
+//		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 {
+//		UserID string `json:"user_id,omitempty"`
+//	}
+//
+//	client.ScaAuthUserDevice.Query().
+//		Select(scaauthuserdevice.FieldUserID).
+//		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)
+}

common/ent/scaauthuserdevice_update.go

@@ -0,0 +1,989 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuserdevice"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthUserDeviceUpdate is the builder for updating ScaAuthUserDevice entities.
+type ScaAuthUserDeviceUpdate struct {
+	config
+	hooks    []Hook
+	mutation *ScaAuthUserDeviceMutation
+}
+
+// Where appends a list predicates to the ScaAuthUserDeviceUpdate builder.
+func (saudu *ScaAuthUserDeviceUpdate) Where(ps ...predicate.ScaAuthUserDevice) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.Where(ps...)
+	return saudu
+}
+
+// SetUserID sets the "user_id" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetUserID(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetUserID(s)
+	return saudu
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableUserID(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetUserID(*s)
+	}
+	return saudu
+}
+
+// SetIP sets the "ip" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetIP(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetIP(s)
+	return saudu
+}
+
+// SetNillableIP sets the "ip" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableIP(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetIP(*s)
+	}
+	return saudu
+}
+
+// SetLocation sets the "location" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetLocation(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetLocation(s)
+	return saudu
+}
+
+// SetNillableLocation sets the "location" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableLocation(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetLocation(*s)
+	}
+	return saudu
+}
+
+// SetAgent sets the "agent" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetAgent(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetAgent(s)
+	return saudu
+}
+
+// SetNillableAgent sets the "agent" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableAgent(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetAgent(*s)
+	}
+	return saudu
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetUpdateAt(t time.Time) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetUpdateAt(t)
+	return saudu
+}
+
+// SetDeleted sets the "deleted" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetDeleted(i int) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.ResetDeleted()
+	saudu.mutation.SetDeleted(i)
+	return saudu
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableDeleted(i *int) *ScaAuthUserDeviceUpdate {
+	if i != nil {
+		saudu.SetDeleted(*i)
+	}
+	return saudu
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (saudu *ScaAuthUserDeviceUpdate) AddDeleted(i int) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.AddDeleted(i)
+	return saudu
+}
+
+// SetBrowser sets the "browser" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetBrowser(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetBrowser(s)
+	return saudu
+}
+
+// SetNillableBrowser sets the "browser" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableBrowser(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetBrowser(*s)
+	}
+	return saudu
+}
+
+// SetOperatingSystem sets the "operating_system" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetOperatingSystem(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetOperatingSystem(s)
+	return saudu
+}
+
+// SetNillableOperatingSystem sets the "operating_system" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableOperatingSystem(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetOperatingSystem(*s)
+	}
+	return saudu
+}
+
+// SetBrowserVersion sets the "browser_version" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetBrowserVersion(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetBrowserVersion(s)
+	return saudu
+}
+
+// SetNillableBrowserVersion sets the "browser_version" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableBrowserVersion(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetBrowserVersion(*s)
+	}
+	return saudu
+}
+
+// SetMobile sets the "mobile" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetMobile(i int) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.ResetMobile()
+	saudu.mutation.SetMobile(i)
+	return saudu
+}
+
+// SetNillableMobile sets the "mobile" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableMobile(i *int) *ScaAuthUserDeviceUpdate {
+	if i != nil {
+		saudu.SetMobile(*i)
+	}
+	return saudu
+}
+
+// AddMobile adds i to the "mobile" field.
+func (saudu *ScaAuthUserDeviceUpdate) AddMobile(i int) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.AddMobile(i)
+	return saudu
+}
+
+// SetBot sets the "bot" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetBot(i int) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.ResetBot()
+	saudu.mutation.SetBot(i)
+	return saudu
+}
+
+// SetNillableBot sets the "bot" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableBot(i *int) *ScaAuthUserDeviceUpdate {
+	if i != nil {
+		saudu.SetBot(*i)
+	}
+	return saudu
+}
+
+// AddBot adds i to the "bot" field.
+func (saudu *ScaAuthUserDeviceUpdate) AddBot(i int) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.AddBot(i)
+	return saudu
+}
+
+// SetMozilla sets the "mozilla" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetMozilla(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetMozilla(s)
+	return saudu
+}
+
+// SetNillableMozilla sets the "mozilla" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableMozilla(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetMozilla(*s)
+	}
+	return saudu
+}
+
+// SetPlatform sets the "platform" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetPlatform(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetPlatform(s)
+	return saudu
+}
+
+// SetNillablePlatform sets the "platform" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillablePlatform(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetPlatform(*s)
+	}
+	return saudu
+}
+
+// SetEngineName sets the "engine_name" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetEngineName(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetEngineName(s)
+	return saudu
+}
+
+// SetNillableEngineName sets the "engine_name" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableEngineName(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetEngineName(*s)
+	}
+	return saudu
+}
+
+// SetEngineVersion sets the "engine_version" field.
+func (saudu *ScaAuthUserDeviceUpdate) SetEngineVersion(s string) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetEngineVersion(s)
+	return saudu
+}
+
+// SetNillableEngineVersion sets the "engine_version" field if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableEngineVersion(s *string) *ScaAuthUserDeviceUpdate {
+	if s != nil {
+		saudu.SetEngineVersion(*s)
+	}
+	return saudu
+}
+
+// SetScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID.
+func (saudu *ScaAuthUserDeviceUpdate) SetScaAuthUserID(id int64) *ScaAuthUserDeviceUpdate {
+	saudu.mutation.SetScaAuthUserID(id)
+	return saudu
+}
+
+// SetNillableScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID if the given value is not nil.
+func (saudu *ScaAuthUserDeviceUpdate) SetNillableScaAuthUserID(id *int64) *ScaAuthUserDeviceUpdate {
+	if id != nil {
+		saudu = saudu.SetScaAuthUserID(*id)
+	}
+	return saudu
+}
+
+// SetScaAuthUser sets the "sca_auth_user" edge to the ScaAuthUser entity.
+func (saudu *ScaAuthUserDeviceUpdate) SetScaAuthUser(s *ScaAuthUser) *ScaAuthUserDeviceUpdate {
+	return saudu.SetScaAuthUserID(s.ID)
+}
+
+// Mutation returns the ScaAuthUserDeviceMutation object of the builder.
+func (saudu *ScaAuthUserDeviceUpdate) Mutation() *ScaAuthUserDeviceMutation {
+	return saudu.mutation
+}
+
+// ClearScaAuthUser clears the "sca_auth_user" edge to the ScaAuthUser entity.
+func (saudu *ScaAuthUserDeviceUpdate) ClearScaAuthUser() *ScaAuthUserDeviceUpdate {
+	saudu.mutation.ClearScaAuthUser()
+	return saudu
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (saudu *ScaAuthUserDeviceUpdate) Save(ctx context.Context) (int, error) {
+	saudu.defaults()
+	return withHooks(ctx, saudu.sqlSave, saudu.mutation, saudu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (saudu *ScaAuthUserDeviceUpdate) SaveX(ctx context.Context) int {
+	affected, err := saudu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (saudu *ScaAuthUserDeviceUpdate) Exec(ctx context.Context) error {
+	_, err := saudu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (saudu *ScaAuthUserDeviceUpdate) ExecX(ctx context.Context) {
+	if err := saudu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (saudu *ScaAuthUserDeviceUpdate) defaults() {
+	if _, ok := saudu.mutation.UpdateAt(); !ok {
+		v := scaauthuserdevice.UpdateDefaultUpdateAt()
+		saudu.mutation.SetUpdateAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (saudu *ScaAuthUserDeviceUpdate) check() error {
+	if v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 v, ok := saudu.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 (saudu *ScaAuthUserDeviceUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := saudu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthuserdevice.Table, scaauthuserdevice.Columns, sqlgraph.NewFieldSpec(scaauthuserdevice.FieldID, field.TypeInt64))
+	if ps := saudu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := saudu.mutation.UserID(); ok {
+		_spec.SetField(scaauthuserdevice.FieldUserID, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.IP(); ok {
+		_spec.SetField(scaauthuserdevice.FieldIP, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.Location(); ok {
+		_spec.SetField(scaauthuserdevice.FieldLocation, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.Agent(); ok {
+		_spec.SetField(scaauthuserdevice.FieldAgent, field.TypeString, value)
+	}
+	if saudu.mutation.CreatedAtCleared() {
+		_spec.ClearField(scaauthuserdevice.FieldCreatedAt, field.TypeTime)
+	}
+	if value, ok := saudu.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthuserdevice.FieldUpdateAt, field.TypeTime, value)
+	}
+	if value, ok := saudu.mutation.Deleted(); ok {
+		_spec.SetField(scaauthuserdevice.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := saudu.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthuserdevice.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := saudu.mutation.Browser(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBrowser, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.OperatingSystem(); ok {
+		_spec.SetField(scaauthuserdevice.FieldOperatingSystem, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.BrowserVersion(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBrowserVersion, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.Mobile(); ok {
+		_spec.SetField(scaauthuserdevice.FieldMobile, field.TypeInt, value)
+	}
+	if value, ok := saudu.mutation.AddedMobile(); ok {
+		_spec.AddField(scaauthuserdevice.FieldMobile, field.TypeInt, value)
+	}
+	if value, ok := saudu.mutation.Bot(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBot, field.TypeInt, value)
+	}
+	if value, ok := saudu.mutation.AddedBot(); ok {
+		_spec.AddField(scaauthuserdevice.FieldBot, field.TypeInt, value)
+	}
+	if value, ok := saudu.mutation.Mozilla(); ok {
+		_spec.SetField(scaauthuserdevice.FieldMozilla, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.Platform(); ok {
+		_spec.SetField(scaauthuserdevice.FieldPlatform, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.EngineName(); ok {
+		_spec.SetField(scaauthuserdevice.FieldEngineName, field.TypeString, value)
+	}
+	if value, ok := saudu.mutation.EngineVersion(); ok {
+		_spec.SetField(scaauthuserdevice.FieldEngineVersion, field.TypeString, value)
+	}
+	if saudu.mutation.ScaAuthUserCleared() {
+		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),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := saudu.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)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, saudu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthuserdevice.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	saudu.mutation.done = true
+	return n, nil
+}
+
+// ScaAuthUserDeviceUpdateOne is the builder for updating a single ScaAuthUserDevice entity.
+type ScaAuthUserDeviceUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *ScaAuthUserDeviceMutation
+}
+
+// SetUserID sets the "user_id" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetUserID(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetUserID(s)
+	return sauduo
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableUserID(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetUserID(*s)
+	}
+	return sauduo
+}
+
+// SetIP sets the "ip" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetIP(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetIP(s)
+	return sauduo
+}
+
+// SetNillableIP sets the "ip" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableIP(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetIP(*s)
+	}
+	return sauduo
+}
+
+// SetLocation sets the "location" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetLocation(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetLocation(s)
+	return sauduo
+}
+
+// SetNillableLocation sets the "location" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableLocation(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetLocation(*s)
+	}
+	return sauduo
+}
+
+// SetAgent sets the "agent" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetAgent(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetAgent(s)
+	return sauduo
+}
+
+// SetNillableAgent sets the "agent" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableAgent(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetAgent(*s)
+	}
+	return sauduo
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetUpdateAt(t time.Time) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetUpdateAt(t)
+	return sauduo
+}
+
+// SetDeleted sets the "deleted" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetDeleted(i int) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.ResetDeleted()
+	sauduo.mutation.SetDeleted(i)
+	return sauduo
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableDeleted(i *int) *ScaAuthUserDeviceUpdateOne {
+	if i != nil {
+		sauduo.SetDeleted(*i)
+	}
+	return sauduo
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) AddDeleted(i int) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.AddDeleted(i)
+	return sauduo
+}
+
+// SetBrowser sets the "browser" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetBrowser(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetBrowser(s)
+	return sauduo
+}
+
+// SetNillableBrowser sets the "browser" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableBrowser(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetBrowser(*s)
+	}
+	return sauduo
+}
+
+// SetOperatingSystem sets the "operating_system" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetOperatingSystem(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetOperatingSystem(s)
+	return sauduo
+}
+
+// SetNillableOperatingSystem sets the "operating_system" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableOperatingSystem(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetOperatingSystem(*s)
+	}
+	return sauduo
+}
+
+// SetBrowserVersion sets the "browser_version" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetBrowserVersion(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetBrowserVersion(s)
+	return sauduo
+}
+
+// SetNillableBrowserVersion sets the "browser_version" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableBrowserVersion(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetBrowserVersion(*s)
+	}
+	return sauduo
+}
+
+// SetMobile sets the "mobile" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetMobile(i int) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.ResetMobile()
+	sauduo.mutation.SetMobile(i)
+	return sauduo
+}
+
+// SetNillableMobile sets the "mobile" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableMobile(i *int) *ScaAuthUserDeviceUpdateOne {
+	if i != nil {
+		sauduo.SetMobile(*i)
+	}
+	return sauduo
+}
+
+// AddMobile adds i to the "mobile" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) AddMobile(i int) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.AddMobile(i)
+	return sauduo
+}
+
+// SetBot sets the "bot" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetBot(i int) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.ResetBot()
+	sauduo.mutation.SetBot(i)
+	return sauduo
+}
+
+// SetNillableBot sets the "bot" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableBot(i *int) *ScaAuthUserDeviceUpdateOne {
+	if i != nil {
+		sauduo.SetBot(*i)
+	}
+	return sauduo
+}
+
+// AddBot adds i to the "bot" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) AddBot(i int) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.AddBot(i)
+	return sauduo
+}
+
+// SetMozilla sets the "mozilla" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetMozilla(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetMozilla(s)
+	return sauduo
+}
+
+// SetNillableMozilla sets the "mozilla" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableMozilla(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetMozilla(*s)
+	}
+	return sauduo
+}
+
+// SetPlatform sets the "platform" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetPlatform(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetPlatform(s)
+	return sauduo
+}
+
+// SetNillablePlatform sets the "platform" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillablePlatform(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetPlatform(*s)
+	}
+	return sauduo
+}
+
+// SetEngineName sets the "engine_name" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetEngineName(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetEngineName(s)
+	return sauduo
+}
+
+// SetNillableEngineName sets the "engine_name" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableEngineName(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetEngineName(*s)
+	}
+	return sauduo
+}
+
+// SetEngineVersion sets the "engine_version" field.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetEngineVersion(s string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetEngineVersion(s)
+	return sauduo
+}
+
+// SetNillableEngineVersion sets the "engine_version" field if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableEngineVersion(s *string) *ScaAuthUserDeviceUpdateOne {
+	if s != nil {
+		sauduo.SetEngineVersion(*s)
+	}
+	return sauduo
+}
+
+// SetScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetScaAuthUserID(id int64) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.SetScaAuthUserID(id)
+	return sauduo
+}
+
+// SetNillableScaAuthUserID sets the "sca_auth_user" edge to the ScaAuthUser entity by ID if the given value is not nil.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetNillableScaAuthUserID(id *int64) *ScaAuthUserDeviceUpdateOne {
+	if id != nil {
+		sauduo = sauduo.SetScaAuthUserID(*id)
+	}
+	return sauduo
+}
+
+// SetScaAuthUser sets the "sca_auth_user" edge to the ScaAuthUser entity.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SetScaAuthUser(s *ScaAuthUser) *ScaAuthUserDeviceUpdateOne {
+	return sauduo.SetScaAuthUserID(s.ID)
+}
+
+// Mutation returns the ScaAuthUserDeviceMutation object of the builder.
+func (sauduo *ScaAuthUserDeviceUpdateOne) Mutation() *ScaAuthUserDeviceMutation {
+	return sauduo.mutation
+}
+
+// ClearScaAuthUser clears the "sca_auth_user" edge to the ScaAuthUser entity.
+func (sauduo *ScaAuthUserDeviceUpdateOne) ClearScaAuthUser() *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.ClearScaAuthUser()
+	return sauduo
+}
+
+// Where appends a list predicates to the ScaAuthUserDeviceUpdate builder.
+func (sauduo *ScaAuthUserDeviceUpdateOne) Where(ps ...predicate.ScaAuthUserDevice) *ScaAuthUserDeviceUpdateOne {
+	sauduo.mutation.Where(ps...)
+	return sauduo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (sauduo *ScaAuthUserDeviceUpdateOne) Select(field string, fields ...string) *ScaAuthUserDeviceUpdateOne {
+	sauduo.fields = append([]string{field}, fields...)
+	return sauduo
+}
+
+// Save executes the query and returns the updated ScaAuthUserDevice entity.
+func (sauduo *ScaAuthUserDeviceUpdateOne) Save(ctx context.Context) (*ScaAuthUserDevice, error) {
+	sauduo.defaults()
+	return withHooks(ctx, sauduo.sqlSave, sauduo.mutation, sauduo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (sauduo *ScaAuthUserDeviceUpdateOne) SaveX(ctx context.Context) *ScaAuthUserDevice {
+	node, err := sauduo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (sauduo *ScaAuthUserDeviceUpdateOne) Exec(ctx context.Context) error {
+	_, err := sauduo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sauduo *ScaAuthUserDeviceUpdateOne) ExecX(ctx context.Context) {
+	if err := sauduo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sauduo *ScaAuthUserDeviceUpdateOne) defaults() {
+	if _, ok := sauduo.mutation.UpdateAt(); !ok {
+		v := scaauthuserdevice.UpdateDefaultUpdateAt()
+		sauduo.mutation.SetUpdateAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sauduo *ScaAuthUserDeviceUpdateOne) check() error {
+	if v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 v, ok := sauduo.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 (sauduo *ScaAuthUserDeviceUpdateOne) sqlSave(ctx context.Context) (_node *ScaAuthUserDevice, err error) {
+	if err := sauduo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(scaauthuserdevice.Table, scaauthuserdevice.Columns, sqlgraph.NewFieldSpec(scaauthuserdevice.FieldID, field.TypeInt64))
+	id, ok := sauduo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ScaAuthUserDevice.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := sauduo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, scaauthuserdevice.FieldID)
+		for _, f := range fields {
+			if !scaauthuserdevice.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != scaauthuserdevice.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := sauduo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := sauduo.mutation.UserID(); ok {
+		_spec.SetField(scaauthuserdevice.FieldUserID, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.IP(); ok {
+		_spec.SetField(scaauthuserdevice.FieldIP, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.Location(); ok {
+		_spec.SetField(scaauthuserdevice.FieldLocation, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.Agent(); ok {
+		_spec.SetField(scaauthuserdevice.FieldAgent, field.TypeString, value)
+	}
+	if sauduo.mutation.CreatedAtCleared() {
+		_spec.ClearField(scaauthuserdevice.FieldCreatedAt, field.TypeTime)
+	}
+	if value, ok := sauduo.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthuserdevice.FieldUpdateAt, field.TypeTime, value)
+	}
+	if value, ok := sauduo.mutation.Deleted(); ok {
+		_spec.SetField(scaauthuserdevice.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := sauduo.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthuserdevice.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := sauduo.mutation.Browser(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBrowser, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.OperatingSystem(); ok {
+		_spec.SetField(scaauthuserdevice.FieldOperatingSystem, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.BrowserVersion(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBrowserVersion, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.Mobile(); ok {
+		_spec.SetField(scaauthuserdevice.FieldMobile, field.TypeInt, value)
+	}
+	if value, ok := sauduo.mutation.AddedMobile(); ok {
+		_spec.AddField(scaauthuserdevice.FieldMobile, field.TypeInt, value)
+	}
+	if value, ok := sauduo.mutation.Bot(); ok {
+		_spec.SetField(scaauthuserdevice.FieldBot, field.TypeInt, value)
+	}
+	if value, ok := sauduo.mutation.AddedBot(); ok {
+		_spec.AddField(scaauthuserdevice.FieldBot, field.TypeInt, value)
+	}
+	if value, ok := sauduo.mutation.Mozilla(); ok {
+		_spec.SetField(scaauthuserdevice.FieldMozilla, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.Platform(); ok {
+		_spec.SetField(scaauthuserdevice.FieldPlatform, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.EngineName(); ok {
+		_spec.SetField(scaauthuserdevice.FieldEngineName, field.TypeString, value)
+	}
+	if value, ok := sauduo.mutation.EngineVersion(); ok {
+		_spec.SetField(scaauthuserdevice.FieldEngineVersion, field.TypeString, value)
+	}
+	if sauduo.mutation.ScaAuthUserCleared() {
+		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),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := sauduo.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)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &ScaAuthUserDevice{config: sauduo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, sauduo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{scaauthuserdevice.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	sauduo.mutation.done = true
+	return _node, nil
+}

common/ent/scaauthusersocial.go

@@ -0,0 +1,215 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/ent/scaauthusersocial"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// ScaAuthUserSocial is the model entity for the ScaAuthUserSocial schema.
+type ScaAuthUserSocial struct {
+	config `json:"-"`
+	// ID of the ent.
+	// 主键ID
+	ID int64 `json:"id,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"`
+	// 创建时间
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// 更新时间
+	UpdateAt *time.Time `json:"update_at,omitempty"`
+	// 是否删除
+	Deleted int `json:"deleted,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.FieldStatus, scaauthusersocial.FieldDeleted:
+			values[i] = new(sql.NullInt64)
+		case scaauthusersocial.FieldUserID, scaauthusersocial.FieldOpenID, scaauthusersocial.FieldSource:
+			values[i] = new(sql.NullString)
+		case scaauthusersocial.FieldCreatedAt, scaauthusersocial.FieldUpdateAt:
+			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.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.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.FieldUpdateAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field update_at", values[i])
+			} else if value.Valid {
+				saus.UpdateAt = new(time.Time)
+				*saus.UpdateAt = 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 = 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("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.WriteString(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(saus.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	if v := saus.UpdateAt; v != nil {
+		builder.WriteString("update_at=")
+		builder.WriteString(v.Format(time.ANSIC))
+	}
+	builder.WriteString(", ")
+	builder.WriteString("deleted=")
+	builder.WriteString(fmt.Sprintf("%v", saus.Deleted))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ScaAuthUserSocials is a parsable slice of ScaAuthUserSocial.
+type ScaAuthUserSocials []*ScaAuthUserSocial

common/ent/scaauthusersocial/scaauthusersocial.go

@@ -0,0 +1,151 @@
+// 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"
+	// 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"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdateAt holds the string denoting the update_at field in the database.
+	FieldUpdateAt = "update_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// 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_socials"
+	// ScaAuthUserTable is the table that holds the sca_auth_user relation/edge.
+	ScaAuthUserTable = "sca_auth_user_socials"
+	// 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_users"
+	// 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,
+	FieldUserID,
+	FieldOpenID,
+	FieldSource,
+	FieldStatus,
+	FieldCreatedAt,
+	FieldUpdateAt,
+	FieldDeleted,
+}
+
+// ForeignKeys holds the SQL foreign-keys that are owned by the "sca_auth_user_socials"
+// 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 (
+	// 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
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdateAt holds the default value on creation for the "update_at" field.
+	DefaultUpdateAt func() time.Time
+	// UpdateDefaultUpdateAt holds the default value on update for the "update_at" field.
+	UpdateDefaultUpdateAt func() time.Time
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted 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()
+}
+
+// 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()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdateAt orders the results by the update_at field.
+func ByUpdateAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdateAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, 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),
+	)
+}

common/ent/scaauthusersocial/where.go

@@ -0,0 +1,494 @@
+// Code generated by ent, DO NOT EDIT.
+
+package scaauthusersocial
+
+import (
+	"schisandra-album-cloud-microservices/common/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))
+}
+
+// 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))
+}
+
+// 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))
+}
+
+// UpdateAt applies equality check predicate on the "update_at" field. It's identical to UpdateAtEQ.
+func UpdateAt(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldUpdateAt, v))
+}
+
+// Deleted applies equality check predicate on the "deleted" field. It's identical to DeletedEQ.
+func Deleted(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldDeleted, v))
+}
+
+// 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))
+}
+
+// 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))
+}
+
+// UpdateAtEQ applies the EQ predicate on the "update_at" field.
+func UpdateAtEQ(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldUpdateAt, v))
+}
+
+// UpdateAtNEQ applies the NEQ predicate on the "update_at" field.
+func UpdateAtNEQ(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldUpdateAt, v))
+}
+
+// UpdateAtIn applies the In predicate on the "update_at" field.
+func UpdateAtIn(vs ...time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldUpdateAt, vs...))
+}
+
+// UpdateAtNotIn applies the NotIn predicate on the "update_at" field.
+func UpdateAtNotIn(vs ...time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldUpdateAt, vs...))
+}
+
+// UpdateAtGT applies the GT predicate on the "update_at" field.
+func UpdateAtGT(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldUpdateAt, v))
+}
+
+// UpdateAtGTE applies the GTE predicate on the "update_at" field.
+func UpdateAtGTE(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldUpdateAt, v))
+}
+
+// UpdateAtLT applies the LT predicate on the "update_at" field.
+func UpdateAtLT(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldUpdateAt, v))
+}
+
+// UpdateAtLTE applies the LTE predicate on the "update_at" field.
+func UpdateAtLTE(v time.Time) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldUpdateAt, v))
+}
+
+// UpdateAtIsNil applies the IsNil predicate on the "update_at" field.
+func UpdateAtIsNil() predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIsNull(FieldUpdateAt))
+}
+
+// UpdateAtNotNil applies the NotNil predicate on the "update_at" field.
+func UpdateAtNotNil() predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotNull(FieldUpdateAt))
+}
+
+// DeletedEQ applies the EQ predicate on the "deleted" field.
+func DeletedEQ(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldEQ(FieldDeleted, v))
+}
+
+// DeletedNEQ applies the NEQ predicate on the "deleted" field.
+func DeletedNEQ(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNEQ(FieldDeleted, v))
+}
+
+// DeletedIn applies the In predicate on the "deleted" field.
+func DeletedIn(vs ...int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldIn(FieldDeleted, vs...))
+}
+
+// DeletedNotIn applies the NotIn predicate on the "deleted" field.
+func DeletedNotIn(vs ...int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldNotIn(FieldDeleted, vs...))
+}
+
+// DeletedGT applies the GT predicate on the "deleted" field.
+func DeletedGT(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGT(FieldDeleted, v))
+}
+
+// DeletedGTE applies the GTE predicate on the "deleted" field.
+func DeletedGTE(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldGTE(FieldDeleted, v))
+}
+
+// DeletedLT applies the LT predicate on the "deleted" field.
+func DeletedLT(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLT(FieldDeleted, v))
+}
+
+// DeletedLTE applies the LTE predicate on the "deleted" field.
+func DeletedLTE(v int) predicate.ScaAuthUserSocial {
+	return predicate.ScaAuthUserSocial(sql.FieldLTE(FieldDeleted, 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))
+}

common/ent/scaauthusersocial_create.go

@@ -0,0 +1,377 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/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
+}
+
+// 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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (sausc *ScaAuthUserSocialCreate) SetUpdateAt(t time.Time) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetUpdateAt(t)
+	return sausc
+}
+
+// SetNillableUpdateAt sets the "update_at" field if the given value is not nil.
+func (sausc *ScaAuthUserSocialCreate) SetNillableUpdateAt(t *time.Time) *ScaAuthUserSocialCreate {
+	if t != nil {
+		sausc.SetUpdateAt(*t)
+	}
+	return sausc
+}
+
+// SetDeleted sets the "deleted" field.
+func (sausc *ScaAuthUserSocialCreate) SetDeleted(i int) *ScaAuthUserSocialCreate {
+	sausc.mutation.SetDeleted(i)
+	return sausc
+}
+
+// SetNillableDeleted sets the "deleted" field if the given value is not nil.
+func (sausc *ScaAuthUserSocialCreate) SetNillableDeleted(i *int) *ScaAuthUserSocialCreate {
+	if i != nil {
+		sausc.SetDeleted(*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.Status(); !ok {
+		v := scaauthusersocial.DefaultStatus
+		sausc.mutation.SetStatus(v)
+	}
+	if _, ok := sausc.mutation.CreatedAt(); !ok {
+		v := scaauthusersocial.DefaultCreatedAt()
+		sausc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := sausc.mutation.UpdateAt(); !ok {
+		v := scaauthusersocial.DefaultUpdateAt()
+		sausc.mutation.SetUpdateAt(v)
+	}
+	if _, ok := sausc.mutation.Deleted(); !ok {
+		v := scaauthusersocial.DefaultDeleted
+		sausc.mutation.SetDeleted(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sausc *ScaAuthUserSocialCreate) check() error {
+	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"`)}
+	}
+	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.Deleted(); !ok {
+		return &ValidationError{Name: "deleted", err: errors.New(`ent: missing required field "ScaAuthUserSocial.deleted"`)}
+	}
+	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.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 value, ok := sausc.mutation.CreatedAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := sausc.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldUpdateAt, field.TypeTime, value)
+		_node.UpdateAt = &value
+	}
+	if value, ok := sausc.mutation.Deleted(); ok {
+		_spec.SetField(scaauthusersocial.FieldDeleted, field.TypeInt, value)
+		_node.Deleted = 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)
+	}
+}

common/ent/scaauthusersocial_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/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)
+	}
+}

common/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/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/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 {
+//		UserID string `json:"user_id,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ScaAuthUserSocial.Query().
+//		GroupBy(scaauthusersocial.FieldUserID).
+//		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 {
+//		UserID string `json:"user_id,omitempty"`
+//	}
+//
+//	client.ScaAuthUserSocial.Query().
+//		Select(scaauthusersocial.FieldUserID).
+//		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)
+}

common/ent/scaauthusersocial_update.go

@@ -0,0 +1,595 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/common/ent/predicate"
+	"schisandra-album-cloud-microservices/common/ent/scaauthuser"
+	"schisandra-album-cloud-microservices/common/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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (sausu *ScaAuthUserSocialUpdate) SetUpdateAt(t time.Time) *ScaAuthUserSocialUpdate {
+	sausu.mutation.SetUpdateAt(t)
+	return sausu
+}
+
+// ClearUpdateAt clears the value of the "update_at" field.
+func (sausu *ScaAuthUserSocialUpdate) ClearUpdateAt() *ScaAuthUserSocialUpdate {
+	sausu.mutation.ClearUpdateAt()
+	return sausu
+}
+
+// SetDeleted sets the "deleted" field.
+func (sausu *ScaAuthUserSocialUpdate) SetDeleted(i int) *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 *int) *ScaAuthUserSocialUpdate {
+	if i != nil {
+		sausu.SetDeleted(*i)
+	}
+	return sausu
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (sausu *ScaAuthUserSocialUpdate) AddDeleted(i int) *ScaAuthUserSocialUpdate {
+	sausu.mutation.AddDeleted(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.UpdateAt(); !ok && !sausu.mutation.UpdateAtCleared() {
+		v := scaauthusersocial.UpdateDefaultUpdateAt()
+		sausu.mutation.SetUpdateAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sausu *ScaAuthUserSocialUpdate) check() error {
+	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.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 value, ok := sausu.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldUpdateAt, field.TypeTime, value)
+	}
+	if sausu.mutation.UpdateAtCleared() {
+		_spec.ClearField(scaauthusersocial.FieldUpdateAt, field.TypeTime)
+	}
+	if value, ok := sausu.mutation.Deleted(); ok {
+		_spec.SetField(scaauthusersocial.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := sausu.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthusersocial.FieldDeleted, 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
+}
+
+// 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
+}
+
+// SetUpdateAt sets the "update_at" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetUpdateAt(t time.Time) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.SetUpdateAt(t)
+	return sausuo
+}
+
+// ClearUpdateAt clears the value of the "update_at" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) ClearUpdateAt() *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.ClearUpdateAt()
+	return sausuo
+}
+
+// SetDeleted sets the "deleted" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) SetDeleted(i int) *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 *int) *ScaAuthUserSocialUpdateOne {
+	if i != nil {
+		sausuo.SetDeleted(*i)
+	}
+	return sausuo
+}
+
+// AddDeleted adds i to the "deleted" field.
+func (sausuo *ScaAuthUserSocialUpdateOne) AddDeleted(i int) *ScaAuthUserSocialUpdateOne {
+	sausuo.mutation.AddDeleted(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.UpdateAt(); !ok && !sausuo.mutation.UpdateAtCleared() {
+		v := scaauthusersocial.UpdateDefaultUpdateAt()
+		sausuo.mutation.SetUpdateAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sausuo *ScaAuthUserSocialUpdateOne) check() error {
+	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.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 value, ok := sausuo.mutation.UpdateAt(); ok {
+		_spec.SetField(scaauthusersocial.FieldUpdateAt, field.TypeTime, value)
+	}
+	if sausuo.mutation.UpdateAtCleared() {
+		_spec.ClearField(scaauthusersocial.FieldUpdateAt, field.TypeTime)
+	}
+	if value, ok := sausuo.mutation.Deleted(); ok {
+		_spec.SetField(scaauthusersocial.FieldDeleted, field.TypeInt, value)
+	}
+	if value, ok := sausuo.mutation.AddedDeleted(); ok {
+		_spec.AddField(scaauthusersocial.FieldDeleted, 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
+}

common/ent/schema/sca_auth_permission_rule.go

@@ -0,0 +1,58 @@
+package schema
+
+import (
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"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(),
+	}
+}
+
+// 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(),
+	}
+}

common/ent/schema/sca_auth_role.go

@@ -0,0 +1,55 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+)
+
+// ScaAuthRole holds the schema definition for the ScaAuthRole entity.
+type ScaAuthRole struct {
+	ent.Schema
+}
+
+// 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("角色关键字"),
+		field.Time("created_at").
+			Default(time.Now).
+			Immutable().
+			Comment("创建时间"),
+		field.Time("update_at").
+			Default(time.Now).UpdateDefault(time.Now).
+			Comment("更新时间"),
+		field.Int("deleted").
+			Default(0).
+			Comment("是否删除 0 未删除 1已删除"),
+	}
+}
+
+// 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
+}

common/ent/schema/sca_auth_user.go

@@ -0,0 +1,115 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// ScaAuthUser holds the schema definition for the ScaAuthUser entity.
+type ScaAuthUser struct {
+	ent.Schema
+}
+
+// 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.Time("created_at").
+			Default(time.Now).
+			Immutable().
+			Comment("创建时间"),
+		field.Time("update_at").
+			Default(time.Now).UpdateDefault(time.Now).
+			Nillable().
+			Optional().
+			Comment("更新时间"),
+		field.Int8("deleted").
+			Default(0).
+			Comment("是否删除 0 未删除 1 已删除"),
+		field.String("blog").
+			MaxLen(30).
+			Nillable().
+			Optional().
+			Comment("博客"),
+		field.String("location").
+			MaxLen(50).
+			Nillable().
+			Optional().
+			Comment("地址"),
+		field.String("company").
+			MaxLen(50).
+			Nillable().
+			Optional().
+			Comment("公司"),
+	}
+}
+
+// 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(),
+	}
+}

common/ent/schema/sca_auth_user_device.go

@@ -0,0 +1,94 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// ScaAuthUserDevice holds the schema definition for the ScaAuthUserDevice entity.
+type ScaAuthUserDevice struct {
+	ent.Schema
+}
+
+// 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.Time("created_at").
+			Default(time.Now).
+			Optional().
+			Immutable().
+			Comment("创建时间"),
+		field.Time("update_at").
+			Default(time.Now).UpdateDefault(time.Now).
+			Nillable().
+			Comment("更新时间"),
+		field.Int("deleted").
+			Default(0).
+			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("引擎版本"),
+	}
+}
+
+// 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(),
+	}
+}

common/ent/schema/sca_auth_user_social.go

@@ -0,0 +1,69 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/index"
+)
+
+// ScaAuthUserSocial holds the schema definition for the ScaAuthUserSocial entity.
+type ScaAuthUserSocial struct {
+	ent.Schema
+}
+
+// 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 封禁"),
+		field.Time("created_at").
+			Default(time.Now).
+			Immutable().
+			Comment("创建时间"),
+		field.Time("update_at").
+			Default(time.Now).UpdateDefault(time.Now).
+			Optional().
+			Nillable().
+			Comment("更新时间"),
+		field.Int("deleted").
+			Default(0).
+			Comment("是否删除"),
+	}
+}
+
+// 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", "user_id", "open_id").
+			Unique(),
+	}
+}

common/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)

common/middleware/i18n_middleware.go

@@ -0,0 +1,7 @@
+package middleware
+
+import "net/http"
+
+func I18nMiddleware(w http.ResponseWriter, r *http.Request) {
+
+}

common/middleware/security_headers_middleware.go

@@ -0,0 +1,13 @@
+package middleware
+
+import "net/http"
+
+func SecurityHeadersMiddleware(w http.ResponseWriter, r *http.Request) {
+	r.Header.Set("X-Frame-Options", "DENY")
+	r.Header.Set("Content-Security-Policy", "default-src 'self'; connect-src *; font-src *; script-src-elem * 'unsafe-inline'; img-src * data:; style-src * 'unsafe-inline';")
+	r.Header.Set("X-XSS-Protection", "1; mode=block")
+	r.Header.Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload")
+	r.Header.Set("Referrer-Policy", "strict-origin")
+	r.Header.Set("X-Content-Type-Options", "nosniff")
+	r.Header.Set("Permissions-Policy", "geolocation=(),midi=(),sync-xhr=(),microphone=(),camera=(),magnetometer=(),gyroscope=(),fullscreen=(self),payment=()")
+}

common/response/response.go

@@ -0,0 +1 @@
+package response

go.mod

@@ -0,0 +1,62 @@
+module schisandra-album-cloud-microservices
+
+go 1.23.3
+
+require (
+	entgo.io/ent v0.14.1
+	github.com/go-sql-driver/mysql v1.8.1
+	github.com/zeromicro/go-zero v1.7.3
+)
+
+require (
+	ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43 // indirect
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/agext/levenshtein v1.2.1 // indirect
+	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/fatih/color v1.17.0 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-openapi/inflect v0.19.0 // indirect
+	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect
+	github.com/hashicorp/hcl/v2 v2.13.0 // indirect
+	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/openzipkin/zipkin-go v0.4.3 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/prometheus/client_golang v1.20.5 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.55.0 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/spaolacci/murmur3 v1.1.0 // indirect
+	github.com/zclconf/go-cty v1.8.0 // indirect
+	go.opentelemetry.io/otel v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/jaeger v1.17.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/zipkin v1.24.0 // indirect
+	go.opentelemetry.io/otel/metric v1.24.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.24.0 // indirect
+	go.opentelemetry.io/otel/trace v1.24.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
+	go.uber.org/automaxprocs v1.6.0 // indirect
+	golang.org/x/mod v0.20.0 // indirect
+	golang.org/x/net v0.30.0 // indirect
+	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect
+	google.golang.org/grpc v1.65.0 // indirect
+	google.golang.org/protobuf v1.35.1 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+)

go.sum

@@ -0,0 +1,191 @@
+ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43 h1:GwdJbXydHCYPedeeLt4x/lrlIISQ4JTH1mRWuE5ZZ14=
+ariga.io/atlas v0.19.1-0.20240203083654-5948b60a8e43/go.mod h1:uj3pm+hUTVN/X5yfdBexHlZv+1Xu5u5ZbZx7+CDavNU=
+entgo.io/ent v0.14.1 h1:fUERL506Pqr92EPHJqr8EYxbPioflJo6PudkrEA8a/s=
+entgo.io/ent v0.14.1/go.mod h1:MH6XLG0KXpkcDQhKiHfANZSzR55TJyPL5IGNpI8wpco=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
+github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
+github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
+github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
+github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw=
+github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
+github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
+github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
+github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
+github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
+github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
+github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 h1:bkypFPDjIYGfCYD5mRBvpqxfYX1YCS1PXdKYWi8FsN0=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0/go.mod h1:P+Lt/0by1T8bfcF3z737NnSbmxQAppXMRziHUxPOC8k=
+github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 h1:2VTzZjLZBgl62/EtslCrtky5vbi9dd7HrQPQIx6wqiw=
+github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
+github.com/hashicorp/hcl/v2 v2.13.0 h1:0Apadu1w6M11dyGFxWnmhhcMjkbAiKCv7G1r/2QgCNc=
+github.com/hashicorp/hcl/v2 v2.13.0/go.mod h1:e4z5nxYlWNPdDSNYX+ph14EvWYMFm3eP0zIUqPc2jr0=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
+github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/openzipkin/zipkin-go v0.4.3 h1:9EGwpqkgnwdEIJ+Od7QVSEIH+ocmm5nPat0G7sjsSdg=
+github.com/openzipkin/zipkin-go v0.4.3/go.mod h1:M9wCJZFWCo2RiY+o1eBCEMe0Dp2S5LDHcMZmk3RmK7c=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
+github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
+github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
+github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
+github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
+github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
+github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/vmihailenco/msgpack/v4 v4.3.12/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4=
+github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
+github.com/zclconf/go-cty v1.8.0 h1:s4AvqaeQzJIu3ndv4gVIhplVD0krU+bgrcLSVUnaWuA=
+github.com/zclconf/go-cty v1.8.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
+github.com/zeromicro/go-zero v1.7.3 h1:yDUQF2DXDhUHc77/NZF6mzsoRPMBfldjPmG2O/ZSzss=
+github.com/zeromicro/go-zero v1.7.3/go.mod h1:9JIW3gHBGuc9LzvjZnNwINIq9QdiKu3AigajLtkJamQ=
+go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
+go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/otel/exporters/jaeger v1.17.0 h1:D7UpUy2Xc2wsi1Ras6V40q806WM07rqoCWzXu7Sqy+4=
+go.opentelemetry.io/otel/exporters/jaeger v1.17.0/go.mod h1:nPCqOnEH9rNLKqH/+rrUjiMzHJdV1BlpKcTwRTyKkKI=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0 h1:t6wl9SPayj+c7lEIFgm4ooDBZVb01IhLB4InpomhRw8=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0/go.mod h1:iSDOcsnSA5INXzZtwaBPrKp/lWu/V14Dd+llD0oI2EA=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.24.0 h1:Mw5xcxMwlqoJd97vwPxA8isEaIoxsta9/Q51+TTJLGE=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.24.0/go.mod h1:CQNu9bj7o7mC6U7+CA/schKEYakYXWr79ucDHTMGhCM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0 h1:Xw8U6u2f8DK2XAkGRFV7BBLENgnTGX9i4rQRxJf+/vs=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0/go.mod h1:6KW1Fm6R/s6Z3PGXwSJN2K4eT6wQB3vXX6CVnYX9NmM=
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.24.0 h1:s0PHtIkN+3xrbDOpt2M8OTG92cWqUESvzh2MxiR5xY8=
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.24.0/go.mod h1:hZlFbDbRt++MMPCCfSJfmhkGIWnX1h3XjkfxZUjLrIA=
+go.opentelemetry.io/otel/exporters/zipkin v1.24.0 h1:3evrL5poBuh1KF51D9gO/S+N/1msnm4DaBqs/rpXUqY=
+go.opentelemetry.io/otel/exporters/zipkin v1.24.0/go.mod h1:0EHgD8R0+8yRhUYJOGR8Hfg2dpiJQxDOszd5smVO9wM=
+go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
+go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco=
+go.opentelemetry.io/otel/sdk v1.24.0 h1:YMPPDNymmQN3ZgczicBY3B6sf9n62Dlj9pWD3ucgoDw=
+go.opentelemetry.io/otel/sdk v1.24.0/go.mod h1:KVrIYw6tEubO9E96HQpcmpTKDVn9gdv35HoYiQWGDFg=
+go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
+go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
+go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=
+go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8=
+go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
+go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/mod v0.20.0 h1:utOm6MM3R3dnawAiJgn0y+xvuYRsm1RKM/4giyfDgV0=
+golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
+golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24=
+golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d h1:kHjw/5UfflP/L5EbledDrcG4C2597RtymmGRZvHiCuY=
+google.golang.org/genproto/googleapis/api v0.0.0-20240711142825-46eb208f015d/go.mod h1:mw8MG/Qz5wfgYr6VqVCiZcHe/GJEfI+oGGDCohaVgB0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 h1:BwIjyKYGsK9dMCBOorzRri8MQwmi7mT9rGHsCEinZkA=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
+google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
+google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
+google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/h2non/gock.v1 v1.1.2 h1:jBbHXgGBK/AoPVfJh5x4r/WxIrElvbLel8TCZkkZJoY=
+gopkg.in/h2non/gock.v1 v1.1.2/go.mod h1:n7UGz/ckNChHiK05rDoiC4MYSunEC/lyaUm2WWaDva0=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+k8s.io/utils v0.0.0-20240711033017-18e509b52bc8 h1:pUdcCO1Lk/tbT5ztQWOBi5HBgbBP1J8+AsQnQCKsi8A=
+k8s.io/utils v0.0.0-20240711033017-18e509b52bc8/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=