opticedge-cloud-utils 1.1.30 → 1.1.31

package/dist/db/mongo.d.ts

@@ -2,3 +2,4 @@ import { Db, Collection, Document } from 'mongodb';
 export declare function connectToMongo(uri: string, dbName: string): Promise<void>;
 export declare function getDb(): Db;
 export declare function getCollection<T extends Document = Document>(name: string): Collection<T>;
+export declare function closeMongo(): Promise<void>;

package/dist/db/mongo.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo = connectToMongo;
 exports.getDb = getDb;
 exports.getCollection = getCollection;
+exports.closeMongo = closeMongo;
 const mongodb_1 = require("mongodb");
 let client;
 let db;
@@ -29,3 +30,11 @@ function getCollection(name) {
         throw new Error('Mongo not initialized');
     return db.collection(name);
 }
+async function closeMongo() {
+    if (!client)
+        return;
+    await client.close();
+    client = undefined;
+    db = undefined;
+    connectPromise = undefined;
+}

package/dist/db/mongo2.d.ts

@@ -2,3 +2,4 @@ import { Db, Collection, Document } from 'mongodb';
 export declare function connectToMongo2(uri: string): Promise<void>;
 export declare function getDb2(dbName: string): Db;
 export declare function getCollection2<T extends Document = Document>(dbName: string, collectionName: string): Collection<T>;
+export declare function closeMongo2(): Promise<void>;

package/dist/db/mongo2.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo2 = connectToMongo2;
 exports.getDb2 = getDb2;
 exports.getCollection2 = getCollection2;
+exports.closeMongo2 = closeMongo2;
 // Multi DB safe util
 const mongodb_1 = require("mongodb");
 let client;
@@ -26,3 +27,10 @@ function getDb2(dbName) {
 function getCollection2(dbName, collectionName) {
     return getDb2(dbName).collection(collectionName);
 }
+async function closeMongo2() {
+    if (!client)
+        return;
+    await client.close();
+    client = undefined;
+    connectPromise = undefined;
+}

package/dist/db/mongo3.d.ts

@@ -2,5 +2,7 @@ import { MongoClient, Db, Collection, Document } from 'mongodb';
 export declare function connectToMongo3(uri: string): Promise<MongoClient>;
 export declare function getDb3(uri: string, dbName: string): Db;
 export declare function getCollection3<T extends Document = Document>(uri: string, dbName: string, collectionName: string): Collection<T>;
+export declare function closeMongo3(uri: string): Promise<void>;
+export declare function closeAllMongo3(): Promise<void>;
 export declare const __mongoClients: Map<string, MongoClient>;
 export declare const __connectPromises: Map<string, Promise<void>>;

package/dist/db/mongo3.js

@@ -4,6 +4,8 @@ exports.__connectPromises = exports.__mongoClients = void 0;
 exports.connectToMongo3 = connectToMongo3;
 exports.getDb3 = getDb3;
 exports.getCollection3 = getCollection3;
+exports.closeMongo3 = closeMongo3;
+exports.closeAllMongo3 = closeAllMongo3;
 // Multi cluster safe util
 const mongodb_1 = require("mongodb");
 const clients = new Map();
@@ -30,5 +32,18 @@ function getDb3(uri, dbName) {
 function getCollection3(uri, dbName, collectionName) {
     return getDb3(uri, dbName).collection(collectionName);
 }
+async function closeMongo3(uri) {
+    const client = clients.get(uri);
+    if (client) {
+        await client.close();
+    }
+    clients.delete(uri);
+    connectPromises.delete(uri);
+}
+async function closeAllMongo3() {
+    await Promise.all(Array.from(clients.values()).map(client => client.close()));
+    clients.clear();
+    connectPromises.clear();
+}
 exports.__mongoClients = clients;
 exports.__connectPromises = connectPromises;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.1.30",
+  "version": "1.1.31",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/db/mongo.ts

@@ -1,7 +1,7 @@
 import { MongoClient, Db, Collection, Document } from 'mongodb'
 
-let client: MongoClient
-let db: Db
+let client: MongoClient | undefined
+let db: Db | undefined
 let connectPromise: Promise<void> | undefined
 
 export async function connectToMongo(uri: string, dbName: string) {
@@ -27,3 +27,13 @@ export function getCollection<T extends Document = Document>(name: string): Coll
   if (!db) throw new Error('Mongo not initialized')
   return db.collection<T>(name)
 }
+
+export async function closeMongo(): Promise<void> {
+  if (!client) return
+
+  await client.close()
+
+  client = undefined
+  db = undefined
+  connectPromise = undefined
+}

package/src/db/mongo2.ts

@@ -1,7 +1,7 @@
 // Multi DB safe util
 import { MongoClient, Db, Collection, Document } from 'mongodb'
 
-let client: MongoClient
+let client: MongoClient | undefined
 let connectPromise: Promise<void> | undefined
 
 export async function connectToMongo2(uri: string) {
@@ -28,3 +28,12 @@ export function getCollection2<T extends Document = Document>(
 ): Collection<T> {
   return getDb2(dbName).collection<T>(collectionName)
 }
+
+export async function closeMongo2(): Promise<void> {
+  if (!client) return
+
+  await client.close()
+
+  client = undefined
+  connectPromise = undefined
+}

package/src/db/mongo3.ts

@@ -37,5 +37,23 @@ export function getCollection3<T extends Document = Document>(
   return getDb3(uri, dbName).collection<T>(collectionName)
 }
 
+export async function closeMongo3(uri: string): Promise<void> {
+  const client = clients.get(uri)
+
+  if (client) {
+    await client.close()
+  }
+
+  clients.delete(uri)
+  connectPromises.delete(uri)
+}
+
+export async function closeAllMongo3(): Promise<void> {
+  await Promise.all(Array.from(clients.values()).map(client => client.close()))
+
+  clients.clear()
+  connectPromises.clear()
+}
+
 export const __mongoClients = clients
 export const __connectPromises = connectPromises

package/tests/db/mongo.test.ts

@@ -1,4 +1,4 @@
-import { connectToMongo, getCollection, getDb } from '../../src/db/mongo'
+import { connectToMongo, getCollection, getDb, closeMongo } from '../../src/db/mongo'
 import { MongoClient, Db } from 'mongodb'
 
 jest.mock('mongodb')
@@ -8,12 +8,17 @@ const mockDb = {
 } as unknown as Db
 
 const mockConnect = jest.fn()
+const mockClose = jest.fn()
+
 const mockClient = {
   connect: mockConnect,
+  close: mockClose,
   db: jest.fn().mockReturnValue(mockDb)
 } as unknown as MongoClient
 
-beforeEach(() => {
+beforeEach(async () => {
+  await closeMongo()
+
   jest.clearAllMocks()
   ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
 })
@@ -22,10 +27,19 @@ describe('Mongo Utils', () => {
   it('should connect to MongoDB and store client/db', async () => {
     await connectToMongo('mongo-uri', 'test-db')
 
+    expect(MongoClient).toHaveBeenCalledWith('mongo-uri')
     expect(mockConnect).toHaveBeenCalled()
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
   })
 
+  it('should not reconnect if db is already initialized', async () => {
+    await connectToMongo('mongo-uri', 'test-db')
+    await connectToMongo('mongo-uri', 'test-db')
+
+    expect(MongoClient).toHaveBeenCalledTimes(1)
+    expect(mockConnect).toHaveBeenCalledTimes(1)
+  })
+
   it('should return a collection when db is initialized', async () => {
     await connectToMongo('mongo-uri', 'test-db')
     getCollection('users')
@@ -35,17 +49,23 @@ describe('Mongo Utils', () => {
 
   it('getDb should return the initialized Db instance', async () => {
     await connectToMongo('mongo-uri', 'test-db')
-    const got = getDb()
-    expect(got).toBe(mockDb)
+
+    expect(getDb()).toBe(mockDb)
+  })
+
+  it('should throw error if db is not initialized', async () => {
+    await closeMongo()
+
+    expect(() => getCollection('users')).toThrow(/Mongo not initialized/)
+    expect(() => getDb()).toThrow(/Mongo not initialized/)
   })
 
-  it('should throw error if db is not initialized (getCollection/getDb)', () => {
-    jest.isolateModules(() => {
-      // require a fresh copy of the module so module-level state is uninitialized
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const mod = require('../../src/db/mongo')
-      expect(() => mod.getCollection('users')).toThrow(/Mongo not initialized/)
-      expect(() => mod.getDb()).toThrow(/Mongo not initialized/)
-    })
+  it('should close Mongo and reset state', async () => {
+    await connectToMongo('mongo-uri', 'test-db')
+    await closeMongo()
+
+    expect(mockClose).toHaveBeenCalled()
+
+    expect(() => getDb()).toThrow(/Mongo not initialized/)
   })
 })

package/tests/db/mongo2.test.ts

@@ -1,4 +1,4 @@
-import { connectToMongo2, getDb2, getCollection2 } from '../../src/db/mongo2'
+import { connectToMongo2, getDb2, getCollection2, closeMongo2 } from '../../src/db/mongo2'
 import { MongoClient, Db } from 'mongodb'
 
 jest.mock('mongodb')
@@ -8,12 +8,17 @@ const mockDb = {
 } as unknown as Db
 
 const mockConnect = jest.fn()
+const mockClose = jest.fn()
+
 const mockClient = {
   connect: mockConnect,
+  close: mockClose,
   db: jest.fn().mockReturnValue(mockDb)
 } as unknown as MongoClient
 
-beforeEach(() => {
+beforeEach(async () => {
+  await closeMongo2()
+
   jest.clearAllMocks()
   ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
 })
@@ -22,13 +27,23 @@ describe('Mongo Utils', () => {
   it('should connect to MongoDB and store client', async () => {
     await connectToMongo2('mongo-uri')
 
-    expect(mockConnect).toHaveBeenCalled()
+    expect(MongoClient).toHaveBeenCalledWith('mongo-uri')
+    expect(mockConnect).toHaveBeenCalledTimes(1)
+  })
+
+  it('should not reconnect if client is already initialized', async () => {
+    await connectToMongo2('mongo-uri')
+    await connectToMongo2('mongo-uri')
+
+    expect(MongoClient).toHaveBeenCalledTimes(1)
+    expect(mockConnect).toHaveBeenCalledTimes(1)
   })
 
   it('should return a Db instance when client is initialized', async () => {
     await connectToMongo2('mongo-uri')
 
     const db = getDb2('test-db')
+
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
     expect(db).toBe(mockDb)
   })
@@ -37,23 +52,23 @@ describe('Mongo Utils', () => {
     await connectToMongo2('mongo-uri')
 
     getCollection2('test-db', 'users')
+
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
     expect(mockDb.collection).toHaveBeenCalledWith('users')
   })
 
-  it('should throw error if client is not initialized (getDb)', () => {
-    jest.isolateModules(() => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { getDb2 } = require('../../src/db/mongo2')
-      expect(() => getDb2('test-db')).toThrow('Mongo not initialized')
-    })
+  it('should throw error if client is not initialized', async () => {
+    await closeMongo2()
+
+    expect(() => getDb2('test-db')).toThrow('Mongo not initialized')
+    expect(() => getCollection2('test-db', 'users')).toThrow('Mongo not initialized')
   })
 
-  it('should throw error if client is not initialized (getCollection)', () => {
-    jest.isolateModules(() => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { getCollection2 } = require('../../src/db/mongo2')
-      expect(() => getCollection2('test-db', 'users')).toThrow('Mongo not initialized')
-    })
+  it('should close Mongo and reset state', async () => {
+    await connectToMongo2('mongo-uri')
+    await closeMongo2()
+
+    expect(mockClose).toHaveBeenCalledTimes(1)
+    expect(() => getDb2('test-db')).toThrow('Mongo not initialized')
   })
 })

package/tests/db/mongo3.test.ts

@@ -2,6 +2,8 @@ import {
   connectToMongo3,
   getDb3,
   getCollection3,
+  closeMongo3,
+  closeAllMongo3,
   __mongoClients,
   __connectPromises
 } from '../../src/db/mongo3'
@@ -14,12 +16,17 @@ const mockDb = {
 } as unknown as Db
 
 const mockConnect = jest.fn()
+const mockClose = jest.fn()
+
 const mockClient = {
   connect: mockConnect,
+  close: mockClose,
   db: jest.fn().mockReturnValue(mockDb)
 } as unknown as MongoClient
 
-beforeEach(() => {
+beforeEach(async () => {
+  await closeAllMongo3()
+
   jest.clearAllMocks()
   __mongoClients.clear()
   __connectPromises.clear()
@@ -33,9 +40,11 @@ describe('MongoClientManager (multi-cluster)', () => {
   it('should connect and cache client for a single cluster', async () => {
     await connectToMongo3(clusterAUri)
 
-    expect(mockConnect).toHaveBeenCalled()
+    expect(MongoClient).toHaveBeenCalledWith(clusterAUri)
+    expect(mockConnect).toHaveBeenCalledTimes(1)
 
     const db = getDb3(clusterAUri, 'test-db')
+
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
     expect(db).toBe(mockDb)
   })
@@ -44,6 +53,7 @@ describe('MongoClientManager (multi-cluster)', () => {
     await connectToMongo3(clusterAUri)
     await connectToMongo3(clusterAUri)
 
+    expect(MongoClient).toHaveBeenCalledTimes(1)
     expect(mockConnect).toHaveBeenCalledTimes(1)
   })
 
@@ -51,6 +61,7 @@ describe('MongoClientManager (multi-cluster)', () => {
     await connectToMongo3(clusterAUri)
     await connectToMongo3(clusterBUri)
 
+    expect(MongoClient).toHaveBeenCalledTimes(2)
     expect(mockConnect).toHaveBeenCalledTimes(2)
   })
 
@@ -63,21 +74,31 @@ describe('MongoClientManager (multi-cluster)', () => {
     expect(mockDb.collection).toHaveBeenCalledWith('users')
   })
 
-  it('should throw error if client not initialized (getDb)', () => {
-    jest.isolateModules(() => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { getDb3 } = require('../../src/db/mongo3')
-      expect(() => getDb3('unknown-uri', 'some-db')).toThrow('Mongo client not initialized')
-    })
+  it('should throw error if client not initialized', () => {
+    expect(() => getDb3('unknown-uri', 'some-db')).toThrow('Mongo client not initialized')
+    expect(() => getCollection3('unknown-uri', 'some-db', 'users')).toThrow(
+      'Mongo client not initialized'
+    )
+  })
+
+  it('should close one Mongo client and reset only that uri', async () => {
+    await connectToMongo3(clusterAUri)
+    await closeMongo3(clusterAUri)
+
+    expect(mockClose).toHaveBeenCalledTimes(1)
+    expect(__mongoClients.has(clusterAUri)).toBe(false)
+    expect(__connectPromises.has(clusterAUri)).toBe(false)
+    expect(() => getDb3(clusterAUri, 'test-db')).toThrow('Mongo client not initialized')
   })
 
-  it('should throw error if client not initialized (getCollection)', () => {
-    jest.isolateModules(() => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { getCollection3 } = require('../../src/db/mongo3')
-      expect(() => getCollection3('unknown-uri', 'some-db', 'users')).toThrow(
-        'Mongo client not initialized'
-      )
-    })
+  it('should close all Mongo clients and reset state', async () => {
+    await connectToMongo3(clusterAUri)
+    await connectToMongo3(clusterBUri)
+
+    await closeAllMongo3()
+
+    expect(mockClose).toHaveBeenCalledTimes(2)
+    expect(__mongoClients.size).toBe(0)
+    expect(__connectPromises.size).toBe(0)
   })
 })