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 LocaleResolver func(ctx corectx.Context) *model.LanguageCode

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

	// ComputedContext carries the request's whitelisted context values for SQL-computed
	// fields; the query builder binds them into "${ctx.key}" filter references.
	ComputedContext map[string]any

	// IncludeArchived controls whether archived records take part in the search.
	// It is tri-state on purpose:
	//   - nil: no filtering at all. This is the legacy contract that every internal lookup
	//     relies on, e.g. models.FindTemplateVariants which needs archived rows by design.
	//     Leave it nil when reusing Search to fetch a single known record.
	//   - false: the repository prepends "is_archived = false" to the search graph.
	//     crud.Search sets this when the caller omitted the query parameter, so the public
	//     HTTP API hides archived records by default.
	//   - true: no filtering; archived records are returned alongside active ones.
	//
	// The condition is only prepended on schemas that actually carry the is_archived column
	// (it comes from the optional basemodel.ArchivableModelSchemaBuilder mixin).
	//
	// Note this filters the searched schema only. Nested edge columns are hydrated by
	// follow-up queries that are not filtered, so requesting fields=groups.name with
	// IncludeArchived=false excludes archived rows of this schema but still hydrates
	// archived rows of the edge.
	IncludeArchived *bool
}

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"`

	// Optional flag to include archived records in the result.
	// When omitted, crud.Search treats it as false, so archived records are hidden by default.
	// Set it to true to search archived and active records together.
	IncludeArchived *bool `json:"include_archived" query:"include_archived"`

	// 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"`

	// Optional whitelisted context values for SQL-computed fields (aggregate/exists/lookup)
	// whose filter declares context dependencies. Each value binds a "${ctx.key}" reference;
	// a computed field whose declared key is absent here fails with a validation error.
	Context map[string]any `json:"context" query:"context"`
}

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
}