Package @occupop/lib-mongo

This package is intended to use with @occupop/lib-container being a wrapper for basic MongoDB operations... providing factory for MongoClient, collection getter and repositories.

This implementation refers to https://www.mongodb.com/docs/drivers/node/current/fundamentals/! Check their docs for detailed/advanced usage.

NPM registry token required!

Install

# Yarn
yarn add @occupop/lib-mongo

# NPM
npm install @occupop/lib-mongo

# Bun
bun add @occupop/lib-mongo

Env Setup

ENV variables required and some common values

DB_URI=mongodb://root:secret@localhost
DB_NAME=main

DB_URI=mongodb+srv://AwesomeUsrNme:s&crt^p@[email protected]
DB_NAME=ms-awesome

Register

import {
    makeMongoClient, makeGetMongoCollection
} from '@occupop/lib-mongo'
//... all other imports omited... 

export const container = createTypedContainer({
    // ...
    // Top-level
    mongoClient: { asFunction: makeMongoClient, singleton: true },
    getMongoCollection: { asFunction: makeGetMongoCollection, singleton: true },
    makeBaseRepository: { asValue: makeBaseRepository },
    // Repositories
    fooRepository: { asFunction: makeFooRepository, singleton: true },
    barRepository: { asFunction: makeBarRepository, singleton: true },
    // ...
})

Usage (starting client)

// server.ts
import { container } from '.container'

const { mongoClient } = container.cradle

await mongoClient.connect()
console.log('Mongo connected')

// ...

Usage (repository factory)

// app/foo.ts
export type Foo = {
    uuid: string
    title: string
    age: number
    createdAt: Date
}

// data/foo-repository.ts
import type { Deps } from '.container'
import type { Foo } from './app/foo'

export function makeFooRepository({ getMongoCollection, makeBaseRepository }: Deps) {
    const collection = getMongoCollection<Foo>('foo')
    return makeBaseRepository(collection)
}

Note: passing Foo type/entity to the generic collection getter is optional, but will allow IDE type hint on finds and filters.

Usage (repository usage)

// foo-repository.ts
import type { Deps } from '.container'

export function makeAwesomeService({ fooRepository }: Deps) {
    return {
        async saveSomething(fooUuid: string) {
            const foo = await fooRepository.findOne({uuid: fooUuid})
            // ... do something with `foo`...
            await fooRepository.save(foo)
            return true
        }
    }
}

Repository available methods

interface Repository<Model> {
    // collection getter
    getCollection: () => Collection<Model>

    // finders & aggregate
    find: (filter?: Filter<Model>, options?: FindOptions<Model>) => FindCursor<WithId<Model>>
    findOne: (filter?: Filter<Model>, options?: FindOptions<Model>) => Promise<WithId<Model> | null>
    aggregate: <T extends Document>(pipeline?: Document[], options?: AggregateOptions) => AggregationCursor<T>

    // count & check
    count: (filter?: Filter<Model>) => Promise<number>
    exists: (filter?: Filter<Model>) => Promise<boolean>

    // inserts
    insert: (item: Model) => Promise<boolean>
    insertMany: (items: Model[]) => Promise<number>

    // updates
    update: (filter: Filter<Model>, item: Partial<Model>) => Promise<boolean>
    updateMany: (filter: Filter<Model>, item: Partial<Model>) => Promise<number>
    upsert: (filter: Filter<Model>, item: Partial<Model>) => Promise<{
        modifiedCount: number
        upsertedCount: number
    }>
    
    // deletes
    delete: (filter?: Filter<Model>) => Promise<boolean>
    deleteMany: (filter?: Filter<Model>) => Promise<number>
}

TODO

• createdAt/updatedAt auto fill option
• soft delete option