database

type BeforeCreateHook interface {
	BeforeCreate() error
}

type BeforeDeleteHook interface {
	BeforeDelete() error
}

type BeforeUpdateHook interface {
	BeforeUpdate() error
}

type Connector interface {
	Ping() error
	Disconnect() error
	GetName() string
	GetDatabaseName() string
	GetDriver() any
}

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

type Field struct {
	FieldName         string
	BsonName          string
	JsonName          string
	DataType          string
	IsPointer         bool
	FieldType         reflect.Type
	IndirectFieldType reflect.Type
	StructField       reflect.StructField
	Tag               reflect.StructTag
	FilterTags        FilterTags
}

type FieldDetails struct {
	BsonName  string
	JsonName  string
	FieldType string
}

type FieldTags struct {
	Name      string
	OmitEmpty bool
	MinSize   bool
	Truncate  bool
	Inline    bool
	Skip      bool
	Required  bool
}

type FieldsOptions string

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

type FilterTags struct {
	Fields FieldsOptions
}

type IModel interface {
	GetTableName() string
	GetModelName() string
	GetConnectorName() string
	GetId() any
}

type IRelation interface {
	ResolveForMany(ctx context.Context, ds *Datasource, docs []IModel) (any, error) // Resolve the relation for multiple documents
	ResolveForOne(ctx context.Context, ds *Datasource, doc IModel) (any, error)     // Resolve the relation for a single document
	Set(value any) error                                                            // Set the value of the relation
	// contains filtered or unexported methods
}

type IRelationalModel interface {
	Relations() map[string]ModelRelation
}

type IndexDefinition struct {
	Name   string       // Index name
	Fields []IndexField // Fields that compose the index
	Unique bool         // Whether the index is unique
}

type IndexField struct {
	Name  string // Field name
	Order int    // 1 for ascending, -1 for descending
}

type IndexManager interface {
	// EnsureIndexes creates the indexes for a given model
	EnsureIndexes(model IModel) error

	// ListIndexes returns all indexes for a given model's collection/table
	ListIndexes(model IModel) ([]string, error)

	// CompareIndexes compares defined indexes vs existing ones and returns warnings
	CompareIndexes(model IModel) ([]IndexWarning, error)
}

type IndexWarning struct {
	Type    IndexWarningType
	Message string
	Details map[string]interface{}
}

type IndexWarningType string

type MergeConfig struct {
	// WhereOperator defines how to combine WHERE conditions: "and" (default) or "or"
	WhereOperator string
	// AllowFieldConflicts allows the other FilterBuilder to overwrite field projections
	AllowFieldConflicts bool
	// MaxLimit sets a maximum value for the limit when merging
	MaxLimit *uint
}

type ModelRelation struct {
	Name   string `json:"name"`
	IsList bool   `json:"isList"`

	Resolve func(ctx context.Context, ds *Datasource) (any, error)
	Set     func(value any) error
}

type MongoCollation struct {
	Locale          string
	CaseLevel       bool
	CaseFirst       string
	Strength        int
	NumericOrdering bool
	Alternate       string
	MaxVariable     string
	Backwards       bool
}

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

type MongoConnectorOpts struct {
	options.ClientOptions
	Name     string
	Database string
}

type MongoDate struct {
	time.Time
}

type MongoFilter struct {
	Where   bson.M
	Options MongoFilterOptions
	Include []MongoIncludes
}

type MongoFilterOptions struct {
	Limit  *uint
	Skip   *uint
	Sort   any
	Fields map[string]bool
}

type MongoIncludes struct {
	Relation string
	Scope    lbq.Filter
}

type MongoIndexDefinition struct {
	IndexDefinition

	// MongoDB-specific options
	Background         bool             // Create index in background
	Sparse             bool             // Only index documents that have the indexed field
	ExpireAfterSeconds *int32           // TTL in seconds (for TTL indexes)
	Unique             bool             // Enforce uniqueness
	PartialFilter      map[string]any   // Partial filter expression
	Collation          *MongoCollation  // Collation options
	Weights            map[string]int32 // Text search weights (for text indexes)
	DefaultLanguage    string           // Default language for text indexes
	LanguageOverride   string           // Field name containing language override
	TextVersion        *int32           // Text index version
	SphereVersion      *int32           // 2dsphere index version
	Bits               *int32           // Precision for geohash (for 2d indexes)
	Max                *float64         // Max boundary for 2d indexes
	Min                *float64         // Min boundary for 2d indexes
	BucketSize         *int32           // Bucket size for geoHaystack indexes
	StorageEngine      map[string]any   // Storage engine options
	Hidden             bool             // Hide index from query planner
	WildcardProjection map[string]any   // Wildcard index projection
}

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

type MongoIndexType string

type MongoIndexableModel interface {
	DefineMongoIndexes() []MongoIndexDefinition
}

type MongoRepository[T IModel] struct {
	Options RepositoryOptions
	// contains filtered or unexported fields
}

type MongoUpdate struct {
	CurrentDate any `bson:"$currentDate,omitempty"`
	Inc         any `bson:"$inc,omitempty"`
	Min         any `bson:"$min,omitempty"`
	Max         any `bson:"$max,omitempty"`
	Mul         any `bson:"$mul,omitempty"`
	Rename      any `bson:"$rename,omitempty"`
	Set         any `bson:"$set,omitempty"`
	SetOnInsert any `bson:"$setOnInsert,omitempty"`
	Unset       any `bson:"$unset,omitempty"`
	AddToSet    any `bson:"$addToSet,omitempty"`
	Pop         any `bson:"$pop,omitempty"`
	Pull        any `bson:"$pull,omitempty"`
	PullAll     any `bson:"$pullAll,omitempty"`
	Push        any `bson:"$push,omitempty"`
}

type PostgresIndexDefinition struct {
	IndexDefinition
}

type PostgresIndexableModel interface {
	DefinePostgresIndexes() []PostgresIndexDefinition
}

type Relation struct {
	FieldName    string
	JsonName     string
	RelationType RelationType
	TargetModel  IModel
}

type RelationHasOne struct {
	Model       IModel   // Model for the relation
	Key         []string // Keys for the relation, e.g. ["userId", "userType"]
	TargetModel IModel   // Target model for the relation
	ForeignKey  []string // Keys in the target model that point to the source model, e.g. ["id", "type"]
	Set         func(any) error
}

type RelationType string

type Repository[T IModel] interface {
	// GetSchema returns the schema of the model used by this repository.
	GetSchema() *Schema

	// GetConnector returns the connector used by this repository.
	// This is useful for accessing the underlying database connection.
	// It is typically used for advanced operations that are not covered by the repository methods.
	GetConnector() Connector

	// Find retrieves all documents matching the filter.
	// If no documents match, it returns an empty slice.
	// If an error occurs, it returns an error.
	Find(ctx context.Context, filter *FilterBuilder) ([]T, error)

	// FindOne retrieves a single document matching the filter.
	// If multiple documents match, it returns the first one found.
	// If no documents match, it returns an error.
	FindOne(ctx context.Context, filter *FilterBuilder) (*T, error)

	// FindById retrieves a single document by its ID.
	// If the document does not exist, it returns an error.
	FindById(ctx context.Context, id any, filter *FilterBuilder) (*T, error)

	// Insert inserts a new document into the collection.
	// It returns the inserted document's ID or an error if the operation fails.
	Insert(ctx context.Context, doc T) (any, error)

	// Create inserts a new document into the collection and returns the created document.
	Create(ctx context.Context, doc T) (*T, error)

	// FindOneOrCreate finds a document matching the filter or creates a new one if it does not exist.
	FindOneOrCreate(ctx context.Context, filter *FilterBuilder, doc T) (*T, error)

	// Upsert updates a document matching the filter or inserts a new one if it does not exist.
	Upsert(ctx context.Context, filter *FilterBuilder, update any) error

	// UpdateOne updates a single document matching the filter.
	UpdateOne(ctx context.Context, filter *FilterBuilder, update any) error

	// UpdateById updates a single document by its ID.
	UpdateById(ctx context.Context, id any, update any) error

	// FindOneAndUpdate finds a single document matching the filter and updates it.
	FindOneAndUpdate(ctx context.Context, filter *FilterBuilder, update any) (*T, error)

	// UpdateMany updates all documents matching the filter.
	UpdateMany(ctx context.Context, filter *FilterBuilder, update any) (int64, error)

	// Count returns the number of documents matching the filter.
	Count(ctx context.Context, filter *FilterBuilder) (int64, error)

	// Exists checks if a document with the given ID exists in the collection.
	Exists(ctx context.Context, id any) (bool, error)

	// DeleteOne deletes a single document matching the filter.
	DeleteOne(ctx context.Context, filter *FilterBuilder) error

	// DeleteById deletes a single document by its ID.
	DeleteById(ctx context.Context, id any) error

	// DeleteMany deletes all documents matching the filter.
	DeleteMany(ctx context.Context, filter *FilterBuilder) (int64, error)
}

type RepositoryOptions struct {
	Created        bool
	Modified       bool
	Deleted        bool
	RequiredFields []string
}

type Schema struct {
	Model                IModel
	Name                 string
	CollectionName       string
	JSONFields           map[string]*Field
	Fields               map[string]*Field
	RequiredFilterFields map[string]*Field
	BannedFields         map[string]*Field
	// Relations            []Relation
	ReflectValue reflect.Value
}

type TargetModel struct {
	Name           string
	CollectionName string
}

type UpdateOptions struct {
	Insert bool
	Update bool
}

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