feat: implement new structure

backend/database/models/tenants.query.gen.go

@@ -30,16 +30,11 @@ func newTenant(db *gorm.DB, opts ...gen.DOOption) tenantQuery {
 	_tenantQuery.Code = field.NewString(tableName, "code")
 	_tenantQuery.UUID = field.NewField(tableName, "uuid")
 	_tenantQuery.Name = field.NewString(tableName, "name")
-	_tenantQuery.Status = field.NewField(tableName, "status")
+	_tenantQuery.Status = field.NewString(tableName, "status")
 	_tenantQuery.Config = field.NewJSONB(tableName, "config")
 	_tenantQuery.ExpiredAt = field.NewTime(tableName, "expired_at")
 	_tenantQuery.CreatedAt = field.NewTime(tableName, "created_at")
 	_tenantQuery.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_tenantQuery.Users = tenantQueryManyToManyUsers{
-		db: db.Session(&gorm.Session{}),
-
-		RelationField: field.NewRelation("Users", "User"),
-	}
 
 	_tenantQuery.fillFieldMap()
 
@@ -55,12 +50,11 @@ type tenantQuery struct {
 	Code      field.String
 	UUID      field.Field
 	Name      field.String
-	Status    field.Field
+	Status    field.String
 	Config    field.JSONB
 	ExpiredAt field.Time
 	CreatedAt field.Time
 	UpdatedAt field.Time
-	Users     tenantQueryManyToManyUsers
 
 	fieldMap map[string]field.Expr
 }
@@ -82,7 +76,7 @@ func (t *tenantQuery) updateTableName(table string) *tenantQuery {
 	t.Code = field.NewString(table, "code")
 	t.UUID = field.NewField(table, "uuid")
 	t.Name = field.NewString(table, "name")
-	t.Status = field.NewField(table, "status")
+	t.Status = field.NewString(table, "status")
 	t.Config = field.NewJSONB(table, "config")
 	t.ExpiredAt = field.NewTime(table, "expired_at")
 	t.CreatedAt = field.NewTime(table, "created_at")
@@ -117,7 +111,7 @@ func (t *tenantQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
 }
 
 func (t *tenantQuery) fillFieldMap() {
-	t.fieldMap = make(map[string]field.Expr, 11)
+	t.fieldMap = make(map[string]field.Expr, 10)
 	t.fieldMap["id"] = t.ID
 	t.fieldMap["user_id"] = t.UserID
 	t.fieldMap["code"] = t.Code
@@ -128,103 +122,18 @@ func (t *tenantQuery) fillFieldMap() {
 	t.fieldMap["expired_at"] = t.ExpiredAt
 	t.fieldMap["created_at"] = t.CreatedAt
 	t.fieldMap["updated_at"] = t.UpdatedAt
-
 }
 
 func (t tenantQuery) clone(db *gorm.DB) tenantQuery {
 	t.tenantQueryDo.ReplaceConnPool(db.Statement.ConnPool)
-	t.Users.db = db.Session(&gorm.Session{Initialized: true})
-	t.Users.db.Statement.ConnPool = db.Statement.ConnPool
 	return t
 }
 
 func (t tenantQuery) replaceDB(db *gorm.DB) tenantQuery {
 	t.tenantQueryDo.ReplaceDB(db)
-	t.Users.db = db.Session(&gorm.Session{})
 	return t
 }
 
-type tenantQueryManyToManyUsers struct {
-	db *gorm.DB
-
-	field.RelationField
-}
-
-func (a tenantQueryManyToManyUsers) Where(conds ...field.Expr) *tenantQueryManyToManyUsers {
-	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 tenantQueryManyToManyUsers) WithContext(ctx context.Context) *tenantQueryManyToManyUsers {
-	a.db = a.db.WithContext(ctx)
-	return &a
-}
-
-func (a tenantQueryManyToManyUsers) Session(session *gorm.Session) *tenantQueryManyToManyUsers {
-	a.db = a.db.Session(session)
-	return &a
-}
-
-func (a tenantQueryManyToManyUsers) Model(m *Tenant) *tenantQueryManyToManyUsersTx {
-	return &tenantQueryManyToManyUsersTx{a.db.Model(m).Association(a.Name())}
-}
-
-func (a tenantQueryManyToManyUsers) Unscoped() *tenantQueryManyToManyUsers {
-	a.db = a.db.Unscoped()
-	return &a
-}
-
-type tenantQueryManyToManyUsersTx struct{ tx *gorm.Association }
-
-func (a tenantQueryManyToManyUsersTx) Find() (result []*User, err error) {
-	return result, a.tx.Find(&result)
-}
-
-func (a tenantQueryManyToManyUsersTx) Append(values ...*User) (err error) {
-	targetValues := make([]interface{}, len(values))
-	for i, v := range values {
-		targetValues[i] = v
-	}
-	return a.tx.Append(targetValues...)
-}
-
-func (a tenantQueryManyToManyUsersTx) Replace(values ...*User) (err error) {
-	targetValues := make([]interface{}, len(values))
-	for i, v := range values {
-		targetValues[i] = v
-	}
-	return a.tx.Replace(targetValues...)
-}
-
-func (a tenantQueryManyToManyUsersTx) Delete(values ...*User) (err error) {
-	targetValues := make([]interface{}, len(values))
-	for i, v := range values {
-		targetValues[i] = v
-	}
-	return a.tx.Delete(targetValues...)
-}
-
-func (a tenantQueryManyToManyUsersTx) Clear() error {
-	return a.tx.Clear()
-}
-
-func (a tenantQueryManyToManyUsersTx) Count() int64 {
-	return a.tx.Count()
-}
-
-func (a tenantQueryManyToManyUsersTx) Unscoped() *tenantQueryManyToManyUsersTx {
-	a.tx = a.tx.Unscoped()
-	return &a
-}
-
 type tenantQueryDo struct{ gen.DO }
 
 func (t tenantQueryDo) Debug() *tenantQueryDo {