@sarmorttech/sar-db 1.0.0

package/README.md

@@ -0,0 +1,174 @@
+# nest-mongodb
+
+## Description
+
+This is a MongoDB module for [NestJS](https://nestjs.com/), making it easy to inject the [MongoDB driver](https://www.npmjs.com/package/mongodb) into your project.  It's modeled after the official [Mongoose module](https://github.com/nestjs/mongoose), allowing for asynchronous configuration and such.
+
+## Installation
+
+In your existing NestJS-based project:
+
+```
+$ npm install nest-mongodb mongodb
+```
+
+## Usage
+
+Overall, it works very similarly to the [Mongoose](https://docs.nestjs.com/techniques/mongodb) module described in the NestJS documentation, though without any notion of models.  You may want to refer to those docs as well -- and maybe the [dependency injection](https://docs.nestjs.com/fundamentals/custom-providers) docs too if you're still trying to wrap your head around the NestJS implementation of it.
+
+### Simple example
+
+In the simplest case, you can explicitly specify the database URI, name, and options you'd normally provide to your `MongoClient` using `MongoModule.forRoot()`:
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MongoModule } from 'nest-mongodb'
+
+@Module({
+    imports: [MongoModule.forRoot('mongodb://localhost', 'BestAppEver')]
+})
+export class CatsModule {}
+```
+
+To inject the Mongo `Db` object:
+
+```typescript
+import * as mongo from 'mongodb'
+import { Injectable } from '@nestjs/common'
+import { InjectDb } from 'nest-mongodb'
+import { Cat } from './interfaces/cat'
+
+@Injectable()
+export class CatsRepository {
+    private readonly collection: mongo.Collection
+
+    constructor(@InjectDb() private readonly db: mongo.Db) {
+        this.collection = this.db.collection('cats')
+    }
+
+    async create(cat: Cat) {
+        const result = await this.collection.insertOne(cat)
+
+        if (result.insertedCount !== 1 || result.ops.length < 1) {
+            throw new Error('Insert failed!')
+        }
+
+        return result.ops[0]
+    }
+}
+```
+
+To inject a collection object:
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MongoModule } from 'nest-mongodb'
+import { CatsController } from './cats.controller'
+import { CatsService } from './cats.service'
+
+@Module({
+  imports: [MongoModule.forFeature(['cats'])],
+  controllers: [CatsController],
+  providers: [CatsService],
+})
+export class CatsModule {}
+```
+
+```typescript
+import * as mongo from 'mongodb'
+import { Injectable } from '@nestjs/common'
+import { InjectCollection } from 'nest-mongodb'
+import { Cat } from './interfaces/cat'
+
+@Injectable()
+export class CatsRepository {
+    constructor(@InjectCollection('cats') private readonly catsCollection: mongo.Collection) {}
+
+    async create(cat: Cat) {
+        const result = await this.catsCollection.insertOne(cat)
+
+        if (result.insertedCount !== 1 || result.ops.length < 1) {
+            throw new Error('Insert failed!')
+        }
+
+        return result.ops[0]
+    }
+}
+```
+
+### Asynchronous configuration
+
+If you want to pass in Mongo configuration options from a ConfigService or other provider, you'll need to perform the Mongo module configuration asynchronously, using `MongoModule.forRootAsync()`.  There are several different ways of doing this.
+
+#### Use a factory function
+
+The first is to specify a factory function that populates the options:
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MongoModule } from 'nest-mongodb'
+import { ConfigService } from '../config/config.service'
+
+@Module({
+    imports: [MongoModule.forRootAsync({
+        imports: [ConfigModule],
+        useFactory: (config: ConfigService) => {
+            uri: config.mongoUri,
+            dbName: config.mongoDatabase
+        },
+        inject: [ConfigService]
+    })]
+})
+export class CatsModule {}
+```
+
+#### Use a class
+
+Alternatively, you can write a class that implements the `MongoOptionsFactory` interface and use that to create the options:
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MongoModule, MongoOptionsFactory, MongoModuleOptions } from 'nest-mongodb'
+
+@Injectable()
+export class MongoConfigService implements MongoOptionsFactory {
+    private readonly uri = 'mongodb://localhost'
+    private readonly dbName = 'BestAppEver'
+
+    createMongoOptions(): MongoModuleOptions {
+        return {
+            uri: this.uri,
+            dbName: this.dbName
+        }
+    }
+}
+
+@Module({
+    imports: [MongoModule.forRootAsync({
+        useClass: MongoConfigService
+    })]
+})
+export class CatsModule {}
+```
+
+Just be aware that the `useClass` option will instantiate your class inside the MongoModule, which may not be what you want.
+
+#### Use existing
+
+If you wish to instead import your MongoConfigService class from a different module, the `useExisting` option will allow you to do that.
+
+```typescript
+import { Module } from '@nestjs/common'
+import { MongoModule } from 'nest-mongodb'
+import { ConfigModule, ConfigService } from '../config/config.service'
+
+@Module({
+    imports: [MongoModule.forRootAsync({
+        imports: [ConfigModule]
+        useExisting: ConfigService
+    })]
+})
+export class CatsModule {}
+```
+
+In this example, we're assuming that `ConfigService` implements the `MongoOptionsFactory` interface and can be found in the ConfigModule.

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mongo.decorators';
+export * from './mongo.module';
+export * from './mongo.util';
+export * from './interfaces';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mongo.decorators"), exports);
+__exportStar(require("./mongo.module"), exports);
+__exportStar(require("./mongo.util"), exports);
+__exportStar(require("./interfaces"), exports);

package/lib/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './mongo-options.interface';

package/lib/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mongo-options.interface"), exports);

package/lib/interfaces/mongo-options.interface.d.ts

@@ -0,0 +1,36 @@
+import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
+/**
+ * Options that ultimately need to be provided to create a MongoDB connection
+ */
+export interface MongoModuleOptions {
+    connectionName?: string;
+    uri: string;
+    dbName: string;
+    clientOptions?: any;
+}
+export interface MongoOptionsFactory {
+    createMongoOptions(): Promise<MongoModuleOptions> | MongoModuleOptions;
+}
+/**
+ * Options available when creating the module asynchrously.  You should use only one of the
+ * useExisting, useClass, or useFactory options for creation.
+ */
+export interface MongoModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /** A unique name for the connection.  If not specified, a default one will be used. */
+    connectionName?: string;
+    /** Reuse an injectable factory class created in another module. */
+    useExisting?: Type<MongoOptionsFactory>;
+    /**
+     * Use an injectable factory class to populate the module options, such as URI and database name.
+     */
+    useClass?: Type<MongoOptionsFactory>;
+    /**
+     * A factory function that will populate the module options, such as URI and database name.
+     */
+    useFactory?: (...args: any[]) => Promise<MongoModuleOptions> | MongoModuleOptions;
+    /**
+     * Inject any dependencies required by the Mongo module, such as a configuration service
+     * that supplies the URI and database name
+     */
+    inject?: any[];
+}

package/lib/interfaces/mongo-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/mongo-core.module.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule, OnApplicationShutdown } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { MongoModuleAsyncOptions } from './interfaces/mongo-options.interface';
+export declare class MongoCoreModule implements OnApplicationShutdown {
+    private readonly connectionName;
+    private readonly moduleRef;
+    constructor(connectionName: string, moduleRef: ModuleRef);
+    static forRoot(uri: string, dbName: string, clientOptions?: any, connectionName?: string): DynamicModule;
+    static forRootAsync(options: MongoModuleAsyncOptions): DynamicModule;
+    onApplicationShutdown(): Promise<void>;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/lib/mongo-core.module.js

@@ -0,0 +1,146 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var MongoCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoCoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const mongodb_1 = require("mongodb");
+const mongo_constants_1 = require("./mongo.constants");
+const mongo_util_1 = require("./mongo.util");
+let MongoCoreModule = MongoCoreModule_1 = class MongoCoreModule {
+    constructor(connectionName, moduleRef) {
+        this.connectionName = connectionName;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(uri, dbName, clientOptions, connectionName) {
+        const connectionNameProvider = {
+            provide: mongo_constants_1.MONGO_CONNECTION_NAME,
+            useValue: connectionName !== null && connectionName !== void 0 ? connectionName : mongo_constants_1.DEFAULT_MONGO_CONNECTION_NAME
+        };
+        const clientProvider = {
+            provide: (0, mongo_util_1.getClientToken)(connectionName),
+            useFactory: () => __awaiter(this, void 0, void 0, function* () {
+                const client = new mongodb_1.MongoClient(uri, clientOptions);
+                return yield client.connect();
+            })
+        };
+        const dbProvider = {
+            provide: (0, mongo_util_1.getDbToken)(connectionName),
+            useFactory: (client) => client.db(dbName),
+            inject: [(0, mongo_util_1.getClientToken)(connectionName)]
+        };
+        return {
+            module: MongoCoreModule_1,
+            providers: [connectionNameProvider, clientProvider, dbProvider],
+            exports: [clientProvider, dbProvider]
+        };
+    }
+    static forRootAsync(options) {
+        var _a;
+        const mongoConnectionName = (_a = options.connectionName) !== null && _a !== void 0 ? _a : mongo_constants_1.DEFAULT_MONGO_CONNECTION_NAME;
+        const connectionNameProvider = {
+            provide: mongo_constants_1.MONGO_CONNECTION_NAME,
+            useValue: mongoConnectionName
+        };
+        const clientProvider = {
+            provide: (0, mongo_util_1.getClientToken)(mongoConnectionName),
+            useFactory: (mongoModuleOptions) => __awaiter(this, void 0, void 0, function* () {
+                const { uri, clientOptions } = mongoModuleOptions;
+                const client = new mongodb_1.MongoClient(uri, clientOptions);
+                return yield client.connect();
+            }),
+            inject: [mongo_constants_1.MONGO_MODULE_OPTIONS]
+        };
+        const dbProvider = {
+            provide: (0, mongo_util_1.getDbToken)(mongoConnectionName),
+            useFactory: (mongoModuleOptions, client) => client.db(mongoModuleOptions.dbName),
+            inject: [mongo_constants_1.MONGO_MODULE_OPTIONS, (0, mongo_util_1.getClientToken)(mongoConnectionName)]
+        };
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: MongoCoreModule_1,
+            imports: options.imports,
+            providers: [...asyncProviders, clientProvider, dbProvider, connectionNameProvider],
+            exports: [clientProvider, dbProvider]
+        };
+    }
+    onApplicationShutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.moduleRef.get((0, mongo_util_1.getClientToken)(this.connectionName));
+            if (client)
+                yield client.close();
+        });
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        else if (options.useClass) {
+            return [
+                this.createAsyncOptionsProvider(options),
+                {
+                    provide: options.useClass,
+                    useClass: options.useClass
+                }
+            ];
+        }
+        else {
+            return [];
+        }
+    }
+    static createAsyncOptionsProvider(options) {
+        var _a;
+        if (options.useFactory) {
+            return {
+                provide: mongo_constants_1.MONGO_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: (_a = options.inject) !== null && _a !== void 0 ? _a : []
+            };
+        }
+        else if (options.useExisting) {
+            return {
+                provide: mongo_constants_1.MONGO_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return yield optionsFactory.createMongoOptions(); }),
+                inject: [options.useExisting]
+            };
+        }
+        else if (options.useClass) {
+            return {
+                provide: mongo_constants_1.MONGO_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return yield optionsFactory.createMongoOptions(); }),
+                inject: [options.useClass]
+            };
+        }
+        else {
+            throw new Error('Invalid MongoModule options');
+        }
+    }
+};
+exports.MongoCoreModule = MongoCoreModule;
+exports.MongoCoreModule = MongoCoreModule = MongoCoreModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(mongo_constants_1.MONGO_CONNECTION_NAME)),
+    __metadata("design:paramtypes", [String, core_1.ModuleRef])
+], MongoCoreModule);

package/lib/mongo.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MONGO_CONNECTION_NAME = "MongoConnectionName";
+export declare const MONGO_MODULE_OPTIONS = "MongoModuleOptions";
+export declare const DEFAULT_MONGO_CONNECTION_NAME = "DefaultMongo";

package/lib/mongo.constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MONGO_CONNECTION_NAME = exports.MONGO_MODULE_OPTIONS = exports.MONGO_CONNECTION_NAME = void 0;
+exports.MONGO_CONNECTION_NAME = 'MongoConnectionName';
+exports.MONGO_MODULE_OPTIONS = 'MongoModuleOptions';
+exports.DEFAULT_MONGO_CONNECTION_NAME = 'DefaultMongo';

package/lib/mongo.decorators.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Inject the MongoClient object associated with a connection
+ * @param connectionName The unique name associated with the connection
+ */
+export declare const InjectClient: (connectionName?: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Inject the Mongo Db object associated with a connection
+ * @param connectionName The unique name associated with the connection
+ */
+export declare const InjectDb: (connectionName?: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Inject the Mongo Collection object associated with a Db
+ * @param collectionName The unique name associated with the collection
+ */
+export declare const InjectCollection: (collectionName: string) => PropertyDecorator & ParameterDecorator;

package/lib/mongo.decorators.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectCollection = exports.InjectDb = exports.InjectClient = void 0;
+const common_1 = require("@nestjs/common");
+const mongo_util_1 = require("./mongo.util");
+/**
+ * Inject the MongoClient object associated with a connection
+ * @param connectionName The unique name associated with the connection
+ */
+const InjectClient = (connectionName) => (0, common_1.Inject)((0, mongo_util_1.getClientToken)(connectionName));
+exports.InjectClient = InjectClient;
+/**
+ * Inject the Mongo Db object associated with a connection
+ * @param connectionName The unique name associated with the connection
+ */
+const InjectDb = (connectionName) => (0, common_1.Inject)((0, mongo_util_1.getDbToken)(connectionName));
+exports.InjectDb = InjectDb;
+/**
+ * Inject the Mongo Collection object associated with a Db
+ * @param collectionName The unique name associated with the collection
+ */
+const InjectCollection = (collectionName) => (0, common_1.Inject)((0, mongo_util_1.getCollectionToken)(collectionName));
+exports.InjectCollection = InjectCollection;

package/lib/mongo.module.d.ts

@@ -0,0 +1,29 @@
+import { DynamicModule } from '@nestjs/common';
+import { MongoModuleAsyncOptions } from './interfaces/mongo-options.interface';
+/**
+ * Module for the MongoDB driver
+ */
+export declare class MongoModule {
+    /**
+     * Inject the MongoDB driver synchronously.
+     * @param uri The database URI
+     * @param dbName The database name
+     * @param options Options for the MongoClient that will be created
+     * @param connectionName A unique name for the connection.  If not specified, a default name
+     * will be used.
+     */
+    static forRoot(uri: string, dbName: string, options?: any, connectionName?: string): DynamicModule;
+    /**
+     * Inject the MongoDB driver asynchronously, allowing any dependencies such as a configuration
+     * service to be injected first.
+     * @param options Options for asynchrous injection
+     */
+    static forRootAsync(options: MongoModuleAsyncOptions): DynamicModule;
+    /**
+     * Inject collections.
+     * @param collections An array of the names of the collections to be injected.
+     * @param connectionName A unique name for the connection. If not specified, a default name
+     * will be used.
+     */
+    static forFeature(collections?: string[], connectionName?: string): DynamicModule;
+}

package/lib/mongo.module.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MongoModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoModule = void 0;
+const common_1 = require("@nestjs/common");
+const mongo_providers_1 = require("./mongo.providers");
+const mongo_core_module_1 = require("./mongo-core.module");
+/**
+ * Module for the MongoDB driver
+ */
+let MongoModule = MongoModule_1 = class MongoModule {
+    /**
+     * Inject the MongoDB driver synchronously.
+     * @param uri The database URI
+     * @param dbName The database name
+     * @param options Options for the MongoClient that will be created
+     * @param connectionName A unique name for the connection.  If not specified, a default name
+     * will be used.
+     */
+    static forRoot(uri, dbName, options, connectionName) {
+        return {
+            module: MongoModule_1,
+            imports: [mongo_core_module_1.MongoCoreModule.forRoot(uri, dbName, options, connectionName)]
+        };
+    }
+    /**
+     * Inject the MongoDB driver asynchronously, allowing any dependencies such as a configuration
+     * service to be injected first.
+     * @param options Options for asynchrous injection
+     */
+    static forRootAsync(options) {
+        return {
+            module: MongoModule_1,
+            imports: [mongo_core_module_1.MongoCoreModule.forRootAsync(options)]
+        };
+    }
+    /**
+     * Inject collections.
+     * @param collections An array of the names of the collections to be injected.
+     * @param connectionName A unique name for the connection. If not specified, a default name
+     * will be used.
+     */
+    static forFeature(collections = [], connectionName) {
+        const providers = (0, mongo_providers_1.createMongoProviders)(connectionName, collections);
+        return {
+            module: MongoModule_1,
+            providers: providers,
+            exports: providers
+        };
+    }
+};
+exports.MongoModule = MongoModule;
+exports.MongoModule = MongoModule = MongoModule_1 = __decorate([
+    (0, common_1.Module)({})
+], MongoModule);

package/lib/mongo.providers.d.ts

@@ -0,0 +1,6 @@
+import { Db } from 'mongodb';
+export declare function createMongoProviders(connectionName?: string, collections?: string[]): {
+    provide: string;
+    useFactory: (db: Db) => import("mongodb").Collection<import("bson").Document>;
+    inject: string[];
+}[];

package/lib/mongo.providers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongoProviders = createMongoProviders;
+const mongo_util_1 = require("./mongo.util");
+function createMongoProviders(connectionName, collections = []) {
+    return collections.map(collectionName => ({
+        provide: (0, mongo_util_1.getCollectionToken)(collectionName),
+        useFactory: (db) => db.collection(collectionName),
+        inject: [(0, mongo_util_1.getDbToken)(connectionName)]
+    }));
+}

package/lib/mongo.util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Get a token for the MongoClient object for the given connection name
+ * @param connectionName The unique name for the connection
+ */
+export declare function getClientToken(connectionName?: string): string;
+/**
+ * Get a token for the Mongo Db object for the given connection name
+ * @param connectionName The unique name for the connection
+ */
+export declare function getDbToken(connectionName?: string): string;
+/**
+ * Get a token for the Mongo Db object for the given connection name
+ * @param collectionName The unique name for the collection
+ */
+export declare function getCollectionToken(collectionName: string): string;

package/lib/mongo.util.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientToken = getClientToken;
+exports.getDbToken = getDbToken;
+exports.getCollectionToken = getCollectionToken;
+const mongo_constants_1 = require("./mongo.constants");
+/**
+ * Get a token for the MongoClient object for the given connection name
+ * @param connectionName The unique name for the connection
+ */
+function getClientToken(connectionName = mongo_constants_1.DEFAULT_MONGO_CONNECTION_NAME) {
+    return `${connectionName}Client`;
+}
+/**
+ * Get a token for the Mongo Db object for the given connection name
+ * @param connectionName The unique name for the connection
+ */
+function getDbToken(connectionName = mongo_constants_1.DEFAULT_MONGO_CONNECTION_NAME) {
+    return `${connectionName}Db`;
+}
+/**
+ * Get a token for the Mongo Db object for the given connection name
+ * @param collectionName The unique name for the collection
+ */
+function getCollectionToken(collectionName) {
+    return `${collectionName}Collection`;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@sarmorttech/sar-db",
+    "version": "1.0.0",
+    "description": "A NestJS module for the MongoDB driver",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "scripts": {
+        "build": "npm run build:clean && npm run build:tsc",
+        "build:clean": "rimraf dist",
+        "build:tsc": "tsc",
+        "format:check": "prettier --check \"src/**/*.ts\"",
+        "format:write": "prettier --write \"src/**/*.ts\""
+    },
+    "keywords": [
+        "mongo",
+        "mongodb",
+        "nest",
+        "nestjs"
+    ],
+    "author": "Erik Christensen",
+    "license": "ISC",
+    "devDependencies": {
+        "@nestjs/common": "^11.1.19",
+        "@nestjs/core": "^11.1.19",
+        "@types/node": "^25.6.2",
+        "@types/rimraf": "^4.0.5",
+        "mongodb": "^7.2.0",
+        "prettier": "^3.8.3",
+        "reflect-metadata": "^0.2.2",
+        "rimraf": "^6.1.3",
+        "rxjs": "^7.8.2",
+        "typescript": "^6.0.3"
+    },
+    "peerDependencies": {
+        "@nestjs/common": "^11.1.19",
+        "@nestjs/core": "^11.1.19",
+        "mongodb": "^7.2.0",
+        "reflect-metadata": "^0.2.2",
+        "rxjs": "^7.8.2"
+    }
+}