Add cursor rules and initial configuration for Tender Management Go Backend

2025-08-02 10:43:47 +03:30
parent ad9db7bcce
commit 5a1ceb0bd6
35 changed files with 4123 additions and 4550 deletions
@@ -0,0 +1,301 @@
+package mongo
+
+import (
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// Index represents a MongoDB index
+type Index struct {
+	Name    string                `json:"name"`
+	Keys    bson.D                `json:"keys"`
+	Options *options.IndexOptions `json:"options"`
+}
+
+// NewIndex creates a new index with default options
+func NewIndex(name string, keys bson.D) *Index {
+	return &Index{
+		Name:    name,
+		Keys:    keys,
+		Options: options.Index(),
+	}
+}
+
+// WithUnique sets the unique option for the index
+func (i *Index) WithUnique(unique bool) *Index {
+	i.Options.SetUnique(unique)
+	return i
+}
+
+// WithSparse sets the sparse option for the index
+func (i *Index) WithSparse(sparse bool) *Index {
+	i.Options.SetSparse(sparse)
+	return i
+}
+
+// WithBackground sets the background option for the index
+func (i *Index) WithBackground(background bool) *Index {
+	i.Options.SetBackground(background)
+	return i
+}
+
+// WithExpireAfterSeconds sets the TTL for the index
+func (i *Index) WithExpireAfterSeconds(seconds int32) *Index {
+	i.Options.SetExpireAfterSeconds(seconds)
+	return i
+}
+
+// WithPartialFilterExpression sets the partial filter expression for the index
+func (i *Index) WithPartialFilterExpression(filter bson.M) *Index {
+	i.Options.SetPartialFilterExpression(filter)
+	return i
+}
+
+// WithCollation sets the collation for the index
+func (i *Index) WithCollation(collation *options.Collation) *Index {
+	i.Options.SetCollation(collation)
+	return i
+}
+
+// Common index builders
+
+// CreateUniqueIndex creates a unique index
+func CreateUniqueIndex(name string, keys bson.D) *Index {
+	return NewIndex(name, keys).WithUnique(true)
+}
+
+// CreateTTLIndex creates a TTL index
+func CreateTTLIndex(name string, field string, expireAfterSeconds int32) *Index {
+	return NewIndex(name, bson.D{{Key: field, Value: 1}}).WithExpireAfterSeconds(expireAfterSeconds)
+}
+
+// CreateTextIndex creates a text index
+func CreateTextIndex(name string, fields ...string) *Index {
+	keys := bson.D{}
+	for _, field := range fields {
+		keys = append(keys, bson.E{Key: field, Value: "text"})
+	}
+	return NewIndex(name, keys)
+}
+
+// CreateCompoundIndex creates a compound index
+func CreateCompoundIndex(name string, fields map[string]int) *Index {
+	keys := bson.D{}
+	for field, direction := range fields {
+		keys = append(keys, bson.E{Key: field, Value: direction})
+	}
+	return NewIndex(name, keys)
+}
+
+// CreateGeospatialIndex creates a 2dsphere geospatial index
+func CreateGeospatialIndex(name string, field string) *Index {
+	return NewIndex(name, bson.D{{Key: field, Value: "2dsphere"}})
+}
+
+// CreateHashedIndex creates a hashed index
+func CreateHashedIndex(name string, field string) *Index {
+	return NewIndex(name, bson.D{{Key: field, Value: "hashed"}})
+}
+
+// Common index patterns
+
+// DefaultIndexes returns common default indexes for most collections
+func DefaultIndexes() []Index {
+	return []Index{
+		*CreateUniqueIndex("_id_", bson.D{{Key: "_id", Value: 1}}),
+		*NewIndex("created_at_idx", bson.D{{Key: "created_at", Value: -1}}),
+		*NewIndex("updated_at_idx", bson.D{{Key: "updated_at", Value: -1}}),
+	}
+}
+
+// UserIndexes returns common indexes for user collections
+func UserIndexes() []Index {
+	return []Index{
+		*CreateUniqueIndex("_id_", bson.D{{Key: "_id", Value: 1}}),
+		*CreateUniqueIndex("email_idx", bson.D{{Key: "email", Value: 1}}),
+		*NewIndex("created_at_idx", bson.D{{Key: "created_at", Value: -1}}),
+		*NewIndex("updated_at_idx", bson.D{{Key: "updated_at", Value: -1}}),
+		*NewIndex("is_active_idx", bson.D{{Key: "is_active", Value: 1}}),
+	}
+}
+
+// TenderIndexes returns common indexes for tender collections
+func TenderIndexes() []Index {
+	return []Index{
+		*CreateUniqueIndex("_id_", bson.D{{Key: "_id", Value: 1}}),
+		*NewIndex("created_at_idx", bson.D{{Key: "created_at", Value: -1}}),
+		*NewIndex("updated_at_idx", bson.D{{Key: "updated_at", Value: -1}}),
+		*NewIndex("status_idx", bson.D{{Key: "status", Value: 1}}),
+		*NewIndex("deadline_idx", bson.D{{Key: "deadline", Value: 1}}),
+		*NewIndex("category_idx", bson.D{{Key: "category", Value: 1}}),
+		*NewIndex("location_idx", bson.D{{Key: "location", Value: 1}}),
+	}
+}
+
+// CompanyIndexes returns common indexes for company collections
+func CompanyIndexes() []Index {
+	return []Index{
+		*CreateUniqueIndex("_id_", bson.D{{Key: "_id", Value: 1}}),
+		*CreateUniqueIndex("name_idx", bson.D{{Key: "name", Value: 1}}),
+		*NewIndex("created_at_idx", bson.D{{Key: "created_at", Value: -1}}),
+		*NewIndex("updated_at_idx", bson.D{{Key: "updated_at", Value: -1}}),
+		*NewIndex("is_active_idx", bson.D{{Key: "is_active", Value: 1}}),
+	}
+}
+
+// QueryBuilder provides a fluent interface for building MongoDB queries
+type QueryBuilder struct {
+	filter bson.M
+}
+
+// NewQueryBuilder creates a new query builder
+func NewQueryBuilder() *QueryBuilder {
+	return &QueryBuilder{
+		filter: bson.M{},
+	}
+}
+
+// Where adds a simple equality condition
+func (qb *QueryBuilder) Where(field string, value interface{}) *QueryBuilder {
+	qb.filter[field] = value
+	return qb
+}
+
+// WhereIn adds an $in condition
+func (qb *QueryBuilder) WhereIn(field string, values []interface{}) *QueryBuilder {
+	qb.filter[field] = bson.M{"$in": values}
+	return qb
+}
+
+// WhereNotIn adds a $nin condition
+func (qb *QueryBuilder) WhereNotIn(field string, values []interface{}) *QueryBuilder {
+	qb.filter[field] = bson.M{"$nin": values}
+	return qb
+}
+
+// WhereGreaterThan adds a $gt condition
+func (qb *QueryBuilder) WhereGreaterThan(field string, value interface{}) *QueryBuilder {
+	qb.filter[field] = bson.M{"$gt": value}
+	return qb
+}
+
+// WhereGreaterThanOrEqual adds a $gte condition
+func (qb *QueryBuilder) WhereGreaterThanOrEqual(field string, value interface{}) *QueryBuilder {
+	qb.filter[field] = bson.M{"$gte": value}
+	return qb
+}
+
+// WhereLessThan adds a $lt condition
+func (qb *QueryBuilder) WhereLessThan(field string, value interface{}) *QueryBuilder {
+	qb.filter[field] = bson.M{"$lt": value}
+	return qb
+}
+
+// WhereLessThanOrEqual adds a $lte condition
+func (qb *QueryBuilder) WhereLessThanOrEqual(field string, value interface{}) *QueryBuilder {
+	qb.filter[field] = bson.M{"$lte": value}
+	return qb
+}
+
+// WhereNotEqual adds a $ne condition
+func (qb *QueryBuilder) WhereNotEqual(field string, value interface{}) *QueryBuilder {
+	qb.filter[field] = bson.M{"$ne": value}
+	return qb
+}
+
+// WhereExists adds an $exists condition
+func (qb *QueryBuilder) WhereExists(field string, exists bool) *QueryBuilder {
+	qb.filter[field] = bson.M{"$exists": exists}
+	return qb
+}
+
+// WhereRegex adds a $regex condition
+func (qb *QueryBuilder) WhereRegex(field string, pattern string, options string) *QueryBuilder {
+	qb.filter[field] = bson.M{"$regex": pattern, "$options": options}
+	return qb
+}
+
+// WhereText adds a $text condition
+func (qb *QueryBuilder) WhereText(search string) *QueryBuilder {
+	qb.filter["$text"] = bson.M{"$search": search}
+	return qb
+}
+
+// WhereAnd adds an $and condition
+func (qb *QueryBuilder) WhereAnd(conditions ...bson.M) *QueryBuilder {
+	qb.filter["$and"] = conditions
+	return qb
+}
+
+// WhereOr adds an $or condition
+func (qb *QueryBuilder) WhereOr(conditions ...bson.M) *QueryBuilder {
+	qb.filter["$or"] = conditions
+	return qb
+}
+
+// WhereNor adds a $nor condition
+func (qb *QueryBuilder) WhereNor(conditions ...bson.M) *QueryBuilder {
+	qb.filter["$nor"] = conditions
+	return qb
+}
+
+// Build returns the final filter
+func (qb *QueryBuilder) Build() bson.M {
+	return qb.filter
+}
+
+// PaginationBuilder provides a fluent interface for building pagination options
+type PaginationBuilder struct {
+	pagination Pagination
+}
+
+// NewPaginationBuilder creates a new pagination builder
+func NewPaginationBuilder() *PaginationBuilder {
+	return &PaginationBuilder{
+		pagination: Pagination{
+			Limit:     10,
+			SortField: "_id",
+			SortOrder: -1,
+		},
+	}
+}
+
+// Limit sets the limit
+func (pb *PaginationBuilder) Limit(limit int) *PaginationBuilder {
+	pb.pagination.Limit = limit
+	return pb
+}
+
+// Skip sets the skip value for offset-based pagination
+func (pb *PaginationBuilder) Skip(skip int) *PaginationBuilder {
+	pb.pagination.Skip = skip
+	return pb
+}
+
+// Cursor sets the cursor for cursor-based pagination
+func (pb *PaginationBuilder) Cursor(cursor string) *PaginationBuilder {
+	pb.pagination.Cursor = cursor
+	return pb
+}
+
+// SortBy sets the sort field and order
+func (pb *PaginationBuilder) SortBy(field string, order int) *PaginationBuilder {
+	pb.pagination.SortField = field
+	pb.pagination.SortOrder = order
+	return pb
+}
+
+// SortAsc sorts in ascending order
+func (pb *PaginationBuilder) SortAsc(field string) *PaginationBuilder {
+	return pb.SortBy(field, 1)
+}
+
+// SortDesc sorts in descending order
+func (pb *PaginationBuilder) SortDesc(field string) *PaginationBuilder {
+	return pb.SortBy(field, -1)
+}
+
+// Build returns the final pagination options
+func (pb *PaginationBuilder) Build() Pagination {
+	return pb.pagination
+}