database

type AfterDeleter interface {
	AfterDelete(context.Context, DB) error
}

type AfterFinder interface {
	AfterFind(context.Context, DB) error
}

type AfterInserter interface {
	AfterInsert(context.Context, DB) error
}

type AfterUpdater interface {
	AfterUpdate(context.Context, DB) error
}

type BeforeDeleter interface {
	BeforeDelete(context.Context, DB) error
}

type BeforeInserter interface {
	BeforeInsert(context.Context, DB) error
}

type BeforeUpdater interface {
	BeforeUpdate(context.Context, DB) error
}

type Builder interface {
	// Scope returns current query scope.
	Scope() *query.Scope
	// Err returns error for given query.
	Err() error
	// Ctx returns current query context.
	Ctx() context.Context

	// Count returns the number of model instances in the repository matching given query.
	Count() (int64, error)
	// Insert models into repository. Returns error with class ErrViolationUnique if the model with given primary key already exists.
	Insert() error
	// update updates query models in the repository. Input models with non zero primary key the function would take
	// update these models instances. For a non zero single model with filters it would update all models that match
	// given query. In order to update all models in the repository use UpdateAll method.
	Update() (int64, error)
	// Exists check if input model exists.
	Exists() (bool, error)
	// Get gets single model that matches given query.
	Get() (mapping.Model, error)
	// Find gets all models that matches given query. For models with DeletedAt timestamp field, adds the
	// filter for not nulls DeletedAt models, unless there is other DeletedAt filter.
	Find() ([]mapping.Model, error)
	// deleteQuery deletes models matching given query. If the model has DeletedAt timestamp field it would do the
	// soft delete - update all models matching given query and set their deleted_at field with current timestamp.
	Delete() (int64, error)
	// refreshQuery gets all input models and refreshes all selected fields and included relations.
	Refresh() error

	// Select model fields for the query fieldSet.
	Select(fields ...*mapping.StructField) Builder
	// Where adds the query 'filter' with provided arguments. The query should be composed of the field name and it's
	// operator. In example: 'ID in', 3,4,5 - would result with a filter on primary key field named 'ID' with the
	// IN operator and it's value equal to 3,4 or 5.
	Where(filter string, arguments ...interface{}) Builder
	// Include adds the 'relation' with it's optional fieldset to get for each resulting model to find.
	Include(relation *mapping.StructField, relationFieldset ...*mapping.StructField) Builder
	// OrderBy sorts the results by the fields in the given order.
	OrderBy(fields ...query.Sort) Builder
	// Limit sets the maximum number of the results for given query.
	Limit(limit int64) Builder
	// Offset sets the number of the results to omit in the query.
	Offset(offset int64) Builder
	// Filter adds the filter field to the given query.
	Filter(filter filter.Filter) Builder
	// WhereOr creates a OrGroup filter for provided simple filters.
	WhereOr(filters ...filter.Simple) Builder

	// AddRelations adds the 'relations' models to input models for 'relationField'
	AddRelations(relationField *mapping.StructField, relations ...mapping.Model) error
	// querySetRelations clears all 'relationField' for the input models and set their values to the 'relations'.
	// The relation's foreign key must be allowed to set to null.
	SetRelations(relationField *mapping.StructField, relations ...mapping.Model) error
	// ClearRelations clears all 'relationField' relations for given input models.
	// The relation's foreign key must be allowed to set to null.
	RemoveRelations(relationField *mapping.StructField) (int64, error)
	// IncludeRelation adds the 'relations' models to input models for 'relationField'
	GetRelations(relationField *mapping.StructField, relationFieldSet ...*mapping.StructField) ([]mapping.Model, error)
}

type DB interface {
	// Query creates a new query for provided 'model'.
	Query(model *mapping.ModelStruct, models ...mapping.Model) Builder
	// QueryCtx creates a new query for provided 'model'. The query should take a context on it's
	QueryCtx(ctx context.Context, model *mapping.ModelStruct, models ...mapping.Model) Builder

	// Insert inserts provided models into mapped repositories. The DB would use models non zero fields. Provided models
	// must have non zero primary key values. The function allows to insert multiple models at once.
	Insert(ctx context.Context, mStruct *mapping.ModelStruct, models ...mapping.Model) error
	// update updates provided models in their mapped repositories. The DB would use models non zero fields. Provided models
	// must have non zero primary key values. The function allows to update multiple models at once.
	Update(ctx context.Context, mStruct *mapping.ModelStruct, models ...mapping.Model) (int64, error)
	// deleteQuery deletes provided models from their mapped repositories. The DB would use models non zero fields. Provided models
	// must have non zero primary key values. The function allows to delete multiple model values at once.
	Delete(ctx context.Context, mStruct *mapping.ModelStruct, models ...mapping.Model) (int64, error)
	// refreshQuery refreshes fields (attributes, foreign keys) for provided models.
	Refresh(ctx context.Context, mStruct *mapping.ModelStruct, models ...mapping.Model) error

	// AddRelations adds the 'relations' models to input models for 'relationField'
	AddRelations(ctx context.Context, model mapping.Model, relationField *mapping.StructField, relations ...mapping.Model) error
	// querySetRelations clears all 'relationField' for the input models and set their values to the 'relations'.
	// The relation's foreign key must be allowed to set to null.
	SetRelations(ctx context.Context, model mapping.Model, relationField *mapping.StructField, relations ...mapping.Model) error
	// ClearRelations clears all 'relationField' relations for given input models.
	// The relation's foreign key must be allowed to set to null.
	ClearRelations(ctx context.Context, model mapping.Model, relationField *mapping.StructField) (int64, error)
	// IncludeRelation includes the relations at the 'relationField' for provided models. An optional relationFieldset might be provided.
	IncludeRelations(ctx context.Context, mStruct *mapping.ModelStruct, models []mapping.Model, relationField *mapping.StructField, relationFieldset ...*mapping.StructField) error
	// GetRelations gets the 'relatedField' Models for provided the input 'models. An optional relationFieldset might be provided for the relation models.
	GetRelations(ctx context.Context, mStruct *mapping.ModelStruct, models []mapping.Model, relationField *mapping.StructField, relationFieldset ...*mapping.StructField) ([]mapping.Model, error)

	// Now returns current time used by the database layer.
	Now() time.Time

	// ModelMap gets related model map.
	ModelMap() *mapping.ModelMap
}

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

type DefaultRepositoryGetter interface {
	// GetDefaultRepository gets the default repository.
	GetDefaultRepository() (repository.Repository, bool)
}

type Option func(o *Options)

type Options struct {
	// DefaultRepository is the default repository for given controller.
	DefaultRepository repository.Repository
	// RepositoryModels is the mapping between repository and it's models.
	RepositoryModels map[repository.Repository][]mapping.Model
	// ModelMap is a mapping for the model's structures.
	ModelMap *mapping.ModelMap
	// TimeFunc is the time function used by timestamps.
	TimeFunc func() time.Time
	// SynchronousConnections gets the synchronous connections.
	SynchronousConnections bool
	// MigrateModels are the models set up for database migration.
	MigrateModels []mapping.Model
}

type QueryDeleter interface {
	// DeleteQuery deletes the values provided in the query's scope.
	DeleteQuery(ctx context.Context, q *query.Scope) (int64, error)
}

type QueryFinder interface {
	// QueryFind gets the values from the repository with respect to the query filters, sorts, pagination and included values.
	// Provided 'ctx' context.Context would be used while querying the repositories.
	QueryFind(ctx context.Context, q *query.Scope) ([]mapping.Model, error)
}

type QueryGetter interface {
	// QueryGet gets single value from the repository taking into account the scope filters and parameters.
	QueryGet(ctx context.Context, q *query.Scope) (mapping.Model, error)
}

type QueryInserter interface {
	// InsertQuery stores the values within the given scope's value repository.
	InsertQuery(ctx context.Context, q *query.Scope) error
}

type QueryRefresher interface {
	QueryRefresh(ctx context.Context, q *query.Scope) error
}

type QueryRelationAdder interface {
	// AddRelations appends relationship 'relField' 'relationModels' to the scope values.
	QueryAddRelations(ctx context.Context, s *query.Scope, relField *mapping.StructField, relationModels ...mapping.Model) error
}

type QueryRelationClearer interface {
	// ClearRelations clears all 'relationField' relations for given query.
	// The relation's foreign key must be allowed to set to null.
	QueryClearRelations(ctx context.Context, s *query.Scope, relField *mapping.StructField) (int64, error)
}

type QueryRelationSetter interface {
	// querySetRelations clears all 'relationField' for the input models and set their values to the 'relations'.
	// The relation's foreign key must be allowed to set to null.
	QuerySetRelations(ctx context.Context, s *query.Scope, relationField *mapping.StructField, relationModels ...mapping.Model) error
}

type QueryUpdater interface {
	// UpdateQuery updates the models with selected fields or a single model with provided filters.
	UpdateQuery(ctx context.Context, q *query.Scope) (modelsAffected int64, err error)
}

type RepositoryGetter interface {
	// GetRepository gets the repository mapped to this model.
	GetRepository(model mapping.Model) (repository.Repository, error)
}

type RepositoryMapper struct {
	// Repositories are the controller registered repositories.
	Repositories map[string]repository.Repository
	// DefaultRepository is the default repository for given controller.
	DefaultRepository repository.Repository
	// ModelRepositories is the mapping between the model and related repositories.
	ModelRepositories map[*mapping.ModelStruct]repository.Repository
	// ModelMap contains the information about the models.
	ModelMap *mapping.ModelMap
}

type Tx struct {
	Transaction *query.Transaction
	// contains filtered or unexported fields
}

type TxFunc func(db DB) error