update

hack/gorm-gen/gorm.go

@@ -1,35 +1,25 @@
 package main
 
 import (
-	"leafdev.top/Leaf/api-platform/internal/entity"
-
 	"gorm.io/gen"
+	"leafdev.top/Leaf/api-platform/internal/entity"
 )
 
-// Dynamic SQL
-//type Querier interface {
-//	// SELECT * FROM @@table WHERE name = @name{{if role !=""}} AND role = @role{{end}}
-//	FilterWithNameAndRole(name, role string) ([]gen.T, error)
-//}
-
 func main() {
-	//app, err := cmd.CreateApp()
-	//if err != nil {
-	//	panic(err)
-	//}
 	g := gen.NewGenerator(gen.Config{
 		OutPath: "../../internal/dao",
 		Mode:    gen.WithoutContext | gen.WithDefaultQuery | gen.WithQueryInterface, // generate mode
 	})
 
-	//g.UseDB(app.GORM)
-
 	g.ApplyBasic(
+		entity.Packages{},
 		entity.Api{},
+		entity.ApiDocument{},
+		entity.Order{},
+		entity.OrderItem{},
+		entity.UserPackage{},
+		entity.PromoCode{},
 	)
 
-	// Generate Type Safe API with Dynamic SQL defined on Querier interface for `model.Api` and `model.Company`
-	//g.ApplyInterface(func(Querier) {}, model.Api{}, model.Company{})
-
 	g.Execute()
 }

internal/dao/api_documents.gen.go

@@ -0,0 +1,478 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dao
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"leafdev.top/Leaf/api-platform/internal/entity"
+)
+
+func newApiDocument(db *gorm.DB, opts ...gen.DOOption) apiDocument {
+	_apiDocument := apiDocument{}
+
+	_apiDocument.apiDocumentDo.UseDB(db, opts...)
+	_apiDocument.apiDocumentDo.UseModel(&entity.ApiDocument{})
+
+	tableName := _apiDocument.apiDocumentDo.TableName()
+	_apiDocument.ALL = field.NewAsterisk(tableName)
+	_apiDocument.Id = field.NewUint(tableName, "id")
+	_apiDocument.CreatedAt = field.NewTime(tableName, "created_at")
+	_apiDocument.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_apiDocument.ApiId = field.NewUint(tableName, "api_id")
+	_apiDocument.OpenAPIUrl = field.NewString(tableName, "openapi_url")
+	_apiDocument.Content = field.NewString(tableName, "content")
+	_apiDocument.Api = apiDocumentBelongsToApi{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Api", "entity.Api"),
+	}
+
+	_apiDocument.fillFieldMap()
+
+	return _apiDocument
+}
+
+type apiDocument struct {
+	apiDocumentDo
+
+	ALL        field.Asterisk
+	Id         field.Uint
+	CreatedAt  field.Time
+	UpdatedAt  field.Time
+	ApiId      field.Uint
+	OpenAPIUrl field.String
+	Content    field.String
+	Api        apiDocumentBelongsToApi
+
+	fieldMap map[string]field.Expr
+}
+
+func (a apiDocument) Table(newTableName string) *apiDocument {
+	a.apiDocumentDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a apiDocument) As(alias string) *apiDocument {
+	a.apiDocumentDo.DO = *(a.apiDocumentDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *apiDocument) updateTableName(table string) *apiDocument {
+	a.ALL = field.NewAsterisk(table)
+	a.Id = field.NewUint(table, "id")
+	a.CreatedAt = field.NewTime(table, "created_at")
+	a.UpdatedAt = field.NewTime(table, "updated_at")
+	a.ApiId = field.NewUint(table, "api_id")
+	a.OpenAPIUrl = field.NewString(table, "openapi_url")
+	a.Content = field.NewString(table, "content")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *apiDocument) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := a.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (a *apiDocument) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 7)
+	a.fieldMap["id"] = a.Id
+	a.fieldMap["created_at"] = a.CreatedAt
+	a.fieldMap["updated_at"] = a.UpdatedAt
+	a.fieldMap["api_id"] = a.ApiId
+	a.fieldMap["openapi_url"] = a.OpenAPIUrl
+	a.fieldMap["content"] = a.Content
+
+}
+
+func (a apiDocument) clone(db *gorm.DB) apiDocument {
+	a.apiDocumentDo.ReplaceConnPool(db.Statement.ConnPool)
+	return a
+}
+
+func (a apiDocument) replaceDB(db *gorm.DB) apiDocument {
+	a.apiDocumentDo.ReplaceDB(db)
+	return a
+}
+
+type apiDocumentBelongsToApi struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a apiDocumentBelongsToApi) Where(conds ...field.Expr) *apiDocumentBelongsToApi {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a apiDocumentBelongsToApi) WithContext(ctx context.Context) *apiDocumentBelongsToApi {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a apiDocumentBelongsToApi) Session(session *gorm.Session) *apiDocumentBelongsToApi {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a apiDocumentBelongsToApi) Model(m *entity.ApiDocument) *apiDocumentBelongsToApiTx {
+	return &apiDocumentBelongsToApiTx{a.db.Model(m).Association(a.Name())}
+}
+
+type apiDocumentBelongsToApiTx struct{ tx *gorm.Association }
+
+func (a apiDocumentBelongsToApiTx) Find() (result *entity.Api, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a apiDocumentBelongsToApiTx) Append(values ...*entity.Api) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a apiDocumentBelongsToApiTx) Replace(values ...*entity.Api) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a apiDocumentBelongsToApiTx) Delete(values ...*entity.Api) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a apiDocumentBelongsToApiTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a apiDocumentBelongsToApiTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type apiDocumentDo struct{ gen.DO }
+
+type IApiDocumentDo interface {
+	gen.SubQuery
+	Debug() IApiDocumentDo
+	WithContext(ctx context.Context) IApiDocumentDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IApiDocumentDo
+	WriteDB() IApiDocumentDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IApiDocumentDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IApiDocumentDo
+	Not(conds ...gen.Condition) IApiDocumentDo
+	Or(conds ...gen.Condition) IApiDocumentDo
+	Select(conds ...field.Expr) IApiDocumentDo
+	Where(conds ...gen.Condition) IApiDocumentDo
+	Order(conds ...field.Expr) IApiDocumentDo
+	Distinct(cols ...field.Expr) IApiDocumentDo
+	Omit(cols ...field.Expr) IApiDocumentDo
+	Join(table schema.Tabler, on ...field.Expr) IApiDocumentDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo
+	Group(cols ...field.Expr) IApiDocumentDo
+	Having(conds ...gen.Condition) IApiDocumentDo
+	Limit(limit int) IApiDocumentDo
+	Offset(offset int) IApiDocumentDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDocumentDo
+	Unscoped() IApiDocumentDo
+	Create(values ...*entity.ApiDocument) error
+	CreateInBatches(values []*entity.ApiDocument, batchSize int) error
+	Save(values ...*entity.ApiDocument) error
+	First() (*entity.ApiDocument, error)
+	Take() (*entity.ApiDocument, error)
+	Last() (*entity.ApiDocument, error)
+	Find() ([]*entity.ApiDocument, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.ApiDocument, err error)
+	FindInBatches(result *[]*entity.ApiDocument, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.ApiDocument) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IApiDocumentDo
+	Assign(attrs ...field.AssignExpr) IApiDocumentDo
+	Joins(fields ...field.RelationField) IApiDocumentDo
+	Preload(fields ...field.RelationField) IApiDocumentDo
+	FirstOrInit() (*entity.ApiDocument, error)
+	FirstOrCreate() (*entity.ApiDocument, error)
+	FindByPage(offset int, limit int) (result []*entity.ApiDocument, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IApiDocumentDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (a apiDocumentDo) Debug() IApiDocumentDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a apiDocumentDo) WithContext(ctx context.Context) IApiDocumentDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a apiDocumentDo) ReadDB() IApiDocumentDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a apiDocumentDo) WriteDB() IApiDocumentDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a apiDocumentDo) Session(config *gorm.Session) IApiDocumentDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a apiDocumentDo) Clauses(conds ...clause.Expression) IApiDocumentDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a apiDocumentDo) Returning(value interface{}, columns ...string) IApiDocumentDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a apiDocumentDo) Not(conds ...gen.Condition) IApiDocumentDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a apiDocumentDo) Or(conds ...gen.Condition) IApiDocumentDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a apiDocumentDo) Select(conds ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a apiDocumentDo) Where(conds ...gen.Condition) IApiDocumentDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a apiDocumentDo) Order(conds ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a apiDocumentDo) Distinct(cols ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a apiDocumentDo) Omit(cols ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a apiDocumentDo) Join(table schema.Tabler, on ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a apiDocumentDo) LeftJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a apiDocumentDo) RightJoin(table schema.Tabler, on ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a apiDocumentDo) Group(cols ...field.Expr) IApiDocumentDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a apiDocumentDo) Having(conds ...gen.Condition) IApiDocumentDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a apiDocumentDo) Limit(limit int) IApiDocumentDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a apiDocumentDo) Offset(offset int) IApiDocumentDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a apiDocumentDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDocumentDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a apiDocumentDo) Unscoped() IApiDocumentDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a apiDocumentDo) Create(values ...*entity.ApiDocument) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a apiDocumentDo) CreateInBatches(values []*entity.ApiDocument, batchSize int) error {
+	return a.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (a apiDocumentDo) Save(values ...*entity.ApiDocument) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a apiDocumentDo) First() (*entity.ApiDocument, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.ApiDocument), nil
+	}
+}
+
+func (a apiDocumentDo) Take() (*entity.ApiDocument, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.ApiDocument), nil
+	}
+}
+
+func (a apiDocumentDo) Last() (*entity.ApiDocument, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.ApiDocument), nil
+	}
+}
+
+func (a apiDocumentDo) Find() ([]*entity.ApiDocument, error) {
+	result, err := a.DO.Find()
+	return result.([]*entity.ApiDocument), err
+}
+
+func (a apiDocumentDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.ApiDocument, err error) {
+	buf := make([]*entity.ApiDocument, 0, batchSize)
+	err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (a apiDocumentDo) FindInBatches(result *[]*entity.ApiDocument, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a apiDocumentDo) Attrs(attrs ...field.AssignExpr) IApiDocumentDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a apiDocumentDo) Assign(attrs ...field.AssignExpr) IApiDocumentDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a apiDocumentDo) Joins(fields ...field.RelationField) IApiDocumentDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a apiDocumentDo) Preload(fields ...field.RelationField) IApiDocumentDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a apiDocumentDo) FirstOrInit() (*entity.ApiDocument, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.ApiDocument), nil
+	}
+}
+
+func (a apiDocumentDo) FirstOrCreate() (*entity.ApiDocument, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.ApiDocument), nil
+	}
+}
+
+func (a apiDocumentDo) FindByPage(offset int, limit int) (result []*entity.ApiDocument, count int64, err error) {
+	result, err = a.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = a.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (a apiDocumentDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = a.Count()
+	if err != nil {
+		return
+	}
+
+	err = a.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (a apiDocumentDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a apiDocumentDo) Delete(models ...*entity.ApiDocument) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+func (a *apiDocumentDo) withDO(do gen.Dao) *apiDocumentDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}

internal/dao/apis.gen.go

@@ -0,0 +1,424 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dao
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"leafdev.top/Leaf/api-platform/internal/entity"
+)
+
+func newApi(db *gorm.DB, opts ...gen.DOOption) api {
+	_api := api{}
+
+	_api.apiDo.UseDB(db, opts...)
+	_api.apiDo.UseModel(&entity.Api{})
+
+	tableName := _api.apiDo.TableName()
+	_api.ALL = field.NewAsterisk(tableName)
+	_api.Id = field.NewUint(tableName, "id")
+	_api.CreatedAt = field.NewTime(tableName, "created_at")
+	_api.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_api.Name = field.NewString(tableName, "name")
+	_api.Description = field.NewString(tableName, "description")
+	_api.BackendUrl = field.NewString(tableName, "backend_url")
+	_api.AuthToken = field.NewString(tableName, "auth_token")
+	_api.OwnershipVerifiedAt = field.NewTime(tableName, "ownership_verified_at")
+	_api.OwnershipVerificationToken = field.NewString(tableName, "ownership_verification_token")
+	_api.UserId = field.NewString(tableName, "user_id")
+	_api.Status = field.NewString(tableName, "status")
+	_api.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_api.fillFieldMap()
+
+	return _api
+}
+
+type api struct {
+	apiDo
+
+	ALL                        field.Asterisk
+	Id                         field.Uint
+	CreatedAt                  field.Time
+	UpdatedAt                  field.Time
+	Name                       field.String
+	Description                field.String
+	BackendUrl                 field.String
+	AuthToken                  field.String
+	OwnershipVerifiedAt        field.Time
+	OwnershipVerificationToken field.String
+	UserId                     field.String
+	Status                     field.String
+	DeletedAt                  field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (a api) Table(newTableName string) *api {
+	a.apiDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a api) As(alias string) *api {
+	a.apiDo.DO = *(a.apiDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *api) updateTableName(table string) *api {
+	a.ALL = field.NewAsterisk(table)
+	a.Id = field.NewUint(table, "id")
+	a.CreatedAt = field.NewTime(table, "created_at")
+	a.UpdatedAt = field.NewTime(table, "updated_at")
+	a.Name = field.NewString(table, "name")
+	a.Description = field.NewString(table, "description")
+	a.BackendUrl = field.NewString(table, "backend_url")
+	a.AuthToken = field.NewString(table, "auth_token")
+	a.OwnershipVerifiedAt = field.NewTime(table, "ownership_verified_at")
+	a.OwnershipVerificationToken = field.NewString(table, "ownership_verification_token")
+	a.UserId = field.NewString(table, "user_id")
+	a.Status = field.NewString(table, "status")
+	a.DeletedAt = field.NewField(table, "deleted_at")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *api) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := a.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (a *api) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 12)
+	a.fieldMap["id"] = a.Id
+	a.fieldMap["created_at"] = a.CreatedAt
+	a.fieldMap["updated_at"] = a.UpdatedAt
+	a.fieldMap["name"] = a.Name
+	a.fieldMap["description"] = a.Description
+	a.fieldMap["backend_url"] = a.BackendUrl
+	a.fieldMap["auth_token"] = a.AuthToken
+	a.fieldMap["ownership_verified_at"] = a.OwnershipVerifiedAt
+	a.fieldMap["ownership_verification_token"] = a.OwnershipVerificationToken
+	a.fieldMap["user_id"] = a.UserId
+	a.fieldMap["status"] = a.Status
+	a.fieldMap["deleted_at"] = a.DeletedAt
+}
+
+func (a api) clone(db *gorm.DB) api {
+	a.apiDo.ReplaceConnPool(db.Statement.ConnPool)
+	return a
+}
+
+func (a api) replaceDB(db *gorm.DB) api {
+	a.apiDo.ReplaceDB(db)
+	return a
+}
+
+type apiDo struct{ gen.DO }
+
+type IApiDo interface {
+	gen.SubQuery
+	Debug() IApiDo
+	WithContext(ctx context.Context) IApiDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IApiDo
+	WriteDB() IApiDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IApiDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IApiDo
+	Not(conds ...gen.Condition) IApiDo
+	Or(conds ...gen.Condition) IApiDo
+	Select(conds ...field.Expr) IApiDo
+	Where(conds ...gen.Condition) IApiDo
+	Order(conds ...field.Expr) IApiDo
+	Distinct(cols ...field.Expr) IApiDo
+	Omit(cols ...field.Expr) IApiDo
+	Join(table schema.Tabler, on ...field.Expr) IApiDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IApiDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IApiDo
+	Group(cols ...field.Expr) IApiDo
+	Having(conds ...gen.Condition) IApiDo
+	Limit(limit int) IApiDo
+	Offset(offset int) IApiDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDo
+	Unscoped() IApiDo
+	Create(values ...*entity.Api) error
+	CreateInBatches(values []*entity.Api, batchSize int) error
+	Save(values ...*entity.Api) error
+	First() (*entity.Api, error)
+	Take() (*entity.Api, error)
+	Last() (*entity.Api, error)
+	Find() ([]*entity.Api, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error)
+	FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Api) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IApiDo
+	Assign(attrs ...field.AssignExpr) IApiDo
+	Joins(fields ...field.RelationField) IApiDo
+	Preload(fields ...field.RelationField) IApiDo
+	FirstOrInit() (*entity.Api, error)
+	FirstOrCreate() (*entity.Api, error)
+	FindByPage(offset int, limit int) (result []*entity.Api, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IApiDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (a apiDo) Debug() IApiDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a apiDo) WithContext(ctx context.Context) IApiDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a apiDo) ReadDB() IApiDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a apiDo) WriteDB() IApiDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a apiDo) Session(config *gorm.Session) IApiDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a apiDo) Clauses(conds ...clause.Expression) IApiDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a apiDo) Returning(value interface{}, columns ...string) IApiDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a apiDo) Not(conds ...gen.Condition) IApiDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a apiDo) Or(conds ...gen.Condition) IApiDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a apiDo) Select(conds ...field.Expr) IApiDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a apiDo) Where(conds ...gen.Condition) IApiDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a apiDo) Order(conds ...field.Expr) IApiDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a apiDo) Distinct(cols ...field.Expr) IApiDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a apiDo) Omit(cols ...field.Expr) IApiDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a apiDo) Join(table schema.Tabler, on ...field.Expr) IApiDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a apiDo) LeftJoin(table schema.Tabler, on ...field.Expr) IApiDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a apiDo) RightJoin(table schema.Tabler, on ...field.Expr) IApiDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a apiDo) Group(cols ...field.Expr) IApiDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a apiDo) Having(conds ...gen.Condition) IApiDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a apiDo) Limit(limit int) IApiDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a apiDo) Offset(offset int) IApiDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a apiDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IApiDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a apiDo) Unscoped() IApiDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a apiDo) Create(values ...*entity.Api) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a apiDo) CreateInBatches(values []*entity.Api, batchSize int) error {
+	return a.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (a apiDo) Save(values ...*entity.Api) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a apiDo) First() (*entity.Api, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Api), nil
+	}
+}
+
+func (a apiDo) Take() (*entity.Api, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Api), nil
+	}
+}
+
+func (a apiDo) Last() (*entity.Api, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Api), nil
+	}
+}
+
+func (a apiDo) Find() ([]*entity.Api, error) {
+	result, err := a.DO.Find()
+	return result.([]*entity.Api), err
+}
+
+func (a apiDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error) {
+	buf := make([]*entity.Api, 0, batchSize)
+	err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (a apiDo) FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a apiDo) Attrs(attrs ...field.AssignExpr) IApiDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a apiDo) Assign(attrs ...field.AssignExpr) IApiDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a apiDo) Joins(fields ...field.RelationField) IApiDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a apiDo) Preload(fields ...field.RelationField) IApiDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a apiDo) FirstOrInit() (*entity.Api, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Api), nil
+	}
+}
+
+func (a apiDo) FirstOrCreate() (*entity.Api, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Api), nil
+	}
+}
+
+func (a apiDo) FindByPage(offset int, limit int) (result []*entity.Api, count int64, err error) {
+	result, err = a.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = a.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (a apiDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = a.Count()
+	if err != nil {
+		return
+	}
+
+	err = a.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (a apiDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a apiDo) Delete(models ...*entity.Api) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+func (a *apiDo) withDO(do gen.Dao) *apiDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}

internal/dao/gen.go

@@ -17,25 +17,49 @@ import (
 
 var (
 	Q           = new(Query)
-	User *user
+	Api         *api
+	ApiDocument *apiDocument
+	Order       *order
+	OrderItem   *orderItem
+	Packages    *packages
+	PromoCode   *promoCode
+	UserPackage *userPackage
 )
 
 func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	*Q = *Use(db, opts...)
-	User = &Q.User
+	Api = &Q.Api
+	ApiDocument = &Q.ApiDocument
+	Order = &Q.Order
+	OrderItem = &Q.OrderItem
+	Packages = &Q.Packages
+	PromoCode = &Q.PromoCode
+	UserPackage = &Q.UserPackage
 }
 
 func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 	return &Query{
 		db:          db,
-		User: newUser(db, opts...),
+		Api:         newApi(db, opts...),
+		ApiDocument: newApiDocument(db, opts...),
+		Order:       newOrder(db, opts...),
+		OrderItem:   newOrderItem(db, opts...),
+		Packages:    newPackages(db, opts...),
+		PromoCode:   newPromoCode(db, opts...),
+		UserPackage: newUserPackage(db, opts...),
 	}
 }
 
 type Query struct {
 	db *gorm.DB
 
-	User user
+	Api         api
+	ApiDocument apiDocument
+	Order       order
+	OrderItem   orderItem
+	Packages    packages
+	PromoCode   promoCode
+	UserPackage userPackage
 }
 
 func (q *Query) Available() bool { return q.db != nil }
@@ -43,7 +67,13 @@ func (q *Query) Available() bool { return q.db != nil }
 func (q *Query) clone(db *gorm.DB) *Query {
 	return &Query{
 		db:          db,
-		User: q.User.clone(db),
+		Api:         q.Api.clone(db),
+		ApiDocument: q.ApiDocument.clone(db),
+		Order:       q.Order.clone(db),
+		OrderItem:   q.OrderItem.clone(db),
+		Packages:    q.Packages.clone(db),
+		PromoCode:   q.PromoCode.clone(db),
+		UserPackage: q.UserPackage.clone(db),
 	}
 }
 
@@ -58,17 +88,35 @@ func (q *Query) WriteDB() *Query {
 func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 	return &Query{
 		db:          db,
-		User: q.User.replaceDB(db),
+		Api:         q.Api.replaceDB(db),
+		ApiDocument: q.ApiDocument.replaceDB(db),
+		Order:       q.Order.replaceDB(db),
+		OrderItem:   q.OrderItem.replaceDB(db),
+		Packages:    q.Packages.replaceDB(db),
+		PromoCode:   q.PromoCode.replaceDB(db),
+		UserPackage: q.UserPackage.replaceDB(db),
 	}
 }
 
 type queryCtx struct {
-	User IUserDo
+	Api         IApiDo
+	ApiDocument IApiDocumentDo
+	Order       IOrderDo
+	OrderItem   IOrderItemDo
+	Packages    IPackagesDo
+	PromoCode   IPromoCodeDo
+	UserPackage IUserPackageDo
 }
 
 func (q *Query) WithContext(ctx context.Context) *queryCtx {
 	return &queryCtx{
-		User: q.User.WithContext(ctx),
+		Api:         q.Api.WithContext(ctx),
+		ApiDocument: q.ApiDocument.WithContext(ctx),
+		Order:       q.Order.WithContext(ctx),
+		OrderItem:   q.OrderItem.WithContext(ctx),
+		Packages:    q.Packages.WithContext(ctx),
+		PromoCode:   q.PromoCode.WithContext(ctx),
+		UserPackage: q.UserPackage.WithContext(ctx),
 	}
 }
 

internal/dao/order_items.gen.go

@@ -0,0 +1,571 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dao
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"leafdev.top/Leaf/api-platform/internal/entity"
+)
+
+func newOrderItem(db *gorm.DB, opts ...gen.DOOption) orderItem {
+	_orderItem := orderItem{}
+
+	_orderItem.orderItemDo.UseDB(db, opts...)
+	_orderItem.orderItemDo.UseModel(&entity.OrderItem{})
+
+	tableName := _orderItem.orderItemDo.TableName()
+	_orderItem.ALL = field.NewAsterisk(tableName)
+	_orderItem.Id = field.NewUint(tableName, "id")
+	_orderItem.CreatedAt = field.NewTime(tableName, "created_at")
+	_orderItem.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_orderItem.OrderId = field.NewUint(tableName, "order_id")
+	_orderItem.PackageId = field.NewUint(tableName, "package_id")
+	_orderItem.Order = orderItemBelongsToOrder{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Order", "entity.Order"),
+		PromoCode: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Order.PromoCode", "entity.PromoCode"),
+		},
+	}
+
+	_orderItem.Package = orderItemBelongsToPackage{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Package", "entity.Packages"),
+		Api: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Package.Api", "entity.Api"),
+		},
+	}
+
+	_orderItem.fillFieldMap()
+
+	return _orderItem
+}
+
+type orderItem struct {
+	orderItemDo
+
+	ALL       field.Asterisk
+	Id        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	OrderId   field.Uint
+	PackageId field.Uint
+	Order     orderItemBelongsToOrder
+
+	Package orderItemBelongsToPackage
+
+	fieldMap map[string]field.Expr
+}
+
+func (o orderItem) Table(newTableName string) *orderItem {
+	o.orderItemDo.UseTable(newTableName)
+	return o.updateTableName(newTableName)
+}
+
+func (o orderItem) As(alias string) *orderItem {
+	o.orderItemDo.DO = *(o.orderItemDo.As(alias).(*gen.DO))
+	return o.updateTableName(alias)
+}
+
+func (o *orderItem) updateTableName(table string) *orderItem {
+	o.ALL = field.NewAsterisk(table)
+	o.Id = field.NewUint(table, "id")
+	o.CreatedAt = field.NewTime(table, "created_at")
+	o.UpdatedAt = field.NewTime(table, "updated_at")
+	o.OrderId = field.NewUint(table, "order_id")
+	o.PackageId = field.NewUint(table, "package_id")
+
+	o.fillFieldMap()
+
+	return o
+}
+
+func (o *orderItem) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := o.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (o *orderItem) fillFieldMap() {
+	o.fieldMap = make(map[string]field.Expr, 7)
+	o.fieldMap["id"] = o.Id
+	o.fieldMap["created_at"] = o.CreatedAt
+	o.fieldMap["updated_at"] = o.UpdatedAt
+	o.fieldMap["order_id"] = o.OrderId
+	o.fieldMap["package_id"] = o.PackageId
+
+}
+
+func (o orderItem) clone(db *gorm.DB) orderItem {
+	o.orderItemDo.ReplaceConnPool(db.Statement.ConnPool)
+	return o
+}
+
+func (o orderItem) replaceDB(db *gorm.DB) orderItem {
+	o.orderItemDo.ReplaceDB(db)
+	return o
+}
+
+type orderItemBelongsToOrder struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	PromoCode struct {
+		field.RelationField
+	}
+}
+
+func (a orderItemBelongsToOrder) Where(conds ...field.Expr) *orderItemBelongsToOrder {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a orderItemBelongsToOrder) WithContext(ctx context.Context) *orderItemBelongsToOrder {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a orderItemBelongsToOrder) Session(session *gorm.Session) *orderItemBelongsToOrder {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a orderItemBelongsToOrder) Model(m *entity.OrderItem) *orderItemBelongsToOrderTx {
+	return &orderItemBelongsToOrderTx{a.db.Model(m).Association(a.Name())}
+}
+
+type orderItemBelongsToOrderTx struct{ tx *gorm.Association }
+
+func (a orderItemBelongsToOrderTx) Find() (result *entity.Order, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a orderItemBelongsToOrderTx) Append(values ...*entity.Order) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a orderItemBelongsToOrderTx) Replace(values ...*entity.Order) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a orderItemBelongsToOrderTx) Delete(values ...*entity.Order) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a orderItemBelongsToOrderTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a orderItemBelongsToOrderTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type orderItemBelongsToPackage struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Api struct {
+		field.RelationField
+	}
+}
+
+func (a orderItemBelongsToPackage) Where(conds ...field.Expr) *orderItemBelongsToPackage {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a orderItemBelongsToPackage) WithContext(ctx context.Context) *orderItemBelongsToPackage {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a orderItemBelongsToPackage) Session(session *gorm.Session) *orderItemBelongsToPackage {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a orderItemBelongsToPackage) Model(m *entity.OrderItem) *orderItemBelongsToPackageTx {
+	return &orderItemBelongsToPackageTx{a.db.Model(m).Association(a.Name())}
+}
+
+type orderItemBelongsToPackageTx struct{ tx *gorm.Association }
+
+func (a orderItemBelongsToPackageTx) Find() (result *entity.Packages, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a orderItemBelongsToPackageTx) Append(values ...*entity.Packages) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a orderItemBelongsToPackageTx) Replace(values ...*entity.Packages) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a orderItemBelongsToPackageTx) Delete(values ...*entity.Packages) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a orderItemBelongsToPackageTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a orderItemBelongsToPackageTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type orderItemDo struct{ gen.DO }
+
+type IOrderItemDo interface {
+	gen.SubQuery
+	Debug() IOrderItemDo
+	WithContext(ctx context.Context) IOrderItemDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IOrderItemDo
+	WriteDB() IOrderItemDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IOrderItemDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IOrderItemDo
+	Not(conds ...gen.Condition) IOrderItemDo
+	Or(conds ...gen.Condition) IOrderItemDo
+	Select(conds ...field.Expr) IOrderItemDo
+	Where(conds ...gen.Condition) IOrderItemDo
+	Order(conds ...field.Expr) IOrderItemDo
+	Distinct(cols ...field.Expr) IOrderItemDo
+	Omit(cols ...field.Expr) IOrderItemDo
+	Join(table schema.Tabler, on ...field.Expr) IOrderItemDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo
+	Group(cols ...field.Expr) IOrderItemDo
+	Having(conds ...gen.Condition) IOrderItemDo
+	Limit(limit int) IOrderItemDo
+	Offset(offset int) IOrderItemDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderItemDo
+	Unscoped() IOrderItemDo
+	Create(values ...*entity.OrderItem) error
+	CreateInBatches(values []*entity.OrderItem, batchSize int) error
+	Save(values ...*entity.OrderItem) error
+	First() (*entity.OrderItem, error)
+	Take() (*entity.OrderItem, error)
+	Last() (*entity.OrderItem, error)
+	Find() ([]*entity.OrderItem, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.OrderItem, err error)
+	FindInBatches(result *[]*entity.OrderItem, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.OrderItem) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IOrderItemDo
+	Assign(attrs ...field.AssignExpr) IOrderItemDo
+	Joins(fields ...field.RelationField) IOrderItemDo
+	Preload(fields ...field.RelationField) IOrderItemDo
+	FirstOrInit() (*entity.OrderItem, error)
+	FirstOrCreate() (*entity.OrderItem, error)
+	FindByPage(offset int, limit int) (result []*entity.OrderItem, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IOrderItemDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (o orderItemDo) Debug() IOrderItemDo {
+	return o.withDO(o.DO.Debug())
+}
+
+func (o orderItemDo) WithContext(ctx context.Context) IOrderItemDo {
+	return o.withDO(o.DO.WithContext(ctx))
+}
+
+func (o orderItemDo) ReadDB() IOrderItemDo {
+	return o.Clauses(dbresolver.Read)
+}
+
+func (o orderItemDo) WriteDB() IOrderItemDo {
+	return o.Clauses(dbresolver.Write)
+}
+
+func (o orderItemDo) Session(config *gorm.Session) IOrderItemDo {
+	return o.withDO(o.DO.Session(config))
+}
+
+func (o orderItemDo) Clauses(conds ...clause.Expression) IOrderItemDo {
+	return o.withDO(o.DO.Clauses(conds...))
+}
+
+func (o orderItemDo) Returning(value interface{}, columns ...string) IOrderItemDo {
+	return o.withDO(o.DO.Returning(value, columns...))
+}
+
+func (o orderItemDo) Not(conds ...gen.Condition) IOrderItemDo {
+	return o.withDO(o.DO.Not(conds...))
+}
+
+func (o orderItemDo) Or(conds ...gen.Condition) IOrderItemDo {
+	return o.withDO(o.DO.Or(conds...))
+}
+
+func (o orderItemDo) Select(conds ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.Select(conds...))
+}
+
+func (o orderItemDo) Where(conds ...gen.Condition) IOrderItemDo {
+	return o.withDO(o.DO.Where(conds...))
+}
+
+func (o orderItemDo) Order(conds ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.Order(conds...))
+}
+
+func (o orderItemDo) Distinct(cols ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.Distinct(cols...))
+}
+
+func (o orderItemDo) Omit(cols ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.Omit(cols...))
+}
+
+func (o orderItemDo) Join(table schema.Tabler, on ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.Join(table, on...))
+}
+
+func (o orderItemDo) LeftJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.LeftJoin(table, on...))
+}
+
+func (o orderItemDo) RightJoin(table schema.Tabler, on ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.RightJoin(table, on...))
+}
+
+func (o orderItemDo) Group(cols ...field.Expr) IOrderItemDo {
+	return o.withDO(o.DO.Group(cols...))
+}
+
+func (o orderItemDo) Having(conds ...gen.Condition) IOrderItemDo {
+	return o.withDO(o.DO.Having(conds...))
+}
+
+func (o orderItemDo) Limit(limit int) IOrderItemDo {
+	return o.withDO(o.DO.Limit(limit))
+}
+
+func (o orderItemDo) Offset(offset int) IOrderItemDo {
+	return o.withDO(o.DO.Offset(offset))
+}
+
+func (o orderItemDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderItemDo {
+	return o.withDO(o.DO.Scopes(funcs...))
+}
+
+func (o orderItemDo) Unscoped() IOrderItemDo {
+	return o.withDO(o.DO.Unscoped())
+}
+
+func (o orderItemDo) Create(values ...*entity.OrderItem) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return o.DO.Create(values)
+}
+
+func (o orderItemDo) CreateInBatches(values []*entity.OrderItem, batchSize int) error {
+	return o.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (o orderItemDo) Save(values ...*entity.OrderItem) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return o.DO.Save(values)
+}
+
+func (o orderItemDo) First() (*entity.OrderItem, error) {
+	if result, err := o.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.OrderItem), nil
+	}
+}
+
+func (o orderItemDo) Take() (*entity.OrderItem, error) {
+	if result, err := o.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.OrderItem), nil
+	}
+}
+
+func (o orderItemDo) Last() (*entity.OrderItem, error) {
+	if result, err := o.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.OrderItem), nil
+	}
+}
+
+func (o orderItemDo) Find() ([]*entity.OrderItem, error) {
+	result, err := o.DO.Find()
+	return result.([]*entity.OrderItem), err
+}
+
+func (o orderItemDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.OrderItem, err error) {
+	buf := make([]*entity.OrderItem, 0, batchSize)
+	err = o.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (o orderItemDo) FindInBatches(result *[]*entity.OrderItem, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return o.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (o orderItemDo) Attrs(attrs ...field.AssignExpr) IOrderItemDo {
+	return o.withDO(o.DO.Attrs(attrs...))
+}
+
+func (o orderItemDo) Assign(attrs ...field.AssignExpr) IOrderItemDo {
+	return o.withDO(o.DO.Assign(attrs...))
+}
+
+func (o orderItemDo) Joins(fields ...field.RelationField) IOrderItemDo {
+	for _, _f := range fields {
+		o = *o.withDO(o.DO.Joins(_f))
+	}
+	return &o
+}
+
+func (o orderItemDo) Preload(fields ...field.RelationField) IOrderItemDo {
+	for _, _f := range fields {
+		o = *o.withDO(o.DO.Preload(_f))
+	}
+	return &o
+}
+
+func (o orderItemDo) FirstOrInit() (*entity.OrderItem, error) {
+	if result, err := o.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.OrderItem), nil
+	}
+}
+
+func (o orderItemDo) FirstOrCreate() (*entity.OrderItem, error) {
+	if result, err := o.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.OrderItem), nil
+	}
+}
+
+func (o orderItemDo) FindByPage(offset int, limit int) (result []*entity.OrderItem, count int64, err error) {
+	result, err = o.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = o.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (o orderItemDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = o.Count()
+	if err != nil {
+		return
+	}
+
+	err = o.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (o orderItemDo) Scan(result interface{}) (err error) {
+	return o.DO.Scan(result)
+}
+
+func (o orderItemDo) Delete(models ...*entity.OrderItem) (result gen.ResultInfo, err error) {
+	return o.DO.Delete(models)
+}
+
+func (o *orderItemDo) withDO(do gen.Dao) *orderItemDo {
+	o.DO = *do.(*gen.DO)
+	return o
+}

internal/dao/orders.gen.go

@@ -0,0 +1,482 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dao
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"leafdev.top/Leaf/api-platform/internal/entity"
+)
+
+func newOrder(db *gorm.DB, opts ...gen.DOOption) order {
+	_order := order{}
+
+	_order.orderDo.UseDB(db, opts...)
+	_order.orderDo.UseModel(&entity.Order{})
+
+	tableName := _order.orderDo.TableName()
+	_order.ALL = field.NewAsterisk(tableName)
+	_order.Id = field.NewUint(tableName, "id")
+	_order.CreatedAt = field.NewTime(tableName, "created_at")
+	_order.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_order.UserId = field.NewString(tableName, "user_id")
+	_order.PromoCodeId = field.NewUint(tableName, "promo_code_id")
+	_order.Price = field.NewFloat64(tableName, "price")
+	_order.OrderDate = field.NewTime(tableName, "order_date")
+	_order.PromoCode = orderBelongsToPromoCode{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("PromoCode", "entity.PromoCode"),
+	}
+
+	_order.fillFieldMap()
+
+	return _order
+}
+
+type order struct {
+	orderDo
+
+	ALL         field.Asterisk
+	Id          field.Uint
+	CreatedAt   field.Time
+	UpdatedAt   field.Time
+	UserId      field.String
+	PromoCodeId field.Uint
+	Price       field.Float64
+	OrderDate   field.Time
+	PromoCode   orderBelongsToPromoCode
+
+	fieldMap map[string]field.Expr
+}
+
+func (o order) Table(newTableName string) *order {
+	o.orderDo.UseTable(newTableName)
+	return o.updateTableName(newTableName)
+}
+
+func (o order) As(alias string) *order {
+	o.orderDo.DO = *(o.orderDo.As(alias).(*gen.DO))
+	return o.updateTableName(alias)
+}
+
+func (o *order) updateTableName(table string) *order {
+	o.ALL = field.NewAsterisk(table)
+	o.Id = field.NewUint(table, "id")
+	o.CreatedAt = field.NewTime(table, "created_at")
+	o.UpdatedAt = field.NewTime(table, "updated_at")
+	o.UserId = field.NewString(table, "user_id")
+	o.PromoCodeId = field.NewUint(table, "promo_code_id")
+	o.Price = field.NewFloat64(table, "price")
+	o.OrderDate = field.NewTime(table, "order_date")
+
+	o.fillFieldMap()
+
+	return o
+}
+
+func (o *order) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := o.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (o *order) fillFieldMap() {
+	o.fieldMap = make(map[string]field.Expr, 8)
+	o.fieldMap["id"] = o.Id
+	o.fieldMap["created_at"] = o.CreatedAt
+	o.fieldMap["updated_at"] = o.UpdatedAt
+	o.fieldMap["user_id"] = o.UserId
+	o.fieldMap["promo_code_id"] = o.PromoCodeId
+	o.fieldMap["price"] = o.Price
+	o.fieldMap["order_date"] = o.OrderDate
+
+}
+
+func (o order) clone(db *gorm.DB) order {
+	o.orderDo.ReplaceConnPool(db.Statement.ConnPool)
+	return o
+}
+
+func (o order) replaceDB(db *gorm.DB) order {
+	o.orderDo.ReplaceDB(db)
+	return o
+}
+
+type orderBelongsToPromoCode struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a orderBelongsToPromoCode) Where(conds ...field.Expr) *orderBelongsToPromoCode {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a orderBelongsToPromoCode) WithContext(ctx context.Context) *orderBelongsToPromoCode {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a orderBelongsToPromoCode) Session(session *gorm.Session) *orderBelongsToPromoCode {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a orderBelongsToPromoCode) Model(m *entity.Order) *orderBelongsToPromoCodeTx {
+	return &orderBelongsToPromoCodeTx{a.db.Model(m).Association(a.Name())}
+}
+
+type orderBelongsToPromoCodeTx struct{ tx *gorm.Association }
+
+func (a orderBelongsToPromoCodeTx) Find() (result *entity.PromoCode, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a orderBelongsToPromoCodeTx) Append(values ...*entity.PromoCode) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a orderBelongsToPromoCodeTx) Replace(values ...*entity.PromoCode) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a orderBelongsToPromoCodeTx) Delete(values ...*entity.PromoCode) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a orderBelongsToPromoCodeTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a orderBelongsToPromoCodeTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type orderDo struct{ gen.DO }
+
+type IOrderDo interface {
+	gen.SubQuery
+	Debug() IOrderDo
+	WithContext(ctx context.Context) IOrderDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IOrderDo
+	WriteDB() IOrderDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IOrderDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IOrderDo
+	Not(conds ...gen.Condition) IOrderDo
+	Or(conds ...gen.Condition) IOrderDo
+	Select(conds ...field.Expr) IOrderDo
+	Where(conds ...gen.Condition) IOrderDo
+	Order(conds ...field.Expr) IOrderDo
+	Distinct(cols ...field.Expr) IOrderDo
+	Omit(cols ...field.Expr) IOrderDo
+	Join(table schema.Tabler, on ...field.Expr) IOrderDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IOrderDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IOrderDo
+	Group(cols ...field.Expr) IOrderDo
+	Having(conds ...gen.Condition) IOrderDo
+	Limit(limit int) IOrderDo
+	Offset(offset int) IOrderDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderDo
+	Unscoped() IOrderDo
+	Create(values ...*entity.Order) error
+	CreateInBatches(values []*entity.Order, batchSize int) error
+	Save(values ...*entity.Order) error
+	First() (*entity.Order, error)
+	Take() (*entity.Order, error)
+	Last() (*entity.Order, error)
+	Find() ([]*entity.Order, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Order, err error)
+	FindInBatches(result *[]*entity.Order, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Order) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IOrderDo
+	Assign(attrs ...field.AssignExpr) IOrderDo
+	Joins(fields ...field.RelationField) IOrderDo
+	Preload(fields ...field.RelationField) IOrderDo
+	FirstOrInit() (*entity.Order, error)
+	FirstOrCreate() (*entity.Order, error)
+	FindByPage(offset int, limit int) (result []*entity.Order, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IOrderDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (o orderDo) Debug() IOrderDo {
+	return o.withDO(o.DO.Debug())
+}
+
+func (o orderDo) WithContext(ctx context.Context) IOrderDo {
+	return o.withDO(o.DO.WithContext(ctx))
+}
+
+func (o orderDo) ReadDB() IOrderDo {
+	return o.Clauses(dbresolver.Read)
+}
+
+func (o orderDo) WriteDB() IOrderDo {
+	return o.Clauses(dbresolver.Write)
+}
+
+func (o orderDo) Session(config *gorm.Session) IOrderDo {
+	return o.withDO(o.DO.Session(config))
+}
+
+func (o orderDo) Clauses(conds ...clause.Expression) IOrderDo {
+	return o.withDO(o.DO.Clauses(conds...))
+}
+
+func (o orderDo) Returning(value interface{}, columns ...string) IOrderDo {
+	return o.withDO(o.DO.Returning(value, columns...))
+}
+
+func (o orderDo) Not(conds ...gen.Condition) IOrderDo {
+	return o.withDO(o.DO.Not(conds...))
+}
+
+func (o orderDo) Or(conds ...gen.Condition) IOrderDo {
+	return o.withDO(o.DO.Or(conds...))
+}
+
+func (o orderDo) Select(conds ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.Select(conds...))
+}
+
+func (o orderDo) Where(conds ...gen.Condition) IOrderDo {
+	return o.withDO(o.DO.Where(conds...))
+}
+
+func (o orderDo) Order(conds ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.Order(conds...))
+}
+
+func (o orderDo) Distinct(cols ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.Distinct(cols...))
+}
+
+func (o orderDo) Omit(cols ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.Omit(cols...))
+}
+
+func (o orderDo) Join(table schema.Tabler, on ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.Join(table, on...))
+}
+
+func (o orderDo) LeftJoin(table schema.Tabler, on ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.LeftJoin(table, on...))
+}
+
+func (o orderDo) RightJoin(table schema.Tabler, on ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.RightJoin(table, on...))
+}
+
+func (o orderDo) Group(cols ...field.Expr) IOrderDo {
+	return o.withDO(o.DO.Group(cols...))
+}
+
+func (o orderDo) Having(conds ...gen.Condition) IOrderDo {
+	return o.withDO(o.DO.Having(conds...))
+}
+
+func (o orderDo) Limit(limit int) IOrderDo {
+	return o.withDO(o.DO.Limit(limit))
+}
+
+func (o orderDo) Offset(offset int) IOrderDo {
+	return o.withDO(o.DO.Offset(offset))
+}
+
+func (o orderDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IOrderDo {
+	return o.withDO(o.DO.Scopes(funcs...))
+}
+
+func (o orderDo) Unscoped() IOrderDo {
+	return o.withDO(o.DO.Unscoped())
+}
+
+func (o orderDo) Create(values ...*entity.Order) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return o.DO.Create(values)
+}
+
+func (o orderDo) CreateInBatches(values []*entity.Order, batchSize int) error {
+	return o.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (o orderDo) Save(values ...*entity.Order) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return o.DO.Save(values)
+}
+
+func (o orderDo) First() (*entity.Order, error) {
+	if result, err := o.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Order), nil
+	}
+}
+
+func (o orderDo) Take() (*entity.Order, error) {
+	if result, err := o.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Order), nil
+	}
+}
+
+func (o orderDo) Last() (*entity.Order, error) {
+	if result, err := o.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Order), nil
+	}
+}
+
+func (o orderDo) Find() ([]*entity.Order, error) {
+	result, err := o.DO.Find()
+	return result.([]*entity.Order), err
+}
+
+func (o orderDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Order, err error) {
+	buf := make([]*entity.Order, 0, batchSize)
+	err = o.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (o orderDo) FindInBatches(result *[]*entity.Order, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return o.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (o orderDo) Attrs(attrs ...field.AssignExpr) IOrderDo {
+	return o.withDO(o.DO.Attrs(attrs...))
+}
+
+func (o orderDo) Assign(attrs ...field.AssignExpr) IOrderDo {
+	return o.withDO(o.DO.Assign(attrs...))
+}
+
+func (o orderDo) Joins(fields ...field.RelationField) IOrderDo {
+	for _, _f := range fields {
+		o = *o.withDO(o.DO.Joins(_f))
+	}
+	return &o
+}
+
+func (o orderDo) Preload(fields ...field.RelationField) IOrderDo {
+	for _, _f := range fields {
+		o = *o.withDO(o.DO.Preload(_f))
+	}
+	return &o
+}
+
+func (o orderDo) FirstOrInit() (*entity.Order, error) {
+	if result, err := o.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Order), nil
+	}
+}
+
+func (o orderDo) FirstOrCreate() (*entity.Order, error) {
+	if result, err := o.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Order), nil
+	}
+}
+
+func (o orderDo) FindByPage(offset int, limit int) (result []*entity.Order, count int64, err error) {
+	result, err = o.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = o.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (o orderDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = o.Count()
+	if err != nil {
+		return
+	}
+
+	err = o.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (o orderDo) Scan(result interface{}) (err error) {
+	return o.DO.Scan(result)
+}
+
+func (o orderDo) Delete(models ...*entity.Order) (result gen.ResultInfo, err error) {
+	return o.DO.Delete(models)
+}
+
+func (o *orderDo) withDO(do gen.Dao) *orderDo {
+	o.DO = *do.(*gen.DO)
+	return o
+}

internal/dao/packages.gen.go

@@ -0,0 +1,510 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dao
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"leafdev.top/Leaf/api-platform/internal/entity"
+)
+
+func newPackages(db *gorm.DB, opts ...gen.DOOption) packages {
+	_packages := packages{}
+
+	_packages.packagesDo.UseDB(db, opts...)
+	_packages.packagesDo.UseModel(&entity.Packages{})
+
+	tableName := _packages.packagesDo.TableName()
+	_packages.ALL = field.NewAsterisk(tableName)
+	_packages.Id = field.NewUint(tableName, "id")
+	_packages.CreatedAt = field.NewTime(tableName, "created_at")
+	_packages.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_packages.Name = field.NewString(tableName, "name")
+	_packages.Description = field.NewString(tableName, "description")
+	_packages.ApiId = field.NewUint(tableName, "api_id")
+	_packages.Price = field.NewFloat64(tableName, "price")
+	_packages.IsHidden = field.NewBool(tableName, "is_hidden")
+	_packages.IsPublished = field.NewBool(tableName, "is_published")
+	_packages.CallLimit = field.NewInt64(tableName, "call_limit")
+	_packages.Duration = field.NewInt64(tableName, "duration")
+	_packages.IsTrial = field.NewBool(tableName, "is_trial")
+	_packages.PurchaseLimit = field.NewInt64(tableName, "purchase_limit")
+	_packages.DeletedAt = field.NewField(tableName, "deleted_at")
+	_packages.Api = packagesBelongsToApi{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Api", "entity.Api"),
+	}
+
+	_packages.fillFieldMap()
+
+	return _packages
+}
+
+type packages struct {
+	packagesDo
+
+	ALL           field.Asterisk
+	Id            field.Uint
+	CreatedAt     field.Time
+	UpdatedAt     field.Time
+	Name          field.String
+	Description   field.String
+	ApiId         field.Uint
+	Price         field.Float64
+	IsHidden      field.Bool
+	IsPublished   field.Bool
+	CallLimit     field.Int64
+	Duration      field.Int64
+	IsTrial       field.Bool
+	PurchaseLimit field.Int64
+	DeletedAt     field.Field
+	Api           packagesBelongsToApi
+
+	fieldMap map[string]field.Expr
+}
+
+func (p packages) Table(newTableName string) *packages {
+	p.packagesDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p packages) As(alias string) *packages {
+	p.packagesDo.DO = *(p.packagesDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *packages) updateTableName(table string) *packages {
+	p.ALL = field.NewAsterisk(table)
+	p.Id = field.NewUint(table, "id")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+	p.Name = field.NewString(table, "name")
+	p.Description = field.NewString(table, "description")
+	p.ApiId = field.NewUint(table, "api_id")
+	p.Price = field.NewFloat64(table, "price")
+	p.IsHidden = field.NewBool(table, "is_hidden")
+	p.IsPublished = field.NewBool(table, "is_published")
+	p.CallLimit = field.NewInt64(table, "call_limit")
+	p.Duration = field.NewInt64(table, "duration")
+	p.IsTrial = field.NewBool(table, "is_trial")
+	p.PurchaseLimit = field.NewInt64(table, "purchase_limit")
+	p.DeletedAt = field.NewField(table, "deleted_at")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *packages) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := p.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (p *packages) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 15)
+	p.fieldMap["id"] = p.Id
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+	p.fieldMap["name"] = p.Name
+	p.fieldMap["description"] = p.Description
+	p.fieldMap["api_id"] = p.ApiId
+	p.fieldMap["price"] = p.Price
+	p.fieldMap["is_hidden"] = p.IsHidden
+	p.fieldMap["is_published"] = p.IsPublished
+	p.fieldMap["call_limit"] = p.CallLimit
+	p.fieldMap["duration"] = p.Duration
+	p.fieldMap["is_trial"] = p.IsTrial
+	p.fieldMap["purchase_limit"] = p.PurchaseLimit
+	p.fieldMap["deleted_at"] = p.DeletedAt
+
+}
+
+func (p packages) clone(db *gorm.DB) packages {
+	p.packagesDo.ReplaceConnPool(db.Statement.ConnPool)
+	return p
+}
+
+func (p packages) replaceDB(db *gorm.DB) packages {
+	p.packagesDo.ReplaceDB(db)
+	return p
+}
+
+type packagesBelongsToApi struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a packagesBelongsToApi) Where(conds ...field.Expr) *packagesBelongsToApi {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a packagesBelongsToApi) WithContext(ctx context.Context) *packagesBelongsToApi {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a packagesBelongsToApi) Session(session *gorm.Session) *packagesBelongsToApi {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a packagesBelongsToApi) Model(m *entity.Packages) *packagesBelongsToApiTx {
+	return &packagesBelongsToApiTx{a.db.Model(m).Association(a.Name())}
+}
+
+type packagesBelongsToApiTx struct{ tx *gorm.Association }
+
+func (a packagesBelongsToApiTx) Find() (result *entity.Api, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a packagesBelongsToApiTx) Append(values ...*entity.Api) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a packagesBelongsToApiTx) Replace(values ...*entity.Api) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a packagesBelongsToApiTx) Delete(values ...*entity.Api) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a packagesBelongsToApiTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a packagesBelongsToApiTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type packagesDo struct{ gen.DO }
+
+type IPackagesDo interface {
+	gen.SubQuery
+	Debug() IPackagesDo
+	WithContext(ctx context.Context) IPackagesDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IPackagesDo
+	WriteDB() IPackagesDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IPackagesDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IPackagesDo
+	Not(conds ...gen.Condition) IPackagesDo
+	Or(conds ...gen.Condition) IPackagesDo
+	Select(conds ...field.Expr) IPackagesDo
+	Where(conds ...gen.Condition) IPackagesDo
+	Order(conds ...field.Expr) IPackagesDo
+	Distinct(cols ...field.Expr) IPackagesDo
+	Omit(cols ...field.Expr) IPackagesDo
+	Join(table schema.Tabler, on ...field.Expr) IPackagesDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IPackagesDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IPackagesDo
+	Group(cols ...field.Expr) IPackagesDo
+	Having(conds ...gen.Condition) IPackagesDo
+	Limit(limit int) IPackagesDo
+	Offset(offset int) IPackagesDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IPackagesDo
+	Unscoped() IPackagesDo
+	Create(values ...*entity.Packages) error
+	CreateInBatches(values []*entity.Packages, batchSize int) error
+	Save(values ...*entity.Packages) error
+	First() (*entity.Packages, error)
+	Take() (*entity.Packages, error)
+	Last() (*entity.Packages, error)
+	Find() ([]*entity.Packages, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Packages, err error)
+	FindInBatches(result *[]*entity.Packages, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Packages) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IPackagesDo
+	Assign(attrs ...field.AssignExpr) IPackagesDo
+	Joins(fields ...field.RelationField) IPackagesDo
+	Preload(fields ...field.RelationField) IPackagesDo
+	FirstOrInit() (*entity.Packages, error)
+	FirstOrCreate() (*entity.Packages, error)
+	FindByPage(offset int, limit int) (result []*entity.Packages, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IPackagesDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (p packagesDo) Debug() IPackagesDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p packagesDo) WithContext(ctx context.Context) IPackagesDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p packagesDo) ReadDB() IPackagesDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p packagesDo) WriteDB() IPackagesDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p packagesDo) Session(config *gorm.Session) IPackagesDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p packagesDo) Clauses(conds ...clause.Expression) IPackagesDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p packagesDo) Returning(value interface{}, columns ...string) IPackagesDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p packagesDo) Not(conds ...gen.Condition) IPackagesDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p packagesDo) Or(conds ...gen.Condition) IPackagesDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p packagesDo) Select(conds ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p packagesDo) Where(conds ...gen.Condition) IPackagesDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p packagesDo) Order(conds ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p packagesDo) Distinct(cols ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p packagesDo) Omit(cols ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p packagesDo) Join(table schema.Tabler, on ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p packagesDo) LeftJoin(table schema.Tabler, on ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p packagesDo) RightJoin(table schema.Tabler, on ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p packagesDo) Group(cols ...field.Expr) IPackagesDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p packagesDo) Having(conds ...gen.Condition) IPackagesDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p packagesDo) Limit(limit int) IPackagesDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p packagesDo) Offset(offset int) IPackagesDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p packagesDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IPackagesDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p packagesDo) Unscoped() IPackagesDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p packagesDo) Create(values ...*entity.Packages) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p packagesDo) CreateInBatches(values []*entity.Packages, batchSize int) error {
+	return p.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (p packagesDo) Save(values ...*entity.Packages) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p packagesDo) First() (*entity.Packages, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Packages), nil
+	}
+}
+
+func (p packagesDo) Take() (*entity.Packages, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Packages), nil
+	}
+}
+
+func (p packagesDo) Last() (*entity.Packages, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Packages), nil
+	}
+}
+
+func (p packagesDo) Find() ([]*entity.Packages, error) {
+	result, err := p.DO.Find()
+	return result.([]*entity.Packages), err
+}
+
+func (p packagesDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Packages, err error) {
+	buf := make([]*entity.Packages, 0, batchSize)
+	err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (p packagesDo) FindInBatches(result *[]*entity.Packages, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p packagesDo) Attrs(attrs ...field.AssignExpr) IPackagesDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p packagesDo) Assign(attrs ...field.AssignExpr) IPackagesDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p packagesDo) Joins(fields ...field.RelationField) IPackagesDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p packagesDo) Preload(fields ...field.RelationField) IPackagesDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p packagesDo) FirstOrInit() (*entity.Packages, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Packages), nil
+	}
+}
+
+func (p packagesDo) FirstOrCreate() (*entity.Packages, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Packages), nil
+	}
+}
+
+func (p packagesDo) FindByPage(offset int, limit int) (result []*entity.Packages, count int64, err error) {
+	result, err = p.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = p.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (p packagesDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = p.Count()
+	if err != nil {
+		return
+	}
+
+	err = p.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (p packagesDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p packagesDo) Delete(models ...*entity.Packages) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *packagesDo) withDO(do gen.Dao) *packagesDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}

internal/dao/promo_codes.gen.go

@@ -0,0 +1,412 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dao
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"leafdev.top/Leaf/api-platform/internal/entity"
+)
+
+func newPromoCode(db *gorm.DB, opts ...gen.DOOption) promoCode {
+	_promoCode := promoCode{}
+
+	_promoCode.promoCodeDo.UseDB(db, opts...)
+	_promoCode.promoCodeDo.UseModel(&entity.PromoCode{})
+
+	tableName := _promoCode.promoCodeDo.TableName()
+	_promoCode.ALL = field.NewAsterisk(tableName)
+	_promoCode.Id = field.NewUint(tableName, "id")
+	_promoCode.CreatedAt = field.NewTime(tableName, "created_at")
+	_promoCode.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_promoCode.Code = field.NewString(tableName, "code")
+	_promoCode.DiscountType = field.NewString(tableName, "discount_type")
+	_promoCode.DiscountValue = field.NewFloat64(tableName, "discount_value")
+	_promoCode.ExpirationDate = field.NewTime(tableName, "expiration_date")
+	_promoCode.IsActive = field.NewBool(tableName, "is_active")
+	_promoCode.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_promoCode.fillFieldMap()
+
+	return _promoCode
+}
+
+type promoCode struct {
+	promoCodeDo
+
+	ALL            field.Asterisk
+	Id             field.Uint
+	CreatedAt      field.Time
+	UpdatedAt      field.Time
+	Code           field.String
+	DiscountType   field.String
+	DiscountValue  field.Float64
+	ExpirationDate field.Time
+	IsActive       field.Bool
+	DeletedAt      field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (p promoCode) Table(newTableName string) *promoCode {
+	p.promoCodeDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p promoCode) As(alias string) *promoCode {
+	p.promoCodeDo.DO = *(p.promoCodeDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *promoCode) updateTableName(table string) *promoCode {
+	p.ALL = field.NewAsterisk(table)
+	p.Id = field.NewUint(table, "id")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+	p.Code = field.NewString(table, "code")
+	p.DiscountType = field.NewString(table, "discount_type")
+	p.DiscountValue = field.NewFloat64(table, "discount_value")
+	p.ExpirationDate = field.NewTime(table, "expiration_date")
+	p.IsActive = field.NewBool(table, "is_active")
+	p.DeletedAt = field.NewField(table, "deleted_at")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *promoCode) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := p.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (p *promoCode) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 9)
+	p.fieldMap["id"] = p.Id
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+	p.fieldMap["code"] = p.Code
+	p.fieldMap["discount_type"] = p.DiscountType
+	p.fieldMap["discount_value"] = p.DiscountValue
+	p.fieldMap["expiration_date"] = p.ExpirationDate
+	p.fieldMap["is_active"] = p.IsActive
+	p.fieldMap["deleted_at"] = p.DeletedAt
+}
+
+func (p promoCode) clone(db *gorm.DB) promoCode {
+	p.promoCodeDo.ReplaceConnPool(db.Statement.ConnPool)
+	return p
+}
+
+func (p promoCode) replaceDB(db *gorm.DB) promoCode {
+	p.promoCodeDo.ReplaceDB(db)
+	return p
+}
+
+type promoCodeDo struct{ gen.DO }
+
+type IPromoCodeDo interface {
+	gen.SubQuery
+	Debug() IPromoCodeDo
+	WithContext(ctx context.Context) IPromoCodeDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IPromoCodeDo
+	WriteDB() IPromoCodeDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IPromoCodeDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IPromoCodeDo
+	Not(conds ...gen.Condition) IPromoCodeDo
+	Or(conds ...gen.Condition) IPromoCodeDo
+	Select(conds ...field.Expr) IPromoCodeDo
+	Where(conds ...gen.Condition) IPromoCodeDo
+	Order(conds ...field.Expr) IPromoCodeDo
+	Distinct(cols ...field.Expr) IPromoCodeDo
+	Omit(cols ...field.Expr) IPromoCodeDo
+	Join(table schema.Tabler, on ...field.Expr) IPromoCodeDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo
+	Group(cols ...field.Expr) IPromoCodeDo
+	Having(conds ...gen.Condition) IPromoCodeDo
+	Limit(limit int) IPromoCodeDo
+	Offset(offset int) IPromoCodeDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IPromoCodeDo
+	Unscoped() IPromoCodeDo
+	Create(values ...*entity.PromoCode) error
+	CreateInBatches(values []*entity.PromoCode, batchSize int) error
+	Save(values ...*entity.PromoCode) error
+	First() (*entity.PromoCode, error)
+	Take() (*entity.PromoCode, error)
+	Last() (*entity.PromoCode, error)
+	Find() ([]*entity.PromoCode, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.PromoCode, err error)
+	FindInBatches(result *[]*entity.PromoCode, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.PromoCode) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IPromoCodeDo
+	Assign(attrs ...field.AssignExpr) IPromoCodeDo
+	Joins(fields ...field.RelationField) IPromoCodeDo
+	Preload(fields ...field.RelationField) IPromoCodeDo
+	FirstOrInit() (*entity.PromoCode, error)
+	FirstOrCreate() (*entity.PromoCode, error)
+	FindByPage(offset int, limit int) (result []*entity.PromoCode, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IPromoCodeDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (p promoCodeDo) Debug() IPromoCodeDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p promoCodeDo) WithContext(ctx context.Context) IPromoCodeDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p promoCodeDo) ReadDB() IPromoCodeDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p promoCodeDo) WriteDB() IPromoCodeDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p promoCodeDo) Session(config *gorm.Session) IPromoCodeDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p promoCodeDo) Clauses(conds ...clause.Expression) IPromoCodeDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p promoCodeDo) Returning(value interface{}, columns ...string) IPromoCodeDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p promoCodeDo) Not(conds ...gen.Condition) IPromoCodeDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p promoCodeDo) Or(conds ...gen.Condition) IPromoCodeDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p promoCodeDo) Select(conds ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p promoCodeDo) Where(conds ...gen.Condition) IPromoCodeDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p promoCodeDo) Order(conds ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p promoCodeDo) Distinct(cols ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p promoCodeDo) Omit(cols ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p promoCodeDo) Join(table schema.Tabler, on ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p promoCodeDo) LeftJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p promoCodeDo) RightJoin(table schema.Tabler, on ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p promoCodeDo) Group(cols ...field.Expr) IPromoCodeDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p promoCodeDo) Having(conds ...gen.Condition) IPromoCodeDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p promoCodeDo) Limit(limit int) IPromoCodeDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p promoCodeDo) Offset(offset int) IPromoCodeDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p promoCodeDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IPromoCodeDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p promoCodeDo) Unscoped() IPromoCodeDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p promoCodeDo) Create(values ...*entity.PromoCode) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p promoCodeDo) CreateInBatches(values []*entity.PromoCode, batchSize int) error {
+	return p.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (p promoCodeDo) Save(values ...*entity.PromoCode) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p promoCodeDo) First() (*entity.PromoCode, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.PromoCode), nil
+	}
+}
+
+func (p promoCodeDo) Take() (*entity.PromoCode, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.PromoCode), nil
+	}
+}
+
+func (p promoCodeDo) Last() (*entity.PromoCode, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.PromoCode), nil
+	}
+}
+
+func (p promoCodeDo) Find() ([]*entity.PromoCode, error) {
+	result, err := p.DO.Find()
+	return result.([]*entity.PromoCode), err
+}
+
+func (p promoCodeDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.PromoCode, err error) {
+	buf := make([]*entity.PromoCode, 0, batchSize)
+	err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (p promoCodeDo) FindInBatches(result *[]*entity.PromoCode, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p promoCodeDo) Attrs(attrs ...field.AssignExpr) IPromoCodeDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p promoCodeDo) Assign(attrs ...field.AssignExpr) IPromoCodeDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p promoCodeDo) Joins(fields ...field.RelationField) IPromoCodeDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p promoCodeDo) Preload(fields ...field.RelationField) IPromoCodeDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p promoCodeDo) FirstOrInit() (*entity.PromoCode, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.PromoCode), nil
+	}
+}
+
+func (p promoCodeDo) FirstOrCreate() (*entity.PromoCode, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.PromoCode), nil
+	}
+}
+
+func (p promoCodeDo) FindByPage(offset int, limit int) (result []*entity.PromoCode, count int64, err error) {
+	result, err = p.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = p.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (p promoCodeDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = p.Count()
+	if err != nil {
+		return
+	}
+
+	err = p.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (p promoCodeDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p promoCodeDo) Delete(models ...*entity.PromoCode) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *promoCodeDo) withDO(do gen.Dao) *promoCodeDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}

internal/dao/user_packages.gen.go

@@ -0,0 +1,499 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package dao
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"leafdev.top/Leaf/api-platform/internal/entity"
+)
+
+func newUserPackage(db *gorm.DB, opts ...gen.DOOption) userPackage {
+	_userPackage := userPackage{}
+
+	_userPackage.userPackageDo.UseDB(db, opts...)
+	_userPackage.userPackageDo.UseModel(&entity.UserPackage{})
+
+	tableName := _userPackage.userPackageDo.TableName()
+	_userPackage.ALL = field.NewAsterisk(tableName)
+	_userPackage.Id = field.NewUint(tableName, "id")
+	_userPackage.CreatedAt = field.NewTime(tableName, "created_at")
+	_userPackage.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_userPackage.UserId = field.NewString(tableName, "user_id")
+	_userPackage.PackageId = field.NewUint(tableName, "package_id")
+	_userPackage.CallsLeft = field.NewInt64(tableName, "calls_left")
+	_userPackage.IsActive = field.NewBool(tableName, "is_active")
+	_userPackage.ExpirationAt = field.NewTime(tableName, "expiration_at")
+	_userPackage.PurchaseAt = field.NewTime(tableName, "purchase_at")
+	_userPackage.Package = userPackageBelongsToPackage{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Package", "entity.Packages"),
+		Api: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Package.Api", "entity.Api"),
+		},
+	}
+
+	_userPackage.fillFieldMap()
+
+	return _userPackage
+}
+
+type userPackage struct {
+	userPackageDo
+
+	ALL          field.Asterisk
+	Id           field.Uint
+	CreatedAt    field.Time
+	UpdatedAt    field.Time
+	UserId       field.String
+	PackageId    field.Uint
+	CallsLeft    field.Int64
+	IsActive     field.Bool
+	ExpirationAt field.Time
+	PurchaseAt   field.Time
+	Package      userPackageBelongsToPackage
+
+	fieldMap map[string]field.Expr
+}
+
+func (u userPackage) Table(newTableName string) *userPackage {
+	u.userPackageDo.UseTable(newTableName)
+	return u.updateTableName(newTableName)
+}
+
+func (u userPackage) As(alias string) *userPackage {
+	u.userPackageDo.DO = *(u.userPackageDo.As(alias).(*gen.DO))
+	return u.updateTableName(alias)
+}
+
+func (u *userPackage) updateTableName(table string) *userPackage {
+	u.ALL = field.NewAsterisk(table)
+	u.Id = field.NewUint(table, "id")
+	u.CreatedAt = field.NewTime(table, "created_at")
+	u.UpdatedAt = field.NewTime(table, "updated_at")
+	u.UserId = field.NewString(table, "user_id")
+	u.PackageId = field.NewUint(table, "package_id")
+	u.CallsLeft = field.NewInt64(table, "calls_left")
+	u.IsActive = field.NewBool(table, "is_active")
+	u.ExpirationAt = field.NewTime(table, "expiration_at")
+	u.PurchaseAt = field.NewTime(table, "purchase_at")
+
+	u.fillFieldMap()
+
+	return u
+}
+
+func (u *userPackage) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := u.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (u *userPackage) fillFieldMap() {
+	u.fieldMap = make(map[string]field.Expr, 10)
+	u.fieldMap["id"] = u.Id
+	u.fieldMap["created_at"] = u.CreatedAt
+	u.fieldMap["updated_at"] = u.UpdatedAt
+	u.fieldMap["user_id"] = u.UserId
+	u.fieldMap["package_id"] = u.PackageId
+	u.fieldMap["calls_left"] = u.CallsLeft
+	u.fieldMap["is_active"] = u.IsActive
+	u.fieldMap["expiration_at"] = u.ExpirationAt
+	u.fieldMap["purchase_at"] = u.PurchaseAt
+
+}
+
+func (u userPackage) clone(db *gorm.DB) userPackage {
+	u.userPackageDo.ReplaceConnPool(db.Statement.ConnPool)
+	return u
+}
+
+func (u userPackage) replaceDB(db *gorm.DB) userPackage {
+	u.userPackageDo.ReplaceDB(db)
+	return u
+}
+
+type userPackageBelongsToPackage struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Api struct {
+		field.RelationField
+	}
+}
+
+func (a userPackageBelongsToPackage) Where(conds ...field.Expr) *userPackageBelongsToPackage {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a userPackageBelongsToPackage) WithContext(ctx context.Context) *userPackageBelongsToPackage {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a userPackageBelongsToPackage) Session(session *gorm.Session) *userPackageBelongsToPackage {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a userPackageBelongsToPackage) Model(m *entity.UserPackage) *userPackageBelongsToPackageTx {
+	return &userPackageBelongsToPackageTx{a.db.Model(m).Association(a.Name())}
+}
+
+type userPackageBelongsToPackageTx struct{ tx *gorm.Association }
+
+func (a userPackageBelongsToPackageTx) Find() (result *entity.Packages, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a userPackageBelongsToPackageTx) Append(values ...*entity.Packages) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a userPackageBelongsToPackageTx) Replace(values ...*entity.Packages) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a userPackageBelongsToPackageTx) Delete(values ...*entity.Packages) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a userPackageBelongsToPackageTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a userPackageBelongsToPackageTx) Count() int64 {
+	return a.tx.Count()
+}
+
+type userPackageDo struct{ gen.DO }
+
+type IUserPackageDo interface {
+	gen.SubQuery
+	Debug() IUserPackageDo
+	WithContext(ctx context.Context) IUserPackageDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IUserPackageDo
+	WriteDB() IUserPackageDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IUserPackageDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IUserPackageDo
+	Not(conds ...gen.Condition) IUserPackageDo
+	Or(conds ...gen.Condition) IUserPackageDo
+	Select(conds ...field.Expr) IUserPackageDo
+	Where(conds ...gen.Condition) IUserPackageDo
+	Order(conds ...field.Expr) IUserPackageDo
+	Distinct(cols ...field.Expr) IUserPackageDo
+	Omit(cols ...field.Expr) IUserPackageDo
+	Join(table schema.Tabler, on ...field.Expr) IUserPackageDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo
+	Group(cols ...field.Expr) IUserPackageDo
+	Having(conds ...gen.Condition) IUserPackageDo
+	Limit(limit int) IUserPackageDo
+	Offset(offset int) IUserPackageDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPackageDo
+	Unscoped() IUserPackageDo
+	Create(values ...*entity.UserPackage) error
+	CreateInBatches(values []*entity.UserPackage, batchSize int) error
+	Save(values ...*entity.UserPackage) error
+	First() (*entity.UserPackage, error)
+	Take() (*entity.UserPackage, error)
+	Last() (*entity.UserPackage, error)
+	Find() ([]*entity.UserPackage, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPackage, err error)
+	FindInBatches(result *[]*entity.UserPackage, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.UserPackage) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IUserPackageDo
+	Assign(attrs ...field.AssignExpr) IUserPackageDo
+	Joins(fields ...field.RelationField) IUserPackageDo
+	Preload(fields ...field.RelationField) IUserPackageDo
+	FirstOrInit() (*entity.UserPackage, error)
+	FirstOrCreate() (*entity.UserPackage, error)
+	FindByPage(offset int, limit int) (result []*entity.UserPackage, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IUserPackageDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (u userPackageDo) Debug() IUserPackageDo {
+	return u.withDO(u.DO.Debug())
+}
+
+func (u userPackageDo) WithContext(ctx context.Context) IUserPackageDo {
+	return u.withDO(u.DO.WithContext(ctx))
+}
+
+func (u userPackageDo) ReadDB() IUserPackageDo {
+	return u.Clauses(dbresolver.Read)
+}
+
+func (u userPackageDo) WriteDB() IUserPackageDo {
+	return u.Clauses(dbresolver.Write)
+}
+
+func (u userPackageDo) Session(config *gorm.Session) IUserPackageDo {
+	return u.withDO(u.DO.Session(config))
+}
+
+func (u userPackageDo) Clauses(conds ...clause.Expression) IUserPackageDo {
+	return u.withDO(u.DO.Clauses(conds...))
+}
+
+func (u userPackageDo) Returning(value interface{}, columns ...string) IUserPackageDo {
+	return u.withDO(u.DO.Returning(value, columns...))
+}
+
+func (u userPackageDo) Not(conds ...gen.Condition) IUserPackageDo {
+	return u.withDO(u.DO.Not(conds...))
+}
+
+func (u userPackageDo) Or(conds ...gen.Condition) IUserPackageDo {
+	return u.withDO(u.DO.Or(conds...))
+}
+
+func (u userPackageDo) Select(conds ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.Select(conds...))
+}
+
+func (u userPackageDo) Where(conds ...gen.Condition) IUserPackageDo {
+	return u.withDO(u.DO.Where(conds...))
+}
+
+func (u userPackageDo) Order(conds ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.Order(conds...))
+}
+
+func (u userPackageDo) Distinct(cols ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.Distinct(cols...))
+}
+
+func (u userPackageDo) Omit(cols ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.Omit(cols...))
+}
+
+func (u userPackageDo) Join(table schema.Tabler, on ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.Join(table, on...))
+}
+
+func (u userPackageDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.LeftJoin(table, on...))
+}
+
+func (u userPackageDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.RightJoin(table, on...))
+}
+
+func (u userPackageDo) Group(cols ...field.Expr) IUserPackageDo {
+	return u.withDO(u.DO.Group(cols...))
+}
+
+func (u userPackageDo) Having(conds ...gen.Condition) IUserPackageDo {
+	return u.withDO(u.DO.Having(conds...))
+}
+
+func (u userPackageDo) Limit(limit int) IUserPackageDo {
+	return u.withDO(u.DO.Limit(limit))
+}
+
+func (u userPackageDo) Offset(offset int) IUserPackageDo {
+	return u.withDO(u.DO.Offset(offset))
+}
+
+func (u userPackageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPackageDo {
+	return u.withDO(u.DO.Scopes(funcs...))
+}
+
+func (u userPackageDo) Unscoped() IUserPackageDo {
+	return u.withDO(u.DO.Unscoped())
+}
+
+func (u userPackageDo) Create(values ...*entity.UserPackage) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Create(values)
+}
+
+func (u userPackageDo) CreateInBatches(values []*entity.UserPackage, batchSize int) error {
+	return u.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (u userPackageDo) Save(values ...*entity.UserPackage) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Save(values)
+}
+
+func (u userPackageDo) First() (*entity.UserPackage, error) {
+	if result, err := u.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPackage), nil
+	}
+}
+
+func (u userPackageDo) Take() (*entity.UserPackage, error) {
+	if result, err := u.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPackage), nil
+	}
+}
+
+func (u userPackageDo) Last() (*entity.UserPackage, error) {
+	if result, err := u.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPackage), nil
+	}
+}
+
+func (u userPackageDo) Find() ([]*entity.UserPackage, error) {
+	result, err := u.DO.Find()
+	return result.([]*entity.UserPackage), err
+}
+
+func (u userPackageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPackage, err error) {
+	buf := make([]*entity.UserPackage, 0, batchSize)
+	err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (u userPackageDo) FindInBatches(result *[]*entity.UserPackage, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return u.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (u userPackageDo) Attrs(attrs ...field.AssignExpr) IUserPackageDo {
+	return u.withDO(u.DO.Attrs(attrs...))
+}
+
+func (u userPackageDo) Assign(attrs ...field.AssignExpr) IUserPackageDo {
+	return u.withDO(u.DO.Assign(attrs...))
+}
+
+func (u userPackageDo) Joins(fields ...field.RelationField) IUserPackageDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Joins(_f))
+	}
+	return &u
+}
+
+func (u userPackageDo) Preload(fields ...field.RelationField) IUserPackageDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Preload(_f))
+	}
+	return &u
+}
+
+func (u userPackageDo) FirstOrInit() (*entity.UserPackage, error) {
+	if result, err := u.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPackage), nil
+	}
+}
+
+func (u userPackageDo) FirstOrCreate() (*entity.UserPackage, error) {
+	if result, err := u.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPackage), nil
+	}
+}
+
+func (u userPackageDo) FindByPage(offset int, limit int) (result []*entity.UserPackage, count int64, err error) {
+	result, err = u.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = u.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (u userPackageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = u.Count()
+	if err != nil {
+		return
+	}
+
+	err = u.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (u userPackageDo) Scan(result interface{}) (err error) {
+	return u.DO.Scan(result)
+}
+
+func (u userPackageDo) Delete(models ...*entity.UserPackage) (result gen.ResultInfo, err error) {
+	return u.DO.Delete(models)
+}
+
+func (u *userPackageDo) withDO(do gen.Dao) *userPackageDo {
+	u.DO = *do.(*gen.DO)
+	return u
+}

internal/dao/users.gen.go

@@ -1,392 +0,0 @@
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-// Code generated by gorm.io/gen. DO NOT EDIT.
-
-package dao
-
-import (
-	"context"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-
-	"leafdev.top/Leaf/api-platform/internal/entity"
-)
-
-func newUser(db *gorm.DB, opts ...gen.DOOption) user {
-	_user := user{}
-
-	_user.userDo.UseDB(db, opts...)
-	_user.userDo.UseModel(&entity.Api{})
-
-	tableName := _user.userDo.TableName()
-	_user.ALL = field.NewAsterisk(tableName)
-	_user.Id = field.NewUint(tableName, "id")
-	_user.CreatedAt = field.NewTime(tableName, "created_at")
-	_user.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_user.Name = field.NewString(tableName, "name")
-
-	_user.fillFieldMap()
-
-	return _user
-}
-
-type user struct {
-	userDo
-
-	ALL       field.Asterisk
-	Id        field.Uint
-	CreatedAt field.Time
-	UpdatedAt field.Time
-	Name      field.String
-
-	fieldMap map[string]field.Expr
-}
-
-func (u user) Table(newTableName string) *user {
-	u.userDo.UseTable(newTableName)
-	return u.updateTableName(newTableName)
-}
-
-func (u user) As(alias string) *user {
-	u.userDo.DO = *(u.userDo.As(alias).(*gen.DO))
-	return u.updateTableName(alias)
-}
-
-func (u *user) updateTableName(table string) *user {
-	u.ALL = field.NewAsterisk(table)
-	u.Id = field.NewUint(table, "id")
-	u.CreatedAt = field.NewTime(table, "created_at")
-	u.UpdatedAt = field.NewTime(table, "updated_at")
-	u.Name = field.NewString(table, "name")
-
-	u.fillFieldMap()
-
-	return u
-}
-
-func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := u.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (u *user) fillFieldMap() {
-	u.fieldMap = make(map[string]field.Expr, 4)
-	u.fieldMap["id"] = u.Id
-	u.fieldMap["created_at"] = u.CreatedAt
-	u.fieldMap["updated_at"] = u.UpdatedAt
-	u.fieldMap["name"] = u.Name
-}
-
-func (u user) clone(db *gorm.DB) user {
-	u.userDo.ReplaceConnPool(db.Statement.ConnPool)
-	return u
-}
-
-func (u user) replaceDB(db *gorm.DB) user {
-	u.userDo.ReplaceDB(db)
-	return u
-}
-
-type userDo struct{ gen.DO }
-
-type IUserDo interface {
-	gen.SubQuery
-	Debug() IUserDo
-	WithContext(ctx context.Context) IUserDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IUserDo
-	WriteDB() IUserDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IUserDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IUserDo
-	Not(conds ...gen.Condition) IUserDo
-	Or(conds ...gen.Condition) IUserDo
-	Select(conds ...field.Expr) IUserDo
-	Where(conds ...gen.Condition) IUserDo
-	Order(conds ...field.Expr) IUserDo
-	Distinct(cols ...field.Expr) IUserDo
-	Omit(cols ...field.Expr) IUserDo
-	Join(table schema.Tabler, on ...field.Expr) IUserDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IUserDo
-	Group(cols ...field.Expr) IUserDo
-	Having(conds ...gen.Condition) IUserDo
-	Limit(limit int) IUserDo
-	Offset(offset int) IUserDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo
-	Unscoped() IUserDo
-	Create(values ...*entity.Api) error
-	CreateInBatches(values []*entity.Api, batchSize int) error
-	Save(values ...*entity.Api) error
-	First() (*entity.Api, error)
-	Take() (*entity.Api, error)
-	Last() (*entity.Api, error)
-	Find() ([]*entity.Api, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error)
-	FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*entity.Api) (info gen.ResultInfo, err error)
-	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
-	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
-	Updates(value interface{}) (info gen.ResultInfo, err error)
-	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
-	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
-	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
-	UpdateFrom(q gen.SubQuery) gen.Dao
-	Attrs(attrs ...field.AssignExpr) IUserDo
-	Assign(attrs ...field.AssignExpr) IUserDo
-	Joins(fields ...field.RelationField) IUserDo
-	Preload(fields ...field.RelationField) IUserDo
-	FirstOrInit() (*entity.Api, error)
-	FirstOrCreate() (*entity.Api, error)
-	FindByPage(offset int, limit int) (result []*entity.Api, count int64, err error)
-	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
-	Scan(result interface{}) (err error)
-	Returning(value interface{}, columns ...string) IUserDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (u userDo) Debug() IUserDo {
-	return u.withDO(u.DO.Debug())
-}
-
-func (u userDo) WithContext(ctx context.Context) IUserDo {
-	return u.withDO(u.DO.WithContext(ctx))
-}
-
-func (u userDo) ReadDB() IUserDo {
-	return u.Clauses(dbresolver.Read)
-}
-
-func (u userDo) WriteDB() IUserDo {
-	return u.Clauses(dbresolver.Write)
-}
-
-func (u userDo) Session(config *gorm.Session) IUserDo {
-	return u.withDO(u.DO.Session(config))
-}
-
-func (u userDo) Clauses(conds ...clause.Expression) IUserDo {
-	return u.withDO(u.DO.Clauses(conds...))
-}
-
-func (u userDo) Returning(value interface{}, columns ...string) IUserDo {
-	return u.withDO(u.DO.Returning(value, columns...))
-}
-
-func (u userDo) Not(conds ...gen.Condition) IUserDo {
-	return u.withDO(u.DO.Not(conds...))
-}
-
-func (u userDo) Or(conds ...gen.Condition) IUserDo {
-	return u.withDO(u.DO.Or(conds...))
-}
-
-func (u userDo) Select(conds ...field.Expr) IUserDo {
-	return u.withDO(u.DO.Select(conds...))
-}
-
-func (u userDo) Where(conds ...gen.Condition) IUserDo {
-	return u.withDO(u.DO.Where(conds...))
-}
-
-func (u userDo) Order(conds ...field.Expr) IUserDo {
-	return u.withDO(u.DO.Order(conds...))
-}
-
-func (u userDo) Distinct(cols ...field.Expr) IUserDo {
-	return u.withDO(u.DO.Distinct(cols...))
-}
-
-func (u userDo) Omit(cols ...field.Expr) IUserDo {
-	return u.withDO(u.DO.Omit(cols...))
-}
-
-func (u userDo) Join(table schema.Tabler, on ...field.Expr) IUserDo {
-	return u.withDO(u.DO.Join(table, on...))
-}
-
-func (u userDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo {
-	return u.withDO(u.DO.LeftJoin(table, on...))
-}
-
-func (u userDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo {
-	return u.withDO(u.DO.RightJoin(table, on...))
-}
-
-func (u userDo) Group(cols ...field.Expr) IUserDo {
-	return u.withDO(u.DO.Group(cols...))
-}
-
-func (u userDo) Having(conds ...gen.Condition) IUserDo {
-	return u.withDO(u.DO.Having(conds...))
-}
-
-func (u userDo) Limit(limit int) IUserDo {
-	return u.withDO(u.DO.Limit(limit))
-}
-
-func (u userDo) Offset(offset int) IUserDo {
-	return u.withDO(u.DO.Offset(offset))
-}
-
-func (u userDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo {
-	return u.withDO(u.DO.Scopes(funcs...))
-}
-
-func (u userDo) Unscoped() IUserDo {
-	return u.withDO(u.DO.Unscoped())
-}
-
-func (u userDo) Create(values ...*entity.Api) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return u.DO.Create(values)
-}
-
-func (u userDo) CreateInBatches(values []*entity.Api, batchSize int) error {
-	return u.DO.CreateInBatches(values, batchSize)
-}
-
-// Save : !!! underlying implementation is different with GORM
-// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
-func (u userDo) Save(values ...*entity.Api) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return u.DO.Save(values)
-}
-
-func (u userDo) First() (*entity.Api, error) {
-	if result, err := u.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*entity.Api), nil
-	}
-}
-
-func (u userDo) Take() (*entity.Api, error) {
-	if result, err := u.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*entity.Api), nil
-	}
-}
-
-func (u userDo) Last() (*entity.Api, error) {
-	if result, err := u.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*entity.Api), nil
-	}
-}
-
-func (u userDo) Find() ([]*entity.Api, error) {
-	result, err := u.DO.Find()
-	return result.([]*entity.Api), err
-}
-
-func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Api, err error) {
-	buf := make([]*entity.Api, 0, batchSize)
-	err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
-		defer func() { results = append(results, buf...) }()
-		return fc(tx, batch)
-	})
-	return results, err
-}
-
-func (u userDo) FindInBatches(result *[]*entity.Api, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return u.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (u userDo) Attrs(attrs ...field.AssignExpr) IUserDo {
-	return u.withDO(u.DO.Attrs(attrs...))
-}
-
-func (u userDo) Assign(attrs ...field.AssignExpr) IUserDo {
-	return u.withDO(u.DO.Assign(attrs...))
-}
-
-func (u userDo) Joins(fields ...field.RelationField) IUserDo {
-	for _, _f := range fields {
-		u = *u.withDO(u.DO.Joins(_f))
-	}
-	return &u
-}
-
-func (u userDo) Preload(fields ...field.RelationField) IUserDo {
-	for _, _f := range fields {
-		u = *u.withDO(u.DO.Preload(_f))
-	}
-	return &u
-}
-
-func (u userDo) FirstOrInit() (*entity.Api, error) {
-	if result, err := u.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*entity.Api), nil
-	}
-}
-
-func (u userDo) FirstOrCreate() (*entity.Api, error) {
-	if result, err := u.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*entity.Api), nil
-	}
-}
-
-func (u userDo) FindByPage(offset int, limit int) (result []*entity.Api, count int64, err error) {
-	result, err = u.Offset(offset).Limit(limit).Find()
-	if err != nil {
-		return
-	}
-
-	if size := len(result); 0 < limit && 0 < size && size < limit {
-		count = int64(size + offset)
-		return
-	}
-
-	count, err = u.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (u userDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = u.Count()
-	if err != nil {
-		return
-	}
-
-	err = u.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (u userDo) Scan(result interface{}) (err error) {
-	return u.DO.Scan(result)
-}
-
-func (u userDo) Delete(models ...*entity.Api) (result gen.ResultInfo, err error) {
-	return u.DO.Delete(models)
-}
-
-func (u *userDo) withDO(do gen.Dao) *userDo {
-	u.DO = *do.(*gen.DO)
-	return u
-}

internal/entity/Order.go

@@ -23,7 +23,7 @@ type OrderItem struct {
 	OrderId   schema.EntityId `json:"order_id"`
 	PackageId schema.EntityId `json:"package_id"`
 	Order     *Order
-	Package   *Package
+	Package   *Packages
 }
 
 func (u *OrderItem) TableName() string {

internal/entity/Package.go

@@ -6,7 +6,8 @@ import (
 	"time"
 )
 
-type Package struct {
+// Packages 其实不应该加 s，但是 gorm gen 生成的代码中，package 是关键字，所以只能加 s
+type Packages struct {
 	Model
 	Name          string          `json:"name"`
 	Description   string          `json:"description"`
@@ -22,7 +23,7 @@ type Package struct {
 	DeletedAt     *gorm.DeletedAt `json:"deleted_at"`
 }
 
-func (u *Package) TableName() string {
+func (u *Packages) TableName() string {
 	return "packages"
 }
 
@@ -30,7 +31,7 @@ type UserPackage struct {
 	Model
 	UserId       schema.UserId   `json:"user_id"`
 	PackageId    schema.EntityId `json:"package_id"`
-	Package      *Package        `json:"api_package"`
+	Package      *Packages       `json:"api_package"`
 	CallsLeft    int64           `json:"calls_left"`
 	IsActive     bool            `json:"is_active"`
 	ExpirationAt *time.Time      `json:"expiration_at"`