replica-failover-mongodb-ts 3.0.3 → 3.0.9

package/Readme.md

@@ -120,7 +120,11 @@ O Node Balancer utiliza as seguintes tecnologias:
 
 ## Uso como Biblioteca (Library)
 
-Você pode usar o gerenciador de conexões resiliente deste projeto em sua própria aplicação Node.js.
+Você pode usar o gerenciador de conexões resiliente deste projeto em sua própria aplicação Node.js ou NestJS.
+
+### Modo Simples (Recomendado)
+
+Basta passar a string de conexão padrão do MongoDB. A lib detecta automaticamente os nós e o banco de dados.
 
 1.  **Instale a lib:**
     ```bash
@@ -131,18 +135,113 @@ Você pode usar o gerenciador de conexões resiliente deste projeto em sua próp
     ```typescript
     import { ConnectionManager } from 'replica-failover-mongodb-ts';
 
+    // ✨ Plug & Play: Apenas a string de conexão!
     const db = new ConnectionManager({
-        nodes: [
-            'mongodb://mongo1:27017/mydb',
-            'mongodb://mongo2:27017/mydb'
-        ],
-        healthCheckIntervalMs: 5000
+        connectionString: 'mongodb://mongo1:27017,mongo2:27017/mydb'
     });
 
     await db.init();
-    const myCollection = db.getDb().collection('users');
+    
+    // ✅ Failover automático para QUALQUER collection
+    // Você NÃO precisa configurar as collections antes. Basta usar o nome.
+    
+    // Leitura na collection 'users'
+    const users = await db.read('users', c => c.find().toArray());
+    
+    // Escrita na collection 'logs'
+    await db.write('logs', c => c.insertOne({ event: 'login' }));
+    
+    // Leitura na collection 'products' com preferência Secundária
+    const products = await db.read('products', c => c.find().toArray(), {}, 'secondaryPreferred');
     ```
 
+    const products = await db.read('products', c => c.find().toArray(), {}, 'secondaryPreferred');
+    ```
+
+
+### 🛰️ Monitoramento e Status (Plug & Play)
+
+Você pode verificar a saúde das conexões a qualquer momento ou ouvir eventos em tempo real.
+
+**Verificar Status:**
+```typescript
+const status = db.getStatus();
+console.log(status);
+/* Retorno:
+{
+  isConnected: true,
+  dbName: 'mydb',
+  primary: 'mongodb://mongo1:27017/mydb',
+  secondaries: ['mongodb://mongo2:27017/mydb'],
+  totalNodes: 2
+}
+*/
+```
+
+**Ouvir Eventos (Real-time):**
+A classe `ConnectionManager` emite eventos que você pode escutar:
+
+```typescript
+db.on('failover-start', (reason) => {
+    console.warn('⚠️ O banco principal caiu! Iniciando failover...', reason);
+});
+
+db.on('failover-complete', ({ newPrimary }) => {
+    console.info('✅ Novo banco principal eleito:', newPrimary);
+});
+
+db.on('node-lost', ({ count }) => {
+    console.error('❌ Um nó secundário caiu. Total restante:', count);
+});
+```
+
+```typescript
+const db = new ConnectionManager({
+    nodes: [
+        'mongodb://mongo1:27017/mydb',
+        'mongodb://mongo2:27017/mydb'
+    ],
+    healthCheckIntervalMs: 5000,
+    minPoolSize: 5
+});
+```
+
+### Uso com NestJS
+
+Se você usa NestJS, a integração é nativa:
+
+```typescript
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { NodeBalancerModule } from 'replica-failover-mongodb-ts/dist/nestjs';
+
+@Module({
+  imports: [
+    NodeBalancerModule.forRoot({
+      connectionString: 'mongodb://localhost:27017,localhost:27018/mydb',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+E para usar nos seus services:
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { InjectConnectionManager } from 'replica-failover-mongodb-ts/dist/nestjs';
+import { ConnectionManager } from 'replica-failover-mongodb-ts';
+
+@Injectable()
+export class UserService {
+  constructor(@InjectConnectionManager() private readonly db: ConnectionManager) {}
+
+  async getUsers() {
+    return this.db.read('users', (col) => col.find().toArray());
+  }
+}
+```
+
 ---
 
 ## Visual Dashboard (Painel de Controle)

package/dist/config/connectionManager.js

@@ -13,37 +13,87 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionManager = void 0;
+const events_1 = require("events");
 const mongodb_1 = require("mongodb");
 const axios_1 = __importDefault(require("axios"));
 const logger_1 = require("../middlewares/logger");
 const websocket_1 = require("./websocket");
 const metrics_1 = require("./metrics");
-class ConnectionManager {
+class ConnectionManager extends events_1.EventEmitter {
     constructor(opts) {
-        var _a;
+        var _a, _b, _c;
+        super();
         this.primaryClient = null;
         this.primaryDb = null;
+        this.secondaryClients = [];
+        this.rrIndex = 0;
         this.nodes = [];
         this.replicaUri = opts.replicaUri;
-        this.nodes = (opts.nodes || []).map((u, i) => ({ uri: u, name: `node${i + 1}` }));
-        this.dbName = opts.dbName || 'node-balancer';
         this.healthCheckIntervalMs = (_a = opts.healthCheckIntervalMs) !== null && _a !== void 0 ? _a : 5000;
         this.webhookUrl = opts.webhookUrl;
+        this.maxPoolSize = (_b = opts.maxPoolSize) !== null && _b !== void 0 ? _b : 20;
+        this.minPoolSize = (_c = opts.minPoolSize) !== null && _c !== void 0 ? _c : 1;
+        let parsedDbName;
+        if (opts.connectionString) {
+            parsedDbName = this.parseConnectionString(opts.connectionString);
+        }
+        else {
+            this.nodes = (opts.nodes || []).map((u, i) => ({ uri: u, name: `node${i + 1}` }));
+        }
+        // Use parsed dbName if allowed, or fallback to opts, or default
+        this.dbName = opts.dbName || parsedDbName || 'node-balancer';
+    }
+    parseConnectionString(uri) {
+        // Basic Regex to capture: protocol, auth(optional), hosts, db(optional), options(optional)
+        const regex = /^(mongodb(?:\+srv)?):\/\/((?:[^@\/]+@)?)?([^/?]+)(?:\/([^?]+))?(?:\?.*)?$/;
+        const match = uri.match(regex);
+        let foundDbName;
+        if (!match) {
+            logger_1.logger.warn('Invalid connection string format. Fallback to manual nodes if provided.');
+            return undefined;
+        }
+        const protocol = match[1];
+        const auth = match[2] || '';
+        const hostsPart = match[3];
+        const dbPart = match[4];
+        if (dbPart)
+            foundDbName = dbPart;
+        if (protocol === 'mongodb+srv') {
+            logger_1.logger.info('Detected SRV connection string. Using as replicaUri.');
+            this.replicaUri = uri;
+        }
+        else {
+            const hosts = hostsPart.split(',');
+            this.nodes = hosts.map((h, i) => ({
+                uri: `${protocol}://${auth}${h}`,
+                name: `node${i + 1}`
+            }));
+            logger_1.logger.info(`Parsed ${this.nodes.length} nodes from connection string.`);
+        }
+        return foundDbName;
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.logger.info('ConnectionManager: init() starting');
-            // First try replica uri if provided (let driver handle replica set)
+            // 1. Try Replica URI
             if (this.replicaUri) {
                 logger_1.logger.info(`Trying replica URI: ${this.replicaUri}`);
                 try {
-                    const c = new mongodb_1.MongoClient(this.replicaUri, { monitorCommands: true });
+                    const c = new mongodb_1.MongoClient(this.replicaUri, {
+                        monitorCommands: true,
+                        minPoolSize: this.minPoolSize,
+                        maxPoolSize: this.maxPoolSize
+                    });
+                    c._uri = this.replicaUri;
+                    // Attach events BEFORE connecting to capture initial pool creation
+                    this.attachPoolMonitor(c, 'primary', 'replica-uri');
                     yield c.connect();
                     const isWritable = yield this.checkWritable(c);
                     if (isWritable) {
                         logger_1.logger.info('Connected to replicaSet URI and found writable primary.');
                         this.attachClient(c);
                         this.startHealthChecks();
+                        this.emit('ready', { mode: 'replica-set', uri: this.replicaUri });
                         return;
                     }
                     else {
@@ -55,58 +105,102 @@ class ConnectionManager {
                     logger_1.logger.warn(`Replica URI connect failed: ${err.message}`);
                 }
             }
-            // Fallback: iterate nodes and find a writable node
+            // 2. Fallback: Multi-node Manual Connection
+            logger_1.logger.info('Initializing multi-node connection...');
+            let connectedCount = 0;
             for (const n of this.nodes) {
-                logger_1.logger.info(`Trying node ${n.uri}`);
+                logger_1.logger.info(`Connecting to node ${n.uri}`);
                 try {
-                    const c = new mongodb_1.MongoClient(n.uri, { directConnection: true, monitorCommands: true });
+                    const c = new mongodb_1.MongoClient(n.uri, {
+                        directConnection: true,
+                        monitorCommands: true,
+                        minPoolSize: this.minPoolSize,
+                        maxPoolSize: this.maxPoolSize
+                    });
+                    c._uri = n.uri;
+                    this.attachPoolMonitor(c, 'unknown', n.uri);
                     yield c.connect();
+                    connectedCount++;
                     const writable = yield this.checkWritable(c);
-                    if (writable) {
-                        logger_1.logger.info(`Found writable node at ${n.uri}`);
+                    if (writable && !this.primaryClient) {
+                        logger_1.logger.info(`Found Primary node at ${n.uri}`);
                         this.attachClient(c);
-                        this.startHealthChecks();
-                        return;
                     }
                     else {
-                        yield c.close();
+                        logger_1.logger.info(`Connected to Secondary node at ${n.uri}`);
+                        this.secondaryClients.push(c);
                     }
                 }
                 catch (err) {
                     logger_1.logger.warn(`Node connect failed ${n.uri}: ${err.message}`);
                 }
             }
-            throw new Error('No writable MongoDB node found. Check your nodes/replica set.');
+            if (connectedCount === 0) {
+                throw new Error('No available MongoDB nodes found. Check your cluster.');
+            }
+            if (!this.primaryClient) {
+                logger_1.logger.warn('Initialized without a Primary node! System in Read-Only mode until a node becomes writable.');
+                this.emit('warn', 'Initialized in Read-Only mode (No Primary)');
+            }
+            else {
+                this.emit('ready', { mode: 'multi-node' });
+            }
+            this.startHealthChecks();
         });
     }
+    getStatus() {
+        return {
+            isConnected: !!this.primaryClient,
+            dbName: this.dbName,
+            primary: this.primaryClient ? this.primaryClient._uri : null,
+            secondaries: this.secondaryClients.map(c => c._uri),
+            totalNodes: (this.primaryClient ? 1 : 0) + this.secondaryClients.length
+        };
+    }
+    attachPoolMonitor(client, type, nodeUri) {
+        const label = { type, node: nodeUri };
+        client.on('connectionCreated', () => metrics_1.poolSize.inc(label));
+        client.on('connectionClosed', () => metrics_1.poolSize.dec(label));
+        client.on('connectionCheckedOut', () => {
+            metrics_1.poolCheckedOut.inc(label);
+        });
+        client.on('connectionCheckedIn', () => {
+            metrics_1.poolCheckedOut.dec(label);
+        });
+        client.on('connectionCheckOutStarted', () => metrics_1.poolWaitQueue.inc(label));
+        client.on('connectionCheckOutFailed', () => metrics_1.poolWaitQueue.dec(label));
+        client.on('connectionCheckedOut', () => metrics_1.poolWaitQueue.dec(label));
+    }
     attachClient(client) {
         this.primaryClient = client;
         this.primaryDb = client.db(this.dbName);
-        // register monitoring events on the client
+        const uri = client._uri;
+        this.emit('primary-elected', { uri });
         client.on('topologyDescriptionChanged', (td) => {
             var _a;
-            logger_1.logger.info(`topologyDescriptionChanged: ${JSON.stringify(this.summarizeTopology(td))}`);
             const summary = this.summarizeTopology(td);
             this.recordEvent('topologyDescriptionChanged', { td: summary }).catch(() => { });
             (_a = (0, websocket_1.getIO)()) === null || _a === void 0 ? void 0 : _a.emit('topology-change', summary);
+            this.emit('topology-change', summary);
         });
         client.on('serverHeartbeatFailed', (event) => {
             logger_1.logger.warn(`serverHeartbeatFailed: ${JSON.stringify(event)}`);
             this.recordEvent('serverHeartbeatFailed', { event }).catch(() => { });
             this.sendAlert('serverHeartbeatFailed', event).catch(() => { });
+            this.emit('server-heartbeat-failed', event);
         });
         client.on('serverHeartbeatSucceeded', (event) => {
-            logger_1.logger.debug(`serverHeartbeatSucceeded: ${JSON.stringify(event)}`);
+            // verbose
         });
         client.on('close', () => {
             logger_1.logger.warn('MongoClient close event');
             this.recordEvent('clientClose', {}).catch(() => { });
+            this.emit('close');
         });
         logger_1.logger.info('Primary client attached.');
         metrics_1.connectionStatus.set(1);
     }
     summarizeTopology(td) {
-        // gentle summary - driver topologyDescription shape may vary
         try {
             return {
                 servers: Object.keys(td.servers || {}).map((k) => ({
@@ -123,15 +217,14 @@ class ConnectionManager {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const admin = client.db('admin');
-                // isWritablePrimary command is supported
                 const res = yield admin.command({ isWritablePrimary: 1 }).catch(() => null);
                 if (res && res.isWritablePrimary)
                     return true;
-                // fallback: isMaster / hello
                 const info = yield admin.command({ hello: 1 }).catch(() => null);
-                if (info && (info.isWritablePrimary || info.isWritablePrimary === true))
+                if (info && (info.isWritablePrimary ||
+                    info.isWritablePrimary === true ||
+                    info.ismaster === true))
                     return true;
-                // if driver can't tell, assume writable if connected and write to a temp collection test (careful)
                 return false;
             }
             catch (err) {
@@ -144,19 +237,14 @@ class ConnectionManager {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             try {
-                const event = {
-                    ts: new Date(),
-                    level: 'event',
-                    type,
-                    payload,
-                };
+                const event = { ts: new Date(), level: 'event', type, payload };
                 (_a = (0, websocket_1.getIO)()) === null || _a === void 0 ? void 0 : _a.emit('log', event);
                 if (!this.primaryDb)
                     return;
                 yield this.primaryDb.collection('logs').insertOne(event);
             }
             catch (err) {
-                logger_1.logger.warn('recordEvent failed: ' + err.message);
+                // logger.warn('recordEvent failed: ' + (err as Error).message);
             }
         });
     }
@@ -182,70 +270,111 @@ class ConnectionManager {
     }
     healthCheckLoop() {
         return __awaiter(this, void 0, void 0, function* () {
-            // If primary still writable -> do nothing
+            // 1. Check Primary
             if (this.primaryClient) {
                 const ok = yield this.checkWritable(this.primaryClient).catch(() => false);
-                if (ok)
-                    return;
-                logger_1.logger.warn('Primary client no longer writable. Will search for a writable node.');
-                try {
-                    yield this.primaryClient.close();
+                if (!ok) {
+                    logger_1.logger.warn('Primary client no longer writable. Demoting to potential secondary.');
+                    this.secondaryClients.push(this.primaryClient);
+                    this.primaryClient = null;
+                    this.primaryDb = null;
+                    metrics_1.connectionStatus.set(0);
+                    this.emit('failover-start', { reason: 'Primary not writable' });
                 }
-                catch (_a) { }
-                this.primaryClient = null;
-                this.primaryDb = null;
-                metrics_1.connectionStatus.set(0);
             }
-            // attempt to find a writable node among nodes (directConnection)
-            for (const n of this.nodes) {
+            // 2. Check Secondaries
+            for (let i = this.secondaryClients.length - 1; i >= 0; i--) {
+                const sec = this.secondaryClients[i];
                 try {
-                    const c = new mongodb_1.MongoClient(n.uri, { directConnection: true, monitorCommands: true });
-                    yield c.connect();
-                    const writable = yield this.checkWritable(c);
-                    if (writable) {
-                        logger_1.logger.info(`Health-check: promoted ${n.uri} to primary connection`);
-                        this.attachClient(c);
-                        yield this.recordEvent('promote', { node: n.uri });
-                        yield this.sendAlert('promote', { node: n.uri, message: 'Promoted new primary connection' });
-                        metrics_1.failoverCount.inc();
-                        return;
-                    }
-                    else {
-                        yield c.close();
-                    }
+                    yield sec.db('admin').command({ ping: 1 });
                 }
                 catch (err) {
-                    logger_1.logger.debug(`Health-check connect failed ${n.uri}: ${err.message}`);
+                    logger_1.logger.warn('Secondary node lost connection. Removing.');
+                    try {
+                        yield sec.close();
+                    }
+                    catch (_a) { }
+                    this.secondaryClients.splice(i, 1);
+                    this.emit('node-lost', { count: this.secondaryClients.length });
+                }
+            }
+            // 3. Promote if needed
+            if (!this.primaryClient) {
+                // logger.warn('No Primary! Searching among secondaries...');
+                for (let i = 0; i < this.secondaryClients.length; i++) {
+                    const client = this.secondaryClients[i];
+                    const isWritable = yield this.checkWritable(client);
+                    if (isWritable) {
+                        logger_1.logger.info('Promoting secondary to Primary!');
+                        this.attachClient(client);
+                        this.secondaryClients.splice(i, 1);
+                        yield this.recordEvent('promote', { message: 'Promoted secondary to primary' });
+                        yield this.sendAlert('promote', { message: 'Promoted new primary connection' });
+                        metrics_1.failoverCount.inc();
+                        this.emit('failover-complete', { newPrimary: client._uri });
+                        break;
+                    }
                 }
             }
-            // no writable found
-            logger_1.logger.error('Health-check: no writable nodes found.');
-            yield this.recordEvent('no-writable', {});
-            yield this.sendAlert('no-writable', { message: 'CRITICAL: No writable nodes found in cluster!' });
         });
     }
+    getSecondary() {
+        if (this.secondaryClients.length === 0)
+            return null;
+        const c = this.secondaryClients[this.rrIndex % this.secondaryClients.length];
+        this.rrIndex++;
+        return c;
+    }
     getDb() {
         return this.primaryDb;
     }
-    // Generic wrappers that log operations to collection 'logs'
     read(collectionName_1, op_1) {
-        return __awaiter(this, arguments, void 0, function* (collectionName, op, meta = {}) {
-            const db = this.getDb();
+        return __awaiter(this, arguments, void 0, function* (collectionName, op, meta = {}, readPref = 'primary') {
+            let clientToUse = this.primaryClient;
+            let effectivePref = readPref;
+            if (readPref === 'secondary') {
+                const sec = this.getSecondary();
+                if (sec) {
+                    clientToUse = sec;
+                }
+                else {
+                    throw new Error('No secondary node available for read preference "secondary"');
+                }
+            }
+            else if (readPref === 'secondaryPreferred') {
+                const sec = this.getSecondary();
+                if (sec) {
+                    clientToUse = sec;
+                    effectivePref = 'secondary';
+                }
+                else {
+                    clientToUse = this.primaryClient;
+                    effectivePref = 'primary';
+                }
+            }
+            if (!clientToUse) {
+                throw new Error('No active connection available for requested read preference');
+            }
+            const db = clientToUse.db(this.dbName);
             const start = Date.now();
             try {
-                if (!db)
-                    throw new Error('No DB connection');
-                const res = yield op(db.collection(collectionName));
+                const collection = db.collection(collectionName);
+                const res = yield op(collection);
                 const took = Date.now() - start;
                 yield this.safeLog({
                     ts: new Date(),
                     op: 'read',
                     collection: collectionName,
                     success: true,
-                    meta,
+                    meta: Object.assign(Object.assign({}, meta), { readPref: effectivePref }),
                     durationMs: took,
                 });
-                metrics_1.operationDuration.observe({ operation: 'read', collection: collectionName, success: 'true' }, took / 1000);
+                metrics_1.operationDuration.observe({
+                    operation: 'read',
+                    collection: collectionName,
+                    success: 'true',
+                    read_preference: effectivePref
+                }, took / 1000);
                 return res;
             }
             catch (err) {
@@ -256,10 +385,15 @@ class ConnectionManager {
                     collection: collectionName,
                     success: false,
                     error: err.message,
-                    meta,
+                    meta: Object.assign(Object.assign({}, meta), { readPref: effectivePref }),
                     durationMs: took,
                 });
-                metrics_1.operationDuration.observe({ operation: 'read', collection: collectionName, success: 'false' }, took / 1000);
+                metrics_1.operationDuration.observe({
+                    operation: 'read',
+                    collection: collectionName,
+                    success: 'false',
+                    read_preference: effectivePref
+                }, took / 1000);
                 throw err;
             }
         });
@@ -306,14 +440,13 @@ class ConnectionManager {
             try {
                 (_a = (0, websocket_1.getIO)()) === null || _a === void 0 ? void 0 : _a.emit('log', doc);
                 if (!this.primaryDb) {
-                    logger_1.logger.warn('safeLog: no primaryDb, skipping db log. Logging to console instead.');
-                    logger_1.logger.info(JSON.stringify(doc));
+                    // logger.warn('safeLog: no primaryDb, skipping db log.');
                     return;
                 }
                 yield this.primaryDb.collection('logs').insertOne(doc);
             }
             catch (err) {
-                logger_1.logger.warn('safeLog failed: ' + err.message);
+                // silent fail for log
             }
         });
     }
@@ -321,11 +454,14 @@ class ConnectionManager {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.healthInterval)
                 clearInterval(this.healthInterval);
-            if (this.primaryClient) {
+            if (this.primaryClient)
                 yield this.primaryClient.close().catch(() => { });
-                this.primaryClient = null;
-                this.primaryDb = null;
-            }
+            for (const c of this.secondaryClients)
+                yield c.close().catch(() => { });
+            this.primaryClient = null;
+            this.primaryDb = null;
+            this.secondaryClients = [];
+            this.removeAllListeners();
         });
     }
 }

package/dist/config/metrics.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.operationDuration = exports.failoverCount = exports.connectionStatus = exports.register = void 0;
+exports.poolWaitQueue = exports.poolCheckedOut = exports.poolSize = exports.operationDuration = exports.failoverCount = exports.connectionStatus = exports.register = void 0;
 const prom_client_1 = __importDefault(require("prom-client"));
 // Create a Registry
 exports.register = new prom_client_1.default.Registry();
@@ -23,7 +23,25 @@ exports.failoverCount = new prom_client_1.default.Counter({
 exports.operationDuration = new prom_client_1.default.Histogram({
     name: 'node_balancer_operation_duration_seconds',
     help: 'Duration of database operations in seconds',
-    labelNames: ['operation', 'collection', 'success'],
+    labelNames: ['operation', 'collection', 'success', 'read_preference'],
     buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5],
     registers: [exports.register]
 });
+exports.poolSize = new prom_client_1.default.Gauge({
+    name: 'node_balancer_pool_size',
+    help: 'Current size of the connection pool',
+    labelNames: ['type', 'node'],
+    registers: [exports.register]
+});
+exports.poolCheckedOut = new prom_client_1.default.Gauge({
+    name: 'node_balancer_pool_checked_out',
+    help: 'Number of connections currently checked out',
+    labelNames: ['type', 'node'],
+    registers: [exports.register]
+});
+exports.poolWaitQueue = new prom_client_1.default.Gauge({
+    name: 'node_balancer_pool_wait_queue',
+    help: 'Number of requests waiting for a connection',
+    labelNames: ['type', 'node'],
+    registers: [exports.register]
+});

package/dist/index.js

@@ -1,5 +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 });
 exports.ConnectionManager = void 0;
 var connectionManager_1 = require("./config/connectionManager");
 Object.defineProperty(exports, "ConnectionManager", { enumerable: true, get: function () { return connectionManager_1.ConnectionManager; } });
+__exportStar(require("./nestjs"), exports);

package/dist/nestjs/index.js

@@ -0,0 +1,18 @@
+"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("./node-balancer.module"), exports);
+__exportStar(require("./node-balancer.decorators"), exports);

package/dist/nestjs/node-balancer.decorators.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_BALANCER_CONNECTION = void 0;
+exports.InjectConnectionManager = InjectConnectionManager;
+const common_1 = require("@nestjs/common");
+exports.NODE_BALANCER_CONNECTION = 'NODE_BALANCER_CONNECTION';
+function InjectConnectionManager() {
+    return (0, common_1.Inject)(exports.NODE_BALANCER_CONNECTION);
+}

package/dist/nestjs/node-balancer.module.js

@@ -0,0 +1,65 @@
+"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 __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 NodeBalancerModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeBalancerModule = void 0;
+const common_1 = require("@nestjs/common");
+const connectionManager_1 = require("../config/connectionManager");
+const node_balancer_decorators_1 = require("./node-balancer.decorators");
+let NodeBalancerModule = NodeBalancerModule_1 = class NodeBalancerModule {
+    static forRoot(options) {
+        const connectionProvider = {
+            provide: node_balancer_decorators_1.NODE_BALANCER_CONNECTION,
+            useFactory: () => __awaiter(this, void 0, void 0, function* () {
+                console.log('DEBUG: NodeBalancerModule useFactory called');
+                const manager = new connectionManager_1.ConnectionManager(options);
+                console.log('DEBUG: Manager created, initializing...');
+                yield manager.init();
+                console.log('DEBUG: Manager initialized successfully');
+                return manager;
+            }),
+        };
+        return {
+            module: NodeBalancerModule_1,
+            providers: [connectionProvider],
+            exports: [connectionProvider],
+        };
+    }
+    static forRootAsync(options) {
+        const connectionProvider = {
+            provide: node_balancer_decorators_1.NODE_BALANCER_CONNECTION,
+            useFactory: (...args) => __awaiter(this, void 0, void 0, function* () {
+                const config = yield options.useFactory(...args);
+                const manager = new connectionManager_1.ConnectionManager(config);
+                yield manager.init();
+                return manager;
+            }),
+            inject: options.inject || [],
+        };
+        return {
+            module: NodeBalancerModule_1,
+            imports: options.imports || [],
+            providers: [connectionProvider],
+            exports: [connectionProvider],
+        };
+    }
+};
+exports.NodeBalancerModule = NodeBalancerModule;
+exports.NodeBalancerModule = NodeBalancerModule = NodeBalancerModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], NodeBalancerModule);

package/dist/scripts/test_connection_string.js

@@ -0,0 +1,58 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connectionManager_1 = require("../config/connectionManager");
+function testConnectionString() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('--- Testing Single Connection String Support ---');
+        // Test 1: Standard Multi-node string
+        const uri = 'mongodb://localhost:27017,localhost:27018/test_db_string';
+        console.log(`Testing URI: ${uri}`);
+        const cm = new connectionManager_1.ConnectionManager({
+            connectionString: uri,
+            minPoolSize: 1,
+            maxPoolSize: 2
+        });
+        // internal check (using any to bypass private check for test)
+        const nodes = cm.nodes;
+        console.log('Parsed Nodes:', nodes);
+        const dbName = cm.dbName;
+        console.log('Parsed DB Name:', dbName);
+        if (nodes.length !== 2)
+            console.error('❌ Incorrect node count parsed');
+        else
+            console.log('✅ Node count correct');
+        if (dbName !== 'test_db_string')
+            console.error('❌ Incorrect DB name parsed');
+        else
+            console.log('✅ DB name correct');
+        try {
+            console.log('Attempting connection (might fail if no DB)...');
+            yield cm.init();
+            console.log('✅ Init success with connection string');
+            const db = cm.getDb();
+            if (db) {
+                console.log('✅ DB Connection active');
+            }
+            else {
+                console.warn('⚠️ No active DB (might be no primary available, but parse worked)');
+            }
+        }
+        catch (err) {
+            console.warn('⚠️ Connection failed (expected if DB is down):', err.message);
+            console.log('✅ Parsing logic verified independently of connection.');
+        }
+        finally {
+            yield cm.close();
+        }
+    });
+}
+testConnectionString();

package/dist/scripts/test_monitoring.js

@@ -0,0 +1,46 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connectionManager_1 = require("../config/connectionManager");
+function testMonitoring() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('--- Testing Monitoring & Events ---');
+        const uri = 'mongodb://localhost:27017,localhost:27018/test_monitor_db';
+        const cm = new connectionManager_1.ConnectionManager({
+            connectionString: uri,
+            minPoolSize: 1
+        });
+        // Check Initial Status
+        console.log('Initial Status:', cm.getStatus());
+        // Listen to Events
+        cm.on('ready', (info) => {
+            console.log('✅ EVENT: ready', info);
+        });
+        cm.on('primary-elected', (info) => {
+            console.log('✅ EVENT: primary-elected', info);
+        });
+        try {
+            console.log('Initializing...');
+            // We expect this to fail connecting if DB is down, but 'warn' event might emit?
+            // Or if it connects, 'ready' emits.
+            yield cm.init();
+            console.log('Post-Init Status:', cm.getStatus());
+        }
+        catch (err) {
+            console.warn('⚠️ Connection failed (expected if DB is down). Checking status anyway...');
+            console.log('Final Status:', cm.getStatus());
+        }
+        finally {
+            yield cm.close();
+        }
+    });
+}
+testMonitoring();

package/dist/scripts/test_nestjs_usage.js

@@ -0,0 +1,131 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const node_balancer_module_1 = require("../nestjs/node-balancer.module");
+const node_balancer_decorators_1 = require("../nestjs/node-balancer.decorators");
+const connectionManager_1 = require("../config/connectionManager");
+process.on('unhandledRejection', (reason, p) => {
+    console.error('Unhandled Rejection at:', p, 'reason:', reason);
+    process.exit(1);
+});
+process.on('uncaughtException', (err) => {
+    console.error('Uncaught Exception:', err);
+    process.exit(1);
+});
+let AppService = class AppService {
+    constructor(connectionManager) {
+        this.connectionManager = connectionManager;
+    }
+    check() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connectionManager) {
+                console.log('✅ ConnectionManager injected successfully!');
+                const db = this.connectionManager.getDb();
+                console.log(`✅ Database context available: ${db ? 'Yes' : 'No (init might be pending or failed)'}`);
+                return 'ok';
+            }
+            else {
+                console.error('❌ ConnectionManager failed to inject.');
+                return 'fail';
+            }
+        });
+    }
+};
+AppService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, node_balancer_decorators_1.InjectConnectionManager)()),
+    __metadata("design:paramtypes", [connectionManager_1.ConnectionManager])
+], AppService);
+let AppController = class AppController {
+    constructor(appService) {
+        this.appService = appService;
+    }
+    getHello() {
+        return this.appService.check();
+    }
+};
+__decorate([
+    (0, common_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], AppController.prototype, "getHello", null);
+AppController = __decorate([
+    (0, common_1.Controller)(),
+    __metadata("design:paramtypes", [AppService])
+], AppController);
+let AppModule = class AppModule {
+};
+AppModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            node_balancer_module_1.NodeBalancerModule.forRoot({
+                nodes: ['mongodb://localhost:27017', 'mongodb://localhost:27018', 'mongodb://localhost:27019'],
+                minPoolSize: 1,
+                maxPoolSize: 5,
+                dbName: 'test_nest'
+            })
+        ],
+        controllers: [AppController],
+        providers: [AppService],
+    })
+], AppModule);
+function manualTest() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('DEBUG: Starting manual test...');
+        try {
+            const m = new connectionManager_1.ConnectionManager({
+                nodes: ['mongodb://localhost:27017', 'mongodb://localhost:27018', 'mongodb://localhost:27019'],
+                minPoolSize: 1,
+                maxPoolSize: 5
+            });
+            yield m.init();
+            console.log('DEBUG: Manual test passed');
+            // await m.close(); // Keep it open or close? Close.
+        }
+        catch (e) {
+            console.error('DEBUG: Manual test failed', e);
+        }
+    });
+}
+function bootstrap() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('🚀 Starting NestJS Context...');
+        yield manualTest();
+        try {
+            const app = yield core_1.NestFactory.createApplicationContext(AppModule, { logger: ['error', 'warn', 'debug', 'verbose'] });
+            const service = app.get(AppService);
+            yield service.check();
+            yield app.close();
+            console.log('✅ NestJS Test Finished.');
+        }
+        catch (error) {
+            console.error('❌ NestJS Boot failed:', error);
+            process.exit(1);
+        }
+    });
+}
+bootstrap();

package/dist/scripts/test_read_pref.js

@@ -0,0 +1,87 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connectionManager_1 = require("../config/connectionManager");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config({ path: '.env.local' });
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const envNodes = process.env.MONGODB_NODES || '';
+        const nodes = envNodes ? envNodes.split(',') : [
+            'mongodb://localhost:27017',
+            'mongodb://localhost:27018',
+            'mongodb://localhost:27019'
+        ];
+        console.log('--- Testing Read Preference and Multi-Node support ---');
+        console.log(`Nodes: ${nodes.join(', ')}`);
+        const db = new connectionManager_1.ConnectionManager({
+            nodes,
+            healthCheckIntervalMs: 2000,
+            maxPoolSize: 5,
+            minPoolSize: 1
+        });
+        try {
+            yield db.init();
+            console.log('✅ Initialization complete.');
+            // Test Write (Primary)
+            console.log('📝 Testing Write (Primary)...');
+            try {
+                yield db.write('test_reads', (col) => __awaiter(this, void 0, void 0, function* () {
+                    yield col.insertOne({ test: 'read_pref', date: new Date() });
+                }));
+                console.log('✅ Write successful.');
+            }
+            catch (err) {
+                console.warn('⚠️ Write failed (No Primary?), skipping to read tests... Error:', err.message);
+            }
+            // Test Read (Primary default)
+            console.log('📖 Testing Read (Primary Default)...');
+            try {
+                const res1 = yield db.read('test_reads', (col) => __awaiter(this, void 0, void 0, function* () {
+                    return col.findOne({ test: 'read_pref' });
+                }));
+                console.log('✅ Read Primary result:', res1 === null || res1 === void 0 ? void 0 : res1._id);
+            }
+            catch (err) {
+                console.warn('⚠️ Read Primary failed (No Primary?), skipping... Error:', err.message);
+            }
+            // Test Read (Secondary Strict)
+            console.log('📖 Testing Read (Secondary Strict)...');
+            try {
+                const res2 = yield db.read('test_reads', (col) => __awaiter(this, void 0, void 0, function* () {
+                    return col.findOne({ test: 'read_pref' });
+                }), {}, 'secondary'); // <--- requesting secondary
+                console.log('✅ Read Secondary result:', res2 === null || res2 === void 0 ? void 0 : res2._id);
+            }
+            catch (err) {
+                console.error('❌ Read Secondary failed:', err.message);
+            }
+            // Test Read (Secondary Preferred)
+            console.log('📖 Testing Read (Secondary Preferred)...');
+            const res3 = yield db.read('test_reads', (col) => __awaiter(this, void 0, void 0, function* () {
+                return col.findOne({ test: 'read_pref' });
+            }), {}, 'secondaryPreferred');
+            console.log('✅ Read SecondaryPreferred result:', res3 === null || res3 === void 0 ? void 0 : res3._id);
+        }
+        catch (err) {
+            console.error('❌ Test failed:', err);
+        }
+        finally {
+            yield db.close();
+            console.log('👋 Connection closed.');
+            process.exit(0);
+        }
+    });
+}
+run();

package/dist/server.js

@@ -23,7 +23,8 @@ app_1.default.get('/metrics', (req, res) => __awaiter(void 0, void 0, void 0, fu
         res.end(yield metrics_1.register.metrics());
     }
     catch (ex) {
-        res.status(500).end(ex);
+        logger_1.logger.error('Error while serving /metrics endpoint', ex);
+        res.status(500).end('Internal server error');
     }
 }));
 const server = app_1.default.listen(PORT, () => {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "replica-failover-mongodb-ts",
-  "version": "3.0.3",
+  "version": "3.0.9",
   "description": "O sistema replica um dos conceitos básicos da arquitetura de sistemas distribuído, na qual ele tem uma API em express.js com TypeScript, e usando o mongoDB com replicaSET e failover, consegue automáticamente garantir disponibilidade e redundância de dados das requisições.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
+    "test": "node dist/scripts/test_read_pref.js",
     "dev": "nodemon --exec ts-node src/server.ts",
     "build": "tsc",
     "start": "node dist/server.js",
@@ -29,6 +30,11 @@
   "keywords": [],
   "author": "",
   "license": "ISC",
+  "peerDependencies": {
+    "@nestjs/common": "^8.0.0 || ^9.0.0 || ^10.0.0",
+    "@nestjs/core": "^8.0.0 || ^9.0.0 || ^10.0.0",
+    "rxjs": "^7.0.0"
+  },
   "dependencies": {
     "@types/blessed": "^0.1.26",
     "@types/inquirer": "^9.0.9",
@@ -46,11 +52,16 @@
     "winston": "^3.18.3"
   },
   "devDependencies": {
+    "@nestjs/common": "^11.1.13",
+    "@nestjs/core": "^11.1.13",
+    "@nestjs/platform-express": "^11.1.13",
     "@types/express": "^5.0.3",
     "@types/morgan": "^1.9.10",
     "@types/node": "^24.8.0",
     "nodemon": "^3.1.10",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.6.3"
   }
 }