fix: api descript

app/player/rpc/internal/config/config.go

@@ -0,0 +1,17 @@
+package config
+
+import (
+	"github.com/zeromicro/go-zero/core/stores/cache"
+	"github.com/zeromicro/go-zero/zrpc"
+)
+
+type Config struct {
+	zrpc.RpcServerConf
+
+	SnowflakeRpcConf zrpc.RpcClientConf
+	DB struct {
+		Master string
+		Slaves string
+	}
+	CacheConf cache.CacheConf
+}

app/player/rpc/internal/logic/addPlayerServicesLogic.go

@@ -0,0 +1,54 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+	"juwan-backend/app/snowflake/rpc/snowflake"
+
+	"github.com/shopspring/decimal"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AddPlayerServicesLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewAddPlayerServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AddPlayerServicesLogic {
+	return &AddPlayerServicesLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// -----------------------playerServices-----------------------
+func (l *AddPlayerServicesLogic) AddPlayerServices(in *pb.AddPlayerServicesReq) (*pb.AddPlayerServicesResp, error) {
+	idResp, err := l.svcCtx.Snowflake.NextId(l.ctx, &snowflake.NextIdReq{})
+	if err != nil {
+		logx.Errorf("addPlayerServices err:%v", err)
+		return nil, errors.New("create player service id failed")
+	}
+	_, err = l.svcCtx.PlayerModelRW.PlayerServices.Create().
+		SetID(idResp.Id).
+		SetPlayerID(in.PlayerId).
+		SetGameID(in.GameId).
+		SetTitle(in.Title).
+		SetDescription(in.Description).
+		SetPrice(decimal.NewFromFloat(in.Price)).
+		SetUnit(in.Unit).
+		SetRankRange(in.RankRange).
+		SetAvailability(in.Availability).
+		SetRating(decimal.NewFromFloat(in.Rating)).
+		SetIsActive(in.IsActive).
+		Save(l.ctx)
+	if err != nil {
+		logx.Errorf("addPlayerServices err:%v", err)
+		return nil, errors.New("add player service failed")
+	}
+
+	return &pb.AddPlayerServicesResp{}, nil
+}

app/player/rpc/internal/logic/addPlayersLogic.go

@@ -0,0 +1,57 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"juwan-backend/app/snowflake/rpc/snowflake"
+
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/shopspring/decimal"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AddPlayersLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewAddPlayersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AddPlayersLogic {
+	return &AddPlayersLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// -----------------------players-----------------------
+func (l *AddPlayersLogic) AddPlayers(in *pb.AddPlayersReq) (*pb.AddPlayersResp, error) {
+	idResp, err := l.svcCtx.Snowflake.NextId(l.ctx, &snowflake.NextIdReq{})
+	if err != nil {
+		logx.Errorf("addPlayerServices err:%v", err)
+		return nil, errors.New("create player service id failed")
+	}
+	gender := 0
+	if in.Gender != 0 {
+		gender = 1
+	}
+	_, err = l.svcCtx.PlayerModelRW.Players.Create().
+		SetID(idResp.Id).
+		SetUserID(in.UserId).
+		SetStatus(in.Status).
+		SetRating(decimal.NewFromFloat(in.Rating)).
+		SetTotalOrders(int(in.TotalOrders)).
+		SetCompletedOrders(int(in.CompletedOrders)).
+		SetShopID(in.ShopId).
+		SetTags(in.Tags).
+		SetGender(gender).
+		SetGames(in.Games).
+		Save(l.ctx)
+	if err != nil {
+		logx.Errorf("addPlayerServices err:%v", err)
+		return nil, errors.New("add player service failed")
+	}
+	return &pb.AddPlayersResp{}, nil
+}

app/player/rpc/internal/logic/delPlayerServicesLogic.go

@@ -0,0 +1,35 @@
+package logic
+
+import (
+	"context"
+	"errors"
+
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DelPlayerServicesLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDelPlayerServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DelPlayerServicesLogic {
+	return &DelPlayerServicesLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DelPlayerServicesLogic) DelPlayerServices(in *pb.DelPlayerServicesReq) (*pb.DelPlayerServicesResp, error) {
+	err := l.svcCtx.PlayerModelRW.PlayerServices.DeleteOneID(in.Id).Exec(l.ctx)
+	if err != nil {
+		logx.Errorf("delete player services failed, %s", err.Error())
+		return nil, errors.New("delete failed")
+	}
+
+	return &pb.DelPlayerServicesResp{}, nil
+}

app/player/rpc/internal/logic/delPlayersLogic.go

@@ -0,0 +1,35 @@
+package logic
+
+import (
+	"context"
+	"errors"
+
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DelPlayersLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDelPlayersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DelPlayersLogic {
+	return &DelPlayersLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DelPlayersLogic) DelPlayers(in *pb.DelPlayersReq) (*pb.DelPlayersResp, error) {
+	err := l.svcCtx.PlayerModelRW.Players.DeleteOneID(in.Id).Exec(l.ctx)
+	if err != nil {
+		logx.Errorf("delete player services failed, %s", err.Error())
+		return nil, errors.New("delete failed")
+	}
+
+	return &pb.DelPlayersResp{}, nil
+}

app/player/rpc/internal/logic/getPlayerServicesByIdLogic.go

@@ -0,0 +1,56 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetPlayerServicesByIdLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetPlayerServicesByIdLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPlayerServicesByIdLogic {
+	return &GetPlayerServicesByIdLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *GetPlayerServicesByIdLogic) GetPlayerServicesById(in *pb.GetPlayerServicesByIdReq) (*pb.GetPlayerServicesByIdResp, error) {
+	playerService, err := l.svcCtx.PlayerModelRO.PlayerServices.Query().Where(playerservices.IDEQ(in.Id)).First(l.ctx)
+	if err != nil {
+		logx.WithContext(l.ctx).Errorf("GetPlayerServicesByIdLogic err: %v", err)
+		return nil, errors.New("get player services by id failed")
+	}
+
+	pbPlayerService := pb.PlayerServices{
+		Id:           playerService.ID,
+		PlayerId:     playerService.PlayerID,
+		GameId:       playerService.GameID,
+		Title:        playerService.Title,
+		Price:        playerService.Price.InexactFloat64(),
+		Unit:         playerService.Unit,
+		Availability: playerService.Availability,
+		Rating:       playerService.Rating.InexactFloat64(),
+		IsActive:     playerService.IsActive,
+		CreatedAt:    playerService.CreatedAt.Unix(),
+		UpdatedAt:    playerService.UpdatedAt.Unix(),
+	}
+	if playerService.Description != nil {
+		pbPlayerService.Description = *playerService.Description
+	}
+	if playerService.RankRange != nil {
+		pbPlayerService.RankRange = *playerService.RankRange
+	}
+
+	return &pb.GetPlayerServicesByIdResp{PlayerServices: &pbPlayerService}, nil
+}

app/player/rpc/internal/logic/getPlayersByIdLogic.go

@@ -0,0 +1,52 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"juwan-backend/app/player/rpc/internal/models/players"
+
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetPlayersByIdLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetPlayersByIdLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPlayersByIdLogic {
+	return &GetPlayersByIdLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *GetPlayersByIdLogic) GetPlayersById(in *pb.GetPlayersByIdReq) (*pb.GetPlayersByIdResp, error) {
+	player, err := l.svcCtx.PlayerModelRO.Players.Query().Where(players.IDEQ(in.Id)).First(l.ctx)
+	if err != nil {
+		logx.WithContext(l.ctx).Errorf("GetPlayersByIdLogic err: %v", err)
+		return nil, errors.New("get players by id failed")
+	}
+
+	pbPlayer := pb.Players{
+		Id:              player.ID,
+		UserId:          player.UserID,
+		Status:          player.Status,
+		Rating:          player.Rating.InexactFloat64(),
+		TotalOrders:     int64(player.TotalOrders),
+		CompletedOrders: int64(player.CompletedOrders),
+		Tags:            player.Tags,
+		Games:           []int64(player.Games),
+		CreatedAt:       player.CreatedAt.Unix(),
+		UpdatedAt:       player.UpdatedAt.Unix(),
+	}
+	if player.ShopID != nil {
+		pbPlayer.ShopId = *player.ShopID
+	}
+
+	return &pb.GetPlayersByIdResp{Players: &pbPlayer}, nil
+}

app/player/rpc/internal/logic/searchPlayerServicesLogic.go

@@ -0,0 +1,70 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type SearchPlayerServicesLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewSearchPlayerServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SearchPlayerServicesLogic {
+	return &SearchPlayerServicesLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *SearchPlayerServicesLogic) SearchPlayerServices(in *pb.SearchPlayerServicesReq) (*pb.SearchPlayerServicesResp, error) {
+	if in.Limit > 1000 {
+		return nil, errors.New("limit too large")
+	}
+
+	update := l.svcCtx.PlayerModelRO.PlayerServices.Query()
+	if in.PlayerId != 0 {
+		update.Where(playerservices.PlayerIDEQ(in.PlayerId))
+	}
+
+	all, err := update.
+		Limit(int(in.Limit)).
+		Offset(int(in.Limit * in.Page)).
+		All(l.ctx)
+	if err != nil {
+		return nil, errors.New("query all player services err")
+	}
+
+	list := make([]*pb.PlayerServices, 0, len(all))
+	for _, v := range all {
+		temp := &pb.PlayerServices{
+			Id:           v.ID,
+			PlayerId:     v.PlayerID,
+			GameId:       v.GameID,
+			Title:        v.Title,
+			Price:        v.Price.InexactFloat64(),
+			Unit:         v.Unit,
+			Availability: v.Availability,
+			Rating:       v.Rating.InexactFloat64(),
+			IsActive:     v.IsActive,
+			CreatedAt:    v.CreatedAt.Unix(),
+			UpdatedAt:    v.UpdatedAt.Unix(),
+		}
+		if v.Description != nil {
+			temp.Description = *v.Description
+		}
+		if v.RankRange != nil {
+			temp.RankRange = *v.RankRange
+		}
+		list = append(list, temp)
+	}
+
+	return &pb.SearchPlayerServicesResp{PlayerServices: list}, nil
+}

app/player/rpc/internal/logic/searchPlayersLogic.go

@@ -0,0 +1,57 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"juwan-backend/app/player/rpc/internal/models/players"
+
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/jinzhu/copier"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type SearchPlayersLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewSearchPlayersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SearchPlayersLogic {
+	return &SearchPlayersLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *SearchPlayersLogic) SearchPlayers(in *pb.SearchPlayersReq) (*pb.SearchPlayersResp, error) {
+	gender := 0
+	if in.Gender > 0 {
+		gender = 1
+	}
+	searcher := l.svcCtx.PlayerModelRO.Players.Query()
+	if in.Gender >= 0 {
+		searcher.Where(players.GenderEQ(gender))
+	}
+
+	all, err := searcher.Limit(int(in.Limit)).Offset(int(in.Page * in.Limit)).All(l.ctx)
+	if err != nil {
+		logx.Errorf("SearchPlayers err: %v", err)
+		return nil, errors.New("search players")
+	}
+	list := make([]*pb.Players, 0, len(all))
+	for _, v := range all {
+		temp := &pb.Players{}
+		err := copier.Copy(temp, v)
+		if err != nil {
+			logx.Errorf("SearchPlayers copier.Copy err: %v", err)
+			continue
+		}
+		list = append(list, temp)
+	}
+
+	return &pb.SearchPlayersResp{Players: list}, nil
+
+}

app/player/rpc/internal/logic/updatePlayerServicesLogic.go

@@ -0,0 +1,52 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/shopspring/decimal"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UpdatePlayerServicesLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewUpdatePlayerServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdatePlayerServicesLogic {
+	return &UpdatePlayerServicesLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *UpdatePlayerServicesLogic) UpdatePlayerServices(in *pb.UpdatePlayerServicesReq) (*pb.UpdatePlayerServicesResp, error) {
+	update := l.svcCtx.PlayerModelRW.PlayerServices.UpdateOneID(in.Id).
+		SetNillablePlayerID(in.PlayerId).
+		SetNillableDescription(in.Description).
+		SetNillableGameID(in.GameId).
+		SetNillableIsActive(in.IsActive).
+		SetNillableRankRange(in.RankRange).
+		SetNillableTitle(in.Title).
+		SetNillableUnit(in.Unit).
+		SetAvailability(in.Availability)
+	if in.Price != nil {
+		price := decimal.NewFromFloat(*in.Price)
+		update.SetNillablePrice(&price)
+	}
+	if in.Rating != nil {
+		rating := decimal.NewFromFloat(*in.Rating)
+		update.SetNillableRating(&rating)
+	}
+
+	_, err := update.Save(l.ctx)
+	if err != nil {
+		logx.Errorf("failed to update player services: " + err.Error())
+		return nil, errors.New("failed to update player services")
+	}
+	return &pb.UpdatePlayerServicesResp{}, nil
+}

app/player/rpc/internal/logic/updatePlayersLogic.go

@@ -0,0 +1,37 @@
+package logic
+
+import (
+	"context"
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+
+	"github.com/shopspring/decimal"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UpdatePlayersLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewUpdatePlayersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdatePlayersLogic {
+	return &UpdatePlayersLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *UpdatePlayersLogic) UpdatePlayers(in *pb.UpdatePlayersReq) (*pb.UpdatePlayersResp, error) {
+	update := l.svcCtx.PlayerModelRW.Players.UpdateOneID(in.Id).
+		SetNillableStatus(in.Status).
+		SetNillableUserID(in.UserId).
+		SetNillableShopID(in.ShopId)
+	if in.Rating != nil {
+		rating := decimal.NewFromFloat(*in.Rating)
+		update.SetRating(rating)
+	}
+
+	return &pb.UpdatePlayersResp{}, nil
+}

app/player/rpc/internal/models/client.go

@@ -0,0 +1,484 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"reflect"
+
+	"juwan-backend/app/player/rpc/internal/models/migrate"
+
+	"juwan-backend/app/player/rpc/internal/models/players"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+)
+
+// Client is the client that holds all ent builders.
+type Client struct {
+	config
+	// Schema is the client for creating, migrating and dropping schema.
+	Schema *migrate.Schema
+	// PlayerServices is the client for interacting with the PlayerServices builders.
+	PlayerServices *PlayerServicesClient
+	// Players is the client for interacting with the Players builders.
+	Players *PlayersClient
+}
+
+// NewClient creates a new client configured with the given options.
+func NewClient(opts ...Option) *Client {
+	client := &Client{config: newConfig(opts...)}
+	client.init()
+	return client
+}
+
+func (c *Client) init() {
+	c.Schema = migrate.NewSchema(c.driver)
+	c.PlayerServices = NewPlayerServicesClient(c.config)
+	c.Players = NewPlayersClient(c.config)
+}
+
+type (
+	// config is the configuration for the client and its builder.
+	config struct {
+		// driver used for executing database requests.
+		driver dialect.Driver
+		// debug enable a debug logging.
+		debug bool
+		// log used for logging on debug mode.
+		log func(...any)
+		// hooks to execute on mutations.
+		hooks *hooks
+		// interceptors to execute on queries.
+		inters *inters
+	}
+	// Option function to configure the client.
+	Option func(*config)
+)
+
+// newConfig creates a new config for the client.
+func newConfig(opts ...Option) config {
+	cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
+	cfg.options(opts...)
+	return cfg
+}
+
+// options applies the options on the config object.
+func (c *config) options(opts ...Option) {
+	for _, opt := range opts {
+		opt(c)
+	}
+	if c.debug {
+		c.driver = dialect.Debug(c.driver, c.log)
+	}
+}
+
+// Debug enables debug logging on the ent.Driver.
+func Debug() Option {
+	return func(c *config) {
+		c.debug = true
+	}
+}
+
+// Log sets the logging function for debug mode.
+func Log(fn func(...any)) Option {
+	return func(c *config) {
+		c.log = fn
+	}
+}
+
+// Driver configures the client driver.
+func Driver(driver dialect.Driver) Option {
+	return func(c *config) {
+		c.driver = driver
+	}
+}
+
+// Open opens a database/sql.DB specified by the driver name and
+// the data source name, and returns a new client attached to it.
+// Optional parameters can be added for configuring the client.
+func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
+	switch driverName {
+	case dialect.MySQL, dialect.Postgres, dialect.SQLite:
+		drv, err := sql.Open(driverName, dataSourceName)
+		if err != nil {
+			return nil, err
+		}
+		return NewClient(append(options, Driver(drv))...), nil
+	default:
+		return nil, fmt.Errorf("unsupported driver: %q", driverName)
+	}
+}
+
+// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
+var ErrTxStarted = errors.New("models: cannot start a transaction within a transaction")
+
+// Tx returns a new transactional client. The provided context
+// is used until the transaction is committed or rolled back.
+func (c *Client) Tx(ctx context.Context) (*Tx, error) {
+	if _, ok := c.driver.(*txDriver); ok {
+		return nil, ErrTxStarted
+	}
+	tx, err := newTx(ctx, c.driver)
+	if err != nil {
+		return nil, fmt.Errorf("models: starting a transaction: %w", err)
+	}
+	cfg := c.config
+	cfg.driver = tx
+	return &Tx{
+		ctx:            ctx,
+		config:         cfg,
+		PlayerServices: NewPlayerServicesClient(cfg),
+		Players:        NewPlayersClient(cfg),
+	}, nil
+}
+
+// BeginTx returns a transactional client with specified options.
+func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
+	if _, ok := c.driver.(*txDriver); ok {
+		return nil, errors.New("ent: cannot start a transaction within a transaction")
+	}
+	tx, err := c.driver.(interface {
+		BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
+	}).BeginTx(ctx, opts)
+	if err != nil {
+		return nil, fmt.Errorf("ent: starting a transaction: %w", err)
+	}
+	cfg := c.config
+	cfg.driver = &txDriver{tx: tx, drv: c.driver}
+	return &Tx{
+		ctx:            ctx,
+		config:         cfg,
+		PlayerServices: NewPlayerServicesClient(cfg),
+		Players:        NewPlayersClient(cfg),
+	}, nil
+}
+
+// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
+//
+//	client.Debug().
+//		PlayerServices.
+//		Query().
+//		Count(ctx)
+func (c *Client) Debug() *Client {
+	if c.debug {
+		return c
+	}
+	cfg := c.config
+	cfg.driver = dialect.Debug(c.driver, c.log)
+	client := &Client{config: cfg}
+	client.init()
+	return client
+}
+
+// Close closes the database connection and prevents new queries from starting.
+func (c *Client) Close() error {
+	return c.driver.Close()
+}
+
+// Use adds the mutation hooks to all the entity clients.
+// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
+func (c *Client) Use(hooks ...Hook) {
+	c.PlayerServices.Use(hooks...)
+	c.Players.Use(hooks...)
+}
+
+// Intercept adds the query interceptors to all the entity clients.
+// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
+func (c *Client) Intercept(interceptors ...Interceptor) {
+	c.PlayerServices.Intercept(interceptors...)
+	c.Players.Intercept(interceptors...)
+}
+
+// Mutate implements the ent.Mutator interface.
+func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
+	switch m := m.(type) {
+	case *PlayerServicesMutation:
+		return c.PlayerServices.mutate(ctx, m)
+	case *PlayersMutation:
+		return c.Players.mutate(ctx, m)
+	default:
+		return nil, fmt.Errorf("models: unknown mutation type %T", m)
+	}
+}
+
+// PlayerServicesClient is a client for the PlayerServices schema.
+type PlayerServicesClient struct {
+	config
+}
+
+// NewPlayerServicesClient returns a client for the PlayerServices from the given config.
+func NewPlayerServicesClient(c config) *PlayerServicesClient {
+	return &PlayerServicesClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `playerservices.Hooks(f(g(h())))`.
+func (c *PlayerServicesClient) Use(hooks ...Hook) {
+	c.hooks.PlayerServices = append(c.hooks.PlayerServices, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `playerservices.Intercept(f(g(h())))`.
+func (c *PlayerServicesClient) Intercept(interceptors ...Interceptor) {
+	c.inters.PlayerServices = append(c.inters.PlayerServices, interceptors...)
+}
+
+// Create returns a builder for creating a PlayerServices entity.
+func (c *PlayerServicesClient) Create() *PlayerServicesCreate {
+	mutation := newPlayerServicesMutation(c.config, OpCreate)
+	return &PlayerServicesCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of PlayerServices entities.
+func (c *PlayerServicesClient) CreateBulk(builders ...*PlayerServicesCreate) *PlayerServicesCreateBulk {
+	return &PlayerServicesCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *PlayerServicesClient) MapCreateBulk(slice any, setFunc func(*PlayerServicesCreate, int)) *PlayerServicesCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &PlayerServicesCreateBulk{err: fmt.Errorf("calling to PlayerServicesClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*PlayerServicesCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &PlayerServicesCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for PlayerServices.
+func (c *PlayerServicesClient) Update() *PlayerServicesUpdate {
+	mutation := newPlayerServicesMutation(c.config, OpUpdate)
+	return &PlayerServicesUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *PlayerServicesClient) UpdateOne(_m *PlayerServices) *PlayerServicesUpdateOne {
+	mutation := newPlayerServicesMutation(c.config, OpUpdateOne, withPlayerServices(_m))
+	return &PlayerServicesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *PlayerServicesClient) UpdateOneID(id int64) *PlayerServicesUpdateOne {
+	mutation := newPlayerServicesMutation(c.config, OpUpdateOne, withPlayerServicesID(id))
+	return &PlayerServicesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for PlayerServices.
+func (c *PlayerServicesClient) Delete() *PlayerServicesDelete {
+	mutation := newPlayerServicesMutation(c.config, OpDelete)
+	return &PlayerServicesDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *PlayerServicesClient) DeleteOne(_m *PlayerServices) *PlayerServicesDeleteOne {
+	return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *PlayerServicesClient) DeleteOneID(id int64) *PlayerServicesDeleteOne {
+	builder := c.Delete().Where(playerservices.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &PlayerServicesDeleteOne{builder}
+}
+
+// Query returns a query builder for PlayerServices.
+func (c *PlayerServicesClient) Query() *PlayerServicesQuery {
+	return &PlayerServicesQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypePlayerServices},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a PlayerServices entity by its id.
+func (c *PlayerServicesClient) Get(ctx context.Context, id int64) (*PlayerServices, error) {
+	return c.Query().Where(playerservices.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *PlayerServicesClient) GetX(ctx context.Context, id int64) *PlayerServices {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *PlayerServicesClient) Hooks() []Hook {
+	return c.hooks.PlayerServices
+}
+
+// Interceptors returns the client interceptors.
+func (c *PlayerServicesClient) Interceptors() []Interceptor {
+	return c.inters.PlayerServices
+}
+
+func (c *PlayerServicesClient) mutate(ctx context.Context, m *PlayerServicesMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&PlayerServicesCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&PlayerServicesUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&PlayerServicesUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&PlayerServicesDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("models: unknown PlayerServices mutation op: %q", m.Op())
+	}
+}
+
+// PlayersClient is a client for the Players schema.
+type PlayersClient struct {
+	config
+}
+
+// NewPlayersClient returns a client for the Players from the given config.
+func NewPlayersClient(c config) *PlayersClient {
+	return &PlayersClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `players.Hooks(f(g(h())))`.
+func (c *PlayersClient) Use(hooks ...Hook) {
+	c.hooks.Players = append(c.hooks.Players, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `players.Intercept(f(g(h())))`.
+func (c *PlayersClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Players = append(c.inters.Players, interceptors...)
+}
+
+// Create returns a builder for creating a Players entity.
+func (c *PlayersClient) Create() *PlayersCreate {
+	mutation := newPlayersMutation(c.config, OpCreate)
+	return &PlayersCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Players entities.
+func (c *PlayersClient) CreateBulk(builders ...*PlayersCreate) *PlayersCreateBulk {
+	return &PlayersCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *PlayersClient) MapCreateBulk(slice any, setFunc func(*PlayersCreate, int)) *PlayersCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &PlayersCreateBulk{err: fmt.Errorf("calling to PlayersClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*PlayersCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &PlayersCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Players.
+func (c *PlayersClient) Update() *PlayersUpdate {
+	mutation := newPlayersMutation(c.config, OpUpdate)
+	return &PlayersUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *PlayersClient) UpdateOne(_m *Players) *PlayersUpdateOne {
+	mutation := newPlayersMutation(c.config, OpUpdateOne, withPlayers(_m))
+	return &PlayersUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *PlayersClient) UpdateOneID(id int64) *PlayersUpdateOne {
+	mutation := newPlayersMutation(c.config, OpUpdateOne, withPlayersID(id))
+	return &PlayersUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Players.
+func (c *PlayersClient) Delete() *PlayersDelete {
+	mutation := newPlayersMutation(c.config, OpDelete)
+	return &PlayersDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *PlayersClient) DeleteOne(_m *Players) *PlayersDeleteOne {
+	return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *PlayersClient) DeleteOneID(id int64) *PlayersDeleteOne {
+	builder := c.Delete().Where(players.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &PlayersDeleteOne{builder}
+}
+
+// Query returns a query builder for Players.
+func (c *PlayersClient) Query() *PlayersQuery {
+	return &PlayersQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypePlayers},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a Players entity by its id.
+func (c *PlayersClient) Get(ctx context.Context, id int64) (*Players, error) {
+	return c.Query().Where(players.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *PlayersClient) GetX(ctx context.Context, id int64) *Players {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// Hooks returns the client hooks.
+func (c *PlayersClient) Hooks() []Hook {
+	return c.hooks.Players
+}
+
+// Interceptors returns the client interceptors.
+func (c *PlayersClient) Interceptors() []Interceptor {
+	return c.inters.Players
+}
+
+func (c *PlayersClient) mutate(ctx context.Context, m *PlayersMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&PlayersCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&PlayersUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&PlayersUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&PlayersDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("models: unknown Players mutation op: %q", m.Op())
+	}
+}
+
+// hooks and interceptors per client, for fast access.
+type (
+	hooks struct {
+		PlayerServices, Players []ent.Hook
+	}
+	inters struct {
+		PlayerServices, Players []ent.Interceptor
+	}
+)

app/player/rpc/internal/models/ent.go

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

app/player/rpc/internal/models/enttest/enttest.go

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

app/player/rpc/internal/models/hook/hook.go

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

app/player/rpc/internal/models/migrate/migrate.go

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

app/player/rpc/internal/models/migrate/schema.go

@@ -0,0 +1,70 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/dialect/sql/schema"
+	"entgo.io/ent/schema/field"
+)
+
+var (
+	// PlayerServicesColumns holds the columns for the "player_services" table.
+	PlayerServicesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true},
+		{Name: "player_id", Type: field.TypeInt64},
+		{Name: "game_id", Type: field.TypeInt64},
+		{Name: "title", Type: field.TypeString, Size: 200},
+		{Name: "description", Type: field.TypeString, Nullable: true},
+		{Name: "price", Type: field.TypeOther, SchemaType: map[string]string{"postgres": "decimal(10,2)"}},
+		{Name: "unit", Type: field.TypeString, Size: 20},
+		{Name: "rank_range", Type: field.TypeString, Nullable: true, Size: 100},
+		{Name: "availability", Type: field.TypeJSON, Nullable: true},
+		{Name: "rating", Type: field.TypeOther, SchemaType: map[string]string{"postgres": "decimal(3,2)"}},
+		{Name: "is_active", Type: field.TypeBool, Nullable: true, Default: true},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+	}
+	// PlayerServicesTable holds the schema information for the "player_services" table.
+	PlayerServicesTable = &schema.Table{
+		Name:       "player_services",
+		Columns:    PlayerServicesColumns,
+		PrimaryKey: []*schema.Column{PlayerServicesColumns[0]},
+	}
+	// PlayersColumns holds the columns for the "players" table.
+	PlayersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt64, Increment: true},
+		{Name: "user_id", Type: field.TypeInt64, Unique: true},
+		{Name: "status", Type: field.TypeString, Size: 20, Default: "offline"},
+		{Name: "gender", Type: field.TypeInt, Unique: true},
+		{Name: "rating", Type: field.TypeOther, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(3,2)"}},
+		{Name: "total_orders", Type: field.TypeInt, Nullable: true, Default: 0},
+		{Name: "completed_orders", Type: field.TypeInt, Nullable: true, Default: 0},
+		{Name: "shop_id", Type: field.TypeInt64, Nullable: true},
+		{Name: "tags", Type: field.TypeJSON, Nullable: true},
+		{Name: "games", Type: field.TypeOther, Nullable: true, SchemaType: map[string]string{"postgres": "bigint[]"}},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+	}
+	// PlayersTable holds the schema information for the "players" table.
+	PlayersTable = &schema.Table{
+		Name:       "players",
+		Columns:    PlayersColumns,
+		PrimaryKey: []*schema.Column{PlayersColumns[0]},
+	}
+	// Tables holds all the tables in the schema.
+	Tables = []*schema.Table{
+		PlayerServicesTable,
+		PlayersTable,
+	}
+)
+
+func init() {
+	PlayerServicesTable.Annotation = &entsql.Annotation{
+		Table: "player_services",
+	}
+	PlayerServicesTable.Annotation.Checks = map[string]string{
+		"chk_price_positive": "price > 0",
+		"chk_service_rating": "rating >= 0 AND rating <= 5",
+	}
+}

app/player/rpc/internal/models/players.go

@@ -0,0 +1,230 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"encoding/json"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/players"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/lib/pq"
+	"github.com/shopspring/decimal"
+)
+
+// Players is the model entity for the Players schema.
+type Players struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID int64 `json:"id,omitempty"`
+	// UserID holds the value of the "user_id" field.
+	UserID int64 `json:"user_id,omitempty"`
+	// Status holds the value of the "status" field.
+	Status string `json:"status,omitempty"`
+	// Gender holds the value of the "gender" field.
+	Gender int `json:"gender,omitempty"`
+	// Rating holds the value of the "rating" field.
+	Rating decimal.Decimal `json:"rating,omitempty"`
+	// TotalOrders holds the value of the "total_orders" field.
+	TotalOrders int `json:"total_orders,omitempty"`
+	// CompletedOrders holds the value of the "completed_orders" field.
+	CompletedOrders int `json:"completed_orders,omitempty"`
+	// ShopID holds the value of the "shop_id" field.
+	ShopID *int64 `json:"shop_id,omitempty"`
+	// Tags holds the value of the "tags" field.
+	Tags []string `json:"tags,omitempty"`
+	// Games holds the value of the "games" field.
+	Games pq.Int64Array `json:"games,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt    time.Time `json:"updated_at,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Players) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case players.FieldTags:
+			values[i] = new([]byte)
+		case players.FieldRating:
+			values[i] = new(decimal.Decimal)
+		case players.FieldGames:
+			values[i] = new(pq.Int64Array)
+		case players.FieldID, players.FieldUserID, players.FieldGender, players.FieldTotalOrders, players.FieldCompletedOrders, players.FieldShopID:
+			values[i] = new(sql.NullInt64)
+		case players.FieldStatus:
+			values[i] = new(sql.NullString)
+		case players.FieldCreatedAt, players.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Players fields.
+func (_m *Players) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case players.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			_m.ID = int64(value.Int64)
+		case players.FieldUserID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field user_id", values[i])
+			} else if value.Valid {
+				_m.UserID = value.Int64
+			}
+		case players.FieldStatus:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field status", values[i])
+			} else if value.Valid {
+				_m.Status = value.String
+			}
+		case players.FieldGender:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field gender", values[i])
+			} else if value.Valid {
+				_m.Gender = int(value.Int64)
+			}
+		case players.FieldRating:
+			if value, ok := values[i].(*decimal.Decimal); !ok {
+				return fmt.Errorf("unexpected type %T for field rating", values[i])
+			} else if value != nil {
+				_m.Rating = *value
+			}
+		case players.FieldTotalOrders:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field total_orders", values[i])
+			} else if value.Valid {
+				_m.TotalOrders = int(value.Int64)
+			}
+		case players.FieldCompletedOrders:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field completed_orders", values[i])
+			} else if value.Valid {
+				_m.CompletedOrders = int(value.Int64)
+			}
+		case players.FieldShopID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field shop_id", values[i])
+			} else if value.Valid {
+				_m.ShopID = new(int64)
+				*_m.ShopID = value.Int64
+			}
+		case players.FieldTags:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field tags", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &_m.Tags); err != nil {
+					return fmt.Errorf("unmarshal field tags: %w", err)
+				}
+			}
+		case players.FieldGames:
+			if value, ok := values[i].(*pq.Int64Array); !ok {
+				return fmt.Errorf("unexpected type %T for field games", values[i])
+			} else if value != nil {
+				_m.Games = *value
+			}
+		case players.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				_m.CreatedAt = value.Time
+			}
+		case players.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				_m.UpdatedAt = value.Time
+			}
+		default:
+			_m.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Players.
+// This includes values selected through modifiers, order, etc.
+func (_m *Players) Value(name string) (ent.Value, error) {
+	return _m.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this Players.
+// Note that you need to call Players.Unwrap() before calling this method if this Players
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *Players) Update() *PlayersUpdateOne {
+	return NewPlayersClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the Players entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (_m *Players) Unwrap() *Players {
+	_tx, ok := _m.config.driver.(*txDriver)
+	if !ok {
+		panic("models: Players is not a transactional entity")
+	}
+	_m.config.driver = _tx.drv
+	return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *Players) String() string {
+	var builder strings.Builder
+	builder.WriteString("Players(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+	builder.WriteString("user_id=")
+	builder.WriteString(fmt.Sprintf("%v", _m.UserID))
+	builder.WriteString(", ")
+	builder.WriteString("status=")
+	builder.WriteString(_m.Status)
+	builder.WriteString(", ")
+	builder.WriteString("gender=")
+	builder.WriteString(fmt.Sprintf("%v", _m.Gender))
+	builder.WriteString(", ")
+	builder.WriteString("rating=")
+	builder.WriteString(fmt.Sprintf("%v", _m.Rating))
+	builder.WriteString(", ")
+	builder.WriteString("total_orders=")
+	builder.WriteString(fmt.Sprintf("%v", _m.TotalOrders))
+	builder.WriteString(", ")
+	builder.WriteString("completed_orders=")
+	builder.WriteString(fmt.Sprintf("%v", _m.CompletedOrders))
+	builder.WriteString(", ")
+	if v := _m.ShopID; v != nil {
+		builder.WriteString("shop_id=")
+		builder.WriteString(fmt.Sprintf("%v", *v))
+	}
+	builder.WriteString(", ")
+	builder.WriteString("tags=")
+	builder.WriteString(fmt.Sprintf("%v", _m.Tags))
+	builder.WriteString(", ")
+	builder.WriteString("games=")
+	builder.WriteString(fmt.Sprintf("%v", _m.Games))
+	builder.WriteString(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// PlayersSlice is a parsable slice of Players.
+type PlayersSlice []*Players

app/player/rpc/internal/models/players/players.go

@@ -0,0 +1,149 @@
+// Code generated by ent, DO NOT EDIT.
+
+package players
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/lib/pq"
+	"github.com/shopspring/decimal"
+)
+
+const (
+	// Label holds the string label denoting the players type in the database.
+	Label = "players"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldUserID holds the string denoting the user_id field in the database.
+	FieldUserID = "user_id"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldGender holds the string denoting the gender field in the database.
+	FieldGender = "gender"
+	// FieldRating holds the string denoting the rating field in the database.
+	FieldRating = "rating"
+	// FieldTotalOrders holds the string denoting the total_orders field in the database.
+	FieldTotalOrders = "total_orders"
+	// FieldCompletedOrders holds the string denoting the completed_orders field in the database.
+	FieldCompletedOrders = "completed_orders"
+	// FieldShopID holds the string denoting the shop_id field in the database.
+	FieldShopID = "shop_id"
+	// FieldTags holds the string denoting the tags field in the database.
+	FieldTags = "tags"
+	// FieldGames holds the string denoting the games field in the database.
+	FieldGames = "games"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the players in the database.
+	Table = "players"
+)
+
+// Columns holds all SQL columns for players fields.
+var Columns = []string{
+	FieldID,
+	FieldUserID,
+	FieldStatus,
+	FieldGender,
+	FieldRating,
+	FieldTotalOrders,
+	FieldCompletedOrders,
+	FieldShopID,
+	FieldTags,
+	FieldGames,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
+	StatusValidator func(string) error
+	// DefaultRating holds the default value on creation for the "rating" field.
+	DefaultRating decimal.Decimal
+	// DefaultTotalOrders holds the default value on creation for the "total_orders" field.
+	DefaultTotalOrders int
+	// DefaultCompletedOrders holds the default value on creation for the "completed_orders" field.
+	DefaultCompletedOrders int
+	// DefaultTags holds the default value on creation for the "tags" field.
+	DefaultTags []string
+	// DefaultGames holds the default value on creation for the "games" field.
+	DefaultGames pq.Int64Array
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+)
+
+// OrderOption defines the ordering options for the Players queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByGender orders the results by the gender field.
+func ByGender(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldGender, opts...).ToFunc()
+}
+
+// ByRating orders the results by the rating field.
+func ByRating(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRating, opts...).ToFunc()
+}
+
+// ByTotalOrders orders the results by the total_orders field.
+func ByTotalOrders(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTotalOrders, opts...).ToFunc()
+}
+
+// ByCompletedOrders orders the results by the completed_orders field.
+func ByCompletedOrders(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCompletedOrders, opts...).ToFunc()
+}
+
+// ByShopID orders the results by the shop_id field.
+func ByShopID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldShopID, opts...).ToFunc()
+}
+
+// ByGames orders the results by the games field.
+func ByGames(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldGames, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}

app/player/rpc/internal/models/players/where.go

@@ -0,0 +1,607 @@
+// Code generated by ent, DO NOT EDIT.
+
+package players
+
+import (
+	"juwan-backend/app/player/rpc/internal/models/predicate"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/lib/pq"
+	"github.com/shopspring/decimal"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int64) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int64) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int64) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int64) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int64) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int64) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int64) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int64) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int64) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldID, id))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v int64) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldUserID, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldStatus, v))
+}
+
+// Gender applies equality check predicate on the "gender" field. It's identical to GenderEQ.
+func Gender(v int) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldGender, v))
+}
+
+// Rating applies equality check predicate on the "rating" field. It's identical to RatingEQ.
+func Rating(v decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldRating, v))
+}
+
+// TotalOrders applies equality check predicate on the "total_orders" field. It's identical to TotalOrdersEQ.
+func TotalOrders(v int) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldTotalOrders, v))
+}
+
+// CompletedOrders applies equality check predicate on the "completed_orders" field. It's identical to CompletedOrdersEQ.
+func CompletedOrders(v int) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldCompletedOrders, v))
+}
+
+// ShopID applies equality check predicate on the "shop_id" field. It's identical to ShopIDEQ.
+func ShopID(v int64) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldShopID, v))
+}
+
+// Games applies equality check predicate on the "games" field. It's identical to GamesEQ.
+func Games(v pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldGames, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v int64) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v int64) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...int64) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...int64) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// UserIDGT applies the GT predicate on the "user_id" field.
+func UserIDGT(v int64) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldUserID, v))
+}
+
+// UserIDGTE applies the GTE predicate on the "user_id" field.
+func UserIDGTE(v int64) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldUserID, v))
+}
+
+// UserIDLT applies the LT predicate on the "user_id" field.
+func UserIDLT(v int64) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldUserID, v))
+}
+
+// UserIDLTE applies the LTE predicate on the "user_id" field.
+func UserIDLTE(v int64) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldUserID, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.Players {
+	return predicate.Players(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.Players {
+	return predicate.Players(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.Players {
+	return predicate.Players(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.Players {
+	return predicate.Players(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.Players {
+	return predicate.Players(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// GenderEQ applies the EQ predicate on the "gender" field.
+func GenderEQ(v int) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldGender, v))
+}
+
+// GenderNEQ applies the NEQ predicate on the "gender" field.
+func GenderNEQ(v int) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldGender, v))
+}
+
+// GenderIn applies the In predicate on the "gender" field.
+func GenderIn(vs ...int) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldGender, vs...))
+}
+
+// GenderNotIn applies the NotIn predicate on the "gender" field.
+func GenderNotIn(vs ...int) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldGender, vs...))
+}
+
+// GenderGT applies the GT predicate on the "gender" field.
+func GenderGT(v int) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldGender, v))
+}
+
+// GenderGTE applies the GTE predicate on the "gender" field.
+func GenderGTE(v int) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldGender, v))
+}
+
+// GenderLT applies the LT predicate on the "gender" field.
+func GenderLT(v int) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldGender, v))
+}
+
+// GenderLTE applies the LTE predicate on the "gender" field.
+func GenderLTE(v int) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldGender, v))
+}
+
+// RatingEQ applies the EQ predicate on the "rating" field.
+func RatingEQ(v decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldRating, v))
+}
+
+// RatingNEQ applies the NEQ predicate on the "rating" field.
+func RatingNEQ(v decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldRating, v))
+}
+
+// RatingIn applies the In predicate on the "rating" field.
+func RatingIn(vs ...decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldRating, vs...))
+}
+
+// RatingNotIn applies the NotIn predicate on the "rating" field.
+func RatingNotIn(vs ...decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldRating, vs...))
+}
+
+// RatingGT applies the GT predicate on the "rating" field.
+func RatingGT(v decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldRating, v))
+}
+
+// RatingGTE applies the GTE predicate on the "rating" field.
+func RatingGTE(v decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldRating, v))
+}
+
+// RatingLT applies the LT predicate on the "rating" field.
+func RatingLT(v decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldRating, v))
+}
+
+// RatingLTE applies the LTE predicate on the "rating" field.
+func RatingLTE(v decimal.Decimal) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldRating, v))
+}
+
+// RatingIsNil applies the IsNil predicate on the "rating" field.
+func RatingIsNil() predicate.Players {
+	return predicate.Players(sql.FieldIsNull(FieldRating))
+}
+
+// RatingNotNil applies the NotNil predicate on the "rating" field.
+func RatingNotNil() predicate.Players {
+	return predicate.Players(sql.FieldNotNull(FieldRating))
+}
+
+// TotalOrdersEQ applies the EQ predicate on the "total_orders" field.
+func TotalOrdersEQ(v int) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldTotalOrders, v))
+}
+
+// TotalOrdersNEQ applies the NEQ predicate on the "total_orders" field.
+func TotalOrdersNEQ(v int) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldTotalOrders, v))
+}
+
+// TotalOrdersIn applies the In predicate on the "total_orders" field.
+func TotalOrdersIn(vs ...int) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldTotalOrders, vs...))
+}
+
+// TotalOrdersNotIn applies the NotIn predicate on the "total_orders" field.
+func TotalOrdersNotIn(vs ...int) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldTotalOrders, vs...))
+}
+
+// TotalOrdersGT applies the GT predicate on the "total_orders" field.
+func TotalOrdersGT(v int) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldTotalOrders, v))
+}
+
+// TotalOrdersGTE applies the GTE predicate on the "total_orders" field.
+func TotalOrdersGTE(v int) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldTotalOrders, v))
+}
+
+// TotalOrdersLT applies the LT predicate on the "total_orders" field.
+func TotalOrdersLT(v int) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldTotalOrders, v))
+}
+
+// TotalOrdersLTE applies the LTE predicate on the "total_orders" field.
+func TotalOrdersLTE(v int) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldTotalOrders, v))
+}
+
+// TotalOrdersIsNil applies the IsNil predicate on the "total_orders" field.
+func TotalOrdersIsNil() predicate.Players {
+	return predicate.Players(sql.FieldIsNull(FieldTotalOrders))
+}
+
+// TotalOrdersNotNil applies the NotNil predicate on the "total_orders" field.
+func TotalOrdersNotNil() predicate.Players {
+	return predicate.Players(sql.FieldNotNull(FieldTotalOrders))
+}
+
+// CompletedOrdersEQ applies the EQ predicate on the "completed_orders" field.
+func CompletedOrdersEQ(v int) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldCompletedOrders, v))
+}
+
+// CompletedOrdersNEQ applies the NEQ predicate on the "completed_orders" field.
+func CompletedOrdersNEQ(v int) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldCompletedOrders, v))
+}
+
+// CompletedOrdersIn applies the In predicate on the "completed_orders" field.
+func CompletedOrdersIn(vs ...int) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldCompletedOrders, vs...))
+}
+
+// CompletedOrdersNotIn applies the NotIn predicate on the "completed_orders" field.
+func CompletedOrdersNotIn(vs ...int) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldCompletedOrders, vs...))
+}
+
+// CompletedOrdersGT applies the GT predicate on the "completed_orders" field.
+func CompletedOrdersGT(v int) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldCompletedOrders, v))
+}
+
+// CompletedOrdersGTE applies the GTE predicate on the "completed_orders" field.
+func CompletedOrdersGTE(v int) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldCompletedOrders, v))
+}
+
+// CompletedOrdersLT applies the LT predicate on the "completed_orders" field.
+func CompletedOrdersLT(v int) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldCompletedOrders, v))
+}
+
+// CompletedOrdersLTE applies the LTE predicate on the "completed_orders" field.
+func CompletedOrdersLTE(v int) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldCompletedOrders, v))
+}
+
+// CompletedOrdersIsNil applies the IsNil predicate on the "completed_orders" field.
+func CompletedOrdersIsNil() predicate.Players {
+	return predicate.Players(sql.FieldIsNull(FieldCompletedOrders))
+}
+
+// CompletedOrdersNotNil applies the NotNil predicate on the "completed_orders" field.
+func CompletedOrdersNotNil() predicate.Players {
+	return predicate.Players(sql.FieldNotNull(FieldCompletedOrders))
+}
+
+// ShopIDEQ applies the EQ predicate on the "shop_id" field.
+func ShopIDEQ(v int64) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldShopID, v))
+}
+
+// ShopIDNEQ applies the NEQ predicate on the "shop_id" field.
+func ShopIDNEQ(v int64) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldShopID, v))
+}
+
+// ShopIDIn applies the In predicate on the "shop_id" field.
+func ShopIDIn(vs ...int64) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldShopID, vs...))
+}
+
+// ShopIDNotIn applies the NotIn predicate on the "shop_id" field.
+func ShopIDNotIn(vs ...int64) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldShopID, vs...))
+}
+
+// ShopIDGT applies the GT predicate on the "shop_id" field.
+func ShopIDGT(v int64) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldShopID, v))
+}
+
+// ShopIDGTE applies the GTE predicate on the "shop_id" field.
+func ShopIDGTE(v int64) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldShopID, v))
+}
+
+// ShopIDLT applies the LT predicate on the "shop_id" field.
+func ShopIDLT(v int64) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldShopID, v))
+}
+
+// ShopIDLTE applies the LTE predicate on the "shop_id" field.
+func ShopIDLTE(v int64) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldShopID, v))
+}
+
+// ShopIDIsNil applies the IsNil predicate on the "shop_id" field.
+func ShopIDIsNil() predicate.Players {
+	return predicate.Players(sql.FieldIsNull(FieldShopID))
+}
+
+// ShopIDNotNil applies the NotNil predicate on the "shop_id" field.
+func ShopIDNotNil() predicate.Players {
+	return predicate.Players(sql.FieldNotNull(FieldShopID))
+}
+
+// TagsIsNil applies the IsNil predicate on the "tags" field.
+func TagsIsNil() predicate.Players {
+	return predicate.Players(sql.FieldIsNull(FieldTags))
+}
+
+// TagsNotNil applies the NotNil predicate on the "tags" field.
+func TagsNotNil() predicate.Players {
+	return predicate.Players(sql.FieldNotNull(FieldTags))
+}
+
+// GamesEQ applies the EQ predicate on the "games" field.
+func GamesEQ(v pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldGames, v))
+}
+
+// GamesNEQ applies the NEQ predicate on the "games" field.
+func GamesNEQ(v pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldGames, v))
+}
+
+// GamesIn applies the In predicate on the "games" field.
+func GamesIn(vs ...pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldGames, vs...))
+}
+
+// GamesNotIn applies the NotIn predicate on the "games" field.
+func GamesNotIn(vs ...pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldGames, vs...))
+}
+
+// GamesGT applies the GT predicate on the "games" field.
+func GamesGT(v pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldGames, v))
+}
+
+// GamesGTE applies the GTE predicate on the "games" field.
+func GamesGTE(v pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldGames, v))
+}
+
+// GamesLT applies the LT predicate on the "games" field.
+func GamesLT(v pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldGames, v))
+}
+
+// GamesLTE applies the LTE predicate on the "games" field.
+func GamesLTE(v pq.Int64Array) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldGames, v))
+}
+
+// GamesIsNil applies the IsNil predicate on the "games" field.
+func GamesIsNil() predicate.Players {
+	return predicate.Players(sql.FieldIsNull(FieldGames))
+}
+
+// GamesNotNil applies the NotNil predicate on the "games" field.
+func GamesNotNil() predicate.Players {
+	return predicate.Players(sql.FieldNotNull(FieldGames))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.Players {
+	return predicate.Players(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.Players {
+	return predicate.Players(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.Players {
+	return predicate.Players(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Players) predicate.Players {
+	return predicate.Players(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Players) predicate.Players {
+	return predicate.Players(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Players) predicate.Players {
+	return predicate.Players(sql.NotPredicates(p))
+}

app/player/rpc/internal/models/players_create.go

@@ -0,0 +1,409 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/players"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/lib/pq"
+	"github.com/shopspring/decimal"
+)
+
+// PlayersCreate is the builder for creating a Players entity.
+type PlayersCreate struct {
+	config
+	mutation *PlayersMutation
+	hooks    []Hook
+}
+
+// SetUserID sets the "user_id" field.
+func (_c *PlayersCreate) SetUserID(v int64) *PlayersCreate {
+	_c.mutation.SetUserID(v)
+	return _c
+}
+
+// SetStatus sets the "status" field.
+func (_c *PlayersCreate) SetStatus(v string) *PlayersCreate {
+	_c.mutation.SetStatus(v)
+	return _c
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (_c *PlayersCreate) SetNillableStatus(v *string) *PlayersCreate {
+	if v != nil {
+		_c.SetStatus(*v)
+	}
+	return _c
+}
+
+// SetGender sets the "gender" field.
+func (_c *PlayersCreate) SetGender(v int) *PlayersCreate {
+	_c.mutation.SetGender(v)
+	return _c
+}
+
+// SetRating sets the "rating" field.
+func (_c *PlayersCreate) SetRating(v decimal.Decimal) *PlayersCreate {
+	_c.mutation.SetRating(v)
+	return _c
+}
+
+// SetNillableRating sets the "rating" field if the given value is not nil.
+func (_c *PlayersCreate) SetNillableRating(v *decimal.Decimal) *PlayersCreate {
+	if v != nil {
+		_c.SetRating(*v)
+	}
+	return _c
+}
+
+// SetTotalOrders sets the "total_orders" field.
+func (_c *PlayersCreate) SetTotalOrders(v int) *PlayersCreate {
+	_c.mutation.SetTotalOrders(v)
+	return _c
+}
+
+// SetNillableTotalOrders sets the "total_orders" field if the given value is not nil.
+func (_c *PlayersCreate) SetNillableTotalOrders(v *int) *PlayersCreate {
+	if v != nil {
+		_c.SetTotalOrders(*v)
+	}
+	return _c
+}
+
+// SetCompletedOrders sets the "completed_orders" field.
+func (_c *PlayersCreate) SetCompletedOrders(v int) *PlayersCreate {
+	_c.mutation.SetCompletedOrders(v)
+	return _c
+}
+
+// SetNillableCompletedOrders sets the "completed_orders" field if the given value is not nil.
+func (_c *PlayersCreate) SetNillableCompletedOrders(v *int) *PlayersCreate {
+	if v != nil {
+		_c.SetCompletedOrders(*v)
+	}
+	return _c
+}
+
+// SetShopID sets the "shop_id" field.
+func (_c *PlayersCreate) SetShopID(v int64) *PlayersCreate {
+	_c.mutation.SetShopID(v)
+	return _c
+}
+
+// SetNillableShopID sets the "shop_id" field if the given value is not nil.
+func (_c *PlayersCreate) SetNillableShopID(v *int64) *PlayersCreate {
+	if v != nil {
+		_c.SetShopID(*v)
+	}
+	return _c
+}
+
+// SetTags sets the "tags" field.
+func (_c *PlayersCreate) SetTags(v []string) *PlayersCreate {
+	_c.mutation.SetTags(v)
+	return _c
+}
+
+// SetGames sets the "games" field.
+func (_c *PlayersCreate) SetGames(v pq.Int64Array) *PlayersCreate {
+	_c.mutation.SetGames(v)
+	return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *PlayersCreate) SetCreatedAt(v time.Time) *PlayersCreate {
+	_c.mutation.SetCreatedAt(v)
+	return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *PlayersCreate) SetNillableCreatedAt(v *time.Time) *PlayersCreate {
+	if v != nil {
+		_c.SetCreatedAt(*v)
+	}
+	return _c
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_c *PlayersCreate) SetUpdatedAt(v time.Time) *PlayersCreate {
+	_c.mutation.SetUpdatedAt(v)
+	return _c
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_c *PlayersCreate) SetNillableUpdatedAt(v *time.Time) *PlayersCreate {
+	if v != nil {
+		_c.SetUpdatedAt(*v)
+	}
+	return _c
+}
+
+// SetID sets the "id" field.
+func (_c *PlayersCreate) SetID(v int64) *PlayersCreate {
+	_c.mutation.SetID(v)
+	return _c
+}
+
+// Mutation returns the PlayersMutation object of the builder.
+func (_c *PlayersCreate) Mutation() *PlayersMutation {
+	return _c.mutation
+}
+
+// Save creates the Players in the database.
+func (_c *PlayersCreate) Save(ctx context.Context) (*Players, error) {
+	_c.defaults()
+	return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *PlayersCreate) SaveX(ctx context.Context) *Players {
+	v, err := _c.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (_c *PlayersCreate) Exec(ctx context.Context) error {
+	_, err := _c.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *PlayersCreate) ExecX(ctx context.Context) {
+	if err := _c.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *PlayersCreate) defaults() {
+	if _, ok := _c.mutation.Status(); !ok {
+		v := players.DefaultStatus
+		_c.mutation.SetStatus(v)
+	}
+	if _, ok := _c.mutation.Rating(); !ok {
+		v := players.DefaultRating
+		_c.mutation.SetRating(v)
+	}
+	if _, ok := _c.mutation.TotalOrders(); !ok {
+		v := players.DefaultTotalOrders
+		_c.mutation.SetTotalOrders(v)
+	}
+	if _, ok := _c.mutation.CompletedOrders(); !ok {
+		v := players.DefaultCompletedOrders
+		_c.mutation.SetCompletedOrders(v)
+	}
+	if _, ok := _c.mutation.Tags(); !ok {
+		v := players.DefaultTags
+		_c.mutation.SetTags(v)
+	}
+	if _, ok := _c.mutation.Games(); !ok {
+		v := players.DefaultGames
+		_c.mutation.SetGames(v)
+	}
+	if _, ok := _c.mutation.CreatedAt(); !ok {
+		v := players.DefaultCreatedAt()
+		_c.mutation.SetCreatedAt(v)
+	}
+	if _, ok := _c.mutation.UpdatedAt(); !ok {
+		v := players.DefaultUpdatedAt()
+		_c.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *PlayersCreate) check() error {
+	if _, ok := _c.mutation.UserID(); !ok {
+		return &ValidationError{Name: "user_id", err: errors.New(`models: missing required field "Players.user_id"`)}
+	}
+	if _, ok := _c.mutation.Status(); !ok {
+		return &ValidationError{Name: "status", err: errors.New(`models: missing required field "Players.status"`)}
+	}
+	if v, ok := _c.mutation.Status(); ok {
+		if err := players.StatusValidator(v); err != nil {
+			return &ValidationError{Name: "status", err: fmt.Errorf(`models: validator failed for field "Players.status": %w`, err)}
+		}
+	}
+	if _, ok := _c.mutation.Gender(); !ok {
+		return &ValidationError{Name: "gender", err: errors.New(`models: missing required field "Players.gender"`)}
+	}
+	if _, ok := _c.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`models: missing required field "Players.created_at"`)}
+	}
+	if _, ok := _c.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`models: missing required field "Players.updated_at"`)}
+	}
+	return nil
+}
+
+func (_c *PlayersCreate) sqlSave(ctx context.Context) (*Players, error) {
+	if err := _c.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := _c.createSpec()
+	if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != _node.ID {
+		id := _spec.ID.Value.(int64)
+		_node.ID = int64(id)
+	}
+	_c.mutation.id = &_node.ID
+	_c.mutation.done = true
+	return _node, nil
+}
+
+func (_c *PlayersCreate) createSpec() (*Players, *sqlgraph.CreateSpec) {
+	var (
+		_node = &Players{config: _c.config}
+		_spec = sqlgraph.NewCreateSpec(players.Table, sqlgraph.NewFieldSpec(players.FieldID, field.TypeInt64))
+	)
+	if id, ok := _c.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := _c.mutation.UserID(); ok {
+		_spec.SetField(players.FieldUserID, field.TypeInt64, value)
+		_node.UserID = value
+	}
+	if value, ok := _c.mutation.Status(); ok {
+		_spec.SetField(players.FieldStatus, field.TypeString, value)
+		_node.Status = value
+	}
+	if value, ok := _c.mutation.Gender(); ok {
+		_spec.SetField(players.FieldGender, field.TypeInt, value)
+		_node.Gender = value
+	}
+	if value, ok := _c.mutation.Rating(); ok {
+		_spec.SetField(players.FieldRating, field.TypeOther, value)
+		_node.Rating = value
+	}
+	if value, ok := _c.mutation.TotalOrders(); ok {
+		_spec.SetField(players.FieldTotalOrders, field.TypeInt, value)
+		_node.TotalOrders = value
+	}
+	if value, ok := _c.mutation.CompletedOrders(); ok {
+		_spec.SetField(players.FieldCompletedOrders, field.TypeInt, value)
+		_node.CompletedOrders = value
+	}
+	if value, ok := _c.mutation.ShopID(); ok {
+		_spec.SetField(players.FieldShopID, field.TypeInt64, value)
+		_node.ShopID = &value
+	}
+	if value, ok := _c.mutation.Tags(); ok {
+		_spec.SetField(players.FieldTags, field.TypeJSON, value)
+		_node.Tags = value
+	}
+	if value, ok := _c.mutation.Games(); ok {
+		_spec.SetField(players.FieldGames, field.TypeOther, value)
+		_node.Games = value
+	}
+	if value, ok := _c.mutation.CreatedAt(); ok {
+		_spec.SetField(players.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := _c.mutation.UpdatedAt(); ok {
+		_spec.SetField(players.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	return _node, _spec
+}
+
+// PlayersCreateBulk is the builder for creating many Players entities in bulk.
+type PlayersCreateBulk struct {
+	config
+	err      error
+	builders []*PlayersCreate
+}
+
+// Save creates the Players entities in the database.
+func (_c *PlayersCreateBulk) Save(ctx context.Context) ([]*Players, error) {
+	if _c.err != nil {
+		return nil, _c.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+	nodes := make([]*Players, len(_c.builders))
+	mutators := make([]Mutator, len(_c.builders))
+	for i := range _c.builders {
+		func(i int, root context.Context) {
+			builder := _c.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*PlayersMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				if specs[i].ID.Value != nil && nodes[i].ID == 0 {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int64(id)
+				}
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *PlayersCreateBulk) SaveX(ctx context.Context) []*Players {
+	v, err := _c.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (_c *PlayersCreateBulk) Exec(ctx context.Context) error {
+	_, err := _c.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *PlayersCreateBulk) ExecX(ctx context.Context) {
+	if err := _c.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/player/rpc/internal/models/players_delete.go

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

app/player/rpc/internal/models/players_query.go

@@ -0,0 +1,527 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/players"
+	"juwan-backend/app/player/rpc/internal/models/predicate"
+	"math"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// PlayersQuery is the builder for querying Players entities.
+type PlayersQuery struct {
+	config
+	ctx        *QueryContext
+	order      []players.OrderOption
+	inters     []Interceptor
+	predicates []predicate.Players
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the PlayersQuery builder.
+func (_q *PlayersQuery) Where(ps ...predicate.Players) *PlayersQuery {
+	_q.predicates = append(_q.predicates, ps...)
+	return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *PlayersQuery) Limit(limit int) *PlayersQuery {
+	_q.ctx.Limit = &limit
+	return _q
+}
+
+// Offset to start from.
+func (_q *PlayersQuery) Offset(offset int) *PlayersQuery {
+	_q.ctx.Offset = &offset
+	return _q
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (_q *PlayersQuery) Unique(unique bool) *PlayersQuery {
+	_q.ctx.Unique = &unique
+	return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *PlayersQuery) Order(o ...players.OrderOption) *PlayersQuery {
+	_q.order = append(_q.order, o...)
+	return _q
+}
+
+// First returns the first Players entity from the query.
+// Returns a *NotFoundError when no Players was found.
+func (_q *PlayersQuery) First(ctx context.Context) (*Players, error) {
+	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{players.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *PlayersQuery) FirstX(ctx context.Context) *Players {
+	node, err := _q.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first Players ID from the query.
+// Returns a *NotFoundError when no Players ID was found.
+func (_q *PlayersQuery) FirstID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{players.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *PlayersQuery) FirstIDX(ctx context.Context) int64 {
+	id, err := _q.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single Players entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Players entity is found.
+// Returns a *NotFoundError when no Players entities are found.
+func (_q *PlayersQuery) Only(ctx context.Context) (*Players, error) {
+	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{players.Label}
+	default:
+		return nil, &NotSingularError{players.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *PlayersQuery) OnlyX(ctx context.Context) *Players {
+	node, err := _q.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only Players ID in the query.
+// Returns a *NotSingularError when more than one Players ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *PlayersQuery) OnlyID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{players.Label}
+	default:
+		err = &NotSingularError{players.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *PlayersQuery) OnlyIDX(ctx context.Context) int64 {
+	id, err := _q.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of PlayersSlice.
+func (_q *PlayersQuery) All(ctx context.Context) ([]*Players, error) {
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+	if err := _q.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*Players, *PlayersQuery]()
+	return withInterceptors[[]*Players](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *PlayersQuery) AllX(ctx context.Context) []*Players {
+	nodes, err := _q.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of Players IDs.
+func (_q *PlayersQuery) IDs(ctx context.Context) (ids []int64, err error) {
+	if _q.ctx.Unique == nil && _q.path != nil {
+		_q.Unique(true)
+	}
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+	if err = _q.Select(players.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *PlayersQuery) IDsX(ctx context.Context) []int64 {
+	ids, err := _q.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (_q *PlayersQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+	if err := _q.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, _q, querierCount[*PlayersQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *PlayersQuery) CountX(ctx context.Context) int {
+	count, err := _q.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *PlayersQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+	switch _, err := _q.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("models: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *PlayersQuery) ExistX(ctx context.Context) bool {
+	exist, err := _q.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the PlayersQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *PlayersQuery) Clone() *PlayersQuery {
+	if _q == nil {
+		return nil
+	}
+	return &PlayersQuery{
+		config:     _q.config,
+		ctx:        _q.ctx.Clone(),
+		order:      append([]players.OrderOption{}, _q.order...),
+		inters:     append([]Interceptor{}, _q.inters...),
+		predicates: append([]predicate.Players{}, _q.predicates...),
+		// clone intermediate query.
+		sql:  _q.sql.Clone(),
+		path: _q.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		UserID int64 `json:"user_id,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.Players.Query().
+//		GroupBy(players.FieldUserID).
+//		Aggregate(models.Count()).
+//		Scan(ctx, &v)
+func (_q *PlayersQuery) GroupBy(field string, fields ...string) *PlayersGroupBy {
+	_q.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &PlayersGroupBy{build: _q}
+	grbuild.flds = &_q.ctx.Fields
+	grbuild.label = players.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		UserID int64 `json:"user_id,omitempty"`
+//	}
+//
+//	client.Players.Query().
+//		Select(players.FieldUserID).
+//		Scan(ctx, &v)
+func (_q *PlayersQuery) Select(fields ...string) *PlayersSelect {
+	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
+	sbuild := &PlayersSelect{PlayersQuery: _q}
+	sbuild.label = players.Label
+	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a PlayersSelect configured with the given aggregations.
+func (_q *PlayersQuery) Aggregate(fns ...AggregateFunc) *PlayersSelect {
+	return _q.Select().Aggregate(fns...)
+}
+
+func (_q *PlayersQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range _q.inters {
+		if inter == nil {
+			return fmt.Errorf("models: uninitialized interceptor (forgotten import models/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, _q); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range _q.ctx.Fields {
+		if !players.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("models: invalid field %q for query", f)}
+		}
+	}
+	if _q.path != nil {
+		prev, err := _q.path(ctx)
+		if err != nil {
+			return err
+		}
+		_q.sql = prev
+	}
+	return nil
+}
+
+func (_q *PlayersQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Players, error) {
+	var (
+		nodes = []*Players{}
+		_spec = _q.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*Players).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &Players{config: _q.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (_q *PlayersQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := _q.querySpec()
+	_spec.Node.Columns = _q.ctx.Fields
+	if len(_q.ctx.Fields) > 0 {
+		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *PlayersQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(players.Table, players.Columns, sqlgraph.NewFieldSpec(players.FieldID, field.TypeInt64))
+	_spec.From = _q.sql
+	if unique := _q.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if _q.path != nil {
+		_spec.Unique = true
+	}
+	if fields := _q.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, players.FieldID)
+		for i := range fields {
+			if fields[i] != players.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := _q.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := _q.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := _q.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := _q.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (_q *PlayersQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(_q.driver.Dialect())
+	t1 := builder.Table(players.Table)
+	columns := _q.ctx.Fields
+	if len(columns) == 0 {
+		columns = players.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if _q.sql != nil {
+		selector = _q.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if _q.ctx.Unique != nil && *_q.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range _q.predicates {
+		p(selector)
+	}
+	for _, p := range _q.order {
+		p(selector)
+	}
+	if offset := _q.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := _q.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// PlayersGroupBy is the group-by builder for Players entities.
+type PlayersGroupBy struct {
+	selector
+	build *PlayersQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *PlayersGroupBy) Aggregate(fns ...AggregateFunc) *PlayersGroupBy {
+	_g.fns = append(_g.fns, fns...)
+	return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *PlayersGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+	if err := _g.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*PlayersQuery, *PlayersGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *PlayersGroupBy) sqlScan(ctx context.Context, root *PlayersQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(_g.fns))
+	for _, fn := range _g.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+		for _, f := range *_g.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*_g.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// PlayersSelect is the builder for selecting fields of Players entities.
+type PlayersSelect struct {
+	*PlayersQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *PlayersSelect) Aggregate(fns ...AggregateFunc) *PlayersSelect {
+	_s.fns = append(_s.fns, fns...)
+	return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *PlayersSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+	if err := _s.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*PlayersQuery, *PlayersSelect](ctx, _s.PlayersQuery, _s, _s.inters, v)
+}
+
+func (_s *PlayersSelect) sqlScan(ctx context.Context, root *PlayersQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(_s.fns))
+	for _, fn := range _s.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*_s.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

app/player/rpc/internal/models/players_update.go

@@ -0,0 +1,745 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/players"
+	"juwan-backend/app/player/rpc/internal/models/predicate"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/dialect/sql/sqljson"
+	"entgo.io/ent/schema/field"
+	"github.com/lib/pq"
+	"github.com/shopspring/decimal"
+)
+
+// PlayersUpdate is the builder for updating Players entities.
+type PlayersUpdate struct {
+	config
+	hooks    []Hook
+	mutation *PlayersMutation
+}
+
+// Where appends a list predicates to the PlayersUpdate builder.
+func (_u *PlayersUpdate) Where(ps ...predicate.Players) *PlayersUpdate {
+	_u.mutation.Where(ps...)
+	return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *PlayersUpdate) SetUserID(v int64) *PlayersUpdate {
+	_u.mutation.ResetUserID()
+	_u.mutation.SetUserID(v)
+	return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *PlayersUpdate) SetNillableUserID(v *int64) *PlayersUpdate {
+	if v != nil {
+		_u.SetUserID(*v)
+	}
+	return _u
+}
+
+// AddUserID adds value to the "user_id" field.
+func (_u *PlayersUpdate) AddUserID(v int64) *PlayersUpdate {
+	_u.mutation.AddUserID(v)
+	return _u
+}
+
+// SetStatus sets the "status" field.
+func (_u *PlayersUpdate) SetStatus(v string) *PlayersUpdate {
+	_u.mutation.SetStatus(v)
+	return _u
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (_u *PlayersUpdate) SetNillableStatus(v *string) *PlayersUpdate {
+	if v != nil {
+		_u.SetStatus(*v)
+	}
+	return _u
+}
+
+// SetGender sets the "gender" field.
+func (_u *PlayersUpdate) SetGender(v int) *PlayersUpdate {
+	_u.mutation.ResetGender()
+	_u.mutation.SetGender(v)
+	return _u
+}
+
+// SetNillableGender sets the "gender" field if the given value is not nil.
+func (_u *PlayersUpdate) SetNillableGender(v *int) *PlayersUpdate {
+	if v != nil {
+		_u.SetGender(*v)
+	}
+	return _u
+}
+
+// AddGender adds value to the "gender" field.
+func (_u *PlayersUpdate) AddGender(v int) *PlayersUpdate {
+	_u.mutation.AddGender(v)
+	return _u
+}
+
+// SetRating sets the "rating" field.
+func (_u *PlayersUpdate) SetRating(v decimal.Decimal) *PlayersUpdate {
+	_u.mutation.SetRating(v)
+	return _u
+}
+
+// SetNillableRating sets the "rating" field if the given value is not nil.
+func (_u *PlayersUpdate) SetNillableRating(v *decimal.Decimal) *PlayersUpdate {
+	if v != nil {
+		_u.SetRating(*v)
+	}
+	return _u
+}
+
+// ClearRating clears the value of the "rating" field.
+func (_u *PlayersUpdate) ClearRating() *PlayersUpdate {
+	_u.mutation.ClearRating()
+	return _u
+}
+
+// SetTotalOrders sets the "total_orders" field.
+func (_u *PlayersUpdate) SetTotalOrders(v int) *PlayersUpdate {
+	_u.mutation.ResetTotalOrders()
+	_u.mutation.SetTotalOrders(v)
+	return _u
+}
+
+// SetNillableTotalOrders sets the "total_orders" field if the given value is not nil.
+func (_u *PlayersUpdate) SetNillableTotalOrders(v *int) *PlayersUpdate {
+	if v != nil {
+		_u.SetTotalOrders(*v)
+	}
+	return _u
+}
+
+// AddTotalOrders adds value to the "total_orders" field.
+func (_u *PlayersUpdate) AddTotalOrders(v int) *PlayersUpdate {
+	_u.mutation.AddTotalOrders(v)
+	return _u
+}
+
+// ClearTotalOrders clears the value of the "total_orders" field.
+func (_u *PlayersUpdate) ClearTotalOrders() *PlayersUpdate {
+	_u.mutation.ClearTotalOrders()
+	return _u
+}
+
+// SetCompletedOrders sets the "completed_orders" field.
+func (_u *PlayersUpdate) SetCompletedOrders(v int) *PlayersUpdate {
+	_u.mutation.ResetCompletedOrders()
+	_u.mutation.SetCompletedOrders(v)
+	return _u
+}
+
+// SetNillableCompletedOrders sets the "completed_orders" field if the given value is not nil.
+func (_u *PlayersUpdate) SetNillableCompletedOrders(v *int) *PlayersUpdate {
+	if v != nil {
+		_u.SetCompletedOrders(*v)
+	}
+	return _u
+}
+
+// AddCompletedOrders adds value to the "completed_orders" field.
+func (_u *PlayersUpdate) AddCompletedOrders(v int) *PlayersUpdate {
+	_u.mutation.AddCompletedOrders(v)
+	return _u
+}
+
+// ClearCompletedOrders clears the value of the "completed_orders" field.
+func (_u *PlayersUpdate) ClearCompletedOrders() *PlayersUpdate {
+	_u.mutation.ClearCompletedOrders()
+	return _u
+}
+
+// SetShopID sets the "shop_id" field.
+func (_u *PlayersUpdate) SetShopID(v int64) *PlayersUpdate {
+	_u.mutation.ResetShopID()
+	_u.mutation.SetShopID(v)
+	return _u
+}
+
+// SetNillableShopID sets the "shop_id" field if the given value is not nil.
+func (_u *PlayersUpdate) SetNillableShopID(v *int64) *PlayersUpdate {
+	if v != nil {
+		_u.SetShopID(*v)
+	}
+	return _u
+}
+
+// AddShopID adds value to the "shop_id" field.
+func (_u *PlayersUpdate) AddShopID(v int64) *PlayersUpdate {
+	_u.mutation.AddShopID(v)
+	return _u
+}
+
+// ClearShopID clears the value of the "shop_id" field.
+func (_u *PlayersUpdate) ClearShopID() *PlayersUpdate {
+	_u.mutation.ClearShopID()
+	return _u
+}
+
+// SetTags sets the "tags" field.
+func (_u *PlayersUpdate) SetTags(v []string) *PlayersUpdate {
+	_u.mutation.SetTags(v)
+	return _u
+}
+
+// AppendTags appends value to the "tags" field.
+func (_u *PlayersUpdate) AppendTags(v []string) *PlayersUpdate {
+	_u.mutation.AppendTags(v)
+	return _u
+}
+
+// ClearTags clears the value of the "tags" field.
+func (_u *PlayersUpdate) ClearTags() *PlayersUpdate {
+	_u.mutation.ClearTags()
+	return _u
+}
+
+// SetGames sets the "games" field.
+func (_u *PlayersUpdate) SetGames(v pq.Int64Array) *PlayersUpdate {
+	_u.mutation.SetGames(v)
+	return _u
+}
+
+// ClearGames clears the value of the "games" field.
+func (_u *PlayersUpdate) ClearGames() *PlayersUpdate {
+	_u.mutation.ClearGames()
+	return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *PlayersUpdate) SetUpdatedAt(v time.Time) *PlayersUpdate {
+	_u.mutation.SetUpdatedAt(v)
+	return _u
+}
+
+// Mutation returns the PlayersMutation object of the builder.
+func (_u *PlayersUpdate) Mutation() *PlayersMutation {
+	return _u.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *PlayersUpdate) Save(ctx context.Context) (int, error) {
+	_u.defaults()
+	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *PlayersUpdate) SaveX(ctx context.Context) int {
+	affected, err := _u.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (_u *PlayersUpdate) Exec(ctx context.Context) error {
+	_, err := _u.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *PlayersUpdate) ExecX(ctx context.Context) {
+	if err := _u.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *PlayersUpdate) defaults() {
+	if _, ok := _u.mutation.UpdatedAt(); !ok {
+		v := players.UpdateDefaultUpdatedAt()
+		_u.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *PlayersUpdate) check() error {
+	if v, ok := _u.mutation.Status(); ok {
+		if err := players.StatusValidator(v); err != nil {
+			return &ValidationError{Name: "status", err: fmt.Errorf(`models: validator failed for field "Players.status": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (_u *PlayersUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+	if err := _u.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(players.Table, players.Columns, sqlgraph.NewFieldSpec(players.FieldID, field.TypeInt64))
+	if ps := _u.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := _u.mutation.UserID(); ok {
+		_spec.SetField(players.FieldUserID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedUserID(); ok {
+		_spec.AddField(players.FieldUserID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.Status(); ok {
+		_spec.SetField(players.FieldStatus, field.TypeString, value)
+	}
+	if value, ok := _u.mutation.Gender(); ok {
+		_spec.SetField(players.FieldGender, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.AddedGender(); ok {
+		_spec.AddField(players.FieldGender, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.Rating(); ok {
+		_spec.SetField(players.FieldRating, field.TypeOther, value)
+	}
+	if _u.mutation.RatingCleared() {
+		_spec.ClearField(players.FieldRating, field.TypeOther)
+	}
+	if value, ok := _u.mutation.TotalOrders(); ok {
+		_spec.SetField(players.FieldTotalOrders, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.AddedTotalOrders(); ok {
+		_spec.AddField(players.FieldTotalOrders, field.TypeInt, value)
+	}
+	if _u.mutation.TotalOrdersCleared() {
+		_spec.ClearField(players.FieldTotalOrders, field.TypeInt)
+	}
+	if value, ok := _u.mutation.CompletedOrders(); ok {
+		_spec.SetField(players.FieldCompletedOrders, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.AddedCompletedOrders(); ok {
+		_spec.AddField(players.FieldCompletedOrders, field.TypeInt, value)
+	}
+	if _u.mutation.CompletedOrdersCleared() {
+		_spec.ClearField(players.FieldCompletedOrders, field.TypeInt)
+	}
+	if value, ok := _u.mutation.ShopID(); ok {
+		_spec.SetField(players.FieldShopID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedShopID(); ok {
+		_spec.AddField(players.FieldShopID, field.TypeInt64, value)
+	}
+	if _u.mutation.ShopIDCleared() {
+		_spec.ClearField(players.FieldShopID, field.TypeInt64)
+	}
+	if value, ok := _u.mutation.Tags(); ok {
+		_spec.SetField(players.FieldTags, field.TypeJSON, value)
+	}
+	if value, ok := _u.mutation.AppendedTags(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, players.FieldTags, value)
+		})
+	}
+	if _u.mutation.TagsCleared() {
+		_spec.ClearField(players.FieldTags, field.TypeJSON)
+	}
+	if value, ok := _u.mutation.Games(); ok {
+		_spec.SetField(players.FieldGames, field.TypeOther, value)
+	}
+	if _u.mutation.GamesCleared() {
+		_spec.ClearField(players.FieldGames, field.TypeOther)
+	}
+	if value, ok := _u.mutation.UpdatedAt(); ok {
+		_spec.SetField(players.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{players.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	_u.mutation.done = true
+	return _node, nil
+}
+
+// PlayersUpdateOne is the builder for updating a single Players entity.
+type PlayersUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *PlayersMutation
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *PlayersUpdateOne) SetUserID(v int64) *PlayersUpdateOne {
+	_u.mutation.ResetUserID()
+	_u.mutation.SetUserID(v)
+	return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *PlayersUpdateOne) SetNillableUserID(v *int64) *PlayersUpdateOne {
+	if v != nil {
+		_u.SetUserID(*v)
+	}
+	return _u
+}
+
+// AddUserID adds value to the "user_id" field.
+func (_u *PlayersUpdateOne) AddUserID(v int64) *PlayersUpdateOne {
+	_u.mutation.AddUserID(v)
+	return _u
+}
+
+// SetStatus sets the "status" field.
+func (_u *PlayersUpdateOne) SetStatus(v string) *PlayersUpdateOne {
+	_u.mutation.SetStatus(v)
+	return _u
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (_u *PlayersUpdateOne) SetNillableStatus(v *string) *PlayersUpdateOne {
+	if v != nil {
+		_u.SetStatus(*v)
+	}
+	return _u
+}
+
+// SetGender sets the "gender" field.
+func (_u *PlayersUpdateOne) SetGender(v int) *PlayersUpdateOne {
+	_u.mutation.ResetGender()
+	_u.mutation.SetGender(v)
+	return _u
+}
+
+// SetNillableGender sets the "gender" field if the given value is not nil.
+func (_u *PlayersUpdateOne) SetNillableGender(v *int) *PlayersUpdateOne {
+	if v != nil {
+		_u.SetGender(*v)
+	}
+	return _u
+}
+
+// AddGender adds value to the "gender" field.
+func (_u *PlayersUpdateOne) AddGender(v int) *PlayersUpdateOne {
+	_u.mutation.AddGender(v)
+	return _u
+}
+
+// SetRating sets the "rating" field.
+func (_u *PlayersUpdateOne) SetRating(v decimal.Decimal) *PlayersUpdateOne {
+	_u.mutation.SetRating(v)
+	return _u
+}
+
+// SetNillableRating sets the "rating" field if the given value is not nil.
+func (_u *PlayersUpdateOne) SetNillableRating(v *decimal.Decimal) *PlayersUpdateOne {
+	if v != nil {
+		_u.SetRating(*v)
+	}
+	return _u
+}
+
+// ClearRating clears the value of the "rating" field.
+func (_u *PlayersUpdateOne) ClearRating() *PlayersUpdateOne {
+	_u.mutation.ClearRating()
+	return _u
+}
+
+// SetTotalOrders sets the "total_orders" field.
+func (_u *PlayersUpdateOne) SetTotalOrders(v int) *PlayersUpdateOne {
+	_u.mutation.ResetTotalOrders()
+	_u.mutation.SetTotalOrders(v)
+	return _u
+}
+
+// SetNillableTotalOrders sets the "total_orders" field if the given value is not nil.
+func (_u *PlayersUpdateOne) SetNillableTotalOrders(v *int) *PlayersUpdateOne {
+	if v != nil {
+		_u.SetTotalOrders(*v)
+	}
+	return _u
+}
+
+// AddTotalOrders adds value to the "total_orders" field.
+func (_u *PlayersUpdateOne) AddTotalOrders(v int) *PlayersUpdateOne {
+	_u.mutation.AddTotalOrders(v)
+	return _u
+}
+
+// ClearTotalOrders clears the value of the "total_orders" field.
+func (_u *PlayersUpdateOne) ClearTotalOrders() *PlayersUpdateOne {
+	_u.mutation.ClearTotalOrders()
+	return _u
+}
+
+// SetCompletedOrders sets the "completed_orders" field.
+func (_u *PlayersUpdateOne) SetCompletedOrders(v int) *PlayersUpdateOne {
+	_u.mutation.ResetCompletedOrders()
+	_u.mutation.SetCompletedOrders(v)
+	return _u
+}
+
+// SetNillableCompletedOrders sets the "completed_orders" field if the given value is not nil.
+func (_u *PlayersUpdateOne) SetNillableCompletedOrders(v *int) *PlayersUpdateOne {
+	if v != nil {
+		_u.SetCompletedOrders(*v)
+	}
+	return _u
+}
+
+// AddCompletedOrders adds value to the "completed_orders" field.
+func (_u *PlayersUpdateOne) AddCompletedOrders(v int) *PlayersUpdateOne {
+	_u.mutation.AddCompletedOrders(v)
+	return _u
+}
+
+// ClearCompletedOrders clears the value of the "completed_orders" field.
+func (_u *PlayersUpdateOne) ClearCompletedOrders() *PlayersUpdateOne {
+	_u.mutation.ClearCompletedOrders()
+	return _u
+}
+
+// SetShopID sets the "shop_id" field.
+func (_u *PlayersUpdateOne) SetShopID(v int64) *PlayersUpdateOne {
+	_u.mutation.ResetShopID()
+	_u.mutation.SetShopID(v)
+	return _u
+}
+
+// SetNillableShopID sets the "shop_id" field if the given value is not nil.
+func (_u *PlayersUpdateOne) SetNillableShopID(v *int64) *PlayersUpdateOne {
+	if v != nil {
+		_u.SetShopID(*v)
+	}
+	return _u
+}
+
+// AddShopID adds value to the "shop_id" field.
+func (_u *PlayersUpdateOne) AddShopID(v int64) *PlayersUpdateOne {
+	_u.mutation.AddShopID(v)
+	return _u
+}
+
+// ClearShopID clears the value of the "shop_id" field.
+func (_u *PlayersUpdateOne) ClearShopID() *PlayersUpdateOne {
+	_u.mutation.ClearShopID()
+	return _u
+}
+
+// SetTags sets the "tags" field.
+func (_u *PlayersUpdateOne) SetTags(v []string) *PlayersUpdateOne {
+	_u.mutation.SetTags(v)
+	return _u
+}
+
+// AppendTags appends value to the "tags" field.
+func (_u *PlayersUpdateOne) AppendTags(v []string) *PlayersUpdateOne {
+	_u.mutation.AppendTags(v)
+	return _u
+}
+
+// ClearTags clears the value of the "tags" field.
+func (_u *PlayersUpdateOne) ClearTags() *PlayersUpdateOne {
+	_u.mutation.ClearTags()
+	return _u
+}
+
+// SetGames sets the "games" field.
+func (_u *PlayersUpdateOne) SetGames(v pq.Int64Array) *PlayersUpdateOne {
+	_u.mutation.SetGames(v)
+	return _u
+}
+
+// ClearGames clears the value of the "games" field.
+func (_u *PlayersUpdateOne) ClearGames() *PlayersUpdateOne {
+	_u.mutation.ClearGames()
+	return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *PlayersUpdateOne) SetUpdatedAt(v time.Time) *PlayersUpdateOne {
+	_u.mutation.SetUpdatedAt(v)
+	return _u
+}
+
+// Mutation returns the PlayersMutation object of the builder.
+func (_u *PlayersUpdateOne) Mutation() *PlayersMutation {
+	return _u.mutation
+}
+
+// Where appends a list predicates to the PlayersUpdate builder.
+func (_u *PlayersUpdateOne) Where(ps ...predicate.Players) *PlayersUpdateOne {
+	_u.mutation.Where(ps...)
+	return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *PlayersUpdateOne) Select(field string, fields ...string) *PlayersUpdateOne {
+	_u.fields = append([]string{field}, fields...)
+	return _u
+}
+
+// Save executes the query and returns the updated Players entity.
+func (_u *PlayersUpdateOne) Save(ctx context.Context) (*Players, error) {
+	_u.defaults()
+	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *PlayersUpdateOne) SaveX(ctx context.Context) *Players {
+	node, err := _u.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (_u *PlayersUpdateOne) Exec(ctx context.Context) error {
+	_, err := _u.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *PlayersUpdateOne) ExecX(ctx context.Context) {
+	if err := _u.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *PlayersUpdateOne) defaults() {
+	if _, ok := _u.mutation.UpdatedAt(); !ok {
+		v := players.UpdateDefaultUpdatedAt()
+		_u.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *PlayersUpdateOne) check() error {
+	if v, ok := _u.mutation.Status(); ok {
+		if err := players.StatusValidator(v); err != nil {
+			return &ValidationError{Name: "status", err: fmt.Errorf(`models: validator failed for field "Players.status": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (_u *PlayersUpdateOne) sqlSave(ctx context.Context) (_node *Players, err error) {
+	if err := _u.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(players.Table, players.Columns, sqlgraph.NewFieldSpec(players.FieldID, field.TypeInt64))
+	id, ok := _u.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`models: missing "Players.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := _u.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, players.FieldID)
+		for _, f := range fields {
+			if !players.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("models: invalid field %q for query", f)}
+			}
+			if f != players.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := _u.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := _u.mutation.UserID(); ok {
+		_spec.SetField(players.FieldUserID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedUserID(); ok {
+		_spec.AddField(players.FieldUserID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.Status(); ok {
+		_spec.SetField(players.FieldStatus, field.TypeString, value)
+	}
+	if value, ok := _u.mutation.Gender(); ok {
+		_spec.SetField(players.FieldGender, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.AddedGender(); ok {
+		_spec.AddField(players.FieldGender, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.Rating(); ok {
+		_spec.SetField(players.FieldRating, field.TypeOther, value)
+	}
+	if _u.mutation.RatingCleared() {
+		_spec.ClearField(players.FieldRating, field.TypeOther)
+	}
+	if value, ok := _u.mutation.TotalOrders(); ok {
+		_spec.SetField(players.FieldTotalOrders, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.AddedTotalOrders(); ok {
+		_spec.AddField(players.FieldTotalOrders, field.TypeInt, value)
+	}
+	if _u.mutation.TotalOrdersCleared() {
+		_spec.ClearField(players.FieldTotalOrders, field.TypeInt)
+	}
+	if value, ok := _u.mutation.CompletedOrders(); ok {
+		_spec.SetField(players.FieldCompletedOrders, field.TypeInt, value)
+	}
+	if value, ok := _u.mutation.AddedCompletedOrders(); ok {
+		_spec.AddField(players.FieldCompletedOrders, field.TypeInt, value)
+	}
+	if _u.mutation.CompletedOrdersCleared() {
+		_spec.ClearField(players.FieldCompletedOrders, field.TypeInt)
+	}
+	if value, ok := _u.mutation.ShopID(); ok {
+		_spec.SetField(players.FieldShopID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedShopID(); ok {
+		_spec.AddField(players.FieldShopID, field.TypeInt64, value)
+	}
+	if _u.mutation.ShopIDCleared() {
+		_spec.ClearField(players.FieldShopID, field.TypeInt64)
+	}
+	if value, ok := _u.mutation.Tags(); ok {
+		_spec.SetField(players.FieldTags, field.TypeJSON, value)
+	}
+	if value, ok := _u.mutation.AppendedTags(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, players.FieldTags, value)
+		})
+	}
+	if _u.mutation.TagsCleared() {
+		_spec.ClearField(players.FieldTags, field.TypeJSON)
+	}
+	if value, ok := _u.mutation.Games(); ok {
+		_spec.SetField(players.FieldGames, field.TypeOther, value)
+	}
+	if _u.mutation.GamesCleared() {
+		_spec.ClearField(players.FieldGames, field.TypeOther)
+	}
+	if value, ok := _u.mutation.UpdatedAt(); ok {
+		_spec.SetField(players.FieldUpdatedAt, field.TypeTime, value)
+	}
+	_node = &Players{config: _u.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{players.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	_u.mutation.done = true
+	return _node, nil
+}

app/player/rpc/internal/models/playerservices.go

@@ -0,0 +1,243 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"encoding/json"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/shopspring/decimal"
+)
+
+// PlayerServices is the model entity for the PlayerServices schema.
+type PlayerServices struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID int64 `json:"id,omitempty"`
+	// PlayerID holds the value of the "player_id" field.
+	PlayerID int64 `json:"player_id,omitempty"`
+	// GameID holds the value of the "game_id" field.
+	GameID int64 `json:"game_id,omitempty"`
+	// Title holds the value of the "title" field.
+	Title string `json:"title,omitempty"`
+	// Description holds the value of the "description" field.
+	Description *string `json:"description,omitempty"`
+	// Price holds the value of the "price" field.
+	Price decimal.Decimal `json:"price,omitempty"`
+	// Unit holds the value of the "unit" field.
+	Unit string `json:"unit,omitempty"`
+	// RankRange holds the value of the "rank_range" field.
+	RankRange *string `json:"rank_range,omitempty"`
+	// Availability holds the value of the "availability" field.
+	Availability []string `json:"availability,omitempty"`
+	// Rating holds the value of the "rating" field.
+	Rating decimal.Decimal `json:"rating,omitempty"`
+	// IsActive holds the value of the "is_active" field.
+	IsActive bool `json:"is_active,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt    time.Time `json:"updated_at,omitempty"`
+	selectValues sql.SelectValues
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*PlayerServices) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case playerservices.FieldAvailability:
+			values[i] = new([]byte)
+		case playerservices.FieldPrice, playerservices.FieldRating:
+			values[i] = new(decimal.Decimal)
+		case playerservices.FieldIsActive:
+			values[i] = new(sql.NullBool)
+		case playerservices.FieldID, playerservices.FieldPlayerID, playerservices.FieldGameID:
+			values[i] = new(sql.NullInt64)
+		case playerservices.FieldTitle, playerservices.FieldDescription, playerservices.FieldUnit, playerservices.FieldRankRange:
+			values[i] = new(sql.NullString)
+		case playerservices.FieldCreatedAt, playerservices.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the PlayerServices fields.
+func (_m *PlayerServices) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case playerservices.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			_m.ID = int64(value.Int64)
+		case playerservices.FieldPlayerID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field player_id", values[i])
+			} else if value.Valid {
+				_m.PlayerID = value.Int64
+			}
+		case playerservices.FieldGameID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field game_id", values[i])
+			} else if value.Valid {
+				_m.GameID = value.Int64
+			}
+		case playerservices.FieldTitle:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field title", values[i])
+			} else if value.Valid {
+				_m.Title = value.String
+			}
+		case playerservices.FieldDescription:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field description", values[i])
+			} else if value.Valid {
+				_m.Description = new(string)
+				*_m.Description = value.String
+			}
+		case playerservices.FieldPrice:
+			if value, ok := values[i].(*decimal.Decimal); !ok {
+				return fmt.Errorf("unexpected type %T for field price", values[i])
+			} else if value != nil {
+				_m.Price = *value
+			}
+		case playerservices.FieldUnit:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field unit", values[i])
+			} else if value.Valid {
+				_m.Unit = value.String
+			}
+		case playerservices.FieldRankRange:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field rank_range", values[i])
+			} else if value.Valid {
+				_m.RankRange = new(string)
+				*_m.RankRange = value.String
+			}
+		case playerservices.FieldAvailability:
+			if value, ok := values[i].(*[]byte); !ok {
+				return fmt.Errorf("unexpected type %T for field availability", values[i])
+			} else if value != nil && len(*value) > 0 {
+				if err := json.Unmarshal(*value, &_m.Availability); err != nil {
+					return fmt.Errorf("unmarshal field availability: %w", err)
+				}
+			}
+		case playerservices.FieldRating:
+			if value, ok := values[i].(*decimal.Decimal); !ok {
+				return fmt.Errorf("unexpected type %T for field rating", values[i])
+			} else if value != nil {
+				_m.Rating = *value
+			}
+		case playerservices.FieldIsActive:
+			if value, ok := values[i].(*sql.NullBool); !ok {
+				return fmt.Errorf("unexpected type %T for field is_active", values[i])
+			} else if value.Valid {
+				_m.IsActive = value.Bool
+			}
+		case playerservices.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				_m.CreatedAt = value.Time
+			}
+		case playerservices.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				_m.UpdatedAt = value.Time
+			}
+		default:
+			_m.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the PlayerServices.
+// This includes values selected through modifiers, order, etc.
+func (_m *PlayerServices) Value(name string) (ent.Value, error) {
+	return _m.selectValues.Get(name)
+}
+
+// Update returns a builder for updating this PlayerServices.
+// Note that you need to call PlayerServices.Unwrap() before calling this method if this PlayerServices
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *PlayerServices) Update() *PlayerServicesUpdateOne {
+	return NewPlayerServicesClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the PlayerServices entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (_m *PlayerServices) Unwrap() *PlayerServices {
+	_tx, ok := _m.config.driver.(*txDriver)
+	if !ok {
+		panic("models: PlayerServices is not a transactional entity")
+	}
+	_m.config.driver = _tx.drv
+	return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *PlayerServices) String() string {
+	var builder strings.Builder
+	builder.WriteString("PlayerServices(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+	builder.WriteString("player_id=")
+	builder.WriteString(fmt.Sprintf("%v", _m.PlayerID))
+	builder.WriteString(", ")
+	builder.WriteString("game_id=")
+	builder.WriteString(fmt.Sprintf("%v", _m.GameID))
+	builder.WriteString(", ")
+	builder.WriteString("title=")
+	builder.WriteString(_m.Title)
+	builder.WriteString(", ")
+	if v := _m.Description; v != nil {
+		builder.WriteString("description=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	builder.WriteString("price=")
+	builder.WriteString(fmt.Sprintf("%v", _m.Price))
+	builder.WriteString(", ")
+	builder.WriteString("unit=")
+	builder.WriteString(_m.Unit)
+	builder.WriteString(", ")
+	if v := _m.RankRange; v != nil {
+		builder.WriteString("rank_range=")
+		builder.WriteString(*v)
+	}
+	builder.WriteString(", ")
+	builder.WriteString("availability=")
+	builder.WriteString(fmt.Sprintf("%v", _m.Availability))
+	builder.WriteString(", ")
+	builder.WriteString("rating=")
+	builder.WriteString(fmt.Sprintf("%v", _m.Rating))
+	builder.WriteString(", ")
+	builder.WriteString("is_active=")
+	builder.WriteString(fmt.Sprintf("%v", _m.IsActive))
+	builder.WriteString(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// PlayerServicesSlice is a parsable slice of PlayerServices.
+type PlayerServicesSlice []*PlayerServices

app/player/rpc/internal/models/playerservices/playerservices.go

@@ -0,0 +1,154 @@
+// Code generated by ent, DO NOT EDIT.
+
+package playerservices
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/shopspring/decimal"
+)
+
+const (
+	// Label holds the string label denoting the playerservices type in the database.
+	Label = "player_services"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldPlayerID holds the string denoting the player_id field in the database.
+	FieldPlayerID = "player_id"
+	// FieldGameID holds the string denoting the game_id field in the database.
+	FieldGameID = "game_id"
+	// FieldTitle holds the string denoting the title field in the database.
+	FieldTitle = "title"
+	// FieldDescription holds the string denoting the description field in the database.
+	FieldDescription = "description"
+	// FieldPrice holds the string denoting the price field in the database.
+	FieldPrice = "price"
+	// FieldUnit holds the string denoting the unit field in the database.
+	FieldUnit = "unit"
+	// FieldRankRange holds the string denoting the rank_range field in the database.
+	FieldRankRange = "rank_range"
+	// FieldAvailability holds the string denoting the availability field in the database.
+	FieldAvailability = "availability"
+	// FieldRating holds the string denoting the rating field in the database.
+	FieldRating = "rating"
+	// FieldIsActive holds the string denoting the is_active field in the database.
+	FieldIsActive = "is_active"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the playerservices in the database.
+	Table = "player_services"
+)
+
+// Columns holds all SQL columns for playerservices fields.
+var Columns = []string{
+	FieldID,
+	FieldPlayerID,
+	FieldGameID,
+	FieldTitle,
+	FieldDescription,
+	FieldPrice,
+	FieldUnit,
+	FieldRankRange,
+	FieldAvailability,
+	FieldRating,
+	FieldIsActive,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// TitleValidator is a validator for the "title" field. It is called by the builders before save.
+	TitleValidator func(string) error
+	// UnitValidator is a validator for the "unit" field. It is called by the builders before save.
+	UnitValidator func(string) error
+	// RankRangeValidator is a validator for the "rank_range" field. It is called by the builders before save.
+	RankRangeValidator func(string) error
+	// DefaultAvailability holds the default value on creation for the "availability" field.
+	DefaultAvailability []string
+	// DefaultRating holds the default value on creation for the "rating" field.
+	DefaultRating decimal.Decimal
+	// DefaultIsActive holds the default value on creation for the "is_active" field.
+	DefaultIsActive bool
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+)
+
+// OrderOption defines the ordering options for the PlayerServices queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByPlayerID orders the results by the player_id field.
+func ByPlayerID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPlayerID, opts...).ToFunc()
+}
+
+// ByGameID orders the results by the game_id field.
+func ByGameID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldGameID, opts...).ToFunc()
+}
+
+// ByTitle orders the results by the title field.
+func ByTitle(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTitle, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByPrice orders the results by the price field.
+func ByPrice(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPrice, opts...).ToFunc()
+}
+
+// ByUnit orders the results by the unit field.
+func ByUnit(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUnit, opts...).ToFunc()
+}
+
+// ByRankRange orders the results by the rank_range field.
+func ByRankRange(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRankRange, opts...).ToFunc()
+}
+
+// ByRating orders the results by the rating field.
+func ByRating(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRating, opts...).ToFunc()
+}
+
+// ByIsActive orders the results by the is_active field.
+func ByIsActive(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIsActive, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}

app/player/rpc/internal/models/playerservices/where.go

@@ -0,0 +1,676 @@
+// Code generated by ent, DO NOT EDIT.
+
+package playerservices
+
+import (
+	"juwan-backend/app/player/rpc/internal/models/predicate"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"github.com/shopspring/decimal"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldID, id))
+}
+
+// PlayerID applies equality check predicate on the "player_id" field. It's identical to PlayerIDEQ.
+func PlayerID(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldPlayerID, v))
+}
+
+// GameID applies equality check predicate on the "game_id" field. It's identical to GameIDEQ.
+func GameID(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldGameID, v))
+}
+
+// Title applies equality check predicate on the "title" field. It's identical to TitleEQ.
+func Title(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldTitle, v))
+}
+
+// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
+func Description(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldDescription, v))
+}
+
+// Price applies equality check predicate on the "price" field. It's identical to PriceEQ.
+func Price(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldPrice, v))
+}
+
+// Unit applies equality check predicate on the "unit" field. It's identical to UnitEQ.
+func Unit(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldUnit, v))
+}
+
+// RankRange applies equality check predicate on the "rank_range" field. It's identical to RankRangeEQ.
+func RankRange(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldRankRange, v))
+}
+
+// Rating applies equality check predicate on the "rating" field. It's identical to RatingEQ.
+func Rating(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldRating, v))
+}
+
+// IsActive applies equality check predicate on the "is_active" field. It's identical to IsActiveEQ.
+func IsActive(v bool) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldIsActive, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// PlayerIDEQ applies the EQ predicate on the "player_id" field.
+func PlayerIDEQ(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldPlayerID, v))
+}
+
+// PlayerIDNEQ applies the NEQ predicate on the "player_id" field.
+func PlayerIDNEQ(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldPlayerID, v))
+}
+
+// PlayerIDIn applies the In predicate on the "player_id" field.
+func PlayerIDIn(vs ...int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldPlayerID, vs...))
+}
+
+// PlayerIDNotIn applies the NotIn predicate on the "player_id" field.
+func PlayerIDNotIn(vs ...int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldPlayerID, vs...))
+}
+
+// PlayerIDGT applies the GT predicate on the "player_id" field.
+func PlayerIDGT(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldPlayerID, v))
+}
+
+// PlayerIDGTE applies the GTE predicate on the "player_id" field.
+func PlayerIDGTE(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldPlayerID, v))
+}
+
+// PlayerIDLT applies the LT predicate on the "player_id" field.
+func PlayerIDLT(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldPlayerID, v))
+}
+
+// PlayerIDLTE applies the LTE predicate on the "player_id" field.
+func PlayerIDLTE(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldPlayerID, v))
+}
+
+// GameIDEQ applies the EQ predicate on the "game_id" field.
+func GameIDEQ(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldGameID, v))
+}
+
+// GameIDNEQ applies the NEQ predicate on the "game_id" field.
+func GameIDNEQ(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldGameID, v))
+}
+
+// GameIDIn applies the In predicate on the "game_id" field.
+func GameIDIn(vs ...int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldGameID, vs...))
+}
+
+// GameIDNotIn applies the NotIn predicate on the "game_id" field.
+func GameIDNotIn(vs ...int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldGameID, vs...))
+}
+
+// GameIDGT applies the GT predicate on the "game_id" field.
+func GameIDGT(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldGameID, v))
+}
+
+// GameIDGTE applies the GTE predicate on the "game_id" field.
+func GameIDGTE(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldGameID, v))
+}
+
+// GameIDLT applies the LT predicate on the "game_id" field.
+func GameIDLT(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldGameID, v))
+}
+
+// GameIDLTE applies the LTE predicate on the "game_id" field.
+func GameIDLTE(v int64) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldGameID, v))
+}
+
+// TitleEQ applies the EQ predicate on the "title" field.
+func TitleEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldTitle, v))
+}
+
+// TitleNEQ applies the NEQ predicate on the "title" field.
+func TitleNEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldTitle, v))
+}
+
+// TitleIn applies the In predicate on the "title" field.
+func TitleIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldTitle, vs...))
+}
+
+// TitleNotIn applies the NotIn predicate on the "title" field.
+func TitleNotIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldTitle, vs...))
+}
+
+// TitleGT applies the GT predicate on the "title" field.
+func TitleGT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldTitle, v))
+}
+
+// TitleGTE applies the GTE predicate on the "title" field.
+func TitleGTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldTitle, v))
+}
+
+// TitleLT applies the LT predicate on the "title" field.
+func TitleLT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldTitle, v))
+}
+
+// TitleLTE applies the LTE predicate on the "title" field.
+func TitleLTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldTitle, v))
+}
+
+// TitleContains applies the Contains predicate on the "title" field.
+func TitleContains(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContains(FieldTitle, v))
+}
+
+// TitleHasPrefix applies the HasPrefix predicate on the "title" field.
+func TitleHasPrefix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasPrefix(FieldTitle, v))
+}
+
+// TitleHasSuffix applies the HasSuffix predicate on the "title" field.
+func TitleHasSuffix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasSuffix(FieldTitle, v))
+}
+
+// TitleEqualFold applies the EqualFold predicate on the "title" field.
+func TitleEqualFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEqualFold(FieldTitle, v))
+}
+
+// TitleContainsFold applies the ContainsFold predicate on the "title" field.
+func TitleContainsFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContainsFold(FieldTitle, v))
+}
+
+// DescriptionEQ applies the EQ predicate on the "description" field.
+func DescriptionEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldDescription, v))
+}
+
+// DescriptionNEQ applies the NEQ predicate on the "description" field.
+func DescriptionNEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldDescription, v))
+}
+
+// DescriptionIn applies the In predicate on the "description" field.
+func DescriptionIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldDescription, vs...))
+}
+
+// DescriptionNotIn applies the NotIn predicate on the "description" field.
+func DescriptionNotIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldDescription, vs...))
+}
+
+// DescriptionGT applies the GT predicate on the "description" field.
+func DescriptionGT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldDescription, v))
+}
+
+// DescriptionGTE applies the GTE predicate on the "description" field.
+func DescriptionGTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldDescription, v))
+}
+
+// DescriptionLT applies the LT predicate on the "description" field.
+func DescriptionLT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldDescription, v))
+}
+
+// DescriptionLTE applies the LTE predicate on the "description" field.
+func DescriptionLTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldDescription, v))
+}
+
+// DescriptionContains applies the Contains predicate on the "description" field.
+func DescriptionContains(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContains(FieldDescription, v))
+}
+
+// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
+func DescriptionHasPrefix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasPrefix(FieldDescription, v))
+}
+
+// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
+func DescriptionHasSuffix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasSuffix(FieldDescription, v))
+}
+
+// DescriptionIsNil applies the IsNil predicate on the "description" field.
+func DescriptionIsNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIsNull(FieldDescription))
+}
+
+// DescriptionNotNil applies the NotNil predicate on the "description" field.
+func DescriptionNotNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotNull(FieldDescription))
+}
+
+// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
+func DescriptionEqualFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEqualFold(FieldDescription, v))
+}
+
+// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
+func DescriptionContainsFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContainsFold(FieldDescription, v))
+}
+
+// PriceEQ applies the EQ predicate on the "price" field.
+func PriceEQ(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldPrice, v))
+}
+
+// PriceNEQ applies the NEQ predicate on the "price" field.
+func PriceNEQ(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldPrice, v))
+}
+
+// PriceIn applies the In predicate on the "price" field.
+func PriceIn(vs ...decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldPrice, vs...))
+}
+
+// PriceNotIn applies the NotIn predicate on the "price" field.
+func PriceNotIn(vs ...decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldPrice, vs...))
+}
+
+// PriceGT applies the GT predicate on the "price" field.
+func PriceGT(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldPrice, v))
+}
+
+// PriceGTE applies the GTE predicate on the "price" field.
+func PriceGTE(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldPrice, v))
+}
+
+// PriceLT applies the LT predicate on the "price" field.
+func PriceLT(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldPrice, v))
+}
+
+// PriceLTE applies the LTE predicate on the "price" field.
+func PriceLTE(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldPrice, v))
+}
+
+// UnitEQ applies the EQ predicate on the "unit" field.
+func UnitEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldUnit, v))
+}
+
+// UnitNEQ applies the NEQ predicate on the "unit" field.
+func UnitNEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldUnit, v))
+}
+
+// UnitIn applies the In predicate on the "unit" field.
+func UnitIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldUnit, vs...))
+}
+
+// UnitNotIn applies the NotIn predicate on the "unit" field.
+func UnitNotIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldUnit, vs...))
+}
+
+// UnitGT applies the GT predicate on the "unit" field.
+func UnitGT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldUnit, v))
+}
+
+// UnitGTE applies the GTE predicate on the "unit" field.
+func UnitGTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldUnit, v))
+}
+
+// UnitLT applies the LT predicate on the "unit" field.
+func UnitLT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldUnit, v))
+}
+
+// UnitLTE applies the LTE predicate on the "unit" field.
+func UnitLTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldUnit, v))
+}
+
+// UnitContains applies the Contains predicate on the "unit" field.
+func UnitContains(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContains(FieldUnit, v))
+}
+
+// UnitHasPrefix applies the HasPrefix predicate on the "unit" field.
+func UnitHasPrefix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasPrefix(FieldUnit, v))
+}
+
+// UnitHasSuffix applies the HasSuffix predicate on the "unit" field.
+func UnitHasSuffix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasSuffix(FieldUnit, v))
+}
+
+// UnitEqualFold applies the EqualFold predicate on the "unit" field.
+func UnitEqualFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEqualFold(FieldUnit, v))
+}
+
+// UnitContainsFold applies the ContainsFold predicate on the "unit" field.
+func UnitContainsFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContainsFold(FieldUnit, v))
+}
+
+// RankRangeEQ applies the EQ predicate on the "rank_range" field.
+func RankRangeEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldRankRange, v))
+}
+
+// RankRangeNEQ applies the NEQ predicate on the "rank_range" field.
+func RankRangeNEQ(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldRankRange, v))
+}
+
+// RankRangeIn applies the In predicate on the "rank_range" field.
+func RankRangeIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldRankRange, vs...))
+}
+
+// RankRangeNotIn applies the NotIn predicate on the "rank_range" field.
+func RankRangeNotIn(vs ...string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldRankRange, vs...))
+}
+
+// RankRangeGT applies the GT predicate on the "rank_range" field.
+func RankRangeGT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldRankRange, v))
+}
+
+// RankRangeGTE applies the GTE predicate on the "rank_range" field.
+func RankRangeGTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldRankRange, v))
+}
+
+// RankRangeLT applies the LT predicate on the "rank_range" field.
+func RankRangeLT(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldRankRange, v))
+}
+
+// RankRangeLTE applies the LTE predicate on the "rank_range" field.
+func RankRangeLTE(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldRankRange, v))
+}
+
+// RankRangeContains applies the Contains predicate on the "rank_range" field.
+func RankRangeContains(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContains(FieldRankRange, v))
+}
+
+// RankRangeHasPrefix applies the HasPrefix predicate on the "rank_range" field.
+func RankRangeHasPrefix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasPrefix(FieldRankRange, v))
+}
+
+// RankRangeHasSuffix applies the HasSuffix predicate on the "rank_range" field.
+func RankRangeHasSuffix(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldHasSuffix(FieldRankRange, v))
+}
+
+// RankRangeIsNil applies the IsNil predicate on the "rank_range" field.
+func RankRangeIsNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIsNull(FieldRankRange))
+}
+
+// RankRangeNotNil applies the NotNil predicate on the "rank_range" field.
+func RankRangeNotNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotNull(FieldRankRange))
+}
+
+// RankRangeEqualFold applies the EqualFold predicate on the "rank_range" field.
+func RankRangeEqualFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEqualFold(FieldRankRange, v))
+}
+
+// RankRangeContainsFold applies the ContainsFold predicate on the "rank_range" field.
+func RankRangeContainsFold(v string) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldContainsFold(FieldRankRange, v))
+}
+
+// AvailabilityIsNil applies the IsNil predicate on the "availability" field.
+func AvailabilityIsNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIsNull(FieldAvailability))
+}
+
+// AvailabilityNotNil applies the NotNil predicate on the "availability" field.
+func AvailabilityNotNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotNull(FieldAvailability))
+}
+
+// RatingEQ applies the EQ predicate on the "rating" field.
+func RatingEQ(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldRating, v))
+}
+
+// RatingNEQ applies the NEQ predicate on the "rating" field.
+func RatingNEQ(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldRating, v))
+}
+
+// RatingIn applies the In predicate on the "rating" field.
+func RatingIn(vs ...decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldRating, vs...))
+}
+
+// RatingNotIn applies the NotIn predicate on the "rating" field.
+func RatingNotIn(vs ...decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldRating, vs...))
+}
+
+// RatingGT applies the GT predicate on the "rating" field.
+func RatingGT(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldRating, v))
+}
+
+// RatingGTE applies the GTE predicate on the "rating" field.
+func RatingGTE(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldRating, v))
+}
+
+// RatingLT applies the LT predicate on the "rating" field.
+func RatingLT(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldRating, v))
+}
+
+// RatingLTE applies the LTE predicate on the "rating" field.
+func RatingLTE(v decimal.Decimal) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldRating, v))
+}
+
+// IsActiveEQ applies the EQ predicate on the "is_active" field.
+func IsActiveEQ(v bool) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldIsActive, v))
+}
+
+// IsActiveNEQ applies the NEQ predicate on the "is_active" field.
+func IsActiveNEQ(v bool) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldIsActive, v))
+}
+
+// IsActiveIsNil applies the IsNil predicate on the "is_active" field.
+func IsActiveIsNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIsNull(FieldIsActive))
+}
+
+// IsActiveNotNil applies the NotNil predicate on the "is_active" field.
+func IsActiveNotNil() predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotNull(FieldIsActive))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.PlayerServices) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.PlayerServices) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.PlayerServices) predicate.PlayerServices {
+	return predicate.PlayerServices(sql.NotPredicates(p))
+}

app/player/rpc/internal/models/playerservices_create.go

@@ -0,0 +1,417 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/shopspring/decimal"
+)
+
+// PlayerServicesCreate is the builder for creating a PlayerServices entity.
+type PlayerServicesCreate struct {
+	config
+	mutation *PlayerServicesMutation
+	hooks    []Hook
+}
+
+// SetPlayerID sets the "player_id" field.
+func (_c *PlayerServicesCreate) SetPlayerID(v int64) *PlayerServicesCreate {
+	_c.mutation.SetPlayerID(v)
+	return _c
+}
+
+// SetGameID sets the "game_id" field.
+func (_c *PlayerServicesCreate) SetGameID(v int64) *PlayerServicesCreate {
+	_c.mutation.SetGameID(v)
+	return _c
+}
+
+// SetTitle sets the "title" field.
+func (_c *PlayerServicesCreate) SetTitle(v string) *PlayerServicesCreate {
+	_c.mutation.SetTitle(v)
+	return _c
+}
+
+// SetDescription sets the "description" field.
+func (_c *PlayerServicesCreate) SetDescription(v string) *PlayerServicesCreate {
+	_c.mutation.SetDescription(v)
+	return _c
+}
+
+// SetNillableDescription sets the "description" field if the given value is not nil.
+func (_c *PlayerServicesCreate) SetNillableDescription(v *string) *PlayerServicesCreate {
+	if v != nil {
+		_c.SetDescription(*v)
+	}
+	return _c
+}
+
+// SetPrice sets the "price" field.
+func (_c *PlayerServicesCreate) SetPrice(v decimal.Decimal) *PlayerServicesCreate {
+	_c.mutation.SetPrice(v)
+	return _c
+}
+
+// SetUnit sets the "unit" field.
+func (_c *PlayerServicesCreate) SetUnit(v string) *PlayerServicesCreate {
+	_c.mutation.SetUnit(v)
+	return _c
+}
+
+// SetRankRange sets the "rank_range" field.
+func (_c *PlayerServicesCreate) SetRankRange(v string) *PlayerServicesCreate {
+	_c.mutation.SetRankRange(v)
+	return _c
+}
+
+// SetNillableRankRange sets the "rank_range" field if the given value is not nil.
+func (_c *PlayerServicesCreate) SetNillableRankRange(v *string) *PlayerServicesCreate {
+	if v != nil {
+		_c.SetRankRange(*v)
+	}
+	return _c
+}
+
+// SetAvailability sets the "availability" field.
+func (_c *PlayerServicesCreate) SetAvailability(v []string) *PlayerServicesCreate {
+	_c.mutation.SetAvailability(v)
+	return _c
+}
+
+// SetRating sets the "rating" field.
+func (_c *PlayerServicesCreate) SetRating(v decimal.Decimal) *PlayerServicesCreate {
+	_c.mutation.SetRating(v)
+	return _c
+}
+
+// SetNillableRating sets the "rating" field if the given value is not nil.
+func (_c *PlayerServicesCreate) SetNillableRating(v *decimal.Decimal) *PlayerServicesCreate {
+	if v != nil {
+		_c.SetRating(*v)
+	}
+	return _c
+}
+
+// SetIsActive sets the "is_active" field.
+func (_c *PlayerServicesCreate) SetIsActive(v bool) *PlayerServicesCreate {
+	_c.mutation.SetIsActive(v)
+	return _c
+}
+
+// SetNillableIsActive sets the "is_active" field if the given value is not nil.
+func (_c *PlayerServicesCreate) SetNillableIsActive(v *bool) *PlayerServicesCreate {
+	if v != nil {
+		_c.SetIsActive(*v)
+	}
+	return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *PlayerServicesCreate) SetCreatedAt(v time.Time) *PlayerServicesCreate {
+	_c.mutation.SetCreatedAt(v)
+	return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *PlayerServicesCreate) SetNillableCreatedAt(v *time.Time) *PlayerServicesCreate {
+	if v != nil {
+		_c.SetCreatedAt(*v)
+	}
+	return _c
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_c *PlayerServicesCreate) SetUpdatedAt(v time.Time) *PlayerServicesCreate {
+	_c.mutation.SetUpdatedAt(v)
+	return _c
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_c *PlayerServicesCreate) SetNillableUpdatedAt(v *time.Time) *PlayerServicesCreate {
+	if v != nil {
+		_c.SetUpdatedAt(*v)
+	}
+	return _c
+}
+
+// SetID sets the "id" field.
+func (_c *PlayerServicesCreate) SetID(v int64) *PlayerServicesCreate {
+	_c.mutation.SetID(v)
+	return _c
+}
+
+// Mutation returns the PlayerServicesMutation object of the builder.
+func (_c *PlayerServicesCreate) Mutation() *PlayerServicesMutation {
+	return _c.mutation
+}
+
+// Save creates the PlayerServices in the database.
+func (_c *PlayerServicesCreate) Save(ctx context.Context) (*PlayerServices, error) {
+	_c.defaults()
+	return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *PlayerServicesCreate) SaveX(ctx context.Context) *PlayerServices {
+	v, err := _c.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (_c *PlayerServicesCreate) Exec(ctx context.Context) error {
+	_, err := _c.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *PlayerServicesCreate) ExecX(ctx context.Context) {
+	if err := _c.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *PlayerServicesCreate) defaults() {
+	if _, ok := _c.mutation.Availability(); !ok {
+		v := playerservices.DefaultAvailability
+		_c.mutation.SetAvailability(v)
+	}
+	if _, ok := _c.mutation.Rating(); !ok {
+		v := playerservices.DefaultRating
+		_c.mutation.SetRating(v)
+	}
+	if _, ok := _c.mutation.IsActive(); !ok {
+		v := playerservices.DefaultIsActive
+		_c.mutation.SetIsActive(v)
+	}
+	if _, ok := _c.mutation.CreatedAt(); !ok {
+		v := playerservices.DefaultCreatedAt()
+		_c.mutation.SetCreatedAt(v)
+	}
+	if _, ok := _c.mutation.UpdatedAt(); !ok {
+		v := playerservices.DefaultUpdatedAt()
+		_c.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *PlayerServicesCreate) check() error {
+	if _, ok := _c.mutation.PlayerID(); !ok {
+		return &ValidationError{Name: "player_id", err: errors.New(`models: missing required field "PlayerServices.player_id"`)}
+	}
+	if _, ok := _c.mutation.GameID(); !ok {
+		return &ValidationError{Name: "game_id", err: errors.New(`models: missing required field "PlayerServices.game_id"`)}
+	}
+	if _, ok := _c.mutation.Title(); !ok {
+		return &ValidationError{Name: "title", err: errors.New(`models: missing required field "PlayerServices.title"`)}
+	}
+	if v, ok := _c.mutation.Title(); ok {
+		if err := playerservices.TitleValidator(v); err != nil {
+			return &ValidationError{Name: "title", err: fmt.Errorf(`models: validator failed for field "PlayerServices.title": %w`, err)}
+		}
+	}
+	if _, ok := _c.mutation.Price(); !ok {
+		return &ValidationError{Name: "price", err: errors.New(`models: missing required field "PlayerServices.price"`)}
+	}
+	if _, ok := _c.mutation.Unit(); !ok {
+		return &ValidationError{Name: "unit", err: errors.New(`models: missing required field "PlayerServices.unit"`)}
+	}
+	if v, ok := _c.mutation.Unit(); ok {
+		if err := playerservices.UnitValidator(v); err != nil {
+			return &ValidationError{Name: "unit", err: fmt.Errorf(`models: validator failed for field "PlayerServices.unit": %w`, err)}
+		}
+	}
+	if v, ok := _c.mutation.RankRange(); ok {
+		if err := playerservices.RankRangeValidator(v); err != nil {
+			return &ValidationError{Name: "rank_range", err: fmt.Errorf(`models: validator failed for field "PlayerServices.rank_range": %w`, err)}
+		}
+	}
+	if _, ok := _c.mutation.Rating(); !ok {
+		return &ValidationError{Name: "rating", err: errors.New(`models: missing required field "PlayerServices.rating"`)}
+	}
+	if _, ok := _c.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`models: missing required field "PlayerServices.created_at"`)}
+	}
+	if _, ok := _c.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`models: missing required field "PlayerServices.updated_at"`)}
+	}
+	return nil
+}
+
+func (_c *PlayerServicesCreate) sqlSave(ctx context.Context) (*PlayerServices, error) {
+	if err := _c.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := _c.createSpec()
+	if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != _node.ID {
+		id := _spec.ID.Value.(int64)
+		_node.ID = int64(id)
+	}
+	_c.mutation.id = &_node.ID
+	_c.mutation.done = true
+	return _node, nil
+}
+
+func (_c *PlayerServicesCreate) createSpec() (*PlayerServices, *sqlgraph.CreateSpec) {
+	var (
+		_node = &PlayerServices{config: _c.config}
+		_spec = sqlgraph.NewCreateSpec(playerservices.Table, sqlgraph.NewFieldSpec(playerservices.FieldID, field.TypeInt64))
+	)
+	if id, ok := _c.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := _c.mutation.PlayerID(); ok {
+		_spec.SetField(playerservices.FieldPlayerID, field.TypeInt64, value)
+		_node.PlayerID = value
+	}
+	if value, ok := _c.mutation.GameID(); ok {
+		_spec.SetField(playerservices.FieldGameID, field.TypeInt64, value)
+		_node.GameID = value
+	}
+	if value, ok := _c.mutation.Title(); ok {
+		_spec.SetField(playerservices.FieldTitle, field.TypeString, value)
+		_node.Title = value
+	}
+	if value, ok := _c.mutation.Description(); ok {
+		_spec.SetField(playerservices.FieldDescription, field.TypeString, value)
+		_node.Description = &value
+	}
+	if value, ok := _c.mutation.Price(); ok {
+		_spec.SetField(playerservices.FieldPrice, field.TypeOther, value)
+		_node.Price = value
+	}
+	if value, ok := _c.mutation.Unit(); ok {
+		_spec.SetField(playerservices.FieldUnit, field.TypeString, value)
+		_node.Unit = value
+	}
+	if value, ok := _c.mutation.RankRange(); ok {
+		_spec.SetField(playerservices.FieldRankRange, field.TypeString, value)
+		_node.RankRange = &value
+	}
+	if value, ok := _c.mutation.Availability(); ok {
+		_spec.SetField(playerservices.FieldAvailability, field.TypeJSON, value)
+		_node.Availability = value
+	}
+	if value, ok := _c.mutation.Rating(); ok {
+		_spec.SetField(playerservices.FieldRating, field.TypeOther, value)
+		_node.Rating = value
+	}
+	if value, ok := _c.mutation.IsActive(); ok {
+		_spec.SetField(playerservices.FieldIsActive, field.TypeBool, value)
+		_node.IsActive = value
+	}
+	if value, ok := _c.mutation.CreatedAt(); ok {
+		_spec.SetField(playerservices.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := _c.mutation.UpdatedAt(); ok {
+		_spec.SetField(playerservices.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	return _node, _spec
+}
+
+// PlayerServicesCreateBulk is the builder for creating many PlayerServices entities in bulk.
+type PlayerServicesCreateBulk struct {
+	config
+	err      error
+	builders []*PlayerServicesCreate
+}
+
+// Save creates the PlayerServices entities in the database.
+func (_c *PlayerServicesCreateBulk) Save(ctx context.Context) ([]*PlayerServices, error) {
+	if _c.err != nil {
+		return nil, _c.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+	nodes := make([]*PlayerServices, len(_c.builders))
+	mutators := make([]Mutator, len(_c.builders))
+	for i := range _c.builders {
+		func(i int, root context.Context) {
+			builder := _c.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*PlayerServicesMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				if specs[i].ID.Value != nil && nodes[i].ID == 0 {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int64(id)
+				}
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *PlayerServicesCreateBulk) SaveX(ctx context.Context) []*PlayerServices {
+	v, err := _c.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (_c *PlayerServicesCreateBulk) Exec(ctx context.Context) error {
+	_, err := _c.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *PlayerServicesCreateBulk) ExecX(ctx context.Context) {
+	if err := _c.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

app/player/rpc/internal/models/playerservices_delete.go

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

app/player/rpc/internal/models/playerservices_query.go

@@ -0,0 +1,527 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+	"juwan-backend/app/player/rpc/internal/models/predicate"
+	"math"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// PlayerServicesQuery is the builder for querying PlayerServices entities.
+type PlayerServicesQuery struct {
+	config
+	ctx        *QueryContext
+	order      []playerservices.OrderOption
+	inters     []Interceptor
+	predicates []predicate.PlayerServices
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the PlayerServicesQuery builder.
+func (_q *PlayerServicesQuery) Where(ps ...predicate.PlayerServices) *PlayerServicesQuery {
+	_q.predicates = append(_q.predicates, ps...)
+	return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *PlayerServicesQuery) Limit(limit int) *PlayerServicesQuery {
+	_q.ctx.Limit = &limit
+	return _q
+}
+
+// Offset to start from.
+func (_q *PlayerServicesQuery) Offset(offset int) *PlayerServicesQuery {
+	_q.ctx.Offset = &offset
+	return _q
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (_q *PlayerServicesQuery) Unique(unique bool) *PlayerServicesQuery {
+	_q.ctx.Unique = &unique
+	return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *PlayerServicesQuery) Order(o ...playerservices.OrderOption) *PlayerServicesQuery {
+	_q.order = append(_q.order, o...)
+	return _q
+}
+
+// First returns the first PlayerServices entity from the query.
+// Returns a *NotFoundError when no PlayerServices was found.
+func (_q *PlayerServicesQuery) First(ctx context.Context) (*PlayerServices, error) {
+	nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{playerservices.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *PlayerServicesQuery) FirstX(ctx context.Context) *PlayerServices {
+	node, err := _q.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first PlayerServices ID from the query.
+// Returns a *NotFoundError when no PlayerServices ID was found.
+func (_q *PlayerServicesQuery) FirstID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{playerservices.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *PlayerServicesQuery) FirstIDX(ctx context.Context) int64 {
+	id, err := _q.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single PlayerServices entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one PlayerServices entity is found.
+// Returns a *NotFoundError when no PlayerServices entities are found.
+func (_q *PlayerServicesQuery) Only(ctx context.Context) (*PlayerServices, error) {
+	nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{playerservices.Label}
+	default:
+		return nil, &NotSingularError{playerservices.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *PlayerServicesQuery) OnlyX(ctx context.Context) *PlayerServices {
+	node, err := _q.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only PlayerServices ID in the query.
+// Returns a *NotSingularError when more than one PlayerServices ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *PlayerServicesQuery) OnlyID(ctx context.Context) (id int64, err error) {
+	var ids []int64
+	if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{playerservices.Label}
+	default:
+		err = &NotSingularError{playerservices.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *PlayerServicesQuery) OnlyIDX(ctx context.Context) int64 {
+	id, err := _q.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of PlayerServicesSlice.
+func (_q *PlayerServicesQuery) All(ctx context.Context) ([]*PlayerServices, error) {
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+	if err := _q.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*PlayerServices, *PlayerServicesQuery]()
+	return withInterceptors[[]*PlayerServices](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *PlayerServicesQuery) AllX(ctx context.Context) []*PlayerServices {
+	nodes, err := _q.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of PlayerServices IDs.
+func (_q *PlayerServicesQuery) IDs(ctx context.Context) (ids []int64, err error) {
+	if _q.ctx.Unique == nil && _q.path != nil {
+		_q.Unique(true)
+	}
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+	if err = _q.Select(playerservices.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *PlayerServicesQuery) IDsX(ctx context.Context) []int64 {
+	ids, err := _q.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (_q *PlayerServicesQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+	if err := _q.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, _q, querierCount[*PlayerServicesQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *PlayerServicesQuery) CountX(ctx context.Context) int {
+	count, err := _q.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *PlayerServicesQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+	switch _, err := _q.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("models: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *PlayerServicesQuery) ExistX(ctx context.Context) bool {
+	exist, err := _q.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the PlayerServicesQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *PlayerServicesQuery) Clone() *PlayerServicesQuery {
+	if _q == nil {
+		return nil
+	}
+	return &PlayerServicesQuery{
+		config:     _q.config,
+		ctx:        _q.ctx.Clone(),
+		order:      append([]playerservices.OrderOption{}, _q.order...),
+		inters:     append([]Interceptor{}, _q.inters...),
+		predicates: append([]predicate.PlayerServices{}, _q.predicates...),
+		// clone intermediate query.
+		sql:  _q.sql.Clone(),
+		path: _q.path,
+	}
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		PlayerID int64 `json:"player_id,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.PlayerServices.Query().
+//		GroupBy(playerservices.FieldPlayerID).
+//		Aggregate(models.Count()).
+//		Scan(ctx, &v)
+func (_q *PlayerServicesQuery) GroupBy(field string, fields ...string) *PlayerServicesGroupBy {
+	_q.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &PlayerServicesGroupBy{build: _q}
+	grbuild.flds = &_q.ctx.Fields
+	grbuild.label = playerservices.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		PlayerID int64 `json:"player_id,omitempty"`
+//	}
+//
+//	client.PlayerServices.Query().
+//		Select(playerservices.FieldPlayerID).
+//		Scan(ctx, &v)
+func (_q *PlayerServicesQuery) Select(fields ...string) *PlayerServicesSelect {
+	_q.ctx.Fields = append(_q.ctx.Fields, fields...)
+	sbuild := &PlayerServicesSelect{PlayerServicesQuery: _q}
+	sbuild.label = playerservices.Label
+	sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a PlayerServicesSelect configured with the given aggregations.
+func (_q *PlayerServicesQuery) Aggregate(fns ...AggregateFunc) *PlayerServicesSelect {
+	return _q.Select().Aggregate(fns...)
+}
+
+func (_q *PlayerServicesQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range _q.inters {
+		if inter == nil {
+			return fmt.Errorf("models: uninitialized interceptor (forgotten import models/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, _q); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range _q.ctx.Fields {
+		if !playerservices.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("models: invalid field %q for query", f)}
+		}
+	}
+	if _q.path != nil {
+		prev, err := _q.path(ctx)
+		if err != nil {
+			return err
+		}
+		_q.sql = prev
+	}
+	return nil
+}
+
+func (_q *PlayerServicesQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*PlayerServices, error) {
+	var (
+		nodes = []*PlayerServices{}
+		_spec = _q.querySpec()
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*PlayerServices).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &PlayerServices{config: _q.config}
+		nodes = append(nodes, node)
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	return nodes, nil
+}
+
+func (_q *PlayerServicesQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := _q.querySpec()
+	_spec.Node.Columns = _q.ctx.Fields
+	if len(_q.ctx.Fields) > 0 {
+		_spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *PlayerServicesQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(playerservices.Table, playerservices.Columns, sqlgraph.NewFieldSpec(playerservices.FieldID, field.TypeInt64))
+	_spec.From = _q.sql
+	if unique := _q.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if _q.path != nil {
+		_spec.Unique = true
+	}
+	if fields := _q.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, playerservices.FieldID)
+		for i := range fields {
+			if fields[i] != playerservices.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := _q.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := _q.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := _q.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := _q.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (_q *PlayerServicesQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(_q.driver.Dialect())
+	t1 := builder.Table(playerservices.Table)
+	columns := _q.ctx.Fields
+	if len(columns) == 0 {
+		columns = playerservices.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if _q.sql != nil {
+		selector = _q.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if _q.ctx.Unique != nil && *_q.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range _q.predicates {
+		p(selector)
+	}
+	for _, p := range _q.order {
+		p(selector)
+	}
+	if offset := _q.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := _q.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// PlayerServicesGroupBy is the group-by builder for PlayerServices entities.
+type PlayerServicesGroupBy struct {
+	selector
+	build *PlayerServicesQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *PlayerServicesGroupBy) Aggregate(fns ...AggregateFunc) *PlayerServicesGroupBy {
+	_g.fns = append(_g.fns, fns...)
+	return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *PlayerServicesGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+	if err := _g.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*PlayerServicesQuery, *PlayerServicesGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *PlayerServicesGroupBy) sqlScan(ctx context.Context, root *PlayerServicesQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(_g.fns))
+	for _, fn := range _g.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+		for _, f := range *_g.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*_g.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// PlayerServicesSelect is the builder for selecting fields of PlayerServices entities.
+type PlayerServicesSelect struct {
+	*PlayerServicesQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *PlayerServicesSelect) Aggregate(fns ...AggregateFunc) *PlayerServicesSelect {
+	_s.fns = append(_s.fns, fns...)
+	return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *PlayerServicesSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+	if err := _s.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*PlayerServicesQuery, *PlayerServicesSelect](ctx, _s.PlayerServicesQuery, _s, _s.inters, v)
+}
+
+func (_s *PlayerServicesSelect) sqlScan(ctx context.Context, root *PlayerServicesQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(_s.fns))
+	for _, fn := range _s.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*_s.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

app/player/rpc/internal/models/playerservices_update.go

@@ -0,0 +1,718 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+	"juwan-backend/app/player/rpc/internal/models/predicate"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/dialect/sql/sqljson"
+	"entgo.io/ent/schema/field"
+	"github.com/shopspring/decimal"
+)
+
+// PlayerServicesUpdate is the builder for updating PlayerServices entities.
+type PlayerServicesUpdate struct {
+	config
+	hooks    []Hook
+	mutation *PlayerServicesMutation
+}
+
+// Where appends a list predicates to the PlayerServicesUpdate builder.
+func (_u *PlayerServicesUpdate) Where(ps ...predicate.PlayerServices) *PlayerServicesUpdate {
+	_u.mutation.Where(ps...)
+	return _u
+}
+
+// SetPlayerID sets the "player_id" field.
+func (_u *PlayerServicesUpdate) SetPlayerID(v int64) *PlayerServicesUpdate {
+	_u.mutation.ResetPlayerID()
+	_u.mutation.SetPlayerID(v)
+	return _u
+}
+
+// SetNillablePlayerID sets the "player_id" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillablePlayerID(v *int64) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetPlayerID(*v)
+	}
+	return _u
+}
+
+// AddPlayerID adds value to the "player_id" field.
+func (_u *PlayerServicesUpdate) AddPlayerID(v int64) *PlayerServicesUpdate {
+	_u.mutation.AddPlayerID(v)
+	return _u
+}
+
+// SetGameID sets the "game_id" field.
+func (_u *PlayerServicesUpdate) SetGameID(v int64) *PlayerServicesUpdate {
+	_u.mutation.ResetGameID()
+	_u.mutation.SetGameID(v)
+	return _u
+}
+
+// SetNillableGameID sets the "game_id" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillableGameID(v *int64) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetGameID(*v)
+	}
+	return _u
+}
+
+// AddGameID adds value to the "game_id" field.
+func (_u *PlayerServicesUpdate) AddGameID(v int64) *PlayerServicesUpdate {
+	_u.mutation.AddGameID(v)
+	return _u
+}
+
+// SetTitle sets the "title" field.
+func (_u *PlayerServicesUpdate) SetTitle(v string) *PlayerServicesUpdate {
+	_u.mutation.SetTitle(v)
+	return _u
+}
+
+// SetNillableTitle sets the "title" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillableTitle(v *string) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetTitle(*v)
+	}
+	return _u
+}
+
+// SetDescription sets the "description" field.
+func (_u *PlayerServicesUpdate) SetDescription(v string) *PlayerServicesUpdate {
+	_u.mutation.SetDescription(v)
+	return _u
+}
+
+// SetNillableDescription sets the "description" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillableDescription(v *string) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetDescription(*v)
+	}
+	return _u
+}
+
+// ClearDescription clears the value of the "description" field.
+func (_u *PlayerServicesUpdate) ClearDescription() *PlayerServicesUpdate {
+	_u.mutation.ClearDescription()
+	return _u
+}
+
+// SetPrice sets the "price" field.
+func (_u *PlayerServicesUpdate) SetPrice(v decimal.Decimal) *PlayerServicesUpdate {
+	_u.mutation.SetPrice(v)
+	return _u
+}
+
+// SetNillablePrice sets the "price" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillablePrice(v *decimal.Decimal) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetPrice(*v)
+	}
+	return _u
+}
+
+// SetUnit sets the "unit" field.
+func (_u *PlayerServicesUpdate) SetUnit(v string) *PlayerServicesUpdate {
+	_u.mutation.SetUnit(v)
+	return _u
+}
+
+// SetNillableUnit sets the "unit" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillableUnit(v *string) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetUnit(*v)
+	}
+	return _u
+}
+
+// SetRankRange sets the "rank_range" field.
+func (_u *PlayerServicesUpdate) SetRankRange(v string) *PlayerServicesUpdate {
+	_u.mutation.SetRankRange(v)
+	return _u
+}
+
+// SetNillableRankRange sets the "rank_range" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillableRankRange(v *string) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetRankRange(*v)
+	}
+	return _u
+}
+
+// ClearRankRange clears the value of the "rank_range" field.
+func (_u *PlayerServicesUpdate) ClearRankRange() *PlayerServicesUpdate {
+	_u.mutation.ClearRankRange()
+	return _u
+}
+
+// SetAvailability sets the "availability" field.
+func (_u *PlayerServicesUpdate) SetAvailability(v []string) *PlayerServicesUpdate {
+	_u.mutation.SetAvailability(v)
+	return _u
+}
+
+// AppendAvailability appends value to the "availability" field.
+func (_u *PlayerServicesUpdate) AppendAvailability(v []string) *PlayerServicesUpdate {
+	_u.mutation.AppendAvailability(v)
+	return _u
+}
+
+// ClearAvailability clears the value of the "availability" field.
+func (_u *PlayerServicesUpdate) ClearAvailability() *PlayerServicesUpdate {
+	_u.mutation.ClearAvailability()
+	return _u
+}
+
+// SetRating sets the "rating" field.
+func (_u *PlayerServicesUpdate) SetRating(v decimal.Decimal) *PlayerServicesUpdate {
+	_u.mutation.SetRating(v)
+	return _u
+}
+
+// SetNillableRating sets the "rating" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillableRating(v *decimal.Decimal) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetRating(*v)
+	}
+	return _u
+}
+
+// SetIsActive sets the "is_active" field.
+func (_u *PlayerServicesUpdate) SetIsActive(v bool) *PlayerServicesUpdate {
+	_u.mutation.SetIsActive(v)
+	return _u
+}
+
+// SetNillableIsActive sets the "is_active" field if the given value is not nil.
+func (_u *PlayerServicesUpdate) SetNillableIsActive(v *bool) *PlayerServicesUpdate {
+	if v != nil {
+		_u.SetIsActive(*v)
+	}
+	return _u
+}
+
+// ClearIsActive clears the value of the "is_active" field.
+func (_u *PlayerServicesUpdate) ClearIsActive() *PlayerServicesUpdate {
+	_u.mutation.ClearIsActive()
+	return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *PlayerServicesUpdate) SetUpdatedAt(v time.Time) *PlayerServicesUpdate {
+	_u.mutation.SetUpdatedAt(v)
+	return _u
+}
+
+// Mutation returns the PlayerServicesMutation object of the builder.
+func (_u *PlayerServicesUpdate) Mutation() *PlayerServicesMutation {
+	return _u.mutation
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *PlayerServicesUpdate) Save(ctx context.Context) (int, error) {
+	_u.defaults()
+	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *PlayerServicesUpdate) SaveX(ctx context.Context) int {
+	affected, err := _u.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (_u *PlayerServicesUpdate) Exec(ctx context.Context) error {
+	_, err := _u.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *PlayerServicesUpdate) ExecX(ctx context.Context) {
+	if err := _u.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *PlayerServicesUpdate) defaults() {
+	if _, ok := _u.mutation.UpdatedAt(); !ok {
+		v := playerservices.UpdateDefaultUpdatedAt()
+		_u.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *PlayerServicesUpdate) check() error {
+	if v, ok := _u.mutation.Title(); ok {
+		if err := playerservices.TitleValidator(v); err != nil {
+			return &ValidationError{Name: "title", err: fmt.Errorf(`models: validator failed for field "PlayerServices.title": %w`, err)}
+		}
+	}
+	if v, ok := _u.mutation.Unit(); ok {
+		if err := playerservices.UnitValidator(v); err != nil {
+			return &ValidationError{Name: "unit", err: fmt.Errorf(`models: validator failed for field "PlayerServices.unit": %w`, err)}
+		}
+	}
+	if v, ok := _u.mutation.RankRange(); ok {
+		if err := playerservices.RankRangeValidator(v); err != nil {
+			return &ValidationError{Name: "rank_range", err: fmt.Errorf(`models: validator failed for field "PlayerServices.rank_range": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (_u *PlayerServicesUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+	if err := _u.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(playerservices.Table, playerservices.Columns, sqlgraph.NewFieldSpec(playerservices.FieldID, field.TypeInt64))
+	if ps := _u.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := _u.mutation.PlayerID(); ok {
+		_spec.SetField(playerservices.FieldPlayerID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedPlayerID(); ok {
+		_spec.AddField(playerservices.FieldPlayerID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.GameID(); ok {
+		_spec.SetField(playerservices.FieldGameID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedGameID(); ok {
+		_spec.AddField(playerservices.FieldGameID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.Title(); ok {
+		_spec.SetField(playerservices.FieldTitle, field.TypeString, value)
+	}
+	if value, ok := _u.mutation.Description(); ok {
+		_spec.SetField(playerservices.FieldDescription, field.TypeString, value)
+	}
+	if _u.mutation.DescriptionCleared() {
+		_spec.ClearField(playerservices.FieldDescription, field.TypeString)
+	}
+	if value, ok := _u.mutation.Price(); ok {
+		_spec.SetField(playerservices.FieldPrice, field.TypeOther, value)
+	}
+	if value, ok := _u.mutation.Unit(); ok {
+		_spec.SetField(playerservices.FieldUnit, field.TypeString, value)
+	}
+	if value, ok := _u.mutation.RankRange(); ok {
+		_spec.SetField(playerservices.FieldRankRange, field.TypeString, value)
+	}
+	if _u.mutation.RankRangeCleared() {
+		_spec.ClearField(playerservices.FieldRankRange, field.TypeString)
+	}
+	if value, ok := _u.mutation.Availability(); ok {
+		_spec.SetField(playerservices.FieldAvailability, field.TypeJSON, value)
+	}
+	if value, ok := _u.mutation.AppendedAvailability(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, playerservices.FieldAvailability, value)
+		})
+	}
+	if _u.mutation.AvailabilityCleared() {
+		_spec.ClearField(playerservices.FieldAvailability, field.TypeJSON)
+	}
+	if value, ok := _u.mutation.Rating(); ok {
+		_spec.SetField(playerservices.FieldRating, field.TypeOther, value)
+	}
+	if value, ok := _u.mutation.IsActive(); ok {
+		_spec.SetField(playerservices.FieldIsActive, field.TypeBool, value)
+	}
+	if _u.mutation.IsActiveCleared() {
+		_spec.ClearField(playerservices.FieldIsActive, field.TypeBool)
+	}
+	if value, ok := _u.mutation.UpdatedAt(); ok {
+		_spec.SetField(playerservices.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{playerservices.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	_u.mutation.done = true
+	return _node, nil
+}
+
+// PlayerServicesUpdateOne is the builder for updating a single PlayerServices entity.
+type PlayerServicesUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *PlayerServicesMutation
+}
+
+// SetPlayerID sets the "player_id" field.
+func (_u *PlayerServicesUpdateOne) SetPlayerID(v int64) *PlayerServicesUpdateOne {
+	_u.mutation.ResetPlayerID()
+	_u.mutation.SetPlayerID(v)
+	return _u
+}
+
+// SetNillablePlayerID sets the "player_id" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillablePlayerID(v *int64) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetPlayerID(*v)
+	}
+	return _u
+}
+
+// AddPlayerID adds value to the "player_id" field.
+func (_u *PlayerServicesUpdateOne) AddPlayerID(v int64) *PlayerServicesUpdateOne {
+	_u.mutation.AddPlayerID(v)
+	return _u
+}
+
+// SetGameID sets the "game_id" field.
+func (_u *PlayerServicesUpdateOne) SetGameID(v int64) *PlayerServicesUpdateOne {
+	_u.mutation.ResetGameID()
+	_u.mutation.SetGameID(v)
+	return _u
+}
+
+// SetNillableGameID sets the "game_id" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillableGameID(v *int64) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetGameID(*v)
+	}
+	return _u
+}
+
+// AddGameID adds value to the "game_id" field.
+func (_u *PlayerServicesUpdateOne) AddGameID(v int64) *PlayerServicesUpdateOne {
+	_u.mutation.AddGameID(v)
+	return _u
+}
+
+// SetTitle sets the "title" field.
+func (_u *PlayerServicesUpdateOne) SetTitle(v string) *PlayerServicesUpdateOne {
+	_u.mutation.SetTitle(v)
+	return _u
+}
+
+// SetNillableTitle sets the "title" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillableTitle(v *string) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetTitle(*v)
+	}
+	return _u
+}
+
+// SetDescription sets the "description" field.
+func (_u *PlayerServicesUpdateOne) SetDescription(v string) *PlayerServicesUpdateOne {
+	_u.mutation.SetDescription(v)
+	return _u
+}
+
+// SetNillableDescription sets the "description" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillableDescription(v *string) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetDescription(*v)
+	}
+	return _u
+}
+
+// ClearDescription clears the value of the "description" field.
+func (_u *PlayerServicesUpdateOne) ClearDescription() *PlayerServicesUpdateOne {
+	_u.mutation.ClearDescription()
+	return _u
+}
+
+// SetPrice sets the "price" field.
+func (_u *PlayerServicesUpdateOne) SetPrice(v decimal.Decimal) *PlayerServicesUpdateOne {
+	_u.mutation.SetPrice(v)
+	return _u
+}
+
+// SetNillablePrice sets the "price" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillablePrice(v *decimal.Decimal) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetPrice(*v)
+	}
+	return _u
+}
+
+// SetUnit sets the "unit" field.
+func (_u *PlayerServicesUpdateOne) SetUnit(v string) *PlayerServicesUpdateOne {
+	_u.mutation.SetUnit(v)
+	return _u
+}
+
+// SetNillableUnit sets the "unit" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillableUnit(v *string) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetUnit(*v)
+	}
+	return _u
+}
+
+// SetRankRange sets the "rank_range" field.
+func (_u *PlayerServicesUpdateOne) SetRankRange(v string) *PlayerServicesUpdateOne {
+	_u.mutation.SetRankRange(v)
+	return _u
+}
+
+// SetNillableRankRange sets the "rank_range" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillableRankRange(v *string) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetRankRange(*v)
+	}
+	return _u
+}
+
+// ClearRankRange clears the value of the "rank_range" field.
+func (_u *PlayerServicesUpdateOne) ClearRankRange() *PlayerServicesUpdateOne {
+	_u.mutation.ClearRankRange()
+	return _u
+}
+
+// SetAvailability sets the "availability" field.
+func (_u *PlayerServicesUpdateOne) SetAvailability(v []string) *PlayerServicesUpdateOne {
+	_u.mutation.SetAvailability(v)
+	return _u
+}
+
+// AppendAvailability appends value to the "availability" field.
+func (_u *PlayerServicesUpdateOne) AppendAvailability(v []string) *PlayerServicesUpdateOne {
+	_u.mutation.AppendAvailability(v)
+	return _u
+}
+
+// ClearAvailability clears the value of the "availability" field.
+func (_u *PlayerServicesUpdateOne) ClearAvailability() *PlayerServicesUpdateOne {
+	_u.mutation.ClearAvailability()
+	return _u
+}
+
+// SetRating sets the "rating" field.
+func (_u *PlayerServicesUpdateOne) SetRating(v decimal.Decimal) *PlayerServicesUpdateOne {
+	_u.mutation.SetRating(v)
+	return _u
+}
+
+// SetNillableRating sets the "rating" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillableRating(v *decimal.Decimal) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetRating(*v)
+	}
+	return _u
+}
+
+// SetIsActive sets the "is_active" field.
+func (_u *PlayerServicesUpdateOne) SetIsActive(v bool) *PlayerServicesUpdateOne {
+	_u.mutation.SetIsActive(v)
+	return _u
+}
+
+// SetNillableIsActive sets the "is_active" field if the given value is not nil.
+func (_u *PlayerServicesUpdateOne) SetNillableIsActive(v *bool) *PlayerServicesUpdateOne {
+	if v != nil {
+		_u.SetIsActive(*v)
+	}
+	return _u
+}
+
+// ClearIsActive clears the value of the "is_active" field.
+func (_u *PlayerServicesUpdateOne) ClearIsActive() *PlayerServicesUpdateOne {
+	_u.mutation.ClearIsActive()
+	return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *PlayerServicesUpdateOne) SetUpdatedAt(v time.Time) *PlayerServicesUpdateOne {
+	_u.mutation.SetUpdatedAt(v)
+	return _u
+}
+
+// Mutation returns the PlayerServicesMutation object of the builder.
+func (_u *PlayerServicesUpdateOne) Mutation() *PlayerServicesMutation {
+	return _u.mutation
+}
+
+// Where appends a list predicates to the PlayerServicesUpdate builder.
+func (_u *PlayerServicesUpdateOne) Where(ps ...predicate.PlayerServices) *PlayerServicesUpdateOne {
+	_u.mutation.Where(ps...)
+	return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *PlayerServicesUpdateOne) Select(field string, fields ...string) *PlayerServicesUpdateOne {
+	_u.fields = append([]string{field}, fields...)
+	return _u
+}
+
+// Save executes the query and returns the updated PlayerServices entity.
+func (_u *PlayerServicesUpdateOne) Save(ctx context.Context) (*PlayerServices, error) {
+	_u.defaults()
+	return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *PlayerServicesUpdateOne) SaveX(ctx context.Context) *PlayerServices {
+	node, err := _u.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (_u *PlayerServicesUpdateOne) Exec(ctx context.Context) error {
+	_, err := _u.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *PlayerServicesUpdateOne) ExecX(ctx context.Context) {
+	if err := _u.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *PlayerServicesUpdateOne) defaults() {
+	if _, ok := _u.mutation.UpdatedAt(); !ok {
+		v := playerservices.UpdateDefaultUpdatedAt()
+		_u.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *PlayerServicesUpdateOne) check() error {
+	if v, ok := _u.mutation.Title(); ok {
+		if err := playerservices.TitleValidator(v); err != nil {
+			return &ValidationError{Name: "title", err: fmt.Errorf(`models: validator failed for field "PlayerServices.title": %w`, err)}
+		}
+	}
+	if v, ok := _u.mutation.Unit(); ok {
+		if err := playerservices.UnitValidator(v); err != nil {
+			return &ValidationError{Name: "unit", err: fmt.Errorf(`models: validator failed for field "PlayerServices.unit": %w`, err)}
+		}
+	}
+	if v, ok := _u.mutation.RankRange(); ok {
+		if err := playerservices.RankRangeValidator(v); err != nil {
+			return &ValidationError{Name: "rank_range", err: fmt.Errorf(`models: validator failed for field "PlayerServices.rank_range": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (_u *PlayerServicesUpdateOne) sqlSave(ctx context.Context) (_node *PlayerServices, err error) {
+	if err := _u.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(playerservices.Table, playerservices.Columns, sqlgraph.NewFieldSpec(playerservices.FieldID, field.TypeInt64))
+	id, ok := _u.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`models: missing "PlayerServices.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := _u.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, playerservices.FieldID)
+		for _, f := range fields {
+			if !playerservices.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("models: invalid field %q for query", f)}
+			}
+			if f != playerservices.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := _u.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := _u.mutation.PlayerID(); ok {
+		_spec.SetField(playerservices.FieldPlayerID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedPlayerID(); ok {
+		_spec.AddField(playerservices.FieldPlayerID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.GameID(); ok {
+		_spec.SetField(playerservices.FieldGameID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.AddedGameID(); ok {
+		_spec.AddField(playerservices.FieldGameID, field.TypeInt64, value)
+	}
+	if value, ok := _u.mutation.Title(); ok {
+		_spec.SetField(playerservices.FieldTitle, field.TypeString, value)
+	}
+	if value, ok := _u.mutation.Description(); ok {
+		_spec.SetField(playerservices.FieldDescription, field.TypeString, value)
+	}
+	if _u.mutation.DescriptionCleared() {
+		_spec.ClearField(playerservices.FieldDescription, field.TypeString)
+	}
+	if value, ok := _u.mutation.Price(); ok {
+		_spec.SetField(playerservices.FieldPrice, field.TypeOther, value)
+	}
+	if value, ok := _u.mutation.Unit(); ok {
+		_spec.SetField(playerservices.FieldUnit, field.TypeString, value)
+	}
+	if value, ok := _u.mutation.RankRange(); ok {
+		_spec.SetField(playerservices.FieldRankRange, field.TypeString, value)
+	}
+	if _u.mutation.RankRangeCleared() {
+		_spec.ClearField(playerservices.FieldRankRange, field.TypeString)
+	}
+	if value, ok := _u.mutation.Availability(); ok {
+		_spec.SetField(playerservices.FieldAvailability, field.TypeJSON, value)
+	}
+	if value, ok := _u.mutation.AppendedAvailability(); ok {
+		_spec.AddModifier(func(u *sql.UpdateBuilder) {
+			sqljson.Append(u, playerservices.FieldAvailability, value)
+		})
+	}
+	if _u.mutation.AvailabilityCleared() {
+		_spec.ClearField(playerservices.FieldAvailability, field.TypeJSON)
+	}
+	if value, ok := _u.mutation.Rating(); ok {
+		_spec.SetField(playerservices.FieldRating, field.TypeOther, value)
+	}
+	if value, ok := _u.mutation.IsActive(); ok {
+		_spec.SetField(playerservices.FieldIsActive, field.TypeBool, value)
+	}
+	if _u.mutation.IsActiveCleared() {
+		_spec.ClearField(playerservices.FieldIsActive, field.TypeBool)
+	}
+	if value, ok := _u.mutation.UpdatedAt(); ok {
+		_spec.SetField(playerservices.FieldUpdatedAt, field.TypeTime, value)
+	}
+	_node = &PlayerServices{config: _u.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{playerservices.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	_u.mutation.done = true
+	return _node, nil
+}

app/player/rpc/internal/models/predicate/predicate.go

@@ -0,0 +1,13 @@
+// Code generated by ent, DO NOT EDIT.
+
+package predicate
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+// PlayerServices is the predicate function for playerservices builders.
+type PlayerServices func(*sql.Selector)
+
+// Players is the predicate function for players builders.
+type Players func(*sql.Selector)

app/player/rpc/internal/models/runtime.go

@@ -0,0 +1,93 @@
+// Code generated by ent, DO NOT EDIT.
+
+package models
+
+import (
+	"juwan-backend/app/player/rpc/internal/models/players"
+	"juwan-backend/app/player/rpc/internal/models/playerservices"
+	"juwan-backend/app/player/rpc/internal/models/schema"
+	"time"
+
+	"github.com/lib/pq"
+	"github.com/shopspring/decimal"
+)
+
+// The init function reads all schema descriptors with runtime code
+// (default values, validators, hooks and policies) and stitches it
+// to their package variables.
+func init() {
+	playerservicesFields := schema.PlayerServices{}.Fields()
+	_ = playerservicesFields
+	// playerservicesDescTitle is the schema descriptor for title field.
+	playerservicesDescTitle := playerservicesFields[3].Descriptor()
+	// playerservices.TitleValidator is a validator for the "title" field. It is called by the builders before save.
+	playerservices.TitleValidator = playerservicesDescTitle.Validators[0].(func(string) error)
+	// playerservicesDescUnit is the schema descriptor for unit field.
+	playerservicesDescUnit := playerservicesFields[6].Descriptor()
+	// playerservices.UnitValidator is a validator for the "unit" field. It is called by the builders before save.
+	playerservices.UnitValidator = playerservicesDescUnit.Validators[0].(func(string) error)
+	// playerservicesDescRankRange is the schema descriptor for rank_range field.
+	playerservicesDescRankRange := playerservicesFields[7].Descriptor()
+	// playerservices.RankRangeValidator is a validator for the "rank_range" field. It is called by the builders before save.
+	playerservices.RankRangeValidator = playerservicesDescRankRange.Validators[0].(func(string) error)
+	// playerservicesDescAvailability is the schema descriptor for availability field.
+	playerservicesDescAvailability := playerservicesFields[8].Descriptor()
+	// playerservices.DefaultAvailability holds the default value on creation for the availability field.
+	playerservices.DefaultAvailability = playerservicesDescAvailability.Default.([]string)
+	// playerservicesDescRating is the schema descriptor for rating field.
+	playerservicesDescRating := playerservicesFields[9].Descriptor()
+	// playerservices.DefaultRating holds the default value on creation for the rating field.
+	playerservices.DefaultRating = playerservicesDescRating.Default.(decimal.Decimal)
+	// playerservicesDescIsActive is the schema descriptor for is_active field.
+	playerservicesDescIsActive := playerservicesFields[10].Descriptor()
+	// playerservices.DefaultIsActive holds the default value on creation for the is_active field.
+	playerservices.DefaultIsActive = playerservicesDescIsActive.Default.(bool)
+	// playerservicesDescCreatedAt is the schema descriptor for created_at field.
+	playerservicesDescCreatedAt := playerservicesFields[11].Descriptor()
+	// playerservices.DefaultCreatedAt holds the default value on creation for the created_at field.
+	playerservices.DefaultCreatedAt = playerservicesDescCreatedAt.Default.(func() time.Time)
+	// playerservicesDescUpdatedAt is the schema descriptor for updated_at field.
+	playerservicesDescUpdatedAt := playerservicesFields[12].Descriptor()
+	// playerservices.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	playerservices.DefaultUpdatedAt = playerservicesDescUpdatedAt.Default.(func() time.Time)
+	// playerservices.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	playerservices.UpdateDefaultUpdatedAt = playerservicesDescUpdatedAt.UpdateDefault.(func() time.Time)
+	playersFields := schema.Players{}.Fields()
+	_ = playersFields
+	// playersDescStatus is the schema descriptor for status field.
+	playersDescStatus := playersFields[2].Descriptor()
+	// players.DefaultStatus holds the default value on creation for the status field.
+	players.DefaultStatus = playersDescStatus.Default.(string)
+	// players.StatusValidator is a validator for the "status" field. It is called by the builders before save.
+	players.StatusValidator = playersDescStatus.Validators[0].(func(string) error)
+	// playersDescRating is the schema descriptor for rating field.
+	playersDescRating := playersFields[4].Descriptor()
+	// players.DefaultRating holds the default value on creation for the rating field.
+	players.DefaultRating = playersDescRating.Default.(decimal.Decimal)
+	// playersDescTotalOrders is the schema descriptor for total_orders field.
+	playersDescTotalOrders := playersFields[5].Descriptor()
+	// players.DefaultTotalOrders holds the default value on creation for the total_orders field.
+	players.DefaultTotalOrders = playersDescTotalOrders.Default.(int)
+	// playersDescCompletedOrders is the schema descriptor for completed_orders field.
+	playersDescCompletedOrders := playersFields[6].Descriptor()
+	// players.DefaultCompletedOrders holds the default value on creation for the completed_orders field.
+	players.DefaultCompletedOrders = playersDescCompletedOrders.Default.(int)
+	// playersDescTags is the schema descriptor for tags field.
+	playersDescTags := playersFields[8].Descriptor()
+	// players.DefaultTags holds the default value on creation for the tags field.
+	players.DefaultTags = playersDescTags.Default.([]string)
+	// playersDescGames is the schema descriptor for games field.
+	playersDescGames := playersFields[9].Descriptor()
+	// players.DefaultGames holds the default value on creation for the games field.
+	players.DefaultGames = playersDescGames.Default.(pq.Int64Array)
+	// playersDescCreatedAt is the schema descriptor for created_at field.
+	playersDescCreatedAt := playersFields[10].Descriptor()
+	// players.DefaultCreatedAt holds the default value on creation for the created_at field.
+	players.DefaultCreatedAt = playersDescCreatedAt.Default.(func() time.Time)
+	// playersDescUpdatedAt is the schema descriptor for updated_at field.
+	playersDescUpdatedAt := playersFields[11].Descriptor()
+	// players.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	players.DefaultUpdatedAt = playersDescUpdatedAt.Default.(func() time.Time)
+	// players.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	players.UpdateDefaultUpdatedAt = playersDescUpdatedAt.UpdateDefault.(func() time.Time)
+}

app/player/rpc/internal/models/runtime/runtime.go

@@ -0,0 +1,10 @@
+// Code generated by ent, DO NOT EDIT.
+
+package runtime
+
+// The schema-stitching logic is generated in juwan-backend/app/player/rpc/internal/models/runtime.go
+
+const (
+	Version = "v0.14.5"                                         // Version of ent codegen.
+	Sum     = "h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4=" // Sum of ent codegen.
+)

app/player/rpc/internal/models/schema/players.go

@@ -0,0 +1,51 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/schema/field"
+	"github.com/lib/pq"
+	"github.com/shopspring/decimal"
+)
+
+var playerDefaultRating = decimal.RequireFromString("5.00")
+
+// Players holds the schema definition for the Players entity.
+type Players struct {
+	ent.Schema
+}
+
+// Fields of the Players.
+func (Players) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int64("id").Immutable().Unique(),
+		field.Int64("user_id").Unique(),
+		field.String("status").MaxLen(20).Default("offline"),
+		field.Int("gender").Unique(),
+		field.Other("rating", decimal.Decimal{}).
+			Optional().
+			Default(playerDefaultRating).
+			SchemaType(map[string]string{
+				dialect.Postgres: "decimal(3,2)",
+			}),
+		field.Int("total_orders").Optional().Default(0),
+		field.Int("completed_orders").Optional().Default(0),
+		field.Int64("shop_id").Optional().Nillable(),
+		field.Strings("tags").Optional().Default([]string{}),
+		field.Other("games", pq.Int64Array{}).
+			Optional().
+			Default(pq.Int64Array{}).
+			SchemaType(map[string]string{
+				dialect.Postgres: "bigint[]",
+			}),
+		field.Time("created_at").Default(time.Now).Immutable(),
+		field.Time("updated_at").Default(time.Now).UpdateDefault(time.Now),
+	}
+}
+
+// Edges of the Players.
+func (Players) Edges() []ent.Edge {
+	return nil
+}

app/player/rpc/internal/models/schema/playerservices.go

@@ -0,0 +1,65 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/field"
+	"github.com/shopspring/decimal"
+)
+
+var (
+	decFive = decimal.RequireFromString("5.00")
+)
+
+// PlayerServices holds the schema definition for the PlayerServices entity.
+type PlayerServices struct {
+	ent.Schema
+}
+
+// Annotations of the PlayerServices.
+func (PlayerServices) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.Annotation{
+			Table: "player_services",
+			Checks: map[string]string{
+				"chk_price_positive": "price > 0",
+				"chk_service_rating": "rating >= 0 AND rating <= 5",
+			},
+		},
+	}
+}
+
+// Fields of the PlayerServices.
+func (PlayerServices) Fields() []ent.Field {
+	return []ent.Field{
+		field.Int64("id").Immutable().Unique(),
+		field.Int64("player_id"),
+		field.Int64("game_id"),
+		field.String("title").MaxLen(200),
+		field.String("description").Optional().Nillable(),
+		field.Other("price", decimal.Decimal{}).
+			SchemaType(map[string]string{
+				dialect.Postgres: "decimal(10,2)",
+			}),
+		field.String("unit").MaxLen(20),
+		field.String("rank_range").MaxLen(100).Optional().Nillable(),
+		field.Strings("availability").Optional().Default([]string{}),
+		field.Other("rating", decimal.Decimal{}).
+			Default(decFive).
+			SchemaType(map[string]string{
+				dialect.Postgres: "decimal(3,2)",
+			}),
+		field.Bool("is_active").Optional().Default(true),
+		field.Time("created_at").Default(time.Now).Immutable(),
+		field.Time("updated_at").Default(time.Now).UpdateDefault(time.Now),
+	}
+}
+
+// Edges of the PlayerServices.
+func (PlayerServices) Edges() []ent.Edge {
+	return nil
+}

app/player/rpc/internal/models/tx.go

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

app/player/rpc/internal/server/playerServiceServer.go

@@ -0,0 +1,76 @@
+// Code generated by goctl. DO NOT EDIT.
+// goctl 1.9.2
+// Source: player.proto
+
+package server
+
+import (
+	"context"
+
+	"juwan-backend/app/player/rpc/internal/logic"
+	"juwan-backend/app/player/rpc/internal/svc"
+	"juwan-backend/app/player/rpc/pb"
+)
+
+type PlayerServiceServer struct {
+	svcCtx *svc.ServiceContext
+	pb.UnimplementedPlayerServiceServer
+}
+
+func NewPlayerServiceServer(svcCtx *svc.ServiceContext) *PlayerServiceServer {
+	return &PlayerServiceServer{
+		svcCtx: svcCtx,
+	}
+}
+
+// -----------------------playerServices-----------------------
+func (s *PlayerServiceServer) AddPlayerServices(ctx context.Context, in *pb.AddPlayerServicesReq) (*pb.AddPlayerServicesResp, error) {
+	l := logic.NewAddPlayerServicesLogic(ctx, s.svcCtx)
+	return l.AddPlayerServices(in)
+}
+
+func (s *PlayerServiceServer) UpdatePlayerServices(ctx context.Context, in *pb.UpdatePlayerServicesReq) (*pb.UpdatePlayerServicesResp, error) {
+	l := logic.NewUpdatePlayerServicesLogic(ctx, s.svcCtx)
+	return l.UpdatePlayerServices(in)
+}
+
+func (s *PlayerServiceServer) DelPlayerServices(ctx context.Context, in *pb.DelPlayerServicesReq) (*pb.DelPlayerServicesResp, error) {
+	l := logic.NewDelPlayerServicesLogic(ctx, s.svcCtx)
+	return l.DelPlayerServices(in)
+}
+
+func (s *PlayerServiceServer) GetPlayerServicesById(ctx context.Context, in *pb.GetPlayerServicesByIdReq) (*pb.GetPlayerServicesByIdResp, error) {
+	l := logic.NewGetPlayerServicesByIdLogic(ctx, s.svcCtx)
+	return l.GetPlayerServicesById(in)
+}
+
+func (s *PlayerServiceServer) SearchPlayerServices(ctx context.Context, in *pb.SearchPlayerServicesReq) (*pb.SearchPlayerServicesResp, error) {
+	l := logic.NewSearchPlayerServicesLogic(ctx, s.svcCtx)
+	return l.SearchPlayerServices(in)
+}
+
+// -----------------------players-----------------------
+func (s *PlayerServiceServer) AddPlayers(ctx context.Context, in *pb.AddPlayersReq) (*pb.AddPlayersResp, error) {
+	l := logic.NewAddPlayersLogic(ctx, s.svcCtx)
+	return l.AddPlayers(in)
+}
+
+func (s *PlayerServiceServer) UpdatePlayers(ctx context.Context, in *pb.UpdatePlayersReq) (*pb.UpdatePlayersResp, error) {
+	l := logic.NewUpdatePlayersLogic(ctx, s.svcCtx)
+	return l.UpdatePlayers(in)
+}
+
+func (s *PlayerServiceServer) DelPlayers(ctx context.Context, in *pb.DelPlayersReq) (*pb.DelPlayersResp, error) {
+	l := logic.NewDelPlayersLogic(ctx, s.svcCtx)
+	return l.DelPlayers(in)
+}
+
+func (s *PlayerServiceServer) GetPlayersById(ctx context.Context, in *pb.GetPlayersByIdReq) (*pb.GetPlayersByIdResp, error) {
+	l := logic.NewGetPlayersByIdLogic(ctx, s.svcCtx)
+	return l.GetPlayersById(in)
+}
+
+func (s *PlayerServiceServer) SearchPlayers(ctx context.Context, in *pb.SearchPlayersReq) (*pb.SearchPlayersResp, error) {
+	l := logic.NewSearchPlayersLogic(ctx, s.svcCtx)
+	return l.SearchPlayers(in)
+}

app/player/rpc/internal/svc/serviceContext.go

@@ -0,0 +1,49 @@
+package svc
+
+import (
+	"juwan-backend/app/player/rpc/internal/config"
+	"juwan-backend/app/player/rpc/internal/models"
+	"juwan-backend/app/snowflake/rpc/snowflake"
+	"juwan-backend/common/redisx"
+	"juwan-backend/common/snowflakex"
+	"juwan-backend/pkg/adapter"
+	"time"
+
+	"ariga.io/entcache"
+	"entgo.io/ent/dialect/sql"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ServiceContext struct {
+	Config        config.Config
+	PlayerModelRW *models.Client
+	PlayerModelRO *models.Client
+	Snowflake     snowflake.SnowflakeServiceClient
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	RWConn, err := sql.Open("pgx", c.DB.Master)
+	if err != nil {
+		panic(err)
+	}
+	ROConn, err := sql.Open("pgx", c.DB.Slaves)
+	if err != nil {
+		panic(err)
+	}
+
+	redisCluster, err := redisx.ConnectMasterSlaveCluster(c.CacheConf, 5*time.Second)
+	if redisCluster == nil || err != nil {
+		logx.Errorf("failed to connect to Redis cluster: %v", err)
+		panic(err)
+	}
+	// snowflakex.NewClient(c.SnowflakeRpcConf)
+
+	RWDrv := entcache.NewDriver(RWConn, entcache.TTL(30*time.Second), entcache.Levels(adapter.NewRedisCache(redisCluster.Client)))
+	RODrv := entcache.NewDriver(ROConn, entcache.TTL(30*time.Second), entcache.Levels(adapter.NewRedisCache(redisCluster.Client)))
+	return &ServiceContext{
+		Config:        c,
+		PlayerModelRW: models.NewClient(models.Driver(RWDrv)),
+		PlayerModelRO: models.NewClient(models.Driver(RODrv)),
+		Snowflake:     snowflakex.NewClient(c.SnowflakeRpcConf),
+	}
+}