opticedge-cloud-utils 1.1.9 → 1.1.11

package/dist/db/mongo.d.ts

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

package/dist/db/mongo.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo = connectToMongo;
+exports.connectToMongoWithUri = connectToMongoWithUri;
 exports.getCollection = getCollection;
 const mongodb_1 = require("mongodb");
 const secrets_1 = require("../secrets");
@@ -20,6 +21,18 @@ async function connectToMongo(projectId, uriSecret, dbName) {
     }
     await connectPromise;
 }
+async function connectToMongoWithUri(uri, dbName) {
+    if (db)
+        return; // already connected
+    if (!connectPromise) {
+        connectPromise = (async () => {
+            client = new mongodb_1.MongoClient(uri);
+            await client.connect();
+            db = client.db(dbName);
+        })();
+    }
+    await connectPromise;
+}
 function getCollection(name) {
     if (!db)
         throw new Error('Mongo not initialized');

package/dist/db/mongo2.d.ts

@@ -1,4 +1,5 @@
 import { Db, Collection, Document } from 'mongodb';
 export declare function connectToMongo2(projectId: string, uriSecret: string): Promise<void>;
+export declare function connectToMongoWithUri2(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>;

package/dist/db/mongo2.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo2 = connectToMongo2;
+exports.connectToMongoWithUri2 = connectToMongoWithUri2;
 exports.getDb2 = getDb2;
 exports.getCollection2 = getCollection2;
 // Multi DB safe util
@@ -20,6 +21,17 @@ async function connectToMongo2(projectId, uriSecret) {
     }
     await connectPromise;
 }
+async function connectToMongoWithUri2(uri) {
+    if (client)
+        return; // already connected
+    if (!connectPromise) {
+        connectPromise = (async () => {
+            client = new mongodb_1.MongoClient(uri);
+            await client.connect();
+        })();
+    }
+    await connectPromise;
+}
 function getDb2(dbName) {
     if (!client)
         throw new Error('Mongo not initialized');

package/dist/db/mongo3.d.ts

@@ -1,5 +1,6 @@
 import { MongoClient, Db, Collection, Document } from 'mongodb';
 export declare function connectToMongo3(projectId: string, uriSecret: string): Promise<MongoClient>;
+export declare function connectToMongoWithUri3(uri: string): Promise<MongoClient>;
 export declare function getDb3(uriSecret: string, dbName: string): Db;
 export declare function getCollection3<T extends Document = Document>(uriSecret: string, dbName: string, collectionName: string): Collection<T>;
 export declare const __mongoClients: Map<string, MongoClient>;

package/dist/db/mongo3.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__connectPromises = exports.__mongoClients = void 0;
 exports.connectToMongo3 = connectToMongo3;
+exports.connectToMongoWithUri3 = connectToMongoWithUri3;
 exports.getDb3 = getDb3;
 exports.getCollection3 = getCollection3;
 // Multi cluster safe util
@@ -25,6 +26,18 @@ async function connectToMongo3(projectId, uriSecret) {
     await connectPromises.get(uriSecret);
     return clients.get(uriSecret);
 }
+async function connectToMongoWithUri3(uri) {
+    if (!connectPromises.has(uri)) {
+        const promise = (async () => {
+            const client = new mongodb_1.MongoClient(uri);
+            await client.connect();
+            clients.set(uri, client);
+        })();
+        connectPromises.set(uri, promise);
+    }
+    await connectPromises.get(uri);
+    return clients.get(uri);
+}
 function getDb3(uriSecret, dbName) {
     const client = clients.get(uriSecret);
     if (!client) {

package/dist/task.js

@@ -62,8 +62,9 @@ async function createTask(projectId, region, queueId, data, serviceAccount, audi
     // retry options with sensible defaults; allow caller to override via opts.retryOptions
     const retryOpts = {
         retries: 3,
-        baseDelayMs: 200,
-        maxDelayMs: 3000,
+        baseDelayMs: 300,
+        maxDelayMs: 2000,
+        timeoutMs: 15000,
         isRetryable: isRetryableCloudTasks,
         onRetry: (err, attempt, delay) => {
             console.warn(`createTask retry #${attempt} in ${delay}ms — ${String(err?.message ?? err)}`);

package/package.json

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

package/src/db/mongo.ts

@@ -20,6 +20,20 @@ export async function connectToMongo(projectId: string, uriSecret: string, dbNam
   await connectPromise
 }
 
+export async function connectToMongoWithUri(uri: string, dbName: string) {
+  if (db) return // already connected
+
+  if (!connectPromise) {
+    connectPromise = (async () => {
+      client = new MongoClient(uri)
+      await client.connect()
+      db = client.db(dbName)
+    })()
+  }
+
+  await connectPromise
+}
+
 export function getCollection<T extends Document = Document>(name: string): Collection<T> {
   if (!db) throw new Error('Mongo not initialized')
   return db.collection<T>(name)

package/src/db/mongo2.ts

@@ -19,6 +19,19 @@ export async function connectToMongo2(projectId: string, uriSecret: string) {
   await connectPromise
 }
 
+export async function connectToMongoWithUri2(uri: string) {
+  if (client) return // already connected
+
+  if (!connectPromise) {
+    connectPromise = (async () => {
+      client = new MongoClient(uri)
+      await client.connect()
+    })()
+  }
+
+  await connectPromise
+}
+
 export function getDb2(dbName: string): Db {
   if (!client) throw new Error('Mongo not initialized')
   return client.db(dbName)

package/src/db/mongo3.ts

@@ -26,6 +26,22 @@ export async function connectToMongo3(projectId: string, uriSecret: string): Pro
   return clients.get(uriSecret)!
 }
 
+export async function connectToMongoWithUri3(uri: string): Promise<MongoClient> {
+  if (!connectPromises.has(uri)) {
+    const promise = (async () => {
+      const client = new MongoClient(uri)
+      await client.connect()
+      clients.set(uri, client)
+    })()
+
+    connectPromises.set(uri, promise)
+  }
+
+  await connectPromises.get(uri)!
+
+  return clients.get(uri)!
+}
+
 export function getDb3(uriSecret: string, dbName: string): Db {
   const client = clients.get(uriSecret)
   if (!client) {

package/src/task.ts

@@ -85,8 +85,9 @@ export async function createTask(
   // retry options with sensible defaults; allow caller to override via opts.retryOptions
   const retryOpts: RetryOptions = {
     retries: 3,
-    baseDelayMs: 200,
-    maxDelayMs: 3000,
+    baseDelayMs: 300,
+    maxDelayMs: 2000,
+    timeoutMs: 15000,
     isRetryable: isRetryableCloudTasks,
     onRetry: (err, attempt, delay) => {
       console.warn(`createTask retry #${attempt} in ${delay}ms — ${String(err?.message ?? err)}`)

package/tests/db/mongo.test.ts

@@ -1,4 +1,4 @@
-import { connectToMongo, getCollection } from '../../src/db/mongo'
+import { connectToMongo, connectToMongoWithUri, getCollection } from '../../src/db/mongo'
 import { MongoClient, Db } from 'mongodb'
 import * as secretsModule from '../../src/secrets'
 
@@ -45,3 +45,23 @@ describe('Mongo Utils', () => {
     })
   })
 })
+
+describe('Mongo Utils 2', () => {
+  it('should connect to MongoDB and store client/db', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri } = require('../../src/db/mongo')
+      await connectToMongoWithUri('mongo-uri', 'test-db')
+
+      expect(mockConnect).toHaveBeenCalled()
+      expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    })
+  })
+
+  it('should return a collection when db is initialized', async () => {
+    await connectToMongoWithUri('mongo-uri', 'test-db')
+    getCollection('users')
+
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+})

package/tests/db/mongo2.test.ts

@@ -1,4 +1,9 @@
-import { connectToMongo2, getDb2, getCollection2 } from '../../src/db/mongo2'
+import {
+  connectToMongo2,
+  getDb2,
+  getCollection2,
+  connectToMongoWithUri2
+} from '../../src/db/mongo2'
 import { MongoClient, Db } from 'mongodb'
 import * as secretsModule from '../../src/secrets'
 
@@ -61,3 +66,31 @@ describe('Mongo Utils', () => {
     })
   })
 })
+
+describe('Mongo Utils 2', () => {
+  it('should connect to MongoDB and store client', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri2 } = require('../../src/db/mongo2')
+      await connectToMongoWithUri2('mongo-uri')
+
+      expect(mockConnect).toHaveBeenCalled()
+    })
+  })
+
+  it('should return a Db instance when client is initialized', async () => {
+    await connectToMongoWithUri2('mongo-uri')
+
+    const db = getDb2('test-db')
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(db).toBe(mockDb)
+  })
+
+  it('should return a collection when client is initialized', async () => {
+    await connectToMongoWithUri2('mongo-uri')
+
+    getCollection2('test-db', 'users')
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+})

package/tests/db/mongo3.test.ts

@@ -3,7 +3,8 @@ import {
   getDb3,
   getCollection3,
   __mongoClients,
-  __connectPromises
+  __connectPromises,
+  connectToMongoWithUri3
 } from '../../src/db/mongo3'
 import { MongoClient, Db } from 'mongodb'
 import * as secretsModule from '../../src/secrets'
@@ -98,3 +99,51 @@ describe('MongoClientManager (multi-cluster)', () => {
     })
   })
 })
+
+describe('MongoClientManager (multi-cluster) 2', () => {
+  const clusterAUri = 'clusterA-uri'
+  const clusterBUri = 'clusterB-uri'
+
+  it('should connect and cache client for a single cluster', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri3, getDb3 } = require('../../src/db/mongo3')
+      await connectToMongoWithUri3(clusterAUri)
+
+      expect(mockConnect).toHaveBeenCalled()
+
+      const db = getDb3(clusterAUri, 'test-db')
+      expect(mockClient.db).toHaveBeenCalledWith('test-db')
+      expect(db).toBe(mockDb)
+    })
+  })
+
+  it('should reuse client if already connected', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri3 } = require('../../src/db/mongo3')
+      await connectToMongoWithUri3(clusterAUri)
+      await connectToMongoWithUri3(clusterAUri)
+      expect(mockConnect).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  it('should connect and cache separate clients for multiple clusters', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri3 } = require('../../src/db/mongo3')
+      await connectToMongoWithUri3(clusterAUri)
+      await connectToMongoWithUri3(clusterBUri)
+      expect(mockConnect).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  it('should return a collection when client is initialized', async () => {
+    await connectToMongoWithUri3(clusterAUri)
+
+    getCollection3(clusterAUri, 'test-db', 'users')
+
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+})