Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

mongo_kit

package module

Go to main page

Versions in this module

v0

v0.2.2

Feb 4, 2026

v0.2.1

Feb 3, 2026

v0.2.0

Feb 2, 2026

Changes in this version

type Config

+ ClientOptions *options.ClientOptions

+ Database string

+ MaxPoolSize uint64

+ Timeout time.Duration

+ URI string

+ type ConfigError struct

+ Field string

+ Message string

+ func (e *ConfigError) Error() string

+ type ConnectionError struct

+ Cause error

+ func (e *ConnectionError) Error() string

+ func (e *ConnectionError) Unwrap() error

+ type OperationError struct

+ Cause error

+ Op string

+ func (e *OperationError) Error() string

+ func (e *OperationError) Unwrap() error

type Option

+ func WithClientOptions(opts *options.ClientOptions) Option

type QueryBuilder

+ func (qb *QueryBuilder) AndConditions(builders ...*QueryBuilder) *QueryBuilder

+ func (qb *QueryBuilder) GetFilter() bson.D

+ func (qb *QueryBuilder) NorConditions(builders ...*QueryBuilder) *QueryBuilder

+ func (qb *QueryBuilder) OrConditions(builders ...*QueryBuilder) *QueryBuilder

+ func (qb *QueryBuilder) Where(expression any) *QueryBuilder

+ type Repository struct

+ func NewRepository[T any](client *client, collection string) *Repository[T]

+ func (r *Repository[T]) Aggregate(ctx context.Context, pipeline any, opts ...*options.AggregateOptions) ([]T, error)

+ func (r *Repository[T]) Collection() string

+ func (r *Repository[T]) Count(ctx context.Context, filter any, opts ...*options.CountOptions) (int64, error)

+ func (r *Repository[T]) CountAll(ctx context.Context, opts ...*options.CountOptions) (int64, error)

+ func (r *Repository[T]) CountWithBuilder(ctx context.Context, qb *QueryBuilder) (int64, error)

+ func (r *Repository[T]) Create(ctx context.Context, document T) (any, error)

+ func (r *Repository[T]) CreateMany(ctx context.Context, documents []T) ([]any, error)

+ func (r *Repository[T]) DeleteByID(ctx context.Context, id any) (*mongo.DeleteResult, error)

+ func (r *Repository[T]) DeleteMany(ctx context.Context, filter any) (*mongo.DeleteResult, error)

+ func (r *Repository[T]) DeleteOne(ctx context.Context, filter any) (*mongo.DeleteResult, error)

+ func (r *Repository[T]) Drop(ctx context.Context) error

+ func (r *Repository[T]) EstimatedCount(ctx context.Context, opts ...*options.EstimatedDocumentCountOptions) (int64, error)

+ func (r *Repository[T]) Exists(ctx context.Context, filter any) (bool, error)

+ func (r *Repository[T]) ExistsByID(ctx context.Context, id any) (bool, error)

+ func (r *Repository[T]) ExistsWithBuilder(ctx context.Context, qb *QueryBuilder) (bool, error)

+ func (r *Repository[T]) Find(ctx context.Context, filter any, opts ...*options.FindOptions) ([]T, error)

+ func (r *Repository[T]) FindAll(ctx context.Context, opts ...*options.FindOptions) ([]T, error)

+ func (r *Repository[T]) FindByID(ctx context.Context, id any) (*T, error)

+ func (r *Repository[T]) FindOne(ctx context.Context, filter any, opts ...*options.FindOneOptions) (*T, error)

+ func (r *Repository[T]) FindOneWithBuilder(ctx context.Context, qb *QueryBuilder) (*T, error)

+ func (r *Repository[T]) FindWithBuilder(ctx context.Context, qb *QueryBuilder) ([]T, error)

+ func (r *Repository[T]) UpdateByID(ctx context.Context, id any, update any, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)

+ func (r *Repository[T]) UpdateMany(ctx context.Context, filter any, update any, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)

+ func (r *Repository[T]) UpdateOne(ctx context.Context, filter any, update any, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error)

+ func (r *Repository[T]) Upsert(ctx context.Context, filter any, update any) (*mongo.UpdateResult, error)

v0.1.0

Dec 1, 2025

v0.0.1

Dec 1, 2025

Changes in this version

+ var Aggregate = options.Aggregate

+ var BSONToMap = helpers.BSONToMap

+ var BulkWrite = options.BulkWrite

+ var Count = options.Count

+ var CreateCollection = options.CreateCollection

+ var DefaultConfig = models.DefaultConfig

+ var Delete = options.Delete

+ var Distinct = options.Distinct

+ var ErrClientClosed = errors.ErrClientClosed

+ var ErrClientDisconnected = mongo.ErrClientDisconnected

+ var ErrCollectionNotFound = errors.ErrCollectionNotFound

+ var ErrConnectionFailed = errors.ErrConnectionFailed

+ var ErrDatabaseNotFound = errors.ErrDatabaseNotFound

+ var ErrEmptySlice = mongo.ErrEmptySlice

+ var ErrInvalidConfig = errors.ErrInvalidConfig

+ var ErrInvalidIndexValue = mongo.ErrInvalidIndexValue

+ var ErrInvalidObjectID = primitive.ErrInvalidHex

+ var ErrInvalidOperation = errors.ErrInvalidOperation

+ var ErrNilDocument = mongo.ErrNilDocument

+ var ErrNilValue = mongo.ErrNilValue

+ var ErrNoDocuments = mongo.ErrNoDocuments

+ var ErrUnacknowledgedWrite = mongo.ErrUnacknowledgedWrite

+ var Find = options.Find

+ var FindOne = options.FindOne

+ var FindOneAndDelete = options.FindOneAndDelete

+ var FindOneAndReplace = options.FindOneAndReplace

+ var FindOneAndUpdate = options.FindOneAndUpdate

+ var Index = options.Index

+ var InsertMany = options.InsertMany

+ var InsertOne = options.InsertOne

+ var IsDuplicateKeyError = mongo.IsDuplicateKeyError

+ var IsNetworkError = mongo.IsNetworkError

+ var IsTimeout = mongo.IsTimeout

+ var IsValidObjectID = helpers.IsValidObjectID

+ var MergeBSON = helpers.MergeBSON

+ var NewObjectID = helpers.NewObjectID

+ var NewOperationError = errors.NewOperationError

+ var Replace = options.Replace

+ var ToBSON = helpers.ToBSON

+ var ToBSONArray = helpers.ToBSONArray

+ var ToObjectID = helpers.ToObjectID

+ var ToObjectIDs = helpers.ToObjectIDs

+ var Update = options.Update

+ var WithAppName = models.WithAppName

+ var WithConnectTimeout = models.WithConnectTimeout

+ var WithDatabase = models.WithDatabase

+ var WithDebug = models.WithDebug

+ var WithDirectConnection = models.WithDirectConnection

+ var WithHeartbeatInterval = models.WithHeartbeatInterval

+ var WithMaxConnIdleTime = models.WithMaxConnIdleTime

+ var WithMaxPoolSize = models.WithMaxPoolSize

+ var WithMinPoolSize = models.WithMinPoolSize

+ var WithReadPreference = models.WithReadPreference

+ var WithReplicaSet = models.WithReplicaSet

+ var WithRetryReads = models.WithRetryReads

+ var WithRetryWrites = models.WithRetryWrites

+ var WithServerSelectionTimeout = models.WithServerSelectionTimeout

+ var WithSocketTimeout = models.WithSocketTimeout

+ var WithTimeout = models.WithTimeout

+ var WithURI = models.WithURI

+ type A = bson.A

+ type AggregateOptions = options.AggregateOptions

+ type AggregationBuilder struct

+ func NewAggregationBuilder() *AggregationBuilder

+ func (ab *AggregationBuilder) AddStage(stage bson.D) *AggregationBuilder

+ func (ab *AggregationBuilder) Build() []bson.D

+ func (ab *AggregationBuilder) Group(id interface{}, fields bson.M) *AggregationBuilder

+ func (ab *AggregationBuilder) Limit(limit int64) *AggregationBuilder

+ func (ab *AggregationBuilder) Lookup(from, localField, foreignField, as string) *AggregationBuilder

+ func (ab *AggregationBuilder) Match(filter interface{}) *AggregationBuilder

+ func (ab *AggregationBuilder) Project(projection interface{}) *AggregationBuilder

+ func (ab *AggregationBuilder) Skip(skip int64) *AggregationBuilder

+ func (ab *AggregationBuilder) Sort(sort interface{}) *AggregationBuilder

+ func (ab *AggregationBuilder) Unwind(path string) *AggregationBuilder

+ type BulkWriteOptions = options.BulkWriteOptions

+ type Client struct

+ func New(cfg models.Config, opts ...models.Option) (*Client, error)

+ func (c *Client) Aggregate(ctx context.Context, collection string, pipeline any, results any, ...) error

+ func (c *Client) BulkWrite(ctx context.Context, collection string, models []mongo.WriteModel, ...) (*mongo.BulkWriteResult, error)

+ func (c *Client) Close(ctx context.Context) error

+ func (c *Client) CountDocuments(ctx context.Context, collection string, filter any, ...) (int64, error)

+ func (c *Client) CreateCollection(ctx context.Context, collection string, ...) error

+ func (c *Client) CreateCollections(ctx context.Context, collections map[string]*options.CreateCollectionOptions) error

+ func (c *Client) CreateIndex(ctx context.Context, collection string, keys any, ...) (string, error)

+ func (c *Client) CreateIndexes(ctx context.Context, indexes map[string][]mongo.IndexModel) (map[string][]string, error)

+ func (c *Client) DeleteMany(ctx context.Context, collection string, filter any, ...) (*mongo.DeleteResult, error)

+ func (c *Client) DeleteOne(ctx context.Context, collection string, filter any, ...) (*mongo.DeleteResult, error)

+ func (c *Client) Distinct(ctx context.Context, collection string, fieldName string, filter any, ...) ([]any, error)

+ func (c *Client) DropIndex(ctx context.Context, collection string, indexName string) error

+ func (c *Client) Find(ctx context.Context, collection string, filter any, results any, ...) error

+ func (c *Client) FindOne(ctx context.Context, collection string, filter any, result any, ...) error

+ func (c *Client) FindOneAndDelete(ctx context.Context, collection string, filter any, result any, ...) error

+ func (c *Client) FindOneAndReplace(ctx context.Context, collection string, filter any, replacement any, ...) error

+ func (c *Client) FindOneAndUpdate(ctx context.Context, collection string, filter any, update any, result any, ...) error

+ func (c *Client) GetCollection(collectionName string) *mongo.Collection

+ func (c *Client) GetCollectionFrom(databaseName, collectionName string) *mongo.Collection

+ func (c *Client) GetConfig() models.Config

+ func (c *Client) GetDatabase(name string) *mongo.Database

+ func (c *Client) InsertMany(ctx context.Context, collection string, documents []any) (*mongo.InsertManyResult, error)

+ func (c *Client) InsertOne(ctx context.Context, collection string, document any) (*mongo.InsertOneResult, error)

+ func (c *Client) IsClosed() bool

+ func (c *Client) IsConnected(ctx context.Context) bool

+ func (c *Client) ListCollections(ctx context.Context) ([]string, error)

+ func (c *Client) ListDatabases(ctx context.Context, filter interface{}) ([]string, error)

+ func (c *Client) ListIndexes(ctx context.Context, collection string) ([]bson.M, error)

+ func (c *Client) Ping(ctx context.Context) error

+ func (c *Client) ReplaceOne(ctx context.Context, collection string, filter any, replacement any, ...) (*mongo.UpdateResult, error)

+ func (c *Client) StartSession(opts ...*options.SessionOptions) (mongo.Session, error)

+ func (c *Client) UpdateMany(ctx context.Context, collection string, filter any, update any, ...) (*mongo.UpdateResult, error)

+ func (c *Client) UpdateOne(ctx context.Context, collection string, filter any, update any, ...) (*mongo.UpdateResult, error)

+ func (c *Client) UseSession(ctx context.Context, fn func(mongo.SessionContext) error) error

+ type Config = models.Config

+ type CountOptions = options.CountOptions

+ type CreateCollectionOptions = options.CreateCollectionOptions

+ type D = bson.D

+ type DeleteOptions = options.DeleteOptions

+ type DistinctOptions = options.DistinctOptions

+ type E = bson.E

+ type FindOneAndDeleteOptions = options.FindOneAndDeleteOptions

+ type FindOneAndReplaceOptions = options.FindOneAndReplaceOptions

+ type FindOneAndUpdateOptions = options.FindOneAndUpdateOptions

+ type FindOneOptions = options.FindOneOptions

+ type FindOptions = options.FindOptions

+ type IndexModel = mongo.IndexModel

+ type IndexOptions = options.IndexOptions

+ type InsertManyOptions = options.InsertManyOptions

+ type InsertOneOptions = options.InsertOneOptions

+ type M = bson.M

+ type ObjectID = primitive.ObjectID

+ type Option = models.Option

+ type QueryBuilder struct

+ func NewQueryBuilder() *QueryBuilder

+ func (qb *QueryBuilder) And(conditions ...bson.D) *QueryBuilder

+ func (qb *QueryBuilder) Build() (bson.D, *options.FindOptions)

+ func (qb *QueryBuilder) BuildFilter() bson.D

+ func (qb *QueryBuilder) BuildOptions() *options.FindOptions

+ func (qb *QueryBuilder) Equals(key string, value interface{}) *QueryBuilder

+ func (qb *QueryBuilder) Exists(key string, exists bool) *QueryBuilder

+ func (qb *QueryBuilder) Filter(key string, value interface{}) *QueryBuilder

+ func (qb *QueryBuilder) GreaterThan(key string, value interface{}) *QueryBuilder

+ func (qb *QueryBuilder) GreaterThanOrEqual(key string, value interface{}) *QueryBuilder

+ func (qb *QueryBuilder) In(key string, values ...interface{}) *QueryBuilder

+ func (qb *QueryBuilder) LessThan(key string, value interface{}) *QueryBuilder

+ func (qb *QueryBuilder) LessThanOrEqual(key string, value interface{}) *QueryBuilder

+ func (qb *QueryBuilder) Limit(limit int64) *QueryBuilder

+ func (qb *QueryBuilder) Nor(conditions ...bson.D) *QueryBuilder

+ func (qb *QueryBuilder) NotEquals(key string, value interface{}) *QueryBuilder

+ func (qb *QueryBuilder) NotIn(key string, values ...interface{}) *QueryBuilder

+ func (qb *QueryBuilder) Or(conditions ...bson.D) *QueryBuilder

+ func (qb *QueryBuilder) Project(projection interface{}) *QueryBuilder

+ func (qb *QueryBuilder) Regex(key string, pattern string, options string) *QueryBuilder

+ func (qb *QueryBuilder) Skip(skip int64) *QueryBuilder

+ func (qb *QueryBuilder) Sort(field string, ascending bool) *QueryBuilder

+ func (qb *QueryBuilder) SortBy(sort interface{}) *QueryBuilder

+ type ReplaceOptions = options.ReplaceOptions

+ type UpdateBuilder struct

+ func NewUpdateBuilder() *UpdateBuilder

+ func (ub *UpdateBuilder) AddToSet(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Build() bson.D

+ func (ub *UpdateBuilder) CurrentDate(key string) *UpdateBuilder

+ func (ub *UpdateBuilder) Inc(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Max(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Min(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Mul(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Pop(key string, first bool) *UpdateBuilder

+ func (ub *UpdateBuilder) Pull(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Push(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Rename(oldName string, newName string) *UpdateBuilder

+ func (ub *UpdateBuilder) Set(key string, value interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) SetMultiple(fields map[string]interface{}) *UpdateBuilder

+ func (ub *UpdateBuilder) Unset(keys ...string) *UpdateBuilder

+ type UpdateOptions = options.UpdateOptions

+ type WriteModel = mongo.WriteModel