odm

type CollectionInterface interface {
	UpdateOne(ctx context.Context, filter interface{}, update interface{}, opts ...options.Lister[options.UpdateOneOptions]) (*mongo.UpdateResult, error)
	FindOne(ctx context.Context, filter interface{}, opts ...options.Lister[options.FindOneOptions]) *mongo.SingleResult
	Find(ctx context.Context, filter interface{}, opts ...options.Lister[options.FindOptions]) (cur *mongo.Cursor, err error)
	DeleteOne(ctx context.Context, filter interface{}, opts ...options.Lister[options.DeleteOneOptions]) (*mongo.DeleteResult, error)
	Aggregate(ctx context.Context, pipeline interface{}, opts ...options.Lister[options.AggregateOptions]) (*mongo.Cursor, error)
	CountDocuments(ctx context.Context, filter interface{}, opts ...options.Lister[options.CountOptions]) (int64, error)
	Distinct(ctx context.Context, field string, filter any, opts ...options.Lister[options.DistinctOptions]) *mongo.DistinctResult
}

type DbModel interface {
	// odm enforces string ID instead of ObjectID.
	// Principally, odm encourages to use data properties to find unique ID for a document.
	// If multiple fields together can uniquely identify a document, then hash those fields into a single string.
	Id() string
	CollectionName() string
}

type DefaultTimer struct{}

type Indexed interface {
	IndexModels() []mongo.IndexModel
}

type MongoClient interface {
	Ping(context.Context, *readpref.ReadPref) error
	Database(name string, opts ...options.Lister[options.DatabaseOptions]) *mongo.Database
	Disconnect(ctx context.Context) error
}

type OdmCollectionInterface[T DbModel] interface {
	Save(ctx context.Context, model T) <-chan async.Result[struct{}]
	FindOneByID(ctx context.Context, id string) <-chan async.Result[*T]
	FindOne(ctx context.Context, filters bson.M) <-chan async.Result[*T]
	Find(ctx context.Context, filters bson.M, sort bson.D, limit, skip int64) <-chan async.Result[[]T]
	DeleteByID(ctx context.Context, id string) <-chan async.Result[struct{}]
	DeleteOne(ctx context.Context, filters bson.M) <-chan async.Result[struct{}]
	Count(ctx context.Context, filters bson.M) <-chan async.Result[int64]
	DistinctInto(ctx context.Context, field string, filters bson.D, out any) error
	Aggregate(ctx context.Context, pipeline mongo.Pipeline) <-chan async.Result[[]T]
	Exists(ctx context.Context, id string) <-chan async.Result[bool]
	VectorSearch(ctx context.Context, embedding []float32, opts VectorSearchParams) <-chan async.Result[[]SearchHit[T]]
	TermSearch(ctx context.Context, query string, params TermSearchParams) <-chan async.Result[[]SearchHit[T]]
}

type SearchHit[T DbModel] struct {
	Score float64 `bson:"score"`
	Doc   T       `bson:"doc"`
}

type SearchIndexed interface {
	TermSearchIndexSpecs() []TermSearchIndexSpec
}

type TermSearchIndexSpec struct {
	Name  string   // index name
	Paths []string // e.g. fields in the struct that holds the text to be indexed.
}

type TermSearchParams struct {
	IndexName string   // required
	Path      []string // field to search
	Filter    bson.M   // optional filter
	Limit     int      // number of results to return
}

type Timer interface {
	Now() int64
}

type VectorIndexSpec struct {
	Name          string `bson:"-"`    //index name
	Type          string `bson:"type"` // field type, e.g. "vector"
	Path          string `bson:"path"` // e.g. field name in the struct/json that holds the embedding.
	NumDimensions int    `bson:"numDimensions"`
	Similarity    string `bson:"similarity,omitempty"` // e.g. "cosine", "dotProduct", "euclidean"
	Quantization  string `bson:"quantization,omitempty"`
}

type VectorIndexed interface {
	VectorIndexSpecs() []VectorIndexSpec
}

type VectorSearchParams struct {
	IndexName     string // Atlas Vector Search index name
	Path          string // field in the collection that holds the embedding (e.g. "embedding")
	K             int    // number of nearest neighbours
	NumCandidates int    // count of initial candidates to be considered for nearest search. These are approximate neighbours..
	Filter        bson.M // optional pre-filter; nil for none
}