mgo

README

Package mgo

The mgo package provides a MongoDB client for Go applications.

Usage

Import the mgo package into your Go file:

import "github.com/thirathawat/mgo"

Configuration

The mgo package reads its configuration from environment variables. Here are the supported environment variables:

• ADDRS: A comma-separated list of host:port addresses for the MongoDB servers.
• NAME: The name of the MongoDB database.
• AUTH_SOURCE: The name of the MongoDB authentication database.
• USER: The name of the MongoDB user.
• PASSWORD: The password for the MongoDB user.

You can use the readConfig function to read the configuration from the environment. It returns a config struct that holds the configuration values.

Creating a MongoDB Client

To create a new MongoDB client and establish a connection, use the New function:

db, cleanup, err := mgo.New()
if err != nil {
    // handle error
}
defer cleanup()

The New function returns a mongo.Database object that represents the MongoDB database. It also returns a cleanup function that should be deferred to close the connection when you're done with the database.

Database Operations

Once you have a mongo.Database object, you can perform various operations on the database, such as inserting, updating, and querying documents. Refer to the MongoDB Go Driver documentation for more information on working with the MongoDB database.

Example

Here's an example of how to use the mgo package:

package main

import (
    "github.com/tirathawat/mgo"
)

func main() {
    db, cleanup, err := mgo.New()
    if err != nil {
        // handle error
    }
    defer cleanup()

    // Perform database operations...
}

Conclusion

The mgo package provides a convenient way to connect to a MongoDB database and perform database operations in your Go applications. It simplifies the process of configuring the client and establishing a connection, allowing you to focus on building your application's functionality.

Documentation

Overview

Package mgo provides a MongoDB client.

Index

• func New() (db *mongo.Database, cleanup func(), err error)
• type Collecter
  • func NewCollection[T entiter](c *mongo.Collection) Collecter[T]
• type Entity
• type Option
• type SetOption

Functions

func New

func New() (db *mongo.Database, cleanup func(), err error)

New creates a new MongoDB client and establishes a connection.

Types

type Collecter

type Collecter[T any] interface {
	// InsertOne insert one document.
	InsertOne(ctx context.Context, model T) error

	// InsertMany insert many documents.
	InsertMany(ctx context.Context, models []T) error

	// FindOne find one document.
	FindOne(ctx context.Context, options ...SetOption) (*T, error)

	// FindMany find many documents.
	FindMany(ctx context.Context, options ...SetOption) ([]T, error)

	// UpdateOne update one document.
	UpdateOne(ctx context.Context, options ...SetOption) error

	// UpdateMany update many documents.
	UpdateMany(ctx context.Context, options ...SetOption) error

	// DeleteOne delete one document.
	DeleteOne(ctx context.Context, options ...SetOption) error

	// DeleteMany delete many documents.
	DeleteMany(ctx context.Context, options ...SetOption) error

	// SoftDeleteOne soft delete one document by setting deleted_at.
	SoftDeleteOne(ctx context.Context, options ...SetOption) error

	// SoftDeleteMany soft delete many documents by setting deleted_at.
	SoftDeleteMany(ctx context.Context, options ...SetOption) error

	// Count count documents.
	Count(ctx context.Context, options ...SetOption) (int64, error)

	// Aggregate aggregate documents.
	Aggregate(ctx context.Context, options ...SetOption) ([]T, error)
}

Collecter is a interface for mongo collection.

func NewCollection

func NewCollection[T entiter](c *mongo.Collection) Collecter[T]

NewCollection is a function to create a new collection.

type Entity

type Entity struct {
	// ID is a id of entity.
	ID primitive.ObjectID `bson:"_id"`

	// CreatedAt is a time when entity is created.
	CreatedAt time.Time `bson:"created_at"`

	// UpdatedAt is a time when entity is updated.
	UpdatedAt time.Time `bson:"update_at"`

	// DeletedAt is a time when entity is deleted.
	// If entity is not deleted, DeletedAt is nil.
	DeletedAt *time.Time `bson:"deleted_at"`
}

Entity is a base entity.

type Option

type Option struct {
	// Filter is a filter to find.
	Filter bson.M

	// Update is a update to update.
	Update bson.M

	// Sort is a sort to sort.
	Sort bson.M

	// Projection is a projection to projection.
	Projection bson.M

	// Pipeline is a pipeline to aggregate.
	Pipeline []bson.M

	// Skip is a skip to skip.
	Skip *int64

	// Limit is a limit to limit.
	Limit *int64
}

Filter is a function to set filter.

type SetOption

type SetOption func(*Option)

SetOption is a function to set option.