diff --git a/backend/app/http/admin/medias.go b/backend/app/http/admin/medias.go
index 568666a..b9087de 100644
--- a/backend/app/http/admin/medias.go
+++ b/backend/app/http/admin/medias.go
@@ -1,7 +1,7 @@
 package admin
 
 import (
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/requests"
 	"quyun/providers/ali"
 
@@ -19,8 +19,8 @@ type medias struct {
 //	@Bind	pagination query
 //	@Bind	query query
 func (ctl *medias) List(ctx fiber.Ctx, pagination *requests.Pagination, query *ListQuery) (*requests.Pager, error) {
-	cond := models.Medias.BuildConditionWithKey(query.Keyword)
-	return models.Medias.List(ctx.Context(), pagination, cond)
+	cond := model.MediasModel.BuildConditionWithKey(query.Keyword)
+	return model.MediasModel.List(ctx.Context(), pagination, cond)
 }
 
 // Show media
@@ -28,7 +28,7 @@ func (ctl *medias) List(ctx fiber.Ctx, pagination *requests.Pagination, query *L
 //	@Router	/admin/medias/:id [get]
 //	@Bind	id path
 func (ctl *medias) Show(ctx fiber.Ctx, id int64) error {
-	media, err := models.Medias.GetByID(ctx.Context(), id)
+	media, err := model.MediasModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		return ctx.SendString("Media not found")
 	}
@@ -46,7 +46,7 @@ func (ctl *medias) Show(ctx fiber.Ctx, id int64) error {
 //	@Router	/admin/medias/:id [delete]
 //	@Bind	id path
 func (ctl *medias) Delete(ctx fiber.Ctx, id int64) error {
-	media, err := models.Medias.GetByID(ctx.Context(), id)
+	media, err := model.MediasModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		return ctx.SendString("Media not found")
 	}
@@ -55,7 +55,7 @@ func (ctl *medias) Delete(ctx fiber.Ctx, id int64) error {
 		return err
 	}
 
-	if err := models.Medias.Delete(ctx.Context(), id); err != nil {
+	if err := model.MediasModel.Delete(ctx.Context(), id); err != nil {
 		return err
 	}
 	return ctx.SendStatus(fiber.StatusNoContent)
diff --git a/backend/app/http/admin/orders.go b/backend/app/http/admin/orders.go
index 616d74b..38f91cd 100644
--- a/backend/app/http/admin/orders.go
+++ b/backend/app/http/admin/orders.go
@@ -3,7 +3,7 @@ package admin
 import (
 	"fmt"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/requests"
 	"quyun/database/fields"
 	"quyun/providers/wepay"
@@ -28,35 +28,35 @@ type orders struct {
 //	@Bind	pagination query
 //	@Bind	query query
 func (ctl *orders) List(ctx fiber.Ctx, pagination *requests.Pagination, query *OrderListQuery) (*requests.Pager, error) {
-	cond := models.Orders.BuildConditionWithKey(query.OrderNumber, query.UserID)
-	return models.Orders.List(ctx.Context(), pagination, cond)
+	cond := model.OrdersModel.BuildConditionWithKey(query.OrderNumber, query.UserID)
+	return model.OrdersModel.List(ctx.Context(), pagination, cond)
 }
 
 // Refund
 // @Router	/admin/orders/:id/refund [post]
 // @Bind	id path
 func (ctl *orders) Refund(ctx fiber.Ctx, id int64) error {
-	order, err := models.Orders.GetByID(ctx.Context(), id)
+	order, err := model.OrdersModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		return err
 	}
 
-	post, err := models.Posts.GetByID(ctx.Context(), order.PostID)
+	post, err := model.PostsModel.GetByID(ctx.Context(), order.PostID)
 	if err != nil {
 		return err
 	}
 
 	if order.PaymentMethod == "balance" {
-		if err := models.Users.AddBalance(ctx.Context(), order.UserID, order.Meta.Data.CostBalance); err != nil {
+		if err := model.UsersModel.AddBalance(ctx.Context(), order.UserID, order.Meta.Data.CostBalance); err != nil {
 			return errors.Wrap(err, "add balance failed")
 		}
 
-		if err := models.Users.RevokePosts(ctx.Context(), order.UserID, order.PostID); err != nil {
+		if err := model.UsersModel.RevokePosts(ctx.Context(), order.UserID, order.PostID); err != nil {
 			return errors.Wrap(err, "revoke posts failed")
 		}
 
 		order.Status = fields.OrderStatusRefundSuccess
-		if err := models.Orders.Update(ctx.Context(), order); err != nil {
+		if err := model.OrdersModel.Update(ctx.Context(), order); err != nil {
 			return errors.Wrap(err, "update order failed")
 		}
 
@@ -82,7 +82,7 @@ func (ctl *orders) Refund(ctx fiber.Ctx, id int64) error {
 	order.RefundTransactionID = resp.RefundId
 	order.Status = fields.OrderStatusRefundProcessing
 
-	if err := models.Orders.Update(ctx.Context(), order); err != nil {
+	if err := model.OrdersModel.Update(ctx.Context(), order); err != nil {
 		return err
 	}
 
diff --git a/backend/app/http/admin/posts.go b/backend/app/http/admin/posts.go
index db7e2ca..a40e702 100644
--- a/backend/app/http/admin/posts.go
+++ b/backend/app/http/admin/posts.go
@@ -1,11 +1,10 @@
 package admin
 
 import (
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/requests"
 	"quyun/database/conds"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
 
 	"github.com/gofiber/fiber/v3"
 	"github.com/samber/lo"
@@ -29,7 +28,7 @@ func (ctl *posts) List(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
 		// conds.Post_Status(fields.PostStatusPublished),
 		conds.Post_Like(query.Keyword),
 	}
-	pager, err := models.Posts.List(ctx.Context(), pagination, conds...)
+	pager, err := model.PostsModel.List(ctx.Context(), pagination, conds...)
 	if err != nil {
 		return nil, err
 	}
@@ -38,7 +37,7 @@ func (ctl *posts) List(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
 		return item.ID
 	})
 	if len(postIds) > 0 {
-		postCntMap, err := models.Posts.BoughtStatistics(ctx.Context(), postIds)
+		postCntMap, err := model.PostsModel.BoughtStatistics(ctx.Context(), postIds)
 		if err != nil {
 			return pager, err
 		}
@@ -86,7 +85,7 @@ func (ctl *posts) Create(ctx fiber.Ctx, form *PostForm) error {
 	}
 
 	if form.Medias != nil {
-		medias, err := models.Medias.GetByIds(ctx.Context(), form.Medias)
+		medias, err := model.MediasModel.GetByIds(ctx.Context(), form.Medias)
 		if err != nil {
 			return err
 		}
@@ -100,7 +99,7 @@ func (ctl *posts) Create(ctx fiber.Ctx, form *PostForm) error {
 		post.Assets = fields.ToJson(assets)
 	}
 
-	if err := models.Posts.Create(ctx.Context(), &post); err != nil {
+	if err := model.PostsModel.Create(ctx.Context(), &post); err != nil {
 		return err
 	}
 	return nil
@@ -112,7 +111,7 @@ func (ctl *posts) Create(ctx fiber.Ctx, form *PostForm) error {
 //	@Bind	id path
 //	@Bind	form body
 func (ctl *posts) Update(ctx fiber.Ctx, id int64, form *PostForm) error {
-	oldPost, err := models.Posts.GetByID(ctx.Context(), id)
+	oldPost, err := model.PostsModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		return err
 	}
@@ -135,7 +134,7 @@ func (ctl *posts) Update(ctx fiber.Ctx, id int64, form *PostForm) error {
 	}
 
 	if form.Medias != nil {
-		medias, err := models.Medias.GetByIds(ctx.Context(), form.Medias)
+		medias, err := model.MediasModel.GetByIds(ctx.Context(), form.Medias)
 		if err != nil {
 			return err
 		}
@@ -149,7 +148,7 @@ func (ctl *posts) Update(ctx fiber.Ctx, id int64, form *PostForm) error {
 		post.Assets = fields.ToJson(assets)
 	}
 
-	if err := models.Posts.Update(ctx.Context(), id, post); err != nil {
+	if err := model.PostsModel.Update(ctx.Context(), id, post); err != nil {
 		return err
 	}
 	return nil
@@ -160,7 +159,7 @@ func (ctl *posts) Update(ctx fiber.Ctx, id int64, form *PostForm) error {
 //	@Router	/admin/posts/:id [delete]
 //	@Bind	id path
 func (ctl *posts) Delete(ctx fiber.Ctx, id int64) error {
-	post, err := models.Posts.GetByID(ctx.Context(), id)
+	post, err := model.PostsModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		return err
 	}
@@ -168,7 +167,7 @@ func (ctl *posts) Delete(ctx fiber.Ctx, id int64) error {
 		return fiber.ErrNotFound
 	}
 
-	if err := models.Posts.DeleteByID(ctx.Context(), id); err != nil {
+	if err := model.PostsModel.DeleteByID(ctx.Context(), id); err != nil {
 		return err
 	}
 	return nil
@@ -185,12 +184,12 @@ type PostItem struct {
 //	@Router	/admin/posts/:id [get]
 //	@Bind	id path
 func (ctl *posts) Show(ctx fiber.Ctx, id int64) (*PostItem, error) {
-	post, err := models.Posts.GetByID(ctx.Context(), id)
+	post, err := model.PostsModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		return nil, err
 	}
 
-	medias, err := models.Medias.GetByIds(ctx.Context(), lo.Map(post.Assets.Data, func(asset fields.MediaAsset, _ int) int64 {
+	medias, err := model.MediasModel.GetByIds(ctx.Context(), lo.Map(post.Assets.Data, func(asset fields.MediaAsset, _ int) int64 {
 		return asset.Media
 	}))
 	if err != nil {
@@ -208,15 +207,15 @@ func (ctl *posts) Show(ctx fiber.Ctx, id int64) (*PostItem, error) {
 //	@Bind	id path
 //	@Bind	userId path
 func (ctl *posts) SendTo(ctx fiber.Ctx, id, userId int64) error {
-	if _, err := models.Posts.GetByID(ctx.Context(), id); err != nil {
+	if _, err := model.PostsModel.GetByID(ctx.Context(), id); err != nil {
 		return err
 	}
 
-	if _, err := models.Users.GetByID(ctx.Context(), userId); err != nil {
+	if _, err := model.UsersModel.GetByID(ctx.Context(), userId); err != nil {
 		return err
 	}
 
-	if err := models.Posts.SendTo(ctx.Context(), id, userId); err != nil {
+	if err := model.PostsModel.SendTo(ctx.Context(), id, userId); err != nil {
 		return err
 	}
 	return nil
diff --git a/backend/app/http/admin/statistics.go b/backend/app/http/admin/statistics.go
index c5f937f..2fd42a3 100644
--- a/backend/app/http/admin/statistics.go
+++ b/backend/app/http/admin/statistics.go
@@ -1,9 +1,9 @@
 package admin
 
 import (
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
 	. "github.com/go-jet/jet/v2/postgres"
 	"github.com/gofiber/fiber/v3"
@@ -29,31 +29,31 @@ func (s *statistics) statistics(ctx fiber.Ctx) (*StatisticsResponse, error) {
 
 	var err error
 
-	statistics.PostDraft, err = models.Posts.Count(ctx.Context(), table.Posts.Status.EQ(Int(int64(fields.PostStatusDraft))))
+	statistics.PostDraft, err = model.PostsModel.Count(ctx.Context(), table.Posts.Status.EQ(Int(int64(fields.PostStatusDraft))))
 	if err != nil {
 		return nil, err
 	}
-	statistics.PostPublished, err = models.Posts.Count(ctx.Context(), table.Posts.Status.EQ(Int(int64(fields.PostStatusPublished))))
+	statistics.PostPublished, err = model.PostsModel.Count(ctx.Context(), table.Posts.Status.EQ(Int(int64(fields.PostStatusPublished))))
 	if err != nil {
 		return nil, err
 	}
 
-	statistics.Media, err = models.Medias.Count(ctx.Context())
+	statistics.Media, err = model.MediasModel.Count(ctx.Context())
 	if err != nil {
 		return nil, err
 	}
 
-	statistics.Order, err = models.Orders.Count(ctx.Context(), table.Orders.Status.EQ(Int(int64(fields.OrderStatusCompleted))))
+	statistics.Order, err = model.OrdersModel.Count(ctx.Context(), table.Orders.Status.EQ(Int(int64(fields.OrderStatusCompleted))))
 	if err != nil {
 		return nil, err
 	}
 
-	statistics.User, err = models.Users.Count(ctx.Context(), BoolExp(Bool(true)))
+	statistics.User, err = model.UsersModel.Count(ctx.Context(), BoolExp(Bool(true)))
 	if err != nil {
 		return nil, err
 	}
 
-	statistics.Amount, err = models.Orders.SumAmount(ctx.Context())
+	statistics.Amount, err = model.OrdersModel.SumAmount(ctx.Context())
 	if err != nil {
 		return nil, err
 	}
diff --git a/backend/app/http/admin/uploads.go b/backend/app/http/admin/uploads.go
index 5d91720..a5f48ef 100644
--- a/backend/app/http/admin/uploads.go
+++ b/backend/app/http/admin/uploads.go
@@ -6,8 +6,7 @@ import (
 	"path/filepath"
 
 	"quyun/app/jobs"
-	"quyun/app/models"
-	"quyun/database/schemas/public/model"
+	"quyun/app/model"
 	"quyun/providers/ali"
 	"quyun/providers/app"
 	"quyun/providers/job"
@@ -39,7 +38,7 @@ type PreCheckResp struct {
 //	@Bind	ext path
 //	@Bind	mime query
 func (up *uploads) PreUploadCheck(ctx fiber.Ctx, md5, ext, mime string) (*PreCheckResp, error) {
-	_, err := models.Medias.GetByHash(ctx.Context(), md5)
+	_, err := model.MediasModel.GetByHash(ctx.Context(), md5)
 	if err != nil && errors.Is(err, qrm.ErrNoRows) {
 		preSign, err := up.oss.PreSignUpload(ctx.Context(), fmt.Sprintf("%s.%s", md5, ext), mime)
 		if err != nil {
@@ -64,7 +63,7 @@ type PostUploadedForm struct {
 //	@Router	/admin/uploads/post-uploaded-action [post]
 //	@Bind	body body
 func (up *uploads) PostUploadedAction(ctx fiber.Ctx, body *PostUploadedForm) error {
-	m, err := models.Medias.GetByHash(ctx.Context(), body.Md5)
+	m, err := model.MediasModel.GetByHash(ctx.Context(), body.Md5)
 	if err != nil && !errors.Is(err, qrm.ErrNoRows) {
 		return err
 	}
@@ -76,7 +75,7 @@ func (up *uploads) PostUploadedAction(ctx fiber.Ctx, body *PostUploadedForm) err
 		Hash:     body.Md5,
 		Path:     filepath.Join(UPLOAD_PATH, body.Md5+filepath.Ext(body.OriginalName)),
 	}
-	if err := models.Medias.Create(ctx.Context(), m); err != nil {
+	if err := model.MediasModel.Create(ctx.Context(), m); err != nil {
 		return err
 	}
 
diff --git a/backend/app/http/admin/users.go b/backend/app/http/admin/users.go
index b95e16a..df98dbe 100644
--- a/backend/app/http/admin/users.go
+++ b/backend/app/http/admin/users.go
@@ -1,9 +1,8 @@
 package admin
 
 import (
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/requests"
-	"quyun/database/schemas/public/model"
 
 	"github.com/gofiber/fiber/v3"
 )
@@ -21,8 +20,8 @@ type users struct{}
 //	@Bind	pagination query
 //	@Bind	query query
 func (ctl *users) List(ctx fiber.Ctx, pagination *requests.Pagination, query *UserListQuery) (*requests.Pager, error) {
-	cond := models.Users.BuildConditionWithKey(query.Keyword)
-	return models.Users.List(ctx.Context(), pagination, cond)
+	cond := model.UsersModel.BuildConditionWithKey(query.Keyword)
+	return model.UsersModel.List(ctx.Context(), pagination, cond)
 }
 
 // Show user
@@ -30,7 +29,7 @@ func (ctl *users) List(ctx fiber.Ctx, pagination *requests.Pagination, query *Us
 //	@Router	/admin/users/:id [get]
 //	@Bind	id path
 func (ctl *users) Show(ctx fiber.Ctx, id int64) (*model.Users, error) {
-	return models.Users.GetByID(ctx.Context(), id)
+	return model.UsersModel.GetByID(ctx.Context(), id)
 }
 
 // Articles show user bought articles
@@ -39,7 +38,7 @@ func (ctl *users) Show(ctx fiber.Ctx, id int64) (*model.Users, error) {
 //	@Bind	id path
 //	@Bind	pagination query
 func (ctl *users) Articles(ctx fiber.Ctx, id int64, pagination *requests.Pagination) (*requests.Pager, error) {
-	return models.Posts.Bought(ctx.Context(), id, pagination)
+	return model.PostsModel.Bought(ctx.Context(), id, pagination)
 }
 
 type UserBalance struct {
@@ -52,5 +51,5 @@ type UserBalance struct {
 //	@Bind	id path
 //	@Bind	balance body
 func (ctl *users) Balance(ctx fiber.Ctx, id int64, balance *UserBalance) error {
-	return models.Users.AddBalance(ctx.Context(), id, balance.Balance)
+	return model.UsersModel.AddBalance(ctx.Context(), id, balance.Balance)
 }
diff --git a/backend/app/http/auth.go b/backend/app/http/auth.go
index 32fdb7a..4c85869 100644
--- a/backend/app/http/auth.go
+++ b/backend/app/http/auth.go
@@ -4,9 +4,8 @@ import (
 	"net/url"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
 	"quyun/pkg/utils"
 	"quyun/providers/jwt"
 	"quyun/providers/wechat"
@@ -90,7 +89,7 @@ func (ctl *auth) Login(ctx fiber.Ctx, code, state, redirect string) error {
 			Scope:             token.Scope,
 		}),
 	}
-	user, err := models.Users.GetUserByOpenIDOrCreate(ctx.Context(), token.GetOpenID(), userModel)
+	user, err := model.UsersModel.GetUserByOpenIDOrCreate(ctx.Context(), token.GetOpenID(), userModel)
 	if err != nil {
 		return errors.Wrap(err, "failed to get user by openid")
 	}
diff --git a/backend/app/http/posts.go b/backend/app/http/posts.go
index d1cccf3..b08eda7 100644
--- a/backend/app/http/posts.go
+++ b/backend/app/http/posts.go
@@ -6,11 +6,10 @@ import (
 	"time"
 
 	"quyun/app/jobs"
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/requests"
 	"quyun/database/conds"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
 	"quyun/providers/ali"
 	"quyun/providers/job"
 	"quyun/providers/wepay"
@@ -46,7 +45,7 @@ func (ctl *posts) List(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
 		conds.Post_Like(query.Keyword),
 	}
 
-	pager, err := models.Posts.List(ctx.Context(), pagination, conds...)
+	pager, err := model.PostsModel.List(ctx.Context(), pagination, conds...)
 	if err != nil {
 		log.WithError(err).Errorf("post list err: %v", err)
 		return nil, err
@@ -54,13 +53,13 @@ func (ctl *posts) List(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
 
 	postIds := lo.Map(pager.Items.([]model.Posts), func(item model.Posts, _ int) int64 { return item.ID })
 	if len(postIds) > 0 {
-		userBoughtIds, err := models.Users.BatchCheckHasBought(ctx.Context(), user.ID, postIds)
+		userBoughtIds, err := model.UsersModel.BatchCheckHasBought(ctx.Context(), user.ID, postIds)
 		if err != nil {
 			log.WithError(err).Errorf("BatchCheckHasBought err: %v", err)
 		}
 
 		items := lo.FilterMap(pager.Items.([]model.Posts), func(item model.Posts, _ int) (PostItem, bool) {
-			medias, err := models.Posts.GetMediaByIds(ctx.Context(), item.HeadImages.Data)
+			medias, err := model.PostsModel.GetMediaByIds(ctx.Context(), item.HeadImages.Data)
 			if err != nil {
 				log.Errorf("GetMediaByIds err: %v", err)
 				return PostItem{}, false
@@ -119,18 +118,18 @@ type PostItem struct {
 func (ctl *posts) Show(ctx fiber.Ctx, id int64, user *model.Users) (*PostItem, error) {
 	log.Infof("Fetching post with ID: %d", id)
 
-	post, err := models.Posts.GetByID(ctx.Context(), id, conds.Post_NotDeleted(), conds.Post_Status(fields.PostStatusPublished))
+	post, err := model.PostsModel.GetByID(ctx.Context(), id, conds.Post_NotDeleted(), conds.Post_Status(fields.PostStatusPublished))
 	if err != nil {
 		log.WithError(err).Errorf("GetByID err: %v", err)
 		return nil, err
 	}
 
-	bought, err := models.Users.HasBought(ctx.Context(), user.ID, post.ID)
+	bought, err := model.UsersModel.HasBought(ctx.Context(), user.ID, post.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	medias, err := models.Posts.GetMediaByIds(ctx.Context(), post.HeadImages.Data)
+	medias, err := model.PostsModel.GetMediaByIds(ctx.Context(), post.HeadImages.Data)
 	if err != nil {
 		return nil, err
 	}
@@ -174,22 +173,22 @@ func (ctl *posts) Play(ctx fiber.Ctx, id int64, user *model.Users) (*PlayUrl, er
 	// }, nil
 
 	preview := false
-	bought, err := models.Users.HasBought(ctx.Context(), user.ID, id)
+	bought, err := model.UsersModel.HasBought(ctx.Context(), user.ID, id)
 	if !bought || err != nil {
 		preview = true
 	}
 
 	log.Infof("Fetching play URL for post ID: %d", id)
-	post, err := models.Posts.GetByID(ctx.Context(), id)
+	post, err := model.PostsModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		log.WithError(err).Errorf("GetByID err: %v", err)
 		return nil, err
 	}
-	go models.Posts.IncrViewCount(ctx.Context(), post.ID)
+	go model.PostsModel.IncrViewCount(ctx.Context(), post.ID)
 
 	for _, asset := range post.Assets.Data {
 		if asset.Type == "video/mp4" && asset.Metas != nil && asset.Metas.Short == preview {
-			media, err := models.Medias.GetByID(ctx.Context(), asset.Media)
+			media, err := model.MediasModel.GetByID(ctx.Context(), asset.Media)
 			if err != nil {
 				log.WithError(err).Errorf("medias GetByID err: %v", err)
 				return nil, err
@@ -223,7 +222,7 @@ func (ctl *posts) Mine(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
 		conds.Post_Status(fields.PostStatusPublished),
 		conds.Post_Like(query.Keyword),
 	}
-	pager, err := models.Users.PostList(ctx.Context(), user.ID, pagination, conds...)
+	pager, err := model.UsersModel.PostList(ctx.Context(), user.ID, pagination, conds...)
 	if err != nil {
 		log.WithError(err).Errorf("post list err: %v", err)
 		return nil, err
@@ -232,7 +231,7 @@ func (ctl *posts) Mine(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
 	postIds := lo.Map(pager.Items.([]model.Posts), func(item model.Posts, _ int) int64 { return item.ID })
 	if len(postIds) > 0 {
 		items := lo.FilterMap(pager.Items.([]model.Posts), func(item model.Posts, _ int) (PostItem, bool) {
-			medias, err := models.Posts.GetMediaByIds(ctx.Context(), item.HeadImages.Data)
+			medias, err := model.PostsModel.GetMediaByIds(ctx.Context(), item.HeadImages.Data)
 			if err != nil {
 				log.Errorf("GetMediaByIds err: %v", err)
 				return PostItem{}, false
@@ -271,7 +270,7 @@ func (ctl *posts) Mine(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
 //	@Bind	id path
 //	@Bind	user local
 func (ctl *posts) Buy(ctx fiber.Ctx, id int64, user *model.Users) (*wechat.JSAPIPayParams, error) {
-	bought, err := models.Users.HasBought(ctx.Context(), user.ID, id)
+	bought, err := model.UsersModel.HasBought(ctx.Context(), user.ID, id)
 	if err != nil {
 		return nil, errors.New("查询购买失败")
 	}
@@ -280,19 +279,19 @@ func (ctl *posts) Buy(ctx fiber.Ctx, id int64, user *model.Users) (*wechat.JSAPI
 		return nil, errors.New("已经购买过了")
 	}
 
-	post, err := models.Posts.GetByID(ctx.Context(), id)
+	post, err := model.PostsModel.GetByID(ctx.Context(), id)
 	if err != nil {
 		return nil, errors.Wrapf(err, " failed to get post: %d", id)
 	}
 	payPrice := post.Price * int64(post.Discount) / 100
 
-	order, err := models.Orders.Create(ctx.Context(), user.ID, post.ID)
+	order, err := model.OrdersModel.Create(ctx.Context(), user.ID, post.ID)
 	if err != nil {
 		return nil, errors.Wrap(err, "订单创建失败")
 	}
 
 	if user.Balance >= payPrice {
-		if err := models.Orders.SetMeta(ctx.Context(), order.ID, func(om fields.OrderMeta) fields.OrderMeta {
+		if err := model.OrdersModel.SetMeta(ctx.Context(), order.ID, func(om fields.OrderMeta) fields.OrderMeta {
 			om.CostBalance = payPrice
 			return om
 		}); err != nil {
@@ -310,7 +309,7 @@ func (ctl *posts) Buy(ctx fiber.Ctx, id int64, user *model.Users) (*wechat.JSAPI
 	}
 
 	payPrice = payPrice - user.Balance
-	if err := models.Orders.SetMeta(ctx.Context(), order.ID, func(om fields.OrderMeta) fields.OrderMeta {
+	if err := model.OrdersModel.SetMeta(ctx.Context(), order.ID, func(om fields.OrderMeta) fields.OrderMeta {
 		om.CostBalance = user.Balance
 		return om
 	}); err != nil {
diff --git a/backend/app/http/routes.gen.go b/backend/app/http/routes.gen.go
index 041e8a8..a63ae10 100644
--- a/backend/app/http/routes.gen.go
+++ b/backend/app/http/routes.gen.go
@@ -8,8 +8,8 @@ import (
 	_ "go.ipao.vip/atom"
 	_ "go.ipao.vip/atom/contracts"
 	. "go.ipao.vip/atom/fen"
+	"quyun/app/model"
 	"quyun/app/requests"
-	"quyun/database/schemas/public/model"
 )
 
 // @provider contracts.HttpRoute atom.GroupRoutes
diff --git a/backend/app/http/users.go b/backend/app/http/users.go
index 046d3ed..926526c 100644
--- a/backend/app/http/users.go
+++ b/backend/app/http/users.go
@@ -4,8 +4,7 @@ import (
 	"strings"
 	"time"
 
-	"quyun/app/models"
-	"quyun/database/schemas/public/model"
+	"quyun/app/model"
 
 	"github.com/gofiber/fiber/v3"
 )
@@ -52,7 +51,7 @@ func (ctl *users) Update(ctx fiber.Ctx, user *model.Users, form *ProfileForm) er
 		return fiber.NewError(fiber.StatusBadRequest, "Username cannot be empty")
 	}
 
-	if err := models.Users.UpdateUsername(ctx.Context(), user.ID, username); err != nil {
+	if err := model.UsersModel.UpdateUsername(ctx.Context(), user.ID, username); err != nil {
 		return err
 	}
 	return nil
diff --git a/backend/app/http/wechats.go b/backend/app/http/wechats.go
index b1e3e43..01f8ebf 100644
--- a/backend/app/http/wechats.go
+++ b/backend/app/http/wechats.go
@@ -3,8 +3,7 @@ package http
 import (
 	"time"
 
-	"quyun/app/models"
-	"quyun/database/schemas/public/model"
+	"quyun/app/model"
 	"quyun/providers/wechat"
 
 	"github.com/gofiber/fiber/v3"
@@ -41,7 +40,7 @@ func (ctl *wechats) GetJsSDK(ctx fiber.Ctx, url string, user *model.Users) (*wec
 		oldToken.StableAccessToken = stableToken.AccessToken
 		oldToken.StableExpiresAt = time.Now().Add(time.Second * time.Duration(stableToken.ExpiresIn))
 
-		if err := models.Users.UpdateUserToken(ctx.Context(), user.ID, oldToken); err != nil {
+		if err := model.UsersModel.UpdateUserToken(ctx.Context(), user.ID, oldToken); err != nil {
 			return nil, err
 		}
 		user.AuthToken.Data = oldToken
diff --git a/backend/app/jobs/balance_pay_notify.go b/backend/app/jobs/balance_pay_notify.go
index 63aa618..53fea12 100644
--- a/backend/app/jobs/balance_pay_notify.go
+++ b/backend/app/jobs/balance_pay_notify.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
 
 	"github.com/pkg/errors"
@@ -45,7 +45,7 @@ func (w *BalancePayNotifyWorker) Work(ctx context.Context, job *Job[BalancePayNo
 	log.Infof("[Start] Working on job with strings: %+v", job.Args)
 	defer log.Infof("[End] Finished %s", job.Args.Kind())
 
-	order, err := models.Orders.GetByOrderNo(context.Background(), job.Args.OrderNo)
+	order, err := model.OrdersModel.GetByOrderNo(context.Background(), job.Args.OrderNo)
 	if err != nil {
 		log.Errorf("GetByOrderNo error:%v", err)
 		return err
@@ -56,7 +56,7 @@ func (w *BalancePayNotifyWorker) Work(ctx context.Context, job *Job[BalancePayNo
 		return JobCancel(fmt.Errorf("Order already paid, currently status: %d", order.Status))
 	}
 
-	user, err := models.Users.GetByID(context.Background(), order.UserID)
+	user, err := model.UsersModel.GetByID(context.Background(), order.UserID)
 	if err != nil {
 		log.Errorf("GetByID error:%v", err)
 		return errors.Wrap(err, "get user error")
@@ -75,25 +75,25 @@ func (w *BalancePayNotifyWorker) Work(ctx context.Context, job *Job[BalancePayNo
 	}
 
 	log.Infof("Updated order details: %+v", order)
-	tx, err := models.Transaction(ctx)
+	tx, err := model.Transaction(ctx)
 	if err != nil {
 		return errors.Wrap(err, "Transaction error")
 	}
 	defer tx.Rollback()
 
 	// update user balance
-	err = models.Users.SetBalance(ctx, user.ID, user.Balance-payPrice)
+	err = model.UsersModel.SetBalance(ctx, user.ID, user.Balance-payPrice)
 	if err != nil {
 		log.WithError(err).Error("SetBalance error")
 		return JobCancel(errors.Wrap(err, "set user balance failed"))
 	}
 
-	if err := models.Users.BuyPosts(context.Background(), order.UserID, order.PostID, order.Price); err != nil {
+	if err := model.UsersModel.BuyPosts(context.Background(), order.UserID, order.PostID, order.Price); err != nil {
 		log.Errorf("BuyPosts error:%v", err)
 		return errors.Wrap(err, "BuyPosts error")
 	}
 
-	if err := models.Orders.Update(context.Background(), order); err != nil {
+	if err := model.OrdersModel.Update(context.Background(), order); err != nil {
 		log.Errorf("Update order error:%v", err)
 		return errors.Wrap(err, "Update order error")
 	}
diff --git a/backend/app/jobs/download_from_alioss.go b/backend/app/jobs/download_from_alioss.go
index 969dd45..fbfab90 100644
--- a/backend/app/jobs/download_from_alioss.go
+++ b/backend/app/jobs/download_from_alioss.go
@@ -6,7 +6,7 @@ import (
 	"path/filepath"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/providers/ali"
 	"quyun/providers/app"
 	"quyun/providers/job"
@@ -55,7 +55,7 @@ func (w *DownloadFromAliOSSWorker) Work(ctx context.Context, job *Job[DownloadFr
 	log.Infof("[Start] Working on job with strings: %+v", job.Args)
 	defer log.Infof("[End] Finished %s", job.Args.Kind())
 
-	media, err := models.Medias.GetByHash(ctx, job.Args.MediaHash)
+	media, err := model.MediasModel.GetByHash(ctx, job.Args.MediaHash)
 	if err != nil {
 		log.Errorf("Error getting media by ID: %v", err)
 		return JobCancel(err)
diff --git a/backend/app/jobs/download_from_alioss_test.go b/backend/app/jobs/download_from_alioss_test.go
index 2c2d2e3..6d2772c 100644
--- a/backend/app/jobs/download_from_alioss_test.go
+++ b/backend/app/jobs/download_from_alioss_test.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"testing"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/service/testx"
 	"quyun/providers/ali"
 	"quyun/providers/app"
@@ -34,7 +34,7 @@ type DownloadFromAliOSSSuite struct {
 }
 
 func Test_DownloadFromAliOSS(t *testing.T) {
-	providers := testx.Default().With(Provide, models.Provide)
+	providers := testx.Default().With(Provide, model.Provide)
 
 	testx.Serve(providers, t, func(p DownloadFromAliOSSSuiteInjectParams) {
 		suite.Run(t, &DownloadFromAliOSSSuite{DownloadFromAliOSSSuiteInjectParams: p})
diff --git a/backend/app/jobs/publish_draft_posts.go b/backend/app/jobs/publish_draft_posts.go
index f7771d3..f5cb13b 100644
--- a/backend/app/jobs/publish_draft_posts.go
+++ b/backend/app/jobs/publish_draft_posts.go
@@ -4,9 +4,8 @@ import (
 	"context"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
 	"quyun/pkg/utils"
 	"quyun/providers/ali"
 	"quyun/providers/app"
@@ -57,13 +56,13 @@ func (w *PublishDraftPostsWorker) Work(ctx context.Context, job *Job[PublishDraf
 	log.Infof("[Start] Working on job with strings: %+v", job.Args)
 	defer log.Infof("[End] Finished %s", job.Args.Kind())
 
-	media, err := models.Medias.GetByHash(ctx, job.Args.MediaHash)
+	media, err := model.MediasModel.GetByHash(ctx, job.Args.MediaHash)
 	if err != nil {
 		log.Errorf("Error getting media by ID: %v", err)
 		return JobCancel(err)
 	}
 
-	relationMedias, err := models.Medias.GetRelations(ctx, media.Hash)
+	relationMedias, err := model.MediasModel.GetRelations(ctx, media.Hash)
 	if err != nil {
 		log.Errorf("Error getting relation medias: %v", err)
 		return JobCancel(err)
@@ -98,7 +97,7 @@ func (w *PublishDraftPostsWorker) Work(ctx context.Context, job *Job[PublishDraf
 			return media.ID, media.MimeType == "image/jpeg"
 		})),
 	}
-	if err := models.Posts.Create(ctx, post); err != nil {
+	if err := model.PostsModel.Create(ctx, post); err != nil {
 		log.Errorf("Error creating post: %v", err)
 		return errors.Wrap(err, "create post")
 	}
diff --git a/backend/app/jobs/video_cut.go b/backend/app/jobs/video_cut.go
index 9e3161c..df8a94d 100644
--- a/backend/app/jobs/video_cut.go
+++ b/backend/app/jobs/video_cut.go
@@ -5,7 +5,7 @@ import (
 	"path/filepath"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
 	"quyun/pkg/utils"
 	"quyun/providers/app"
@@ -54,7 +54,7 @@ func (w *VideoCutWorker) Work(ctx context.Context, job *Job[VideoCut]) error {
 	log.Infof("[Start] Working on job with strings: %+v", job.Args)
 	defer log.Infof("[End] Finished %s", job.Args.Kind())
 
-	media, err := models.Medias.GetByHash(ctx, job.Args.MediaHash)
+	media, err := model.MediasModel.GetByHash(ctx, job.Args.MediaHash)
 	if err != nil {
 		log.Errorf("Error getting media by ID: %v", err)
 		return JobCancel(err)
@@ -81,7 +81,7 @@ func (w *VideoCutWorker) Work(ctx context.Context, job *Job[VideoCut]) error {
 		Short:      false,
 		Duration:   duration,
 	}
-	if err := models.Medias.UpdateMetas(ctx, media.ID, metas); err != nil {
+	if err := model.MediasModel.UpdateMetas(ctx, media.ID, metas); err != nil {
 		log.Errorf("Error updating media metas: %v", err)
 		return errors.Wrap(err, "update media metas")
 	}
diff --git a/backend/app/jobs/video_extract_head_image.go b/backend/app/jobs/video_extract_head_image.go
index a23b342..813df34 100644
--- a/backend/app/jobs/video_extract_head_image.go
+++ b/backend/app/jobs/video_extract_head_image.go
@@ -6,9 +6,8 @@ import (
 	"path/filepath"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
 	"quyun/pkg/utils"
 	"quyun/providers/ali"
 	"quyun/providers/app"
@@ -58,7 +57,7 @@ func (w *VideoExtractHeadImageWorker) Work(ctx context.Context, job *Job[VideoEx
 	log.Infof("[Start] Working on job with strings: %+v", job.Args)
 	defer log.Infof("[End] Finished %s", job.Args.Kind())
 
-	media, err := models.Medias.GetByHash(ctx, job.Args.MediaHash)
+	media, err := model.MediasModel.GetByHash(ctx, job.Args.MediaHash)
 	if err != nil {
 		log.Errorf("Error getting media by ID: %v", err)
 		return JobCancel(err)
@@ -111,7 +110,7 @@ func (w *VideoExtractHeadImageWorker) Work(ctx context.Context, job *Job[VideoEx
 		log.Errorf("Error removing original file: %v", err)
 	}
 
-	if err := models.Medias.Create(ctx, imageMedia); err != nil {
+	if err := model.MediasModel.Create(ctx, imageMedia); err != nil {
 		log.Errorf("Error creating media record: %v", err)
 		return errors.Wrap(err, "failed to create media record")
 	}
diff --git a/backend/app/jobs/video_store_short.go b/backend/app/jobs/video_store_short.go
index b26747d..300a6d5 100644
--- a/backend/app/jobs/video_store_short.go
+++ b/backend/app/jobs/video_store_short.go
@@ -5,9 +5,8 @@ import (
 	"path/filepath"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
 	"quyun/pkg/utils"
 	"quyun/providers/ali"
 	"quyun/providers/app"
@@ -58,7 +57,7 @@ func (w *VideoStoreShortWorker) Work(ctx context.Context, job *Job[VideoStoreSho
 	log.Infof("[Start] Working on job with strings: %+v", job.Args)
 	defer log.Infof("[End] Finished %s", job.Args.Kind())
 
-	media, err := models.Medias.GetByHash(ctx, job.Args.MediaHash)
+	media, err := model.MediasModel.GetByHash(ctx, job.Args.MediaHash)
 	if err != nil {
 		log.Errorf("Error getting media by ID: %v", err)
 		return JobCancel(err)
@@ -113,7 +112,7 @@ func (w *VideoStoreShortWorker) Work(ctx context.Context, job *Job[VideoStoreSho
 	}
 
 	log.Infof("pending create media record %s", job.Args.FilePath)
-	if err := models.Medias.Create(ctx, mediaModel); err != nil {
+	if err := model.MediasModel.Create(ctx, mediaModel); err != nil {
 		log.Errorf("Error saving media record: %v data: %+v", err, mediaModel)
 		return err
 	}
diff --git a/backend/app/jobs/wechat_pay_notify.go b/backend/app/jobs/wechat_pay_notify.go
index e1bc009..857b896 100644
--- a/backend/app/jobs/wechat_pay_notify.go
+++ b/backend/app/jobs/wechat_pay_notify.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
 
 	"github.com/go-pay/gopay/wechat/v3"
@@ -53,7 +53,7 @@ func (w *WechatPayNotifyWorker) Work(ctx context.Context, job *Job[WechatPayNoti
 		return JobCancel(errors.New("TradeState is not SUCCESS"))
 	}
 
-	order, err := models.Orders.GetByOrderNo(context.Background(), notify.OutTradeNo)
+	order, err := model.OrdersModel.GetByOrderNo(context.Background(), notify.OutTradeNo)
 	if err != nil {
 		log.Errorf("GetByOrderNo error:%v", err)
 		return err
@@ -64,7 +64,7 @@ func (w *WechatPayNotifyWorker) Work(ctx context.Context, job *Job[WechatPayNoti
 		return JobCancel(fmt.Errorf("Order already paid, currently status: %d", order.Status))
 	}
 
-	user, err := models.Users.GetByID(context.Background(), order.UserID)
+	user, err := model.UsersModel.GetByID(context.Background(), order.UserID)
 	if err != nil {
 		return errors.Wrapf(err, "get user by id(%d) failed", order.UserID)
 	}
@@ -85,25 +85,25 @@ func (w *WechatPayNotifyWorker) Work(ctx context.Context, job *Job[WechatPayNoti
 	order.Meta = fields.ToJson(meta)
 
 	log.Infof("Updated order details: %+v", order)
-	tx, err := models.Transaction(ctx)
+	tx, err := model.Transaction(ctx)
 	if err != nil {
 		return errors.Wrap(err, "Transaction error")
 	}
 	defer tx.Rollback()
 
 	// update user balance
-	err = models.Users.SetBalance(ctx, user.ID, user.Balance-meta.CostBalance)
+	err = model.UsersModel.SetBalance(ctx, user.ID, user.Balance-meta.CostBalance)
 	if err != nil {
 		log.WithError(err).Error("SetBalance error")
 		return JobCancel(errors.Wrap(err, "set user balance failed"))
 	}
 
-	if err := models.Users.BuyPosts(context.Background(), order.UserID, order.PostID, order.Price); err != nil {
+	if err := model.UsersModel.BuyPosts(context.Background(), order.UserID, order.PostID, order.Price); err != nil {
 		log.Errorf("BuyPosts error:%v", err)
 		return errors.Wrap(err, "BuyPosts error")
 	}
 
-	if err := models.Orders.Update(context.Background(), order); err != nil {
+	if err := model.OrdersModel.Update(context.Background(), order); err != nil {
 		log.Errorf("Update order error:%v", err)
 		return errors.Wrap(err, "Update order error")
 	}
diff --git a/backend/app/jobs/wechat_pay_notify_test.go b/backend/app/jobs/wechat_pay_notify_test.go
index 22ca21e..3cb9a22 100644
--- a/backend/app/jobs/wechat_pay_notify_test.go
+++ b/backend/app/jobs/wechat_pay_notify_test.go
@@ -5,7 +5,7 @@ import (
 	"encoding/json"
 	"testing"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/service/testx"
 
 	"github.com/go-pay/gopay/wechat/v3"
@@ -30,7 +30,7 @@ type WechatPayNotifySuite struct {
 }
 
 func Test_WechatPayNotify(t *testing.T) {
-	providers := testx.Default().With(Provide, models.Provide)
+	providers := testx.Default().With(Provide, model.Provide)
 
 	testx.Serve(providers, t, func(p WechatPayNotifySuiteInjectParams) {
 		suite.Run(t, &WechatPayNotifySuite{WechatPayNotifySuiteInjectParams: p})
diff --git a/backend/app/jobs/wechat_refund_notify.go b/backend/app/jobs/wechat_refund_notify.go
index f3060e0..7fa377f 100644
--- a/backend/app/jobs/wechat_refund_notify.go
+++ b/backend/app/jobs/wechat_refund_notify.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/database/fields"
 
 	"github.com/go-pay/gopay/wechat/v3"
@@ -47,7 +47,7 @@ func (w *WechatRefundNotifyWorker) Work(ctx context.Context, job *Job[WechatRefu
 
 	notify := job.Args.Notify
 
-	order, err := models.Orders.GetByOrderNo(context.Background(), notify.OutTradeNo)
+	order, err := model.OrdersModel.GetByOrderNo(context.Background(), notify.OutTradeNo)
 	if err != nil {
 		log.Errorf("GetByOrderNo error:%v", err)
 		return err
@@ -69,20 +69,20 @@ func (w *WechatRefundNotifyWorker) Work(ctx context.Context, job *Job[WechatRefu
 	order.Meta = fields.ToJson(meta)
 
 	log.Infof("Updated order details: %+v", order)
-	tx, err := models.Transaction(ctx)
+	tx, err := model.Transaction(ctx)
 	if err != nil {
 		return errors.Wrap(err, "Transaction error")
 	}
 	defer tx.Rollback()
 
 	if order.Status == fields.OrderStatusRefundSuccess {
-		if err := models.Users.RevokePosts(context.Background(), order.UserID, order.PostID); err != nil {
+		if err := model.UsersModel.RevokePosts(context.Background(), order.UserID, order.PostID); err != nil {
 			log.Errorf("RevokePosts error:%v", err)
 			return errors.Wrap(err, "RevokePosts error")
 		}
 	}
 
-	if err := models.Orders.Update(context.Background(), order); err != nil {
+	if err := model.OrdersModel.Update(context.Background(), order); err != nil {
 		log.Errorf("Update order error:%v", err)
 		return errors.Wrap(err, "Update order error")
 	}
diff --git a/backend/app/middlewares/mid_auth.go b/backend/app/middlewares/mid_auth.go
index 5744fac..975b24a 100644
--- a/backend/app/middlewares/mid_auth.go
+++ b/backend/app/middlewares/mid_auth.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 	"time"
 
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/pkg/utils"
 
 	"github.com/gofiber/fiber/v3"
@@ -26,7 +26,7 @@ func (f *Middlewares) Auth(ctx fiber.Ctx) error {
 	}
 
 	if f.app.IsDevMode() && false {
-		user, err := models.Users.GetByID(ctx.Context(), 1)
+		user, err := model.UsersModel.GetByID(ctx.Context(), 1)
 		if err != nil {
 			return ctx.Send([]byte("User not found"))
 		}
@@ -66,7 +66,7 @@ func (f *Middlewares) Auth(ctx fiber.Ctx) error {
 		return ctx.Redirect().To(fullUrl)
 	}
 
-	user, err := models.Users.GetByID(ctx.Context(), jwt.UserID)
+	user, err := model.UsersModel.GetByID(ctx.Context(), jwt.UserID)
 	if err != nil {
 		// remove cookie
 		ctx.ClearCookie("token")
diff --git a/backend/database/schemas/public/model/medias.go b/backend/app/model/medias.gen.go
similarity index 100%
rename from backend/database/schemas/public/model/medias.go
rename to backend/app/model/medias.gen.go
diff --git a/backend/app/model/medias.go b/backend/app/model/medias.go
new file mode 100644
index 0000000..858d784
--- /dev/null
+++ b/backend/app/model/medias.go
@@ -0,0 +1,270 @@
+package model
+
+import (
+	"context"
+	"time"
+
+	"quyun/app/requests"
+	"quyun/database/fields"
+	"quyun/database/table"
+
+	. "github.com/go-jet/jet/v2/postgres"
+	"github.com/samber/lo"
+	log "github.com/sirupsen/logrus"
+)
+
+func (m *Medias) log() *log.Entry {
+	return log.WithField("model", "MediasModel")
+}
+
+func (m *Medias) BuildConditionWithKey(key *string) BoolExpression {
+	tbl := table.Medias
+
+	cond := Bool(true)
+
+	if key == nil || *key == "" {
+		return cond
+	}
+
+	cond = cond.AND(
+		tbl.Name.LIKE(String("%" + *key + "%")),
+	)
+
+	return cond
+}
+
+// countByCond
+func (m *Medias) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
+	var cnt struct {
+		Cnt int64
+	}
+
+	tbl := table.Medias
+	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(expr)
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	err := stmt.QueryContext(ctx, db, &cnt)
+	if err != nil {
+		m.log().Errorf("error counting media items: %v", err)
+		return 0, err
+	}
+
+	return cnt.Cnt, nil
+}
+
+func (m *Medias) List(ctx context.Context, pagination *requests.Pagination, expr BoolExpression) (*requests.Pager, error) {
+	pagination.Format()
+
+	tbl := table.Medias
+	stmt := tbl.
+		SELECT(tbl.AllColumns).
+		WHERE(expr).
+		ORDER_BY(tbl.ID.DESC()).
+		LIMIT(pagination.Limit).
+		OFFSET(pagination.Offset)
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	var medias []Medias
+	err := stmt.QueryContext(ctx, db, &medias)
+	if err != nil {
+		m.log().Errorf("error querying media items: %v", err)
+		return nil, err
+	}
+
+	count, err := m.countByCondition(ctx, expr)
+	if err != nil {
+		m.log().Errorf("error getting media count: %v", err)
+		return nil, err
+	}
+
+	return &requests.Pager{
+		Items:      medias,
+		Total:      count,
+		Pagination: *pagination,
+	}, nil
+}
+
+func (m *Medias) BatchCreate(ctx context.Context, models []*Medias) error {
+	stmt := table.Medias.INSERT(table.Medias.MutableColumns).MODELS(models)
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	if _, err := stmt.ExecContext(ctx, db); err != nil {
+		m.log().Errorf("error creating media item: %v", err)
+		return err
+	}
+
+	m.log().Infof("media item created successfully")
+	return nil
+}
+
+func (m *Medias) Create(ctx context.Context, medias *Medias) error {
+	medias.CreatedAt = time.Now()
+	stmt := table.Medias.INSERT(table.Medias.MutableColumns).MODEL(medias).RETURNING(table.Medias.AllColumns)
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	if err := stmt.QueryContext(ctx, db, medias); err != nil {
+		m.log().Errorf("error creating media item: %v", err)
+		return err
+	}
+
+	m.log().Infof("media item created successfully")
+	return nil
+}
+
+// GetByIds
+func (m *Medias) GetByIds(ctx context.Context, ids []int64) ([]*Medias, error) {
+	if len(ids) == 0 {
+		return nil, nil
+	}
+
+	condIds := lo.Map(ids, func(id int64, _ int) Expression {
+		return Int64(id)
+	})
+
+	tbl := table.Medias
+	stmt := tbl.
+		SELECT(tbl.AllColumns).
+		WHERE(tbl.ID.IN(condIds...))
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	var medias []Medias
+	err := stmt.QueryContext(ctx, db, &medias)
+	if err != nil {
+		m.log().Errorf("error querying media items: %v", err)
+		return nil, err
+	}
+
+	return lo.Map(medias, func(media Medias, _ int) *Medias {
+		return &media
+	}), nil
+}
+
+// GetByHash
+func (m *Medias) GetByHash(ctx context.Context, hash string) (*Medias, error) {
+	tbl := table.Medias
+	stmt := tbl.
+		SELECT(tbl.AllColumns).
+		WHERE(tbl.Hash.EQ(String(hash)))
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	var media Medias
+	err := stmt.QueryContext(ctx, db, &media)
+	if err != nil {
+		m.log().Errorf("error querying media item by hash: %v", err)
+		return nil, err
+	}
+
+	return &media, nil
+}
+
+// Update
+func (m *Medias) Update(ctx context.Context, hash string, model *Medias) error {
+	tbl := table.Medias
+	stmt := tbl.
+		UPDATE(tbl.MutableColumns.Except(tbl.CreatedAt)).
+		MODEL(model).
+		WHERE(table.Medias.Hash.EQ(String(hash)))
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	if _, err := stmt.ExecContext(ctx, db); err != nil {
+		m.log().WithField("hash", hash).Errorf("error updating media item: %v", err)
+		return err
+	}
+
+	m.log().Infof("media item updated successfully")
+	return nil
+}
+
+// GetByID
+func (m *Medias) GetByID(ctx context.Context, id int64) (*Medias, error) {
+	tbl := table.Medias
+	stmt := tbl.
+		SELECT(tbl.AllColumns).
+		WHERE(tbl.ID.EQ(Int64(id)))
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	var media Medias
+
+	if err := stmt.QueryContext(ctx, db, &media); err != nil {
+		m.log().Errorf("error querying media item by ID: %v", err)
+		return nil, err
+	}
+
+	return &media, nil
+}
+
+// Delete
+func (m *Medias) Delete(ctx context.Context, id int64) error {
+	tbl := table.Medias
+	stmt := tbl.
+		DELETE().
+		WHERE(tbl.ID.EQ(Int64(id)))
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	if _, err := stmt.ExecContext(ctx, db); err != nil {
+		m.log().Errorf("error deleting media item: %v", err)
+		return err
+	}
+
+	m.log().Infof("media item deleted successfully")
+	return nil
+}
+
+// UpdateMetas
+func (m *Medias) UpdateMetas(ctx context.Context, id int64, metas fields.MediaMetas) error {
+	meta := fields.ToJson(metas)
+
+	tbl := table.Medias
+	stmt := tbl.
+		UPDATE(tbl.Metas).
+		SET(meta).
+		WHERE(tbl.ID.EQ(Int64(id)))
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	if _, err := stmt.ExecContext(ctx, db); err != nil {
+		m.log().Errorf("error updating media metas: %v", err)
+		return err
+	}
+
+	m.log().Infof("media (%d) metas updated successfully", id)
+	return nil
+}
+
+// GetRelationMedias
+func (m *Medias) GetRelations(ctx context.Context, hash string) ([]*Medias, error) {
+	tbl := table.Medias
+	stmt := tbl.
+		SELECT(tbl.AllColumns).
+		WHERE(
+			RawBool("metas->>'parent_hash' = ?", RawArgs{"?": hash}),
+		)
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	var medias []Medias
+	if err := stmt.QueryContext(ctx, db, &medias); err != nil {
+		m.log().Errorf("error querying media items: %v", err)
+		return nil, err
+	}
+
+	return lo.Map(medias, func(media Medias, _ int) *Medias {
+		return &media
+	}), nil
+}
+
+// Count
+func (m *Medias) Count(ctx context.Context) (int64, error) {
+	tbl := table.Medias
+	stmt := tbl.SELECT(COUNT(tbl.ID).AS("count"))
+	m.log().Infof("sql: %s", stmt.DebugSql())
+
+	var count struct {
+		Count int64
+	}
+
+	if err := stmt.QueryContext(ctx, db, &count); err != nil {
+		m.log().Errorf("error counting media items: %v", err)
+		return 0, err
+	}
+
+	return count.Count, nil
+}
diff --git a/backend/app/models/medias_test.go b/backend/app/model/medias_test.go
similarity index 78%
rename from backend/app/models/medias_test.go
rename to backend/app/model/medias_test.go
index 38432e9..ab0ccc3 100644
--- a/backend/app/models/medias_test.go
+++ b/backend/app/model/medias_test.go
@@ -1,4 +1,4 @@
-package models
+package model
 
 import (
 	"context"
@@ -11,8 +11,7 @@ import (
 	"quyun/app/requests"
 	"quyun/app/service/testx"
 	"quyun/database"
-	"quyun/database/schemas/public/model"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
 	. "github.com/smartystreets/goconvey/convey"
 	"go.ipao.vip/atom/contracts"
@@ -33,10 +32,18 @@ type MediasTestSuite struct {
 	MediasInjectParams
 }
 
-func Test_medias(t *testing.T) {
+func Test_Medias(t *testing.T) {
 	providers := testx.Default().With(Provide)
 	testx.Serve(providers, t, func(params MediasInjectParams) {
-		suite.Run(t, &MediasTestSuite{MediasInjectParams: params})
+		suite.Run(t, &MediasTestSuite{
+			MediasInjectParams: params,
+		})
+	})
+}
+
+func (s *MediasTestSuite) Test_Demo() {
+	Convey("Test_Demo", s.T(), func() {
+		database.Truncate(context.Background(), db, table.Medias.TableName())
 	})
 }
 
@@ -45,7 +52,7 @@ func (s *MediasTestSuite) Test_countByCondition() {
 		Convey("no cond", func() {
 			database.Truncate(context.Background(), db, table.Medias.TableName())
 
-			cnt, err := Medias.countByCondition(context.Background(), nil)
+			cnt, err := MediasModel.countByCondition(context.Background(), nil)
 			Convey("should not return an error", func() {
 				So(err, ShouldBeNil)
 			})
@@ -61,7 +68,7 @@ func (s *MediasTestSuite) Test_BatchCreate() {
 		Convey("valid media", func() {
 			database.Truncate(context.Background(), db, table.Medias.TableName())
 
-			models := []*model.Medias{
+			models := []*Medias{
 				{
 					Name:      "test 01",
 					CreatedAt: time.Now(),
@@ -101,7 +108,7 @@ func (s *MediasTestSuite) Test_BatchCreate() {
 
 			count := 10
 			for i := 0; i < count; i++ {
-				err := Medias.BatchCreate(context.Background(), models)
+				err := MediasModel.BatchCreate(context.Background(), models)
 				Convey("Create should not return an error: "+fmt.Sprintf("%d", i), func() {
 					So(err, ShouldBeNil)
 				})
@@ -115,7 +122,7 @@ func (s *MediasTestSuite) Test_Create() {
 		Convey("valid media", func() {
 			database.Truncate(context.Background(), db, table.Medias.TableName())
 
-			model := &model.Medias{
+			model := &Medias{
 				Name:      "test",
 				CreatedAt: time.Now(),
 				MimeType:  "application/pdf",
@@ -123,12 +130,12 @@ func (s *MediasTestSuite) Test_Create() {
 				Path:      "path/to/media.pdf",
 			}
 
-			err := Medias.Create(context.Background(), model)
+			err := MediasModel.Create(context.Background(), model)
 			Convey("Create should not return an error", func() {
 				So(err, ShouldBeNil)
 			})
 
-			cnt, err := Medias.countByCondition(context.Background(), nil)
+			cnt, err := MediasModel.countByCondition(context.Background(), nil)
 			Convey("Count should not return an error", func() {
 				So(err, ShouldBeNil)
 			})
@@ -148,7 +155,7 @@ func (s *MediasTestSuite) Test_Page() {
 			database.Truncate(context.Background(), db, table.Medias.TableName())
 
 			for i := 0; i < 20; i++ {
-				model := &model.Medias{
+				model := &Medias{
 					Name:      fmt.Sprintf("test-%d", i),
 					CreatedAt: time.Now(),
 					MimeType:  "application/pdf",
@@ -156,31 +163,31 @@ func (s *MediasTestSuite) Test_Page() {
 					Path:      "path/to/media.pdf",
 				}
 
-				err := Medias.Create(context.Background(), model)
+				err := MediasModel.Create(context.Background(), model)
 				So(err, ShouldBeNil)
 			}
 
-			cnt, err := Medias.countByCondition(context.Background(), nil)
+			cnt, err := MediasModel.countByCondition(context.Background(), nil)
 			So(err, ShouldBeNil)
 			So(cnt, ShouldEqual, 20)
 		})
 
 		Convey("Page", func() {
 			Convey("page 1", func() {
-				pager, err := Medias.List(context.Background(), &requests.Pagination{Page: 1, Limit: 10}, nil)
+				pager, err := MediasModel.List(context.Background(), &requests.Pagination{Page: 1, Limit: 10}, nil)
 				So(err, ShouldBeNil)
 				So(pager.Total, ShouldEqual, 20)
 				So(pager.Items, ShouldHaveLength, 10)
 			})
 			Convey("page 2", func() {
-				pager, err := Medias.List(context.Background(), &requests.Pagination{Page: 2, Limit: 10}, nil)
+				pager, err := MediasModel.List(context.Background(), &requests.Pagination{Page: 2, Limit: 10}, nil)
 				So(err, ShouldBeNil)
 				So(pager.Total, ShouldEqual, 20)
 				So(pager.Items, ShouldHaveLength, 10)
 			})
 
 			Convey("page 3", func() {
-				pager, err := Medias.List(context.Background(), &requests.Pagination{Page: 3, Limit: 10}, nil)
+				pager, err := MediasModel.List(context.Background(), &requests.Pagination{Page: 3, Limit: 10}, nil)
 				So(err, ShouldBeNil)
 				So(pager.Total, ShouldEqual, 20)
 				So(pager.Items, ShouldBeEmpty)
@@ -191,7 +198,7 @@ func (s *MediasTestSuite) Test_Page() {
 
 func (s *MediasTestSuite) Test_CreateGetID() {
 	Convey("Create", s.T(), func() {
-		model := &model.Medias{
+		model := &Medias{
 			Name:      fmt.Sprintf("test-%d", 1),
 			CreatedAt: time.Now(),
 			MimeType:  "application/pdf",
@@ -199,7 +206,7 @@ func (s *MediasTestSuite) Test_CreateGetID() {
 			Path:      "path/to/media.pdf",
 		}
 
-		err := Medias.Create(context.Background(), model)
+		err := MediasModel.Create(context.Background(), model)
 		So(err, ShouldBeNil)
 		So(model.ID, ShouldNotBeEmpty)
 
@@ -210,7 +217,7 @@ func (s *MediasTestSuite) Test_CreateGetID() {
 func (s *MediasTestSuite) Test_GetRelations() {
 	Convey("GetByHash", s.T(), func() {
 		hash := "ce4cd071128cef282cf315dda75bdab4"
-		media, err := Medias.GetRelations(context.Background(), hash)
+		media, err := MediasModel.GetRelations(context.Background(), hash)
 		So(err, ShouldBeNil)
 		So(media, ShouldNotBeNil)
 
diff --git a/backend/database/schemas/public/model/migrations.go b/backend/app/model/migrations.gen.go
similarity index 100%
rename from backend/database/schemas/public/model/migrations.go
rename to backend/app/model/migrations.gen.go
diff --git a/backend/database/schemas/public/model/orders.go b/backend/app/model/orders.gen.go
similarity index 100%
rename from backend/database/schemas/public/model/orders.go
rename to backend/app/model/orders.gen.go
diff --git a/backend/app/models/orders.go b/backend/app/model/orders.go
similarity index 59%
rename from backend/app/models/orders.go
rename to backend/app/model/orders.go
index 65eb730..a29de1a 100644
--- a/backend/app/models/orders.go
+++ b/backend/app/model/orders.go
@@ -1,4 +1,4 @@
-package models
+package model
 
 import (
 	"context"
@@ -7,27 +7,20 @@ import (
 
 	"quyun/app/requests"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
 	. "github.com/go-jet/jet/v2/postgres"
 	"github.com/pkg/errors"
 	"github.com/samber/lo"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 )
 
-// @provider
-type ordersModel struct {
-	log *logrus.Entry `inject:"false"`
-}
-
-func (m *ordersModel) Prepare() error {
-	m.log = logrus.WithField("model", "ordersModel")
-	return nil
+func (m *Orders) log() *log.Entry {
+	return log.WithField("model", "OrdersModel")
 }
 
 // GetByID returns an order by ID
-func (m *ordersModel) GetByID(ctx context.Context, id int64) (*model.Orders, error) {
+func (m *Orders) GetByID(ctx context.Context, id int64) (*Orders, error) {
 	tbl := table.Orders
 
 	stmt := tbl.
@@ -35,12 +28,12 @@ func (m *ordersModel) GetByID(ctx context.Context, id int64) (*model.Orders, err
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var order model.Orders
+	var order Orders
 	err := stmt.QueryContext(ctx, db, &order)
 	if err != nil {
-		m.log.Errorf("error querying order by ID: %v", err)
+		m.log().Errorf("error querying order by ID: %v", err)
 		return nil, err
 	}
 
@@ -48,7 +41,7 @@ func (m *ordersModel) GetByID(ctx context.Context, id int64) (*model.Orders, err
 }
 
 // BuildConditionWithKey builds the WHERE clause for order queries
-func (m *ordersModel) BuildConditionWithKey(orderNumber *string, userID *int64) BoolExpression {
+func (m *Orders) BuildConditionWithKey(orderNumber *string, userID *int64) BoolExpression {
 	tbl := table.Orders
 
 	cond := Bool(true)
@@ -69,18 +62,18 @@ func (m *ordersModel) BuildConditionWithKey(orderNumber *string, userID *int64)
 }
 
 // countByCondition counts orders matching the given condition
-func (m *ordersModel) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
+func (m *Orders) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
 	var cnt struct {
 		Cnt int64
 	}
 
 	tbl := table.Orders
 	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(expr)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	err := stmt.QueryContext(ctx, db, &cnt)
 	if err != nil {
-		m.log.Errorf("error counting orders: %v", err)
+		m.log().Errorf("error counting orders: %v", err)
 		return 0, err
 	}
 
@@ -88,7 +81,7 @@ func (m *ordersModel) countByCondition(ctx context.Context, expr BoolExpression)
 }
 
 // List returns a paginated list of orders
-func (m *ordersModel) List(ctx context.Context, pagination *requests.Pagination, cond BoolExpression) (*requests.Pager, error) {
+func (m *Orders) List(ctx context.Context, pagination *requests.Pagination, cond BoolExpression) (*requests.Pager, error) {
 	pagination.Format()
 
 	tbl := table.Orders
@@ -98,45 +91,45 @@ func (m *ordersModel) List(ctx context.Context, pagination *requests.Pagination,
 		ORDER_BY(tbl.ID.DESC()).
 		LIMIT(pagination.Limit).
 		OFFSET(pagination.Offset)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var orders []model.Orders = make([]model.Orders, 0)
+	var orders []Orders = make([]Orders, 0)
 	if err := stmt.QueryContext(ctx, db, &orders); err != nil {
-		m.log.Errorf("error querying orders: %v", err)
+		m.log().Errorf("error querying orders: %v", err)
 		return nil, err
 	}
 
-	postsMap, err := Posts.GetPostsMapByIDs(ctx, lo.Map(orders, func(order model.Orders, _ int) int64 {
+	postsMap, err := PostsModel.GetPostsMapByIDs(ctx, lo.Map(orders, func(order Orders, _ int) int64 {
 		return order.PostID
 	}))
 	if err != nil {
-		m.log.Errorf("error getting posts map: %v", err)
+		m.log().Errorf("error getting posts map: %v", err)
 		return nil, err
 	}
 
-	userMap, err := Users.GetUsersMapByIDs(ctx, lo.Map(orders, func(order model.Orders, _ int) int64 {
+	userMap, err := UsersModel.GetUsersMapByIDs(ctx, lo.Map(orders, func(order Orders, _ int) int64 {
 		return order.UserID
 	}))
 	if err != nil {
-		m.log.Errorf("error getting users map: %v", err)
+		m.log().Errorf("error getting users map: %v", err)
 		return nil, err
 	}
 
 	count, err := m.countByCondition(ctx, cond)
 	if err != nil {
-		m.log.Errorf("error getting order count: %v", err)
+		m.log().Errorf("error getting order count: %v", err)
 		return nil, err
 	}
 
 	type orderItem struct {
-		model.Orders
+		Orders
 
 		PostTitle string `json:"post_title"`
 		Username  string `json:"username"`
 	}
 
 	return &requests.Pager{
-		Items: lo.Map(orders, func(order model.Orders, _ int) *orderItem {
+		Items: lo.Map(orders, func(order Orders, _ int) *orderItem {
 			item := &orderItem{
 				Orders: order,
 			}
@@ -157,13 +150,13 @@ func (m *ordersModel) List(ctx context.Context, pagination *requests.Pagination,
 }
 
 // Create creates a new order
-func (o *ordersModel) Create(ctx context.Context, userId, postId int64) (*model.Orders, error) {
-	post, err := Posts.GetByID(ctx, postId)
+func (o *Orders) Create(ctx context.Context, userId, postId int64) (*Orders, error) {
+	post, err := PostsModel.GetByID(ctx, postId)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get post")
 	}
 
-	m := &model.Orders{}
+	m := &Orders{}
 	m.CreatedAt = time.Now()
 	m.UpdatedAt = time.Now()
 	m.Status = fields.OrderStatusPending
@@ -177,17 +170,17 @@ func (o *ordersModel) Create(ctx context.Context, userId, postId int64) (*model.
 
 	tbl := table.Orders
 	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(m).RETURNING(tbl.AllColumns)
-	o.log.Infof("sql: %s", stmt.DebugSql())
+	o.log().Infof("sql: %s", stmt.DebugSql())
 
-	var order model.Orders
+	var order Orders
 	if err := stmt.QueryContext(ctx, db, &order); err != nil {
-		o.log.Errorf("error creating order: %v", err)
+		o.log().Errorf("error creating order: %v", err)
 		return nil, err
 	}
 	return &order, nil
 }
 
-func (m *ordersModel) SetMeta(ctx context.Context, id int64, metaFunc func(fields.OrderMeta) fields.OrderMeta) error {
+func (m *Orders) SetMeta(ctx context.Context, id int64, metaFunc func(fields.OrderMeta) fields.OrderMeta) error {
 	order, err := m.GetByID(ctx, id)
 	if err != nil {
 		return errors.Wrap(err, "failed to get order")
@@ -200,17 +193,17 @@ func (m *ordersModel) SetMeta(ctx context.Context, id int64, metaFunc func(field
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error set order meta: %v", err)
+		m.log().Errorf("error set order meta: %v", err)
 		return err
 	}
 	return nil
 }
 
 // DeleteByID soft deletes an order by ID
-func (m *ordersModel) SetStatus(ctx context.Context, orderNo string, status fields.OrderStatus) error {
+func (m *Orders) SetStatus(ctx context.Context, orderNo string, status fields.OrderStatus) error {
 	tbl := table.Orders
 	stmt := tbl.
 		UPDATE(tbl.Status).
@@ -218,20 +211,20 @@ func (m *ordersModel) SetStatus(ctx context.Context, orderNo string, status fiel
 		WHERE(
 			tbl.OrderNo.EQ(String(orderNo)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error set order status: %v", err)
+		m.log().Errorf("error set order status: %v", err)
 		return err
 	}
 	return nil
 }
 
 // Count
-func (m *ordersModel) Count(ctx context.Context, cond BoolExpression) (int64, error) {
+func (m *Orders) Count(ctx context.Context, cond BoolExpression) (int64, error) {
 	tbl := table.Orders
 	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(cond)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	var cnt struct {
 		Cnt int64
@@ -239,7 +232,7 @@ func (m *ordersModel) Count(ctx context.Context, cond BoolExpression) (int64, er
 
 	err := stmt.QueryContext(ctx, db, &cnt)
 	if err != nil {
-		m.log.Errorf("error counting orders: %v", err)
+		m.log().Errorf("error counting orders: %v", err)
 		return 0, err
 	}
 
@@ -247,12 +240,12 @@ func (m *ordersModel) Count(ctx context.Context, cond BoolExpression) (int64, er
 }
 
 // SumAmount
-func (m *ordersModel) SumAmount(ctx context.Context) (int64, error) {
+func (m *Orders) SumAmount(ctx context.Context) (int64, error) {
 	tbl := table.Orders
 	stmt := SELECT(SUM(tbl.Price).AS("cnt")).FROM(tbl).WHERE(
 		tbl.Status.EQ(Int(int64(fields.OrderStatusCompleted))),
 	)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	var cnt struct {
 		Cnt int64
@@ -260,7 +253,7 @@ func (m *ordersModel) SumAmount(ctx context.Context) (int64, error) {
 
 	err := stmt.QueryContext(ctx, db, &cnt)
 	if err != nil {
-		m.log.Errorf("error summing order amount: %v", err)
+		m.log().Errorf("error summing order amount: %v", err)
 		return 0, err
 	}
 
@@ -268,19 +261,19 @@ func (m *ordersModel) SumAmount(ctx context.Context) (int64, error) {
 }
 
 // GetByOrderNo
-func (m *ordersModel) GetByOrderNo(ctx context.Context, orderNo string) (*model.Orders, error) {
+func (m *Orders) GetByOrderNo(ctx context.Context, orderNo string) (*Orders, error) {
 	tbl := table.Orders
 	stmt := tbl.
 		SELECT(tbl.AllColumns).
 		WHERE(
 			tbl.OrderNo.EQ(String(orderNo)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var order model.Orders
+	var order Orders
 	err := stmt.QueryContext(ctx, db, &order)
 	if err != nil {
-		m.log.Errorf("error querying order by orderNo: %v", err)
+		m.log().Errorf("error querying order by orderNo: %v", err)
 		return nil, err
 	}
 
@@ -288,7 +281,7 @@ func (m *ordersModel) GetByOrderNo(ctx context.Context, orderNo string) (*model.
 }
 
 // SetTranscationID
-func (m *ordersModel) SetTranscationID(ctx context.Context, id int64, transactionID string) error {
+func (m *Orders) SetTranscationID(ctx context.Context, id int64, transactionID string) error {
 	tbl := table.Orders
 	stmt := tbl.
 		UPDATE(tbl.TransactionID).
@@ -296,17 +289,17 @@ func (m *ordersModel) SetTranscationID(ctx context.Context, id int64, transactio
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error set order transaction ID: %v", err)
+		m.log().Errorf("error set order transaction ID: %v", err)
 		return err
 	}
 	return nil
 }
 
 // Update
-func (m *ordersModel) Update(ctx context.Context, order *model.Orders) error {
+func (m *Orders) Update(ctx context.Context, order *Orders) error {
 	tbl := table.Orders
 	stmt := tbl.
 		UPDATE(
@@ -323,10 +316,10 @@ func (m *ordersModel) Update(ctx context.Context, order *model.Orders) error {
 		WHERE(
 			tbl.ID.EQ(Int64(order.ID)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error updating order: %v", err)
+		m.log().Errorf("error updating order: %v", err)
 		return err
 	}
 	return nil
diff --git a/backend/app/models/orders_test.go b/backend/app/model/orders_test.go
similarity index 73%
rename from backend/app/models/orders_test.go
rename to backend/app/model/orders_test.go
index 853d373..d462a5e 100644
--- a/backend/app/models/orders_test.go
+++ b/backend/app/model/orders_test.go
@@ -1,4 +1,4 @@
-package models
+package model
 
 import (
 	"context"
@@ -6,7 +6,7 @@ import (
 
 	"quyun/app/service/testx"
 	"quyun/database"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
 	. "github.com/smartystreets/goconvey/convey"
 	"go.ipao.vip/atom/contracts"
@@ -36,12 +36,8 @@ func Test_Orders(t *testing.T) {
 	})
 }
 
-func (s *OrdersTestSuite) Test_Create() {
-	Convey("Test_Create", s.T(), func() {
+func (s *OrdersTestSuite) Test_Demo() {
+	Convey("Test_Demo", s.T(), func() {
 		database.Truncate(context.Background(), db, table.Orders.TableName())
-
-		order, err := Orders.Create(context.Background(), 1, 1)
-		So(err, ShouldBeNil)
-		s.T().Logf("order: %v", order)
 	})
 }
diff --git a/backend/database/schemas/public/model/posts.go b/backend/app/model/posts.gen.go
similarity index 100%
rename from backend/database/schemas/public/model/posts.go
rename to backend/app/model/posts.gen.go
diff --git a/backend/app/models/posts.go b/backend/app/model/posts.go
similarity index 59%
rename from backend/app/models/posts.go
rename to backend/app/model/posts.go
index 3c32e27..142e9e2 100644
--- a/backend/app/models/posts.go
+++ b/backend/app/model/posts.go
@@ -1,4 +1,4 @@
-package models
+package model
 
 import (
 	"context"
@@ -7,42 +7,35 @@ import (
 
 	"quyun/app/requests"
 	"quyun/database/conds"
-	"quyun/database/schemas/public/model"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
 	. "github.com/go-jet/jet/v2/postgres"
 	"github.com/go-jet/jet/v2/qrm"
 	"github.com/samber/lo"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 )
 
-// @provider
-type postsModel struct {
-	log *logrus.Entry `inject:"false"`
+func (m *Posts) log() *log.Entry {
+	return log.WithField("model", "PostsModel")
 }
 
-func (m *postsModel) Prepare() error {
-	m.log = logrus.WithField("model", "postsModel")
-	return nil
-}
-
-func (m *postsModel) IncrViewCount(ctx context.Context, id int64) error {
+func (m *Posts) IncrViewCount(ctx context.Context, id int64) error {
 	tbl := table.Posts
 
 	stmt := tbl.UPDATE(tbl.Views).SET(tbl.Views.ADD(Int64(1))).WHERE(tbl.ID.EQ(Int64(id)))
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var post model.Posts
+	var post Posts
 	err := stmt.QueryContext(ctx, db, &post)
 	if err != nil {
-		m.log.Errorf("error updating post view count: %v", err)
+		m.log().Errorf("error updating post view count: %v", err)
 		return err
 	}
 	return nil
 }
 
 // GetByID
-func (m *postsModel) GetByID(ctx context.Context, id int64, cond ...conds.Cond) (*model.Posts, error) {
+func (m *Posts) GetByID(ctx context.Context, id int64, cond ...conds.Cond) (*Posts, error) {
 	tbl := table.Posts
 
 	var combinedCond BoolExpression = tbl.ID.EQ(Int64(id))
@@ -50,70 +43,70 @@ func (m *postsModel) GetByID(ctx context.Context, id int64, cond ...conds.Cond)
 		combinedCond = c(combinedCond)
 	}
 	stmt := tbl.SELECT(tbl.AllColumns).WHERE(combinedCond)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var post model.Posts
+	var post Posts
 	err := stmt.QueryContext(ctx, db, &post)
 	if err != nil {
-		m.log.Errorf("error getting post: %v", err)
+		m.log().Errorf("error getting post: %v", err)
 		return nil, err
 	}
 	return &post, nil
 }
 
 // Create
-func (m *postsModel) Create(ctx context.Context, model *model.Posts) error {
-	model.CreatedAt = time.Now()
-	model.UpdatedAt = time.Now()
+func (m *Posts) Create(ctx context.Context, post *Posts) error {
+	post.CreatedAt = time.Now()
+	post.UpdatedAt = time.Now()
 
 	tbl := table.Posts
-	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(model)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(post)
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	_, err := stmt.ExecContext(ctx, db)
 	if err != nil {
-		m.log.Errorf("error creating post: %v", err)
+		m.log().Errorf("error creating post: %v", err)
 		return err
 	}
 	return nil
 }
 
 // Update
-func (m *postsModel) Update(ctx context.Context, id int64, model *model.Posts) error {
-	model.UpdatedAt = time.Now()
+func (m *Posts) Update(ctx context.Context, id int64, posts *Posts) error {
+	posts.UpdatedAt = time.Now()
 
 	tbl := table.Posts
-	stmt := tbl.UPDATE(tbl.MutableColumns.Except(tbl.CreatedAt, tbl.DeletedAt)).MODEL(model).WHERE(tbl.ID.EQ(Int64(id)))
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	stmt := tbl.UPDATE(tbl.MutableColumns.Except(tbl.CreatedAt, tbl.DeletedAt)).MODEL(posts).WHERE(tbl.ID.EQ(Int64(id)))
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	_, err := stmt.ExecContext(ctx, db)
 	if err != nil {
-		m.log.Errorf("error updating post: %v", err)
+		m.log().Errorf("error updating post: %v", err)
 		return err
 	}
 	return nil
 }
 
 // countByCond
-func (m *postsModel) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
+func (m *Posts) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
 	var cnt struct {
 		Cnt int64
 	}
 
 	tbl := table.Posts
 	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(expr)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	err := stmt.QueryContext(ctx, db, &cnt)
 	if err != nil {
-		m.log.Errorf("error counting post items: %v", err)
+		m.log().Errorf("error counting post items: %v", err)
 		return 0, err
 	}
 
 	return cnt.Cnt, nil
 }
 
-func (m *postsModel) List(ctx context.Context, pagination *requests.Pagination, cond ...conds.Cond) (*requests.Pager, error) {
+func (m *Posts) List(ctx context.Context, pagination *requests.Pagination, cond ...conds.Cond) (*requests.Pager, error) {
 	pagination.Format()
 
 	combinedCond := table.Posts.DeletedAt.IS_NULL()
@@ -128,18 +121,18 @@ func (m *postsModel) List(ctx context.Context, pagination *requests.Pagination,
 		ORDER_BY(tbl.ID.DESC()).
 		LIMIT(pagination.Limit).
 		OFFSET(pagination.Offset)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var posts []model.Posts = make([]model.Posts, 0)
+	var posts []Posts = make([]Posts, 0)
 	err := stmt.QueryContext(ctx, db, &posts)
 	if err != nil {
-		m.log.Errorf("error querying post items: %v", err)
+		m.log().Errorf("error querying post items: %v", err)
 		return nil, err
 	}
 
 	count, err := m.countByCondition(ctx, combinedCond)
 	if err != nil {
-		m.log.Errorf("error getting post count: %v", err)
+		m.log().Errorf("error getting post count: %v", err)
 		return nil, err
 	}
 
@@ -150,7 +143,7 @@ func (m *postsModel) List(ctx context.Context, pagination *requests.Pagination,
 	}, nil
 }
 
-func (m *postsModel) IsUserBought(ctx context.Context, userId, postId int64) (bool, error) {
+func (m *Posts) IsUserBought(ctx context.Context, userId, postId int64) (bool, error) {
 	tbl := table.UserPosts
 	stmt := tbl.
 		SELECT(tbl.ID).
@@ -159,54 +152,54 @@ func (m *postsModel) IsUserBought(ctx context.Context, userId, postId int64) (bo
 				tbl.PostID.EQ(Int64(postId)),
 			),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var userPost model.UserPosts
+	var userPost UserPosts
 	err := stmt.QueryContext(ctx, db, &userPost)
 	if err != nil {
 		if errors.Is(err, qrm.ErrNoRows) {
 			return false, nil
 		}
 
-		m.log.Errorf("error querying user post item: %v", err)
+		m.log().Errorf("error querying user post item: %v", err)
 		return false, err
 	}
 
 	return userPost.ID > 0, nil
 }
 
-func (m *postsModel) Buy(ctx context.Context, userId, postId int64) error {
+func (m *Posts) Buy(ctx context.Context, userId, postId int64) error {
 	tbl := table.UserPosts
 
 	post, err := m.GetByID(ctx, postId)
 	if err != nil {
-		m.log.Errorf("error getting post by ID: %v", err)
+		m.log().Errorf("error getting post by ID: %v", err)
 		return err
 	}
 
-	user, err := Users.GetByID(ctx, userId)
+	user, err := UsersModel.GetByID(ctx, userId)
 	if err != nil {
-		m.log.Errorf("error getting user by ID: %v", err)
+		m.log().Errorf("error getting user by ID: %v", err)
 		return err
 	}
 
-	record := model.UserPosts{
+	record := UserPosts{
 		UserID: user.ID,
 		PostID: post.ID,
 		Price:  post.Price * int64(post.Discount) / 100,
 	}
 	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(record)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error buying post: %v", err)
+		m.log().Errorf("error buying post: %v", err)
 		return err
 	}
 	return nil
 }
 
 // DeleteByID soft delete item
-func (m *postsModel) DeleteByID(ctx context.Context, id int64) error {
+func (m *Posts) DeleteByID(ctx context.Context, id int64) error {
 	tbl := table.Posts
 	stmt := tbl.
 		UPDATE(tbl.DeletedAt).
@@ -214,36 +207,36 @@ func (m *postsModel) DeleteByID(ctx context.Context, id int64) error {
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error deleting post: %v", err)
+		m.log().Errorf("error deleting post: %v", err)
 		return err
 	}
 	return nil
 }
 
 // SendTo
-func (m *postsModel) SendTo(ctx context.Context, postId, userId int64) error {
+func (m *Posts) SendTo(ctx context.Context, postId, userId int64) error {
 	// add record to user_posts
 	tbl := table.UserPosts
-	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(model.UserPosts{
+	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(UserPosts{
 		CreatedAt: time.Now(),
 		UpdatedAt: time.Now(),
 		UserID:    userId,
 		PostID:    postId,
 		Price:     -1,
 	})
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error sending post to user: %v", err)
+		m.log().Errorf("error sending post to user: %v", err)
 		return err
 	}
 	return nil
 }
 
 // PostBoughtStatistics 获取指定文件 ID 的购买次数
-func (m *postsModel) BoughtStatistics(ctx context.Context, postIds []int64) (map[int64]int64, error) {
+func (m *Posts) BoughtStatistics(ctx context.Context, postIds []int64) (map[int64]int64, error) {
 	tbl := table.UserPosts
 
 	// select count(user_id), post_id from user_posts up  where post_id in (1, 2,3,4,5,6,7,8,9,10) group by post_id
@@ -258,7 +251,7 @@ func (m *postsModel) BoughtStatistics(ctx context.Context, postIds []int64) (map
 		GROUP_BY(
 			tbl.PostID,
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	var result []struct {
 		Cnt    int64
@@ -266,7 +259,7 @@ func (m *postsModel) BoughtStatistics(ctx context.Context, postIds []int64) (map
 	}
 
 	if err := stmt.QueryContext(ctx, db, &result); err != nil {
-		m.log.Errorf("error getting post bought statistics: %v", err)
+		m.log().Errorf("error getting post bought statistics: %v", err)
 		return nil, err
 	}
 
@@ -280,7 +273,7 @@ func (m *postsModel) BoughtStatistics(ctx context.Context, postIds []int64) (map
 }
 
 // Bought
-func (m *postsModel) Bought(ctx context.Context, userId int64, pagination *requests.Pagination) (*requests.Pager, error) {
+func (m *Posts) Bought(ctx context.Context, userId int64, pagination *requests.Pagination) (*requests.Pager, error) {
 	pagination.Format()
 
 	// select up.price,up.created_at,p.* from user_posts up  left join posts p on up.post_id = p.id where up.user_id =1
@@ -301,7 +294,7 @@ func (m *postsModel) Bought(ctx context.Context, userId int64, pagination *reque
 		LIMIT(pagination.Limit).
 		OFFSET(pagination.Offset)
 
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	var items []struct {
 		Title    string    `json:"title"`
@@ -310,11 +303,11 @@ func (m *postsModel) Bought(ctx context.Context, userId int64, pagination *reque
 	}
 
 	if err := stmt.QueryContext(ctx, db, &items); err != nil {
-		m.log.Errorf("error getting bought posts: %v", err)
+		m.log().Errorf("error getting bought posts: %v", err)
 		return nil, err
 	}
 
-	// convert to model.Posts
+	// convert to Posts
 	var cnt struct {
 		Cnt int64
 	}
@@ -325,7 +318,7 @@ func (m *postsModel) Bought(ctx context.Context, userId int64, pagination *reque
 		)
 
 	if err := stmtCnt.QueryContext(ctx, db, &cnt); err != nil {
-		m.log.Errorf("error getting bought posts count: %v", err)
+		m.log().Errorf("error getting bought posts count: %v", err)
 		return nil, err
 	}
 
@@ -337,7 +330,7 @@ func (m *postsModel) Bought(ctx context.Context, userId int64, pagination *reque
 }
 
 // GetPostsMapByIDs
-func (m *postsModel) GetPostsMapByIDs(ctx context.Context, ids []int64) (map[int64]model.Posts, error) {
+func (m *Posts) GetPostsMapByIDs(ctx context.Context, ids []int64) (map[int64]Posts, error) {
 	if len(ids) == 0 {
 		return nil, nil
 	}
@@ -349,22 +342,22 @@ func (m *postsModel) GetPostsMapByIDs(ctx context.Context, ids []int64) (map[int
 			tbl.ID.IN(lo.Map(ids, func(id int64, _ int) Expression { return Int64(id) })...),
 		)
 
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var posts []model.Posts = make([]model.Posts, 0)
+	var posts []Posts = make([]Posts, 0)
 	err := stmt.QueryContext(ctx, db, &posts)
 	if err != nil {
-		m.log.Errorf("error querying posts: %v", err)
+		m.log().Errorf("error querying posts: %v", err)
 		return nil, err
 	}
 
-	return lo.SliceToMap(posts, func(item model.Posts) (int64, model.Posts) {
+	return lo.SliceToMap(posts, func(item Posts) (int64, Posts) {
 		return item.ID, item
 	}), nil
 }
 
 // GetMediaByIds
-func (m *postsModel) GetMediaByIds(ctx context.Context, ids []int64) ([]model.Medias, error) {
+func (m *Posts) GetMediaByIds(ctx context.Context, ids []int64) ([]Medias, error) {
 	if len(ids) == 0 {
 		return nil, nil
 	}
@@ -376,12 +369,12 @@ func (m *postsModel) GetMediaByIds(ctx context.Context, ids []int64) ([]model.Me
 			tbl.ID.IN(lo.Map(ids, func(id int64, _ int) Expression { return Int64(id) })...),
 		)
 
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var medias []model.Medias
+	var medias []Medias
 
 	if err := stmt.QueryContext(ctx, db, &medias); err != nil {
-		m.log.Errorf("error querying media: %v", err)
+		m.log().Errorf("error querying media: %v", err)
 		return nil, err
 	}
 
@@ -389,7 +382,7 @@ func (m *postsModel) GetMediaByIds(ctx context.Context, ids []int64) ([]model.Me
 }
 
 // Count
-func (m *postsModel) Count(ctx context.Context, cond BoolExpression) (int64, error) {
+func (m *Posts) Count(ctx context.Context, cond BoolExpression) (int64, error) {
 	tbl := table.Posts
 	stmt := tbl.
 		SELECT(COUNT(tbl.ID).AS("count")).
@@ -399,7 +392,7 @@ func (m *postsModel) Count(ctx context.Context, cond BoolExpression) (int64, err
 		Count int64
 	}
 	if err := stmt.QueryContext(ctx, db, &count); err != nil {
-		m.log.Errorf("error counting posts: %v", err)
+		m.log().Errorf("error counting posts: %v", err)
 		return 0, err
 	}
 
diff --git a/backend/app/model/posts_test.go b/backend/app/model/posts_test.go
new file mode 100644
index 0000000..fcd2f6e
--- /dev/null
+++ b/backend/app/model/posts_test.go
@@ -0,0 +1,43 @@
+package model
+
+import (
+	"context"
+	"testing"
+
+	"quyun/app/service/testx"
+	"quyun/database"
+	"quyun/database/table"
+
+	. "github.com/smartystreets/goconvey/convey"
+	"go.ipao.vip/atom/contracts"
+
+	// . "github.com/go-jet/jet/v2/postgres"
+	"github.com/stretchr/testify/suite"
+	"go.uber.org/dig"
+)
+
+type PostsInjectParams struct {
+	dig.In
+	Initials []contracts.Initial `group:"initials"`
+}
+
+type PostsTestSuite struct {
+	suite.Suite
+
+	PostsInjectParams
+}
+
+func Test_Posts(t *testing.T) {
+	providers := testx.Default().With(Provide)
+	testx.Serve(providers, t, func(params PostsInjectParams) {
+		suite.Run(t, &PostsTestSuite{
+			PostsInjectParams: params,
+		})
+	})
+}
+
+func (s *PostsTestSuite) Test_Demo() {
+	Convey("Test_Demo", s.T(), func() {
+		database.Truncate(context.Background(), db, table.Posts.TableName())
+	})
+}
diff --git a/backend/app/model/provider.gen.go b/backend/app/model/provider.gen.go
new file mode 100644
index 0000000..78e7dc8
--- /dev/null
+++ b/backend/app/model/provider.gen.go
@@ -0,0 +1,76 @@
+// Code generated by the atomctl ; DO NOT EDIT.
+// Code generated by the atomctl ; DO NOT EDIT.
+// Code generated by the atomctl ; DO NOT EDIT.
+package model
+
+import (
+	"context"
+	"database/sql"
+
+	"go.ipao.vip/atom"
+	"go.ipao.vip/atom/container"
+	"go.ipao.vip/atom/contracts"
+	"go.ipao.vip/atom/opt"
+)
+
+var db *sql.DB
+var MediasModel *Medias
+var OrdersModel *Orders
+var PostsModel *Posts
+var UsersModel *Users
+
+func Transaction(ctx context.Context) (*sql.Tx, error) {
+	return db.Begin()
+}
+func DB() *sql.DB {
+	return db
+}
+
+func Provide(opts ...opt.Option) error {
+	if err := container.Container.Provide(func() (*Medias, error) {
+		obj := &Medias{}
+		return obj, nil
+	}); err != nil {
+		return err
+	}
+
+	if err := container.Container.Provide(func() (*Orders, error) {
+		obj := &Orders{}
+		return obj, nil
+	}); err != nil {
+		return err
+	}
+
+	if err := container.Container.Provide(func() (*Posts, error) {
+		obj := &Posts{}
+		return obj, nil
+	}); err != nil {
+		return err
+	}
+
+	if err := container.Container.Provide(func() (*Users, error) {
+		obj := &Users{}
+		return obj, nil
+	}); err != nil {
+		return err
+	}
+
+	if err := container.Container.Provide(func(
+		_db *sql.DB,
+		medias *Medias,
+		orders *Orders,
+		posts *Posts,
+		users *Users,
+	) (contracts.Initial, error) {
+		db = _db
+		MediasModel = medias
+		OrdersModel = orders
+		PostsModel = posts
+		UsersModel = users
+
+		return nil, nil
+	}, atom.GroupInitial); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/backend/database/schemas/public/model/user_posts.go b/backend/app/model/user_posts.gen.go
similarity index 100%
rename from backend/database/schemas/public/model/user_posts.go
rename to backend/app/model/user_posts.gen.go
diff --git a/backend/database/schemas/public/model/users.go b/backend/app/model/users.gen.go
similarity index 100%
rename from backend/database/schemas/public/model/users.go
rename to backend/app/model/users.gen.go
diff --git a/backend/app/models/users.go b/backend/app/model/users.go
similarity index 61%
rename from backend/app/models/users.go
rename to backend/app/model/users.go
index aa52d0a..d0a8392 100644
--- a/backend/app/models/users.go
+++ b/backend/app/model/users.go
@@ -1,39 +1,27 @@
-package models
+package model
 
 import (
 	"context"
-	"database/sql"
 	"time"
 
 	"quyun/app/requests"
 	"quyun/database/conds"
 	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
 	. "github.com/go-jet/jet/v2/postgres"
 	"github.com/go-jet/jet/v2/qrm"
 	"github.com/pkg/errors"
 	"github.com/samber/lo"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 )
 
-func Transaction(ctx context.Context) (*sql.Tx, error) {
-	return db.Begin()
-}
-
-// @provider
-type usersModel struct {
-	log *logrus.Entry `inject:"false"`
-}
-
-func (m *usersModel) Prepare() error {
-	m.log = logrus.WithField("model", "usersModel")
-	return nil
+func (m *Users) log() *log.Entry {
+	return log.WithField("model", "UsersModel")
 }
 
 // GetByID
-func (m *usersModel) GetByID(ctx context.Context, id int64) (*model.Users, error) {
+func (m *Users) GetByID(ctx context.Context, id int64) (*Users, error) {
 	tbl := table.Users
 
 	stmt := tbl.
@@ -41,39 +29,39 @@ func (m *usersModel) GetByID(ctx context.Context, id int64) (*model.Users, error
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var user model.Users
+	var user Users
 	err := stmt.QueryContext(ctx, db, &user)
 	if err != nil {
-		m.log.Errorf("error querying user by ID: %v", err)
+		m.log().Errorf("error querying user by ID: %v", err)
 		return nil, err
 	}
 
 	return &user, nil
 }
 
-func (m *usersModel) Own(ctx context.Context, userID, postID int64) error {
+func (m *Users) Own(ctx context.Context, userID, postID int64) error {
 	tbl := table.UserPosts
-	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(&model.UserPosts{
+	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(&UserPosts{
 		UserID:    userID,
 		PostID:    postID,
 		CreatedAt: time.Now(),
 		UpdatedAt: time.Now(),
 	})
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error inserting user post: %v", err)
+		m.log().Errorf("error inserting user post: %v", err)
 		return err
 	}
-	m.log.Infof("user post inserted successfully: userID=%d, postID=%d", userID, postID)
+	m.log().Infof("user post inserted successfully: userID=%d, postID=%d", userID, postID)
 
 	return nil
 }
 
 // BuildConditionWithKey builds the WHERE clause for user queries
-func (m *usersModel) BuildConditionWithKey(key *string) BoolExpression {
+func (m *Users) BuildConditionWithKey(key *string) BoolExpression {
 	tbl := table.Users
 
 	cond := tbl.DeletedAt.IS_NULL()
@@ -90,18 +78,18 @@ func (m *usersModel) BuildConditionWithKey(key *string) BoolExpression {
 }
 
 // countByCondition counts users matching the given condition
-func (m *usersModel) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
+func (m *Users) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
 	var cnt struct {
 		Cnt int64
 	}
 
 	tbl := table.Users
 	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(expr)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	err := stmt.QueryContext(ctx, db, &cnt)
 	if err != nil {
-		m.log.Errorf("error counting users: %v", err)
+		m.log().Errorf("error counting users: %v", err)
 		return 0, err
 	}
 
@@ -109,7 +97,7 @@ func (m *usersModel) countByCondition(ctx context.Context, expr BoolExpression)
 }
 
 // List returns a paginated list of users
-func (m *usersModel) List(ctx context.Context, pagination *requests.Pagination, cond BoolExpression) (*requests.Pager, error) {
+func (m *Users) List(ctx context.Context, pagination *requests.Pagination, cond BoolExpression) (*requests.Pager, error) {
 	pagination.Format()
 
 	tbl := table.Users
@@ -119,18 +107,18 @@ func (m *usersModel) List(ctx context.Context, pagination *requests.Pagination,
 		ORDER_BY(tbl.ID.DESC()).
 		LIMIT(pagination.Limit).
 		OFFSET(pagination.Offset)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var users []model.Users = make([]model.Users, 0)
+	var users []Users = make([]Users, 0)
 	err := stmt.QueryContext(ctx, db, &users)
 	if err != nil {
-		m.log.Errorf("error querying users: %v", err)
+		m.log().Errorf("error querying users: %v", err)
 		return nil, err
 	}
 
 	count, err := m.countByCondition(ctx, cond)
 	if err != nil {
-		m.log.Errorf("error getting user count: %v", err)
+		m.log().Errorf("error getting user count: %v", err)
 		return nil, err
 	}
 
@@ -142,25 +130,25 @@ func (m *usersModel) List(ctx context.Context, pagination *requests.Pagination,
 }
 
 // Create creates a new user
-func (m *usersModel) Create(ctx context.Context, userModel *model.Users) (*model.Users, error) {
+func (m *Users) Create(ctx context.Context, userModel *Users) (*Users, error) {
 	userModel.CreatedAt = time.Now()
 	userModel.UpdatedAt = time.Now()
 
 	tbl := table.Users
 	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(userModel).RETURNING(tbl.AllColumns)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var createdUser model.Users
+	var createdUser Users
 	err := stmt.QueryContext(ctx, db, &createdUser)
 	if err != nil {
-		m.log.Errorf("error creating user: %v", err)
+		m.log().Errorf("error creating user: %v", err)
 		return nil, err
 	}
 	return &createdUser, nil
 }
 
 // Update updates an existing user
-func (m *usersModel) Update(ctx context.Context, id int64, userModel *model.Users) (*model.Users, error) {
+func (m *Users) Update(ctx context.Context, id int64, userModel *Users) (*Users, error) {
 	userModel.UpdatedAt = time.Now()
 
 	tbl := table.Users
@@ -175,18 +163,18 @@ func (m *usersModel) Update(ctx context.Context, id int64, userModel *model.User
 		MODEL(userModel).
 		WHERE(tbl.ID.EQ(Int64(id))).
 		RETURNING(tbl.AllColumns)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var updatedUser model.Users
+	var updatedUser Users
 	if err := stmt.QueryContext(ctx, db, &updatedUser); err != nil {
-		m.log.Errorf("error updating user: %v", err)
+		m.log().Errorf("error updating user: %v", err)
 		return nil, err
 	}
 	return &updatedUser, nil
 }
 
 // DeleteByID soft deletes a user by ID
-func (m *usersModel) DeleteByID(ctx context.Context, id int64) error {
+func (m *Users) DeleteByID(ctx context.Context, id int64) error {
 	tbl := table.Users
 	stmt := tbl.
 		UPDATE(tbl.DeletedAt).
@@ -194,17 +182,17 @@ func (m *usersModel) DeleteByID(ctx context.Context, id int64) error {
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error deleting user: %v", err)
+		m.log().Errorf("error deleting user: %v", err)
 		return err
 	}
 	return nil
 }
 
 // PostList returns a paginated list of posts for a user
-func (m *usersModel) PostList(ctx context.Context, userId int64, pagination *requests.Pagination, conds ...conds.Cond) (*requests.Pager, error) {
+func (m *Users) PostList(ctx context.Context, userId int64, pagination *requests.Pagination, conds ...conds.Cond) (*requests.Pager, error) {
 	pagination.Format()
 
 	tblUserPosts := table.UserPosts
@@ -226,9 +214,9 @@ func (m *usersModel) PostList(ctx context.Context, userId int64, pagination *req
 		ORDER_BY(tblUserPosts.ID.DESC()).
 		LIMIT(pagination.Limit).
 		OFFSET(pagination.Offset)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var posts []model.Posts
+	var posts []Posts
 	err := stmt.QueryContext(ctx, db, &posts)
 	if err != nil {
 		if errors.Is(err, qrm.ErrNoRows) {
@@ -238,7 +226,7 @@ func (m *usersModel) PostList(ctx context.Context, userId int64, pagination *req
 				Pagination: *pagination,
 			}, nil
 		}
-		m.log.Errorf("error querying posts: %v", err)
+		m.log().Errorf("error querying posts: %v", err)
 		return nil, err
 	}
 
@@ -248,10 +236,10 @@ func (m *usersModel) PostList(ctx context.Context, userId int64, pagination *req
 	}
 
 	stmtCnt := tblUserPosts.SELECT(COUNT(tblUserPosts.ID).AS("cnt")).WHERE(tblUserPosts.UserID.EQ(Int64(userId)))
-	m.log.Infof("sql: %s", stmtCnt.DebugSql())
+	m.log().Infof("sql: %s", stmtCnt.DebugSql())
 
 	if err := stmtCnt.QueryContext(ctx, db, &cnt); err != nil {
-		m.log.Errorf("error counting users: %v", err)
+		m.log().Errorf("error counting users: %v", err)
 		return nil, err
 	}
 
@@ -263,7 +251,7 @@ func (m *usersModel) PostList(ctx context.Context, userId int64, pagination *req
 }
 
 // GetUserIDByOpenID
-func (m *usersModel) GetUserByOpenID(ctx context.Context, openID string) (*model.Users, error) {
+func (m *Users) GetUserByOpenID(ctx context.Context, openID string) (*Users, error) {
 	tbl := table.Users
 
 	stmt := tbl.
@@ -271,11 +259,11 @@ func (m *usersModel) GetUserByOpenID(ctx context.Context, openID string) (*model
 		WHERE(
 			tbl.OpenID.EQ(String(openID)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var user model.Users
+	var user Users
 	if err := stmt.QueryContext(ctx, db, &user); err != nil {
-		m.log.Errorf("error querying user by OpenID: %v", err)
+		m.log().Errorf("error querying user by OpenID: %v", err)
 		return nil, err
 	}
 
@@ -283,7 +271,7 @@ func (m *usersModel) GetUserByOpenID(ctx context.Context, openID string) (*model
 }
 
 // GetUserByOpenIDOrCreate
-func (m *usersModel) GetUserByOpenIDOrCreate(ctx context.Context, openID string, userModel *model.Users) (*model.Users, error) {
+func (m *Users) GetUserByOpenIDOrCreate(ctx context.Context, openID string, userModel *Users) (*Users, error) {
 	user, err := m.GetUserByOpenID(ctx, openID)
 	if err != nil {
 		if errors.Is(err, qrm.ErrNoRows) {
@@ -309,7 +297,7 @@ func (m *usersModel) GetUserByOpenIDOrCreate(ctx context.Context, openID string,
 }
 
 // GetUsersMapByIDs
-func (m *usersModel) GetUsersMapByIDs(ctx context.Context, ids []int64) (map[int64]model.Users, error) {
+func (m *Users) GetUsersMapByIDs(ctx context.Context, ids []int64) (map[int64]Users, error) {
 	if len(ids) == 0 {
 		return nil, nil
 	}
@@ -321,21 +309,21 @@ func (m *usersModel) GetUsersMapByIDs(ctx context.Context, ids []int64) (map[int
 			tbl.ID.IN(lo.Map(ids, func(id int64, _ int) Expression { return Int64(id) })...),
 		)
 
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var users []model.Users = make([]model.Users, 0)
+	var users []Users = make([]Users, 0)
 	err := stmt.QueryContext(ctx, db, &users)
 	if err != nil {
-		m.log.Errorf("error querying users: %v", err)
+		m.log().Errorf("error querying users: %v", err)
 		return nil, err
 	}
 
-	return lo.SliceToMap(users, func(item model.Users) (int64, model.Users) {
+	return lo.SliceToMap(users, func(item Users) (int64, Users) {
 		return item.ID, item
 	}), nil
 }
 
-func (m *usersModel) BatchCheckHasBought(ctx context.Context, userID int64, postIDs []int64) (map[int64]bool, error) {
+func (m *Users) BatchCheckHasBought(ctx context.Context, userID int64, postIDs []int64) (map[int64]bool, error) {
 	tbl := table.UserPosts
 	stmt := tbl.SELECT(tbl.PostID.AS("post_id")).WHERE(
 		tbl.UserID.EQ(Int64(userID)).AND(
@@ -347,7 +335,7 @@ func (m *usersModel) BatchCheckHasBought(ctx context.Context, userID int64, post
 		PostID int64
 	}
 	if err := stmt.QueryContext(ctx, db, &userPosts); err != nil {
-		m.log.Errorf("error querying user posts: %v", err)
+		m.log().Errorf("error querying user posts: %v", err)
 		return nil, err
 	}
 
@@ -359,7 +347,7 @@ func (m *usersModel) BatchCheckHasBought(ctx context.Context, userID int64, post
 }
 
 // HasBought
-func (m *usersModel) HasBought(ctx context.Context, userID, postID int64) (bool, error) {
+func (m *Users) HasBought(ctx context.Context, userID, postID int64) (bool, error) {
 	tbl := table.UserPosts
 	stmt := tbl.
 		SELECT(tbl.ID).
@@ -369,14 +357,14 @@ func (m *usersModel) HasBought(ctx context.Context, userID, postID int64) (bool,
 			),
 		)
 
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
-	var userPost model.UserPosts
+	var userPost UserPosts
 	if err := stmt.QueryContext(ctx, db, &userPost); err != nil {
 		if errors.Is(err, qrm.ErrNoRows) {
 			return false, nil
 		}
-		m.log.Errorf("error querying user post: %v", err)
+		m.log().Errorf("error querying user post: %v", err)
 		return false, err
 	}
 
@@ -384,20 +372,20 @@ func (m *usersModel) HasBought(ctx context.Context, userID, postID int64) (bool,
 }
 
 // Count
-func (m *usersModel) Count(ctx context.Context, cond BoolExpression) (int64, error) {
+func (m *Users) Count(ctx context.Context, cond BoolExpression) (int64, error) {
 	tbl := table.Users
 	stmt := tbl.
 		SELECT(COUNT(tbl.ID).AS("cnt")).
 		WHERE(cond)
 
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	var cnt struct {
 		Cnt int64
 	}
 
 	if err := stmt.QueryContext(ctx, db, &cnt); err != nil {
-		m.log.Errorf("error counting users: %v", err)
+		m.log().Errorf("error counting users: %v", err)
 		return 0, err
 	}
 
@@ -405,7 +393,7 @@ func (m *usersModel) Count(ctx context.Context, cond BoolExpression) (int64, err
 }
 
 // UpdateUsername
-func (m *usersModel) UpdateUsername(ctx context.Context, id int64, username string) error {
+func (m *Users) UpdateUsername(ctx context.Context, id int64, username string) error {
 	tbl := table.Users
 	stmt := tbl.
 		UPDATE(tbl.Username).
@@ -413,17 +401,17 @@ func (m *usersModel) UpdateUsername(ctx context.Context, id int64, username stri
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error updating username: %v", err)
+		m.log().Errorf("error updating username: %v", err)
 		return err
 	}
 	return nil
 }
 
 // UpdateUserToken
-func (m *usersModel) UpdateUserToken(ctx context.Context, id int64, token fields.UserAuthToken) error {
+func (m *Users) UpdateUserToken(ctx context.Context, id int64, token fields.UserAuthToken) error {
 	tbl := table.Users
 	stmt := tbl.
 		UPDATE(tbl.AuthToken).
@@ -431,21 +419,21 @@ func (m *usersModel) UpdateUserToken(ctx context.Context, id int64, token fields
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error updating user token: %v", err)
+		m.log().Errorf("error updating user token: %v", err)
 		return err
 	}
 	return nil
 }
 
 // BuyPosts
-func (m *usersModel) BuyPosts(ctx context.Context, userID, postID, price int64) error {
+func (m *Users) BuyPosts(ctx context.Context, userID, postID, price int64) error {
 	tbl := table.UserPosts
 	stmt := tbl.
 		INSERT(tbl.MutableColumns).
-		MODEL(&model.UserPosts{
+		MODEL(&UserPosts{
 			UserID:    userID,
 			PostID:    postID,
 			Price:     price,
@@ -453,16 +441,16 @@ func (m *usersModel) BuyPosts(ctx context.Context, userID, postID, price int64)
 			UpdatedAt: time.Now(),
 		})
 
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error inserting user post: %v", err)
+		m.log().Errorf("error inserting user post: %v", err)
 		return err
 	}
 	return nil
 }
 
-func (m *usersModel) RevokePosts(ctx context.Context, userID, postID int64) error {
+func (m *Users) RevokePosts(ctx context.Context, userID, postID int64) error {
 	tbl := table.UserPosts
 	stmt := tbl.
 		DELETE().
@@ -471,17 +459,17 @@ func (m *usersModel) RevokePosts(ctx context.Context, userID, postID int64) erro
 				tbl.PostID.EQ(Int64(postID)),
 			),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error revoking user post: %v", err)
+		m.log().Errorf("error revoking user post: %v", err)
 		return err
 	}
 	return nil
 }
 
 // SetBalance
-func (m *usersModel) SetBalance(ctx context.Context, id, balance int64) error {
+func (m *Users) SetBalance(ctx context.Context, id, balance int64) error {
 	tbl := table.Users
 	stmt := tbl.
 		UPDATE(tbl.Balance).
@@ -489,17 +477,17 @@ func (m *usersModel) SetBalance(ctx context.Context, id, balance int64) error {
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error updating user balance: %v", err)
+		m.log().Errorf("error updating user balance: %v", err)
 		return err
 	}
 	return nil
 }
 
 // AddBalance adds the given amount to the user's balance
-func (m *usersModel) AddBalance(ctx context.Context, id, amount int64) error {
+func (m *Users) AddBalance(ctx context.Context, id, amount int64) error {
 	tbl := table.Users
 	stmt := tbl.
 		UPDATE(tbl.Balance).
@@ -507,10 +495,10 @@ func (m *usersModel) AddBalance(ctx context.Context, id, amount int64) error {
 		WHERE(
 			tbl.ID.EQ(Int64(id)),
 		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
+	m.log().Infof("sql: %s", stmt.DebugSql())
 
 	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error updating user balance: %v", err)
+		m.log().Errorf("error updating user balance: %v", err)
 		return err
 	}
 	return nil
diff --git a/backend/app/models/users_test.go b/backend/app/model/users_test.go
similarity index 50%
rename from backend/app/models/users_test.go
rename to backend/app/model/users_test.go
index 3cf4c57..29ef82c 100644
--- a/backend/app/models/users_test.go
+++ b/backend/app/model/users_test.go
@@ -1,4 +1,4 @@
-package models
+package model
 
 import (
 	"context"
@@ -6,16 +6,12 @@ import (
 
 	"quyun/app/service/testx"
 	"quyun/database"
-	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
-	"github.com/samber/lo"
 	. "github.com/smartystreets/goconvey/convey"
 	"go.ipao.vip/atom/contracts"
 
 	// . "github.com/go-jet/jet/v2/postgres"
-	gonanoid "github.com/matoous/go-nanoid/v2"
 	"github.com/stretchr/testify/suite"
 	"go.uber.org/dig"
 )
@@ -40,25 +36,8 @@ func Test_Users(t *testing.T) {
 	})
 }
 
-func (s *UsersTestSuite) Test_BatchInsert() {
-	Convey("Test_BatchInsert", s.T(), func() {
+func (s *UsersTestSuite) Test_Demo() {
+	Convey("Test_Demo", s.T(), func() {
 		database.Truncate(context.Background(), db, table.Users.TableName())
-
-		count := 100
-		for i := 0; i < count; i++ {
-			// generate openid use nanoid
-			openID, err := gonanoid.New(10)
-			So(err, ShouldBeNil)
-
-			user := &model.Users{
-				Status:   fields.UserStatusOk,
-				OpenID:   openID,
-				Username: "Username_" + openID,
-				Avatar:   lo.ToPtr("Avatar_" + openID),
-			}
-			m, err := Users.Create(context.Background(), user)
-			So(err, ShouldBeNil)
-			So(m, ShouldNotBeNil)
-		}
 	})
 }
diff --git a/backend/app/models/medias.go b/backend/app/models/medias.go
deleted file mode 100644
index 2eff3cc..0000000
--- a/backend/app/models/medias.go
+++ /dev/null
@@ -1,277 +0,0 @@
-package models
-
-import (
-	"context"
-	"time"
-
-	"quyun/app/requests"
-	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
-	"quyun/database/schemas/public/table"
-
-	. "github.com/go-jet/jet/v2/postgres"
-	"github.com/samber/lo"
-	"github.com/sirupsen/logrus"
-)
-
-// @provider
-type mediasModel struct {
-	log *logrus.Entry `inject:"false"`
-}
-
-func (m *mediasModel) Prepare() error {
-	m.log = logrus.WithField("module", "mediasModel")
-	return nil
-}
-
-func (m *mediasModel) BuildConditionWithKey(key *string) BoolExpression {
-	tbl := table.Medias
-
-	cond := Bool(true)
-
-	if key == nil || *key == "" {
-		return cond
-	}
-
-	cond = cond.AND(
-		tbl.Name.LIKE(String("%" + *key + "%")),
-	)
-
-	return cond
-}
-
-// countByCond
-func (m *mediasModel) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
-	var cnt struct {
-		Cnt int64
-	}
-
-	tbl := table.Medias
-	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(expr)
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	err := stmt.QueryContext(ctx, db, &cnt)
-	if err != nil {
-		m.log.Errorf("error counting media items: %v", err)
-		return 0, err
-	}
-
-	return cnt.Cnt, nil
-}
-
-func (m *mediasModel) List(ctx context.Context, pagination *requests.Pagination, expr BoolExpression) (*requests.Pager, error) {
-	pagination.Format()
-
-	tbl := table.Medias
-	stmt := tbl.
-		SELECT(tbl.AllColumns).
-		WHERE(expr).
-		ORDER_BY(tbl.ID.DESC()).
-		LIMIT(pagination.Limit).
-		OFFSET(pagination.Offset)
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	var medias []model.Medias
-	err := stmt.QueryContext(ctx, db, &medias)
-	if err != nil {
-		m.log.Errorf("error querying media items: %v", err)
-		return nil, err
-	}
-
-	count, err := m.countByCondition(ctx, expr)
-	if err != nil {
-		m.log.Errorf("error getting media count: %v", err)
-		return nil, err
-	}
-
-	return &requests.Pager{
-		Items:      medias,
-		Total:      count,
-		Pagination: *pagination,
-	}, nil
-}
-
-func (m *mediasModel) BatchCreate(ctx context.Context, models []*model.Medias) error {
-	stmt := table.Medias.INSERT(table.Medias.MutableColumns).MODELS(models)
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error creating media item: %v", err)
-		return err
-	}
-
-	m.log.Infof("media item created successfully")
-	return nil
-}
-
-func (m *mediasModel) Create(ctx context.Context, model *model.Medias) error {
-	model.CreatedAt = time.Now()
-	stmt := table.Medias.INSERT(table.Medias.MutableColumns).MODEL(model).RETURNING(table.Medias.AllColumns)
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	if err := stmt.QueryContext(ctx, db, model); err != nil {
-		m.log.Errorf("error creating media item: %v", err)
-		return err
-	}
-
-	m.log.Infof("media item created successfully")
-	return nil
-}
-
-// GetByIds
-func (m *mediasModel) GetByIds(ctx context.Context, ids []int64) ([]*model.Medias, error) {
-	if len(ids) == 0 {
-		return nil, nil
-	}
-
-	condIds := lo.Map(ids, func(id int64, _ int) Expression {
-		return Int64(id)
-	})
-
-	tbl := table.Medias
-	stmt := tbl.
-		SELECT(tbl.AllColumns).
-		WHERE(tbl.ID.IN(condIds...))
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	var medias []model.Medias
-	err := stmt.QueryContext(ctx, db, &medias)
-	if err != nil {
-		m.log.Errorf("error querying media items: %v", err)
-		return nil, err
-	}
-
-	return lo.Map(medias, func(media model.Medias, _ int) *model.Medias {
-		return &media
-	}), nil
-}
-
-// GetByHash
-func (m *mediasModel) GetByHash(ctx context.Context, hash string) (*model.Medias, error) {
-	tbl := table.Medias
-	stmt := tbl.
-		SELECT(tbl.AllColumns).
-		WHERE(tbl.Hash.EQ(String(hash)))
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	var media model.Medias
-	err := stmt.QueryContext(ctx, db, &media)
-	if err != nil {
-		m.log.Errorf("error querying media item by hash: %v", err)
-		return nil, err
-	}
-
-	return &media, nil
-}
-
-// Update
-func (m *mediasModel) Update(ctx context.Context, hash string, model *model.Medias) error {
-	tbl := table.Medias
-	stmt := tbl.
-		UPDATE(tbl.MutableColumns.Except(tbl.CreatedAt)).
-		MODEL(model).
-		WHERE(table.Medias.Hash.EQ(String(hash)))
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.WithField("hash", hash).Errorf("error updating media item: %v", err)
-		return err
-	}
-
-	m.log.Infof("media item updated successfully")
-	return nil
-}
-
-// GetByID
-func (m *mediasModel) GetByID(ctx context.Context, id int64) (*model.Medias, error) {
-	tbl := table.Medias
-	stmt := tbl.
-		SELECT(tbl.AllColumns).
-		WHERE(tbl.ID.EQ(Int64(id)))
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	var media model.Medias
-
-	if err := stmt.QueryContext(ctx, db, &media); err != nil {
-		m.log.Errorf("error querying media item by ID: %v", err)
-		return nil, err
-	}
-
-	return &media, nil
-}
-
-// Delete
-func (m *mediasModel) Delete(ctx context.Context, id int64) error {
-	tbl := table.Medias
-	stmt := tbl.
-		DELETE().
-		WHERE(tbl.ID.EQ(Int64(id)))
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error deleting media item: %v", err)
-		return err
-	}
-
-	m.log.Infof("media item deleted successfully")
-	return nil
-}
-
-// UpdateMetas
-func (m *mediasModel) UpdateMetas(ctx context.Context, id int64, metas fields.MediaMetas) error {
-	meta := fields.ToJson(metas)
-
-	tbl := table.Medias
-	stmt := tbl.
-		UPDATE(tbl.Metas).
-		SET(meta).
-		WHERE(tbl.ID.EQ(Int64(id)))
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	if _, err := stmt.ExecContext(ctx, db); err != nil {
-		m.log.Errorf("error updating media metas: %v", err)
-		return err
-	}
-
-	m.log.Infof("media (%d) metas updated successfully", id)
-	return nil
-}
-
-// GetRelationMedias
-func (m *mediasModel) GetRelations(ctx context.Context, hash string) ([]*model.Medias, error) {
-	tbl := table.Medias
-	stmt := tbl.
-		SELECT(tbl.AllColumns).
-		WHERE(
-			RawBool("metas->>'parent_hash' = ?", RawArgs{"?": hash}),
-		)
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	var medias []model.Medias
-	if err := stmt.QueryContext(ctx, db, &medias); err != nil {
-		m.log.Errorf("error querying media items: %v", err)
-		return nil, err
-	}
-
-	return lo.Map(medias, func(media model.Medias, _ int) *model.Medias {
-		return &media
-	}), nil
-}
-
-// Count
-func (m *mediasModel) Count(ctx context.Context) (int64, error) {
-	tbl := table.Medias
-	stmt := tbl.SELECT(COUNT(tbl.ID).AS("count"))
-	m.log.Infof("sql: %s", stmt.DebugSql())
-
-	var count struct {
-		Count int64
-	}
-
-	if err := stmt.QueryContext(ctx, db, &count); err != nil {
-		m.log.Errorf("error counting media items: %v", err)
-		return 0, err
-	}
-
-	return count.Count, nil
-}
diff --git a/backend/app/models/models.gen.go b/backend/app/models/models.gen.go
deleted file mode 100644
index ca66481..0000000
--- a/backend/app/models/models.gen.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// Code generated by the atomctl ; DO NOT EDIT.
-// Code generated by the atomctl ; DO NOT EDIT.
-// Code generated by the atomctl ; DO NOT EDIT.
-package models
-
-import (
-	"database/sql"
-)
-
-var db *sql.DB
-var Medias *mediasModel
-var Orders *ordersModel
-var Posts *postsModel
-var Users *usersModel
-
-// @provider(model)
-type models struct {
-	db     *sql.DB
-	medias *mediasModel
-	orders *ordersModel
-	posts  *postsModel
-	users  *usersModel
-}
-
-func (m *models) Prepare() error {
-	db = m.db
-	Medias = m.medias
-	Orders = m.orders
-	Posts = m.posts
-	Users = m.users
-	return nil
-}
diff --git a/backend/app/models/posts_test.go b/backend/app/models/posts_test.go
deleted file mode 100644
index c5ea30d..0000000
--- a/backend/app/models/posts_test.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package models
-
-import (
-	"context"
-	"fmt"
-	"math/rand"
-	"testing"
-
-	"quyun/app/service/testx"
-	"quyun/database"
-	"quyun/database/fields"
-	"quyun/database/schemas/public/model"
-	"quyun/database/schemas/public/table"
-
-	. "github.com/smartystreets/goconvey/convey"
-	"go.ipao.vip/atom/contracts"
-
-	// . "github.com/go-jet/jet/v2/postgres"
-	"github.com/stretchr/testify/suite"
-	"go.uber.org/dig"
-)
-
-type PostsInjectParams struct {
-	dig.In
-	Initials []contracts.Initial `group:"initials"`
-}
-
-type PostsTestSuite struct {
-	suite.Suite
-
-	PostsInjectParams
-}
-
-func Test_Posts(t *testing.T) {
-	providers := testx.Default().With(Provide)
-	testx.Serve(providers, t, func(params PostsInjectParams) {
-		suite.Run(t, &PostsTestSuite{
-			PostsInjectParams: params,
-		})
-	})
-}
-
-func (s *PostsTestSuite) Test_BatchInsert() {
-	Convey("Test_Demo", s.T(), func() {
-		database.Truncate(context.Background(), db, table.Posts.TableName())
-
-		count := 100
-		for i := 0; i < count; i++ {
-			model := model.Posts{
-				Status:      fields.PostStatusPublished,
-				Title:       fmt.Sprintf("test-title-%d", i),
-				Description: fmt.Sprintf("test-description-%d", i),
-				Content:     fmt.Sprintf("test-content-%d", i),
-				Price:       rand.Int63n(10000),
-				Discount:    int16(rand.Intn(100)),
-				Views:       rand.Int63n(10000),
-				Likes:       rand.Int63n(10000),
-				Tags:        fields.ToJson([]string{"tag1", "tag2", "tag3"}),
-				Assets: fields.ToJson([]fields.MediaAsset{
-					{
-						Type:  "video/mp4",
-						Media: rand.Int63n(10000),
-					},
-					{
-						Type:  "video/mp4",
-						Media: rand.Int63n(10000),
-					},
-				}),
-			}
-
-			if err := Posts.Create(context.Background(), &model); err != nil {
-				s.T().Fatal(err)
-			}
-		}
-	})
-}
-
-func (s *PostsTestSuite) Test_BatchInsertUserPosts() {
-	Convey("Test_Demo", s.T(), func() {
-		database.Truncate(context.Background(), db, table.UserPosts.TableName())
-
-		count := 10
-		for i := 0; i < count; i++ {
-			if err := Users.Own(context.Background(), 1, int64(i)+1); err != nil {
-				s.T().Fatal(err)
-			}
-		}
-	})
-}
diff --git a/backend/app/models/provider.gen.go b/backend/app/models/provider.gen.go
deleted file mode 100755
index 80fbd4b..0000000
--- a/backend/app/models/provider.gen.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package models
-
-import (
-	"database/sql"
-
-	"go.ipao.vip/atom"
-	"go.ipao.vip/atom/container"
-	"go.ipao.vip/atom/contracts"
-	"go.ipao.vip/atom/opt"
-)
-
-func Provide(opts ...opt.Option) error {
-	if err := container.Container.Provide(func() (*mediasModel, error) {
-		obj := &mediasModel{}
-		if err := obj.Prepare(); err != nil {
-			return nil, err
-		}
-
-		return obj, nil
-	}); err != nil {
-		return err
-	}
-	if err := container.Container.Provide(func(
-		db *sql.DB,
-		medias *mediasModel,
-		orders *ordersModel,
-		posts *postsModel,
-		users *usersModel,
-	) (contracts.Initial, error) {
-		obj := &models{
-			db:     db,
-			medias: medias,
-			orders: orders,
-			posts:  posts,
-			users:  users,
-		}
-		if err := obj.Prepare(); err != nil {
-			return nil, err
-		}
-
-		return obj, nil
-	}, atom.GroupInitial); err != nil {
-		return err
-	}
-	if err := container.Container.Provide(func() (*ordersModel, error) {
-		obj := &ordersModel{}
-		if err := obj.Prepare(); err != nil {
-			return nil, err
-		}
-
-		return obj, nil
-	}); err != nil {
-		return err
-	}
-	if err := container.Container.Provide(func() (*postsModel, error) {
-		obj := &postsModel{}
-		if err := obj.Prepare(); err != nil {
-			return nil, err
-		}
-
-		return obj, nil
-	}); err != nil {
-		return err
-	}
-	if err := container.Container.Provide(func() (*usersModel, error) {
-		obj := &usersModel{}
-		if err := obj.Prepare(); err != nil {
-			return nil, err
-		}
-
-		return obj, nil
-	}); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/backend/app/service/http/http.go b/backend/app/service/http/http.go
index 7566ed6..a6e4b82 100644
--- a/backend/app/service/http/http.go
+++ b/backend/app/service/http/http.go
@@ -7,7 +7,7 @@ import (
 
 	"quyun/app/jobs"
 	"quyun/app/middlewares"
-	"quyun/app/models"
+	"quyun/app/model"
 	"quyun/app/service"
 	"quyun/providers/ali"
 	"quyun/providers/app"
@@ -58,7 +58,7 @@ func Command() atom.Option {
 			defaultProviders().
 				With(
 					jobs.Provide,
-					models.Provide,
+					model.Provide,
 					middlewares.Provide,
 				).
 				WithProviders(
diff --git a/backend/database/conds/posts.go b/backend/database/conds/posts.go
index 244de8d..3efb6f4 100644
--- a/backend/database/conds/posts.go
+++ b/backend/database/conds/posts.go
@@ -2,7 +2,7 @@ package conds
 
 import (
 	"quyun/database/fields"
-	"quyun/database/schemas/public/table"
+	"quyun/database/table"
 
 	. "github.com/go-jet/jet/v2/postgres"
 )
diff --git a/backend/database/schemas/public/enum/river_job_state.go b/backend/database/schemas/public/enum/river_job_state.go
deleted file mode 100644
index 97fa72d..0000000
--- a/backend/database/schemas/public/enum/river_job_state.go
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// Code generated by go-jet DO NOT EDIT.
-//
-// WARNING: Changes to this file may cause incorrect behavior
-// and will be lost if the code is regenerated
-//
-
-package enum
-
-import "github.com/go-jet/jet/v2/postgres"
-
-var RiverJobState = &struct {
-	Available postgres.StringExpression
-	Cancelled postgres.StringExpression
-	Completed postgres.StringExpression
-	Discarded postgres.StringExpression
-	Pending   postgres.StringExpression
-	Retryable postgres.StringExpression
-	Running   postgres.StringExpression
-	Scheduled postgres.StringExpression
-}{
-	Available: postgres.NewEnumValue("available"),
-	Cancelled: postgres.NewEnumValue("cancelled"),
-	Completed: postgres.NewEnumValue("completed"),
-	Discarded: postgres.NewEnumValue("discarded"),
-	Pending:   postgres.NewEnumValue("pending"),
-	Retryable: postgres.NewEnumValue("retryable"),
-	Running:   postgres.NewEnumValue("running"),
-	Scheduled: postgres.NewEnumValue("scheduled"),
-}
diff --git a/backend/database/schemas/public/model/river_job_state.go b/backend/database/schemas/public/model/river_job_state.go
deleted file mode 100644
index 809604b..0000000
--- a/backend/database/schemas/public/model/river_job_state.go
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// Code generated by go-jet DO NOT EDIT.
-//
-// WARNING: Changes to this file may cause incorrect behavior
-// and will be lost if the code is regenerated
-//
-
-package model
-
-import "errors"
-
-type RiverJobState string
-
-const (
-	RiverJobState_Available RiverJobState = "available"
-	RiverJobState_Cancelled RiverJobState = "cancelled"
-	RiverJobState_Completed RiverJobState = "completed"
-	RiverJobState_Discarded RiverJobState = "discarded"
-	RiverJobState_Pending   RiverJobState = "pending"
-	RiverJobState_Retryable RiverJobState = "retryable"
-	RiverJobState_Running   RiverJobState = "running"
-	RiverJobState_Scheduled RiverJobState = "scheduled"
-)
-
-var RiverJobStateAllValues = []RiverJobState{
-	RiverJobState_Available,
-	RiverJobState_Cancelled,
-	RiverJobState_Completed,
-	RiverJobState_Discarded,
-	RiverJobState_Pending,
-	RiverJobState_Retryable,
-	RiverJobState_Running,
-	RiverJobState_Scheduled,
-}
-
-func (e *RiverJobState) Scan(value interface{}) error {
-	var enumValue string
-	switch val := value.(type) {
-	case string:
-		enumValue = val
-	case []byte:
-		enumValue = string(val)
-	default:
-		return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte")
-	}
-
-	switch enumValue {
-	case "available":
-		*e = RiverJobState_Available
-	case "cancelled":
-		*e = RiverJobState_Cancelled
-	case "completed":
-		*e = RiverJobState_Completed
-	case "discarded":
-		*e = RiverJobState_Discarded
-	case "pending":
-		*e = RiverJobState_Pending
-	case "retryable":
-		*e = RiverJobState_Retryable
-	case "running":
-		*e = RiverJobState_Running
-	case "scheduled":
-		*e = RiverJobState_Scheduled
-	default:
-		return errors.New("jet: Invalid scan value '" + enumValue + "' for RiverJobState enum")
-	}
-
-	return nil
-}
-
-func (e RiverJobState) String() string {
-	return string(e)
-}
diff --git a/backend/database/schemas/public/table/medias.go b/backend/database/table/medias.go
similarity index 100%
rename from backend/database/schemas/public/table/medias.go
rename to backend/database/table/medias.go
diff --git a/backend/database/schemas/public/table/migrations.go b/backend/database/table/migrations.go
similarity index 100%
rename from backend/database/schemas/public/table/migrations.go
rename to backend/database/table/migrations.go
diff --git a/backend/database/schemas/public/table/orders.go b/backend/database/table/orders.go
similarity index 100%
rename from backend/database/schemas/public/table/orders.go
rename to backend/database/table/orders.go
diff --git a/backend/database/schemas/public/table/posts.go b/backend/database/table/posts.go
similarity index 100%
rename from backend/database/schemas/public/table/posts.go
rename to backend/database/table/posts.go
diff --git a/backend/database/schemas/public/table/table_use_schema.go b/backend/database/table/table_use_schema.go
similarity index 100%
rename from backend/database/schemas/public/table/table_use_schema.go
rename to backend/database/table/table_use_schema.go
diff --git a/backend/database/schemas/public/table/user_posts.go b/backend/database/table/user_posts.go
similarity index 100%
rename from backend/database/schemas/public/table/user_posts.go
rename to backend/database/table/user_posts.go
diff --git a/backend/database/schemas/public/table/users.go b/backend/database/table/users.go
similarity index 100%
rename from backend/database/schemas/public/table/users.go
rename to backend/database/table/users.go
diff --git a/backend/database/transform.yaml b/backend/database/transform.yaml
index bf332a0..9df97e6 100644
--- a/backend/database/transform.yaml
+++ b/backend/database/transform.yaml
@@ -4,6 +4,7 @@ ignores:
     - river_job
     - river_client
     - river_client_queue
+    - river_job_state
     - river_queue
   model:
     - migrations