dynamicmodel

type BaseDynamicRepository interface {
	Schema() *dmodel.ModelSchema
	BeginTransaction(ctx corectx.Context) (database.DbTransaction, error)
	ExtractClient(ctx corectx.Context) orm.DbClient
	ExecFunc(ctx corectx.Context, sqlFuncName string, sqlFuncArgs ...any) error
	QueryFunc(ctx corectx.Context, sqlFuncName string, sqlFuncArgs ...any) (*sql.Rows, error)

	CheckUniqueCollisions(ctx corectx.Context, data dmodel.DynamicFields) (*OpResult[[][]string], error)
	CountM2m(ctx corectx.Context, param RepoCountM2mParam) (*OpResult[int], error)
	DeleteOne(ctx corectx.Context, keys dmodel.DynamicFields) (*OpResult[int], error)
	Exists(ctx corectx.Context, keys []dmodel.DynamicFields) (*OpResult[RepoExistsResult], error)
	ExistsM2m(ctx corectx.Context, param RepoExistsM2mParam) (bool, error)
	InsertBulk(ctx corectx.Context, data []dmodel.DynamicFields) (*OpResult[int], error)
	GetOne(ctx corectx.Context, param RepoGetOneParam) (*OpResult[dmodel.DynamicFields], error)
	Insert(ctx corectx.Context, data dmodel.DynamicFields) (*OpResult[int], error)
	// ManageM2m inserts and/or deletes junction rows for a finalized many-to-many link to dest schema.
	// Source and destination are identified by id.
	ManageM2m(ctx corectx.Context, param RepoManageM2mParam) (*OpResult[int], error)
	Search(ctx corectx.Context, param RepoSearchParam) (*OpResult[PagedResultData[dmodel.DynamicFields]], error)
	Update(ctx corectx.Context, data dmodel.DynamicFields) (*OpResult[dmodel.DynamicFields], error)
}

type DeleteOneCommand struct {
	Id model.Id `json:"id" param:"id"`
}

type DeleteOneCommandShape interface {
	~struct {
		Id model.Id `json:"id" param:"id"`
	}
}

type DynamicModelPtr[T any] interface {
	*T
	dmodel.DynamicModel
}

type DynamicModelRepository interface {
	BeginTransaction(ctx corectx.Context) (database.DbTransaction, error)
	GetBaseRepo() BaseDynamicRepository
}

type DynamicModelSetterPtr[T any] interface {
	*T
	dmodel.DynamicModelSetter
}

type ExistsQuery struct {
	Ids []model.Id `json:"ids" query:"ids"`
}

type ExistsQueryShape interface {
	~struct {
		Ids []model.Id `json:"ids" query:"ids"`
	}
}

type ExistsResultData struct {
	Existing    []model.Id `json:"existing"`
	NotExisting []model.Id `json:"not_existing"`
}

type GetOneQuery struct {
	Id     model.Id `json:"id" param:"id"`
	Fields []string `json:"fields" query:"fields"`
}

type InitParams struct {
	dig.In
}

type MutateResultData struct {
	AffectedCount int                 `json:"affected_count"`
	AffectedAt    model.ModelDateTime `json:"affected_at"`
	Etag          model.Etag          `json:"etag,omitempty"`
}

type NewBaseDynamicRepositoryFn func(param NewBaseRepoParam) BaseDynamicRepository

type NewBaseRepoParam struct {
	Client       orm.DbClient
	ConfigSvc    config.ConfigService
	Logger       logging.LoggerService
	QueryBuilder orm.QueryBuilder
	Schema       *dmodel.ModelSchema
}

type OpResult[TData any] struct {
	// The result data when success. It is only meaningful if HasData is true and ClientErrors is nil.
	// Otherwise, it could be nil or an empty struct.
	Data TData

	// Contains validation errors, business errors...,
	// or nil if there is no violation.
	ClientErrors ft.ClientErrors

	// Indicates whether "Data" is present (non-zero value: non-empty struct, non-empty array, etc.).
	//
	// If ClientErrors is nil but HasData is false,
	// it means the query is successfull but no data is found.
	HasData bool
}

type PagedResultData[T any] struct {
	Items []T `json:"items"`
	Total int `json:"total"`
	Page  int `json:"page"`
	Size  int `json:"size"`

	// List of fields determined by `View` which are requested to read.
	DesiredFields []string `json:"desired_fields"`

	// Subset of `DesiredFields` that user doesn't have permission to read.
	// These fields will be returned as `nil` values. User can be aware of their existence
	// and ask for permission to read them.
	MaskedFields []string `json:"masked_fields"`

	// The etag of the schema used to generate the response.
	// This is used to check if the schema has changed since the last request.
	// If the schema has changed, the client should fetch the new schema and update its cache.
	SchemaEtag string `json:"schema_etag"`
}

type PagingOptions struct {
	Page int `json:"page" query:"page"`
	Size int `json:"size" query:"size"`
}

type RepoBeforeInsertM2mFn func(ctx corectx.Context, dbRecords []dmodel.DynamicFields) error

type RepoCountM2mParam struct {
	M2mEdge string   `json:"m2m_edge"`
	SrcId   model.Id `json:"src_id"`
}

type RepoExistsM2mParam struct {
	M2mEdge string    `json:"m2m_edge"`
	SrcId   model.Id  `json:"src_id"`
	DestId  *model.Id `json:"dest_id"`
}

type RepoExistsResult struct {
	Existing    []dmodel.DynamicFields `json:"existing"`
	NotExisting []dmodel.DynamicFields `json:"not_existing"`
}

type RepoGetOneParam struct {
	Filter dmodel.DynamicFields
	Fields []string
}

type RepoM2mAssociation struct {
	SrcKeys  dmodel.DynamicFields
	DestKeys dmodel.DynamicFields
}

type RepoManageM2mParam struct {
	DestSchemaName string
	SrcId          model.Id
	// Field name for the source ID used to include in the error message.
	SrcIdFieldForError string
	// M2M edge name on the source schema.
	SrcEdgeName      string
	AssociatedIds    datastructure.Set[model.Id]
	DisassociatedIds datastructure.Set[model.Id]
	BeforeInsert     RepoBeforeInsertM2mFn
}

type RepoSearchParam struct {
	Fields   []string
	Filter   []dmodel.DynamicFields
	Page     int
	Size     int
	Graph    *dmodel.SearchGraph
	Language *model.LanguageCode
}

type SearchQuery struct {
	Fields []string `json:"fields" query:"fields"`
	Page   int      `json:"page" query:"page"`
	Size   int      `json:"size" query:"size"`
	// Optional search graph for advanced search
	Graph *dmodel.SearchGraph `json:"graph" query:"graph"`
	// Optional language code to filter fields with LangJson type
	Language *model.LanguageCode `json:"language" query:"language"`

	// Determines the fields to be returned in the response.
	// If not specified, return all fields that user has permission on.
	// Otherwise, return fields specified by the search name.
	SearchName *string `json:"search_name" query:"search_name"`
}

type SetIsArchivedCommand struct {
	Id         model.Id   `json:"id" param:"id"`
	Etag       model.Etag `json:"etag" param:"etag"`
	IsArchived *bool      `json:"is_archived" param:"is_archived"` // Pointer to trigger missing field error
}

type SingleMetaData struct {

	// List of fields determined by `View` which are requested to read.
	DesiredFields []string `json:"desired_fields"`

	// Subset of `DesiredFields` that user doesn't have permission to read.
	// These fields will be returned as `nil` values. User can be aware of their existence
	// and ask for permission to read them.
	MaskedFields []string `json:"masked_fields"`

	// The etag of the schema used to generate the response.
	// This is used to check if the schema has changed since the last request.
	// If the schema has changed, the client should fetch the new schema and update its cache.
	SchemaEtag string `json:"schema_etag"`
}

type SingleResultData[T any] struct {
	Item T              `json:"item"`
	Meta SingleMetaData `json:"meta"`
}

type Validatable interface {
	Validate() ft.ClientErrors
}

type ValidationFlow struct {
	// contains filtered or unexported fields
}