@xnestjs/mongodb 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# @xnestjs/mongodb
+
+NestJS extension library for MongoDB
+
+## Install
+
+```sh
+npm install @xnestjs/mongodb
+# or using yarn
+yarn add @xnestjs/mongodb
+```
+
+## Usage
+
+### Register sync
+
+An example of nestjs module that import the @xnestjs/mongodb
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { MongoModule } from '@xnestjs/mongodb';
+
+@Module({
+    imports: [
+        MongodbModule.forRoot({
+            useValue: {
+                url: 'https://mydbserver:27017',
+                database: 'test',
+            },
+        }),
+    ],
+})
+export class MyModule {
+}
+```
+
+### Register async
+
+An example of nestjs module that import the @xnestjs/mongodb async
+
+```ts
+// module.ts
+import { Module } from '@nestjs/common';
+import { MongoModule } from '@xnestjs/mongodb';
+
+@Module({
+    imports: [
+        MongodbModule.forRootAsync({
+            inject: [ConfigModule],
+            useFactory: (config: ConfigService) => ({
+                url: config.get('MONGODB_URL'),
+                database: config.get('MONGODB_DATABASE'),
+            }),
+        }),
+    ]
+})
+export class MyModule {
+}
+```
+
+## Environment Variables
+
+The library supports configuration through environment variables. Environment variables below is accepted.
+All environment variables starts with prefix (MONGODB_). This can be configured while registering the module.
+
+| Environment Variable                   | Type    | Default                   | Description                                                                                                                                                                                                                            |
+|----------------------------------------|---------|---------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| MONGODB_URL                            | String  | mongodb://localhost:27017 | URL to MongoDB server                                                                                                                                                                                                                  |
+| MONGODB_USERNAME                       | String  |                           | The username for auth                                                                                                                                                                                                                  |
+| MONGODB_PASSWORD                       | String  |                           | The password for auth                                                                                                                                                                                                                  |
+| MONGODB_AUTH_SOURCE                    | String  |                           | Specify the database name associated with the user’s credentials.                                                                                                                                                                      |
+| MONGODB_DATABASE                       | String  |                           | The database name                                                                                                                                                                                                                      |
+| MONGODB_REPLICA_SET                    | String  |                           | Specifies the name of the replica set, if the mongod is a member of a replica set.                                                                                                                                                     |
+| MONGODB_TLS                            | Boolean | False                     | Enables or disables TLS/SSL for the connection.                                                                                                                                                                                        |
+| MONGODB_TLS_CERT_FILE                  | String  |                           | Specifies the location of a local .pem file that contains either the client's TLS/SSL certificate and key.                                                                                                                             |
+| MONGODB_TLS_CERT_FILE_PASS             | String  |                           | Specifies the password to de-crypt the tlsCertificateKeyFile.                                                                                                                                                                          |
+| MONGODB_TLS_CA_FILE                    | String  |                           | Specifies the location of a local .pem file that contains the root certificate chain from the Certificate Authority. This file is used to validate the certificate presented by the mongod/mongos instance.                            |
+| MONGODB_TLS_CRL_FILE                   | String  |                           | Specifies the location of a local CRL .pem file that contains the client revokation list.                                                                                                                                              |
+| MONGODB_TLS_ALLOW_INVALID_CERTIFICATES | Boolean |                           | Bypasses validation of the certificates presented by the mongod/mongos instance                                                                                                                                                        |
+| MONGODB_TLS_ALLOW_INVALID_HOSTNAMES    | Boolean |                           | Disables hostname validation of the certificate presented by the mongod/mongos instance.                                                                                                                                               |
+| MONGODB_TLS_INSECURE                   | Boolean |                           | Disables various certificate validations.                                                                                                                                                                                              |
+| MONGODB_TIMEOUT                        | Number  |                           | Specifies the time an operation will run until it throws a timeout error                                                                                                                                                               |
+| MONGODB_CONNECT_TIMEOUT                | Number  |                           | The time in milliseconds to attempt a connection before timing out.                                                                                                                                                                    |
+| MONGODB_SOCKET_TIMEOUT                 | Number  |                           | The time in milliseconds to attempt a send or receive on a socket before the attempt times out.                                                                                                                                        |
+| MONGODB_SRV_MAX_HOSTS                  | Number  |                           | The maximum number of hosts to connect to when using an srv connection string, a setting of `0` means unlimited hosts                                                                                                                  |
+| MONGODB_MAX_POOL_SIZE                  | Number  |                           | The maximum number of connections in the connection pool                                                                                                                                                                               |
+| MONGODB_MIN_POOL_SIZE                  | Number  |                           | The minimum number of connections in the connection pool.                                                                                                                                                                              |
+| MONGODB_MAX_CONNECTING                 | Number  |                           | The maximum number of connections that may be in the process of being established concurrently by the connection pool.                                                                                                                 |
+| MONGODB_MAX_IDLE_TIME                  | Number  |                           | The maximum number of milliseconds that a connection can remain idle in the pool before being removed and closed.                                                                                                                      |
+| MONGODB_MAX_WAIT_QUEUE_TIMEOUT         | Number  |                           | The maximum time in milliseconds that a thread can wait for a connection to become available.                                                                                                                                          |
+| MONGODB_MAX_STALENESS_SECONDS          | Number  |                           | Specifies, in seconds, how stale a secondary can be before the client stops using it for read operations.                                                                                                                              |
+| MONGODB_LOCAL_THRESHOLD                | Number  |                           | The size (in milliseconds) of the latency window for selecting among multiple suitable MongoDB instances.                                                                                                                              |
+| MONGODB_SERVER_SELECTION_TIMEOUT       | Number  |                           | Specifies how long (in milliseconds) to block for server selection before throwing an exception.                                                                                                                                       |
+| MONGODB_HEARTBEAT_FREQUENCY            | Number  |                           | heartbeatFrequencyMS controls when the driver checks the state of the MongoDB deployment. Specify the interval (in milliseconds) between checks, counted from the end of the previous check until the beginning of the next one.       |
+| MONGODB_APP_NAME                       | String  |                           | The name of the application that created this MongoClient instance. MongoDB 3.4 and newer will print this value in the server log upon establishing each connection. It is also recorded in the slow query log and profile collections |
+| MONGODB_RETRY_READS                    | Boolean |                           | Enables retryable reads.                                                                                                                                                                                                               |
+| MONGODB_RETRY_WRITES                   | Boolean |                           | Enable retryable writes.                                                                                                                                                                                                               |
+| MONGODB_DIRECT_CONNECTION              | Boolean |                           | Allow a driver to force a Single topology type with a connection string containing one host                                                                                                                                            |
+| MONGODB_LOAD_BALANCED                  | Boolean |                           | Instruct the driver it is connecting to a load balancer fronting a mongos like service                                                                                                                                                 |
+| MONGODB_NO_DELAY                       | Boolean |                           | TCP Connection no delay                                                                                                                                                                                                                |
+| MONGODB_MONITOR_COMMANDS               | Boolean |                           | Enable command monitoring for this client                                                                                                                                                                                              |
+| MONGODB_PROXY_HOST                     | String  |                           | Configures a Socks5 proxy host used for creating TCP connections.                                                                                                                                                                      |
+| MONGODB_PROXY_PORT                     | String  |                           | Configures a Socks5 proxy port used for creating TCP connections.                                                                                                                                                                      |
+| MONGODB_PROXY_USERNAME                 | String  |                           | Configures a Socks5 proxy username when the proxy in proxyHost requires username/password authentication.                                                                                                                              |
+| MONGODB_PROXY_PASSWORD                 | String  |                           | Configures a Socks5 proxy password when the proxy in proxyHost requires username/password authentication.                                                                                                                              |

package/cjs/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MONGODB_MODULE_ID = exports.MONGODB_CONNECTION_OPTIONS = void 0;
+exports.MONGODB_CONNECTION_OPTIONS = Symbol('MONGODB_CONNECTION_OPTIONS');
+exports.MONGODB_MODULE_ID = Symbol('MONGODB_MODULE_ID');

package/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./mongodb.module.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/mongodb-core.module.js

@@ -0,0 +1,173 @@
+"use strict";
+var MongodbCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongodbCoreModule = void 0;
+const tslib_1 = require("tslib");
+const assert = tslib_1.__importStar(require("node:assert"));
+const crypto = tslib_1.__importStar(require("node:crypto"));
+const process = tslib_1.__importStar(require("node:process"));
+const objects_1 = require("@jsopen/objects");
+const common_1 = require("@nestjs/common");
+const colors = tslib_1.__importStar(require("ansi-colors"));
+const mongodb_1 = require("mongodb");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const constants_js_1 = require("./constants.js");
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+let MongodbCoreModule = MongodbCoreModule_1 = class MongodbCoreModule {
+    /**
+     * Configures and returns a dynamic module for MongoDB integration.
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.MONGODB_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
+    }
+    /**
+     * Configures and returns an async dynamic module for MongoDB integration.
+     */
+    static forRootAsync(asyncOptions) {
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: constants_js_1.MONGODB_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? mongodb_1.MongoClient;
+        const dbToken = opts.dbToken ?? mongodb_1.Db;
+        const providers = [
+            {
+                provide: token,
+                inject: [constants_js_1.MONGODB_CONNECTION_OPTIONS],
+                useFactory: async (connectionOptions) => {
+                    const mongoOptions = (0, objects_1.omit)(connectionOptions, ['url', 'database', 'lazyConnect']);
+                    if (mongoOptions.auth && !mongoOptions.auth?.username)
+                        delete mongoOptions.auth;
+                    return new mongodb_1.MongoClient(connectionOptions.url, mongoOptions);
+                },
+            },
+            {
+                provide: dbToken,
+                inject: [token, constants_js_1.MONGODB_CONNECTION_OPTIONS],
+                useFactory: async (client, connectionOptions) => {
+                    return connectionOptions.database ? client.db(connectionOptions.database) : undefined;
+                },
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: common_1.Logger,
+                useValue: typeof opts.logger === 'string' ? new common_1.Logger(opts.logger) : opts.logger,
+            },
+        ];
+        return {
+            module: MongodbCoreModule_1,
+            ...metadata,
+            providers: [
+                ...(metadata.providers ?? []),
+                ...providers,
+                {
+                    provide: constants_js_1.MONGODB_MODULE_ID,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [constants_js_1.MONGODB_CONNECTION_OPTIONS, token, dbToken, ...(metadata.exports ?? [])],
+        };
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'MONGODB_') {
+        const options = (0, objects_1.clone)(moduleOptions);
+        const env = process.env;
+        options.url = options.url || (env[prefix + 'URL'] ?? 'mongodb://localhost:27017');
+        options.timeoutMS = options.timeoutMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'TIMEOUT']);
+        options.replicaSet = options.replicaSet ?? env[prefix + 'REPLICA_SET'];
+        options.tls = options.tls ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'TLS']);
+        options.tlsCertificateKeyFile = options.tlsCertificateKeyFile ?? env[prefix + 'TLS_CERT_FILE'];
+        options.tlsCertificateKeyFilePassword = options.tlsCertificateKeyFilePassword ?? env[prefix + 'TLS_CERT_FILE_PASS'];
+        options.tlsCAFile = options.tlsCAFile ?? env[prefix + 'TLS_CA_FILE'];
+        options.tlsCRLFile = options.tlsCRLFile ?? env[prefix + 'TLS_CRL_FILE'];
+        options.tlsAllowInvalidCertificates =
+            options.tlsAllowInvalidCertificates ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'TLS_ALLOW_INVALID_CERTIFICATES']);
+        options.tlsAllowInvalidCertificates =
+            options.tlsAllowInvalidHostnames ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'TLS_ALLOW_INVALID_HOSTNAMES']);
+        options.tlsInsecure = options.tlsInsecure ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'TLS_INSECURE']);
+        options.connectTimeoutMS = options.connectTimeoutMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'CONNECT_TIMEOUT']);
+        options.socketTimeoutMS = options.socketTimeoutMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'SOCKET_TIMEOUT']);
+        options.database = options.database ?? env[prefix + 'DATABASE'];
+        options.srvMaxHosts = options.srvMaxHosts ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'SRV_MAX_HOSTS']);
+        options.maxPoolSize = options.minPoolSize ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_POOL_SIZE']);
+        options.minPoolSize = options.maxPoolSize ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MIN_POOL_SIZE']);
+        options.maxConnecting = options.maxConnecting ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_CONNECTING']);
+        options.maxIdleTimeMS = options.maxIdleTimeMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_IDLE_TIME']);
+        options.waitQueueTimeoutMS = options.waitQueueTimeoutMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_WAIT_QUEUE_TIMEOUT']);
+        options.maxStalenessSeconds = options.maxStalenessSeconds ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'MAX_STALENESS_SECONDS']);
+        if (!options.auth?.username) {
+            options.auth = options.auth || {};
+            options.auth.username = options.auth.username ?? env[prefix + 'USERNAME'];
+            options.auth.password = options.auth.password ?? env[prefix + 'PASSWORD'];
+        }
+        options.authSource = options.authSource ?? env[prefix + 'AUTH_SOURCE'];
+        options.localThresholdMS = options.localThresholdMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'LOCAL_THRESHOLD']);
+        options.serverSelectionTimeoutMS =
+            options.serverSelectionTimeoutMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'SERVER_SELECTION_TIMEOUT']);
+        options.minHeartbeatFrequencyMS = options.minHeartbeatFrequencyMS ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'HEARTBEAT_FREQUENCY']);
+        options.appName = options.appName ?? env[prefix + 'APP_NAME'];
+        options.retryReads = options.retryReads ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'RETRY_READS']);
+        options.retryWrites = options.retryWrites ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'RETRY_WRITES']);
+        options.directConnection = options.directConnection ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'DIRECT_CONNECTION']);
+        options.loadBalanced = options.loadBalanced ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'LOAD_BALANCED']);
+        options.noDelay = options.noDelay ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'NO_DELAY']);
+        options.monitorCommands = options.monitorCommands ?? (0, putil_varhelpers_1.toBoolean)(env[prefix + 'MONITOR_COMMANDS']);
+        options.proxyHost = options.proxyHost ?? env[prefix + 'PROXY_HOST'];
+        options.proxyPort = options.proxyPort ?? (0, putil_varhelpers_1.toInt)(env[prefix + 'PROXY_PORT']);
+        options.proxyUsername = options.proxyHost ?? env[prefix + 'PROXY_USERNAME'];
+        options.proxyPassword = options.proxyPassword ?? env[prefix + 'PROXY_PASSWORD'];
+        return options;
+    }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
+    onApplicationBootstrap() {
+        const options = this.connectionOptions;
+        if (!options.lazyConnect) {
+            this.logger?.log(`Connecting to MongoDB [${options.database}] at ${colors.blue(options.url)}`);
+            common_1.Logger.flush();
+            return this.client.connect().catch(e => {
+                this.logger?.error('MongoDB connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close(true);
+    }
+};
+exports.MongodbCoreModule = MongodbCoreModule;
+exports.MongodbCoreModule = MongodbCoreModule = MongodbCoreModule_1 = tslib_1.__decorate([
+    tslib_1.__param(0, (0, common_1.Inject)(CLIENT_TOKEN)),
+    tslib_1.__param(1, (0, common_1.Inject)(constants_js_1.MONGODB_CONNECTION_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [mongodb_1.MongoClient, Object, common_1.Logger])
+], MongodbCoreModule);

package/cjs/mongodb.module.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongodbModule = void 0;
+const mongodb_core_module_js_1 = require("./mongodb-core.module.js");
+/**
+ * The `MongodbCoreModule` class provides static methods to configure and
+ * return dynamic modules for MongoDB integration. This module facilitates
+ * the setup of MongoDB connections and connection options. It is designed
+ * to support both synchronous and asynchronous configuration approaches,
+ * making it flexible for various application setups.
+ */
+class MongodbModule {
+    /**
+     * Configures and returns a dynamic module for MongoDB integration.
+     */
+    static forRoot(options) {
+        return {
+            module: MongodbModule,
+            imports: [mongodb_core_module_js_1.MongodbCoreModule.forRoot(options || {})],
+        };
+    }
+    /**
+     * Configures and returns an async dynamic module for MongoDB integration.
+     */
+    static forRootAsync(options) {
+        return {
+            module: MongodbModule,
+            imports: [mongodb_core_module_js_1.MongodbCoreModule.forRootAsync(options)],
+        };
+    }
+}
+exports.MongodbModule = MongodbModule;

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/types.js

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

package/esm/constants.js

@@ -0,0 +1,2 @@
+export const MONGODB_CONNECTION_OPTIONS = Symbol('MONGODB_CONNECTION_OPTIONS');
+export const MONGODB_MODULE_ID = Symbol('MONGODB_MODULE_ID');

package/esm/index.js

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './mongodb.module.js';
+export * from './types.js';

package/esm/mongodb-core.module.js

@@ -0,0 +1,170 @@
+var MongodbCoreModule_1;
+import { __decorate, __metadata, __param } from "tslib";
+import * as assert from 'node:assert';
+import * as crypto from 'node:crypto';
+import * as process from 'node:process';
+import { clone, omit } from '@jsopen/objects';
+import { Inject, Logger } from '@nestjs/common';
+import * as colors from 'ansi-colors';
+import { Db, MongoClient } from 'mongodb';
+import { toBoolean, toInt } from 'putil-varhelpers';
+import { MONGODB_CONNECTION_OPTIONS, MONGODB_MODULE_ID } from './constants.js';
+const CLIENT_TOKEN = Symbol('CLIENT_TOKEN');
+let MongodbCoreModule = MongodbCoreModule_1 = class MongodbCoreModule {
+    /**
+     * Configures and returns a dynamic module for MongoDB integration.
+     */
+    static forRoot(moduleOptions) {
+        const connectionOptions = this._readConnectionOptions(moduleOptions.useValue || {}, moduleOptions.envPrefix);
+        return this._createDynamicModule(moduleOptions, {
+            global: moduleOptions.global,
+            providers: [
+                {
+                    provide: MONGODB_CONNECTION_OPTIONS,
+                    useValue: connectionOptions,
+                },
+            ],
+        });
+    }
+    /**
+     * Configures and returns an async dynamic module for MongoDB integration.
+     */
+    static forRootAsync(asyncOptions) {
+        assert.ok(asyncOptions.useFactory, 'useFactory is required');
+        return this._createDynamicModule(asyncOptions, {
+            global: asyncOptions.global,
+            providers: [
+                {
+                    provide: MONGODB_CONNECTION_OPTIONS,
+                    inject: asyncOptions.inject,
+                    useFactory: async (...args) => {
+                        const opts = await asyncOptions.useFactory(...args);
+                        return this._readConnectionOptions(opts, asyncOptions.envPrefix);
+                    },
+                },
+            ],
+        });
+    }
+    static _createDynamicModule(opts, metadata) {
+        const token = opts.token ?? MongoClient;
+        const dbToken = opts.dbToken ?? Db;
+        const providers = [
+            {
+                provide: token,
+                inject: [MONGODB_CONNECTION_OPTIONS],
+                useFactory: async (connectionOptions) => {
+                    const mongoOptions = omit(connectionOptions, ['url', 'database', 'lazyConnect']);
+                    if (mongoOptions.auth && !mongoOptions.auth?.username)
+                        delete mongoOptions.auth;
+                    return new MongoClient(connectionOptions.url, mongoOptions);
+                },
+            },
+            {
+                provide: dbToken,
+                inject: [token, MONGODB_CONNECTION_OPTIONS],
+                useFactory: async (client, connectionOptions) => {
+                    return connectionOptions.database ? client.db(connectionOptions.database) : undefined;
+                },
+            },
+            {
+                provide: CLIENT_TOKEN,
+                useExisting: token,
+            },
+            {
+                provide: Logger,
+                useValue: typeof opts.logger === 'string' ? new Logger(opts.logger) : opts.logger,
+            },
+        ];
+        return {
+            module: MongodbCoreModule_1,
+            ...metadata,
+            providers: [
+                ...(metadata.providers ?? []),
+                ...providers,
+                {
+                    provide: MONGODB_MODULE_ID,
+                    useValue: crypto.randomUUID(),
+                },
+            ],
+            exports: [MONGODB_CONNECTION_OPTIONS, token, dbToken, ...(metadata.exports ?? [])],
+        };
+    }
+    static _readConnectionOptions(moduleOptions, prefix = 'MONGODB_') {
+        const options = clone(moduleOptions);
+        const env = process.env;
+        options.url = options.url || (env[prefix + 'URL'] ?? 'mongodb://localhost:27017');
+        options.timeoutMS = options.timeoutMS ?? toInt(env[prefix + 'TIMEOUT']);
+        options.replicaSet = options.replicaSet ?? env[prefix + 'REPLICA_SET'];
+        options.tls = options.tls ?? toBoolean(env[prefix + 'TLS']);
+        options.tlsCertificateKeyFile = options.tlsCertificateKeyFile ?? env[prefix + 'TLS_CERT_FILE'];
+        options.tlsCertificateKeyFilePassword = options.tlsCertificateKeyFilePassword ?? env[prefix + 'TLS_CERT_FILE_PASS'];
+        options.tlsCAFile = options.tlsCAFile ?? env[prefix + 'TLS_CA_FILE'];
+        options.tlsCRLFile = options.tlsCRLFile ?? env[prefix + 'TLS_CRL_FILE'];
+        options.tlsAllowInvalidCertificates =
+            options.tlsAllowInvalidCertificates ?? toBoolean(env[prefix + 'TLS_ALLOW_INVALID_CERTIFICATES']);
+        options.tlsAllowInvalidCertificates =
+            options.tlsAllowInvalidHostnames ?? toBoolean(env[prefix + 'TLS_ALLOW_INVALID_HOSTNAMES']);
+        options.tlsInsecure = options.tlsInsecure ?? toBoolean(env[prefix + 'TLS_INSECURE']);
+        options.connectTimeoutMS = options.connectTimeoutMS ?? toInt(env[prefix + 'CONNECT_TIMEOUT']);
+        options.socketTimeoutMS = options.socketTimeoutMS ?? toInt(env[prefix + 'SOCKET_TIMEOUT']);
+        options.database = options.database ?? env[prefix + 'DATABASE'];
+        options.srvMaxHosts = options.srvMaxHosts ?? toInt(env[prefix + 'SRV_MAX_HOSTS']);
+        options.maxPoolSize = options.minPoolSize ?? toInt(env[prefix + 'MAX_POOL_SIZE']);
+        options.minPoolSize = options.maxPoolSize ?? toInt(env[prefix + 'MIN_POOL_SIZE']);
+        options.maxConnecting = options.maxConnecting ?? toInt(env[prefix + 'MAX_CONNECTING']);
+        options.maxIdleTimeMS = options.maxIdleTimeMS ?? toInt(env[prefix + 'MAX_IDLE_TIME']);
+        options.waitQueueTimeoutMS = options.waitQueueTimeoutMS ?? toInt(env[prefix + 'MAX_WAIT_QUEUE_TIMEOUT']);
+        options.maxStalenessSeconds = options.maxStalenessSeconds ?? toInt(env[prefix + 'MAX_STALENESS_SECONDS']);
+        if (!options.auth?.username) {
+            options.auth = options.auth || {};
+            options.auth.username = options.auth.username ?? env[prefix + 'USERNAME'];
+            options.auth.password = options.auth.password ?? env[prefix + 'PASSWORD'];
+        }
+        options.authSource = options.authSource ?? env[prefix + 'AUTH_SOURCE'];
+        options.localThresholdMS = options.localThresholdMS ?? toInt(env[prefix + 'LOCAL_THRESHOLD']);
+        options.serverSelectionTimeoutMS =
+            options.serverSelectionTimeoutMS ?? toInt(env[prefix + 'SERVER_SELECTION_TIMEOUT']);
+        options.minHeartbeatFrequencyMS = options.minHeartbeatFrequencyMS ?? toInt(env[prefix + 'HEARTBEAT_FREQUENCY']);
+        options.appName = options.appName ?? env[prefix + 'APP_NAME'];
+        options.retryReads = options.retryReads ?? toBoolean(env[prefix + 'RETRY_READS']);
+        options.retryWrites = options.retryWrites ?? toBoolean(env[prefix + 'RETRY_WRITES']);
+        options.directConnection = options.directConnection ?? toBoolean(env[prefix + 'DIRECT_CONNECTION']);
+        options.loadBalanced = options.loadBalanced ?? toBoolean(env[prefix + 'LOAD_BALANCED']);
+        options.noDelay = options.noDelay ?? toBoolean(env[prefix + 'NO_DELAY']);
+        options.monitorCommands = options.monitorCommands ?? toBoolean(env[prefix + 'MONITOR_COMMANDS']);
+        options.proxyHost = options.proxyHost ?? env[prefix + 'PROXY_HOST'];
+        options.proxyPort = options.proxyPort ?? toInt(env[prefix + 'PROXY_PORT']);
+        options.proxyUsername = options.proxyHost ?? env[prefix + 'PROXY_USERNAME'];
+        options.proxyPassword = options.proxyPassword ?? env[prefix + 'PROXY_PASSWORD'];
+        return options;
+    }
+    /**
+     *
+     * @constructor
+     */
+    constructor(client, connectionOptions, logger) {
+        this.client = client;
+        this.connectionOptions = connectionOptions;
+        this.logger = logger;
+    }
+    onApplicationBootstrap() {
+        const options = this.connectionOptions;
+        if (!options.lazyConnect) {
+            this.logger?.log(`Connecting to MongoDB [${options.database}] at ${colors.blue(options.url)}`);
+            Logger.flush();
+            return this.client.connect().catch(e => {
+                this.logger?.error('MongoDB connection failed: ' + e.message);
+                throw e;
+            });
+        }
+    }
+    onApplicationShutdown() {
+        return this.client.close(true);
+    }
+};
+MongodbCoreModule = MongodbCoreModule_1 = __decorate([
+    __param(0, Inject(CLIENT_TOKEN)),
+    __param(1, Inject(MONGODB_CONNECTION_OPTIONS)),
+    __metadata("design:paramtypes", [MongoClient, Object, Logger])
+], MongodbCoreModule);
+export { MongodbCoreModule };

package/esm/mongodb.module.js

@@ -0,0 +1,28 @@
+import { MongodbCoreModule } from './mongodb-core.module.js';
+/**
+ * The `MongodbCoreModule` class provides static methods to configure and
+ * return dynamic modules for MongoDB integration. This module facilitates
+ * the setup of MongoDB connections and connection options. It is designed
+ * to support both synchronous and asynchronous configuration approaches,
+ * making it flexible for various application setups.
+ */
+export class MongodbModule {
+    /**
+     * Configures and returns a dynamic module for MongoDB integration.
+     */
+    static forRoot(options) {
+        return {
+            module: MongodbModule,
+            imports: [MongodbCoreModule.forRoot(options || {})],
+        };
+    }
+    /**
+     * Configures and returns an async dynamic module for MongoDB integration.
+     */
+    static forRootAsync(options) {
+        return {
+            module: MongodbModule,
+            imports: [MongodbCoreModule.forRootAsync(options)],
+        };
+    }
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@xnestjs/mongodb",
+  "version": "1.3.0",
+  "description": "NestJS extension library for MongoDb",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@jsopen/objects": "^1.5.2",
+    "ansi-colors": "^4.1.3",
+    "putil-varhelpers": "^1.6.5",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "mongodb": "^6.13.1"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "registry": "https://github.com/panates/xnestjs.git",
+    "directory": "packages/mongodb"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "nestjs",
+    "mongodb"
+  ]
+}

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const MONGODB_CONNECTION_OPTIONS: unique symbol;
+export declare const MONGODB_MODULE_ID: unique symbol;

package/types/index.d.cts

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './mongodb.module.js';
+export * from './types.js';

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './mongodb.module.js';
+export * from './types.js';

package/types/mongodb-core.module.d.ts

@@ -0,0 +1,25 @@
+import { DynamicModule, Logger, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { MongoClient } from 'mongodb';
+import type { MongodbConnectionOptions, MongodbModuleAsyncOptions, MongodbModuleOptions } from './types.js';
+export declare class MongodbCoreModule implements OnApplicationShutdown, OnApplicationBootstrap {
+    protected client: MongoClient;
+    private connectionOptions;
+    private logger?;
+    /**
+     * Configures and returns a dynamic module for MongoDB integration.
+     */
+    static forRoot(moduleOptions: MongodbModuleOptions): DynamicModule;
+    /**
+     * Configures and returns an async dynamic module for MongoDB integration.
+     */
+    static forRootAsync(asyncOptions: MongodbModuleAsyncOptions): DynamicModule;
+    private static _createDynamicModule;
+    private static _readConnectionOptions;
+    /**
+     *
+     * @constructor
+     */
+    constructor(client: MongoClient, connectionOptions: MongodbConnectionOptions, logger?: Logger | undefined);
+    onApplicationBootstrap(): Promise<MongoClient> | undefined;
+    onApplicationShutdown(): Promise<void>;
+}

package/types/mongodb.module.d.ts

@@ -0,0 +1,19 @@
+import type { DynamicModule } from '@nestjs/common';
+import type { MongodbModuleAsyncOptions, MongodbModuleOptions } from './types.js';
+/**
+ * The `MongodbCoreModule` class provides static methods to configure and
+ * return dynamic modules for MongoDB integration. This module facilitates
+ * the setup of MongoDB connections and connection options. It is designed
+ * to support both synchronous and asynchronous configuration approaches,
+ * making it flexible for various application setups.
+ */
+export declare class MongodbModule {
+    /**
+     * Configures and returns a dynamic module for MongoDB integration.
+     */
+    static forRoot(options?: MongodbModuleOptions): DynamicModule;
+    /**
+     * Configures and returns an async dynamic module for MongoDB integration.
+     */
+    static forRootAsync(options: MongodbModuleAsyncOptions): DynamicModule;
+}

package/types/types.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '@nestjs/common';
+import type { ModuleMetadata } from '@nestjs/common/interfaces';
+import type { InjectionToken } from '@nestjs/common/interfaces/modules/injection-token.interface';
+import type { MongoClientOptions } from 'mongodb';
+export interface MongodbConnectionOptions extends MongoClientOptions {
+    url?: string;
+    database?: string;
+    lazyConnect?: boolean;
+}
+interface BaseModuleOptions {
+    token?: InjectionToken;
+    dbToken?: InjectionToken;
+    envPrefix?: string;
+    logger?: Logger | string;
+    global?: boolean;
+}
+export interface MongodbModuleOptions extends BaseModuleOptions {
+    useValue?: MongodbConnectionOptions;
+}
+export interface MongodbModuleAsyncOptions extends BaseModuleOptions, Pick<ModuleMetadata, 'imports'> {
+    inject?: InjectionToken[];
+    useFactory: (...args: any[]) => Promise<MongodbConnectionOptions> | MongodbConnectionOptions;
+}
+export {};