opticedge-cloud-utils 1.1.16 → 1.1.18

package/dist/db/mongo.d.ts

@@ -1,5 +1,4 @@
 import { Db, 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 connectToMongo(uri: string, dbName: string): Promise<void>;
 export declare function getDb(): Db;
 export declare function getCollection<T extends Document = Document>(name: string): Collection<T>;

package/dist/db/mongo.js

@@ -1,28 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo = connectToMongo;
-exports.connectToMongoWithUri = connectToMongoWithUri;
 exports.getDb = getDb;
 exports.getCollection = getCollection;
 const mongodb_1 = require("mongodb");
-const secrets_1 = require("../secrets");
 let client;
 let db;
 let connectPromise;
-async function connectToMongo(projectId, uriSecret, dbName) {
-    if (db)
-        return; // already connected
-    if (!connectPromise) {
-        connectPromise = (async () => {
-            const uri = await (0, secrets_1.getSecret)(projectId, uriSecret);
-            client = new mongodb_1.MongoClient(uri);
-            await client.connect();
-            db = client.db(dbName);
-        })();
-    }
-    await connectPromise;
-}
-async function connectToMongoWithUri(uri, dbName) {
+async function connectToMongo(uri, dbName) {
     if (db)
         return; // already connected
     if (!connectPromise) {

package/dist/db/mongo2.d.ts

@@ -1,5 +1,4 @@
 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 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>;

package/dist/db/mongo2.js

@@ -1,27 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo2 = connectToMongo2;
-exports.connectToMongoWithUri2 = connectToMongoWithUri2;
 exports.getDb2 = getDb2;
 exports.getCollection2 = getCollection2;
 // Multi DB safe util
 const mongodb_1 = require("mongodb");
-const secrets_1 = require("../secrets");
 let client;
 let connectPromise;
-async function connectToMongo2(projectId, uriSecret) {
-    if (client)
-        return; // already connected
-    if (!connectPromise) {
-        connectPromise = (async () => {
-            const uri = await (0, secrets_1.getSecret)(projectId, uriSecret);
-            client = new mongodb_1.MongoClient(uri);
-            await client.connect();
-        })();
-    }
-    await connectPromise;
-}
-async function connectToMongoWithUri2(uri) {
+async function connectToMongo2(uri) {
     if (client)
         return; // already connected
     if (!connectPromise) {

package/dist/db/mongo3.d.ts

@@ -1,7 +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 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 const __mongoClients: Map<string, MongoClient>;
 export declare const __connectPromises: Map<string, Promise<void>>;

package/dist/db/mongo3.js

@@ -2,31 +2,13 @@
 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
 const mongodb_1 = require("mongodb");
-const secrets_1 = require("../secrets");
 const clients = new Map();
 const connectPromises = new Map();
-async function connectToMongo3(projectId, uriSecret) {
-    if (clients.has(uriSecret)) {
-        return clients.get(uriSecret);
-    }
-    if (!connectPromises.has(uriSecret)) {
-        const promise = (async () => {
-            const uri = await (0, secrets_1.getSecret)(projectId, uriSecret);
-            const client = new mongodb_1.MongoClient(uri);
-            await client.connect();
-            clients.set(uriSecret, client);
-        })();
-        connectPromises.set(uriSecret, promise);
-    }
-    await connectPromises.get(uriSecret);
-    return clients.get(uriSecret);
-}
-async function connectToMongoWithUri3(uri) {
+async function connectToMongo3(uri) {
     if (!connectPromises.has(uri)) {
         const promise = (async () => {
             const client = new mongodb_1.MongoClient(uri);
@@ -38,15 +20,15 @@ async function connectToMongoWithUri3(uri) {
     await connectPromises.get(uri);
     return clients.get(uri);
 }
-function getDb3(uriSecret, dbName) {
-    const client = clients.get(uriSecret);
+function getDb3(uri, dbName) {
+    const client = clients.get(uri);
     if (!client) {
-        throw new Error(`Mongo client for secret "${uriSecret}" not initialized`);
+        throw new Error(`Mongo client not initialized`);
     }
     return client.db(dbName);
 }
-function getCollection3(uriSecret, dbName, collectionName) {
-    return getDb3(uriSecret, dbName).collection(collectionName);
+function getCollection3(uri, dbName, collectionName) {
+    return getDb3(uri, dbName).collection(collectionName);
 }
 exports.__mongoClients = clients;
 exports.__connectPromises = connectPromises;

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from './auth';
 export * from './chunk';
 export * from './env';
 export * from './parser';
+export * from './pub';
 export * from './regex';
 export * from './retry';
 export * from './secrets';

package/dist/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./auth"), exports);
 __exportStar(require("./chunk"), exports);
 __exportStar(require("./env"), exports);
 __exportStar(require("./parser"), exports);
+__exportStar(require("./pub"), exports);
 __exportStar(require("./regex"), exports);
 __exportStar(require("./retry"), exports);
 __exportStar(require("./secrets"), exports);

package/dist/pub.d.ts

@@ -0,0 +1 @@
+export declare function publishMessage(projectId: string, topicName: string, envelope: Record<string, unknown>): Promise<string>;

package/dist/pub.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishMessage = publishMessage;
+// src/pub.ts
+const pubsub_1 = require("@google-cloud/pubsub");
+const pubsubCache = new Map();
+function getPubSub(projectId) {
+    if (!projectId)
+        throw new Error('projectId is required');
+    let ps = pubsubCache.get(projectId);
+    if (!ps) {
+        ps = new pubsub_1.PubSub({ projectId });
+        pubsubCache.set(projectId, ps);
+    }
+    return ps;
+}
+async function publishMessage(projectId, topicName, envelope) {
+    if (!projectId)
+        throw new Error('projectId is required');
+    if (!topicName)
+        throw new Error('topicName is required');
+    if (envelope === undefined)
+        throw new Error('envelope is required');
+    try {
+        const pubsub = getPubSub(projectId);
+        const topic = pubsub.topic(topicName);
+        const data = Buffer.from(JSON.stringify(envelope));
+        const messageId = await topic.publishMessage({
+            data
+        });
+        console.info(`INFO: Pub/Sub publish project=${projectId} topic=${topicName} msg_id=${messageId}`);
+        return messageId;
+    }
+    catch (err) {
+        console.error('ERROR: publish failed:', err);
+        throw err;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,6 +16,7 @@
   "author": "Evans Musonda",
   "license": "MIT",
   "dependencies": {
+    "@google-cloud/pubsub": "^5.2.0",
     "@google-cloud/secret-manager": "^6.0.1",
     "@google-cloud/tasks": "^6.1.0",
     "axios": "^1.10.0",

package/src/db/mongo.ts

@@ -1,26 +1,10 @@
 import { MongoClient, Db, Collection, Document } from 'mongodb'
-import { getSecret } from '../secrets'
 
 let client: MongoClient
 let db: Db
 let connectPromise: Promise<void> | undefined
 
-export async function connectToMongo(projectId: string, uriSecret: string, dbName: string) {
-  if (db) return // already connected
-
-  if (!connectPromise) {
-    connectPromise = (async () => {
-      const uri = await getSecret(projectId, uriSecret)
-      client = new MongoClient(uri)
-      await client.connect()
-      db = client.db(dbName)
-    })()
-  }
-
-  await connectPromise
-}
-
-export async function connectToMongoWithUri(uri: string, dbName: string) {
+export async function connectToMongo(uri: string, dbName: string) {
   if (db) return // already connected
 
   if (!connectPromise) {

package/src/db/mongo2.ts

@@ -1,25 +1,10 @@
 // Multi DB safe util
 import { MongoClient, Db, Collection, Document } from 'mongodb'
-import { getSecret } from '../secrets'
 
 let client: MongoClient
 let connectPromise: Promise<void> | undefined
 
-export async function connectToMongo2(projectId: string, uriSecret: string) {
-  if (client) return // already connected
-
-  if (!connectPromise) {
-    connectPromise = (async () => {
-      const uri = await getSecret(projectId, uriSecret)
-      client = new MongoClient(uri)
-      await client.connect()
-    })()
-  }
-
-  await connectPromise
-}
-
-export async function connectToMongoWithUri2(uri: string) {
+export async function connectToMongo2(uri: string) {
   if (client) return // already connected
 
   if (!connectPromise) {

package/src/db/mongo3.ts

@@ -1,32 +1,10 @@
 // Multi cluster safe util
 import { MongoClient, Db, Collection, Document } from 'mongodb'
-import { getSecret } from '../secrets'
 
 const clients: Map<string, MongoClient> = new Map()
 const connectPromises: Map<string, Promise<void>> = new Map()
 
-export async function connectToMongo3(projectId: string, uriSecret: string): Promise<MongoClient> {
-  if (clients.has(uriSecret)) {
-    return clients.get(uriSecret)!
-  }
-
-  if (!connectPromises.has(uriSecret)) {
-    const promise = (async () => {
-      const uri = await getSecret(projectId, uriSecret)
-      const client = new MongoClient(uri)
-      await client.connect()
-      clients.set(uriSecret, client)
-    })()
-
-    connectPromises.set(uriSecret, promise)
-  }
-
-  await connectPromises.get(uriSecret)!
-
-  return clients.get(uriSecret)!
-}
-
-export async function connectToMongoWithUri3(uri: string): Promise<MongoClient> {
+export async function connectToMongo3(uri: string): Promise<MongoClient> {
   if (!connectPromises.has(uri)) {
     const promise = (async () => {
       const client = new MongoClient(uri)
@@ -42,21 +20,21 @@ export async function connectToMongoWithUri3(uri: string): Promise<MongoClient>
   return clients.get(uri)!
 }
 
-export function getDb3(uriSecret: string, dbName: string): Db {
-  const client = clients.get(uriSecret)
+export function getDb3(uri: string, dbName: string): Db {
+  const client = clients.get(uri)
   if (!client) {
-    throw new Error(`Mongo client for secret "${uriSecret}" not initialized`)
+    throw new Error(`Mongo client not initialized`)
   }
 
   return client.db(dbName)
 }
 
 export function getCollection3<T extends Document = Document>(
-  uriSecret: string,
+  uri: string,
   dbName: string,
   collectionName: string
 ): Collection<T> {
-  return getDb3(uriSecret, dbName).collection<T>(collectionName)
+  return getDb3(uri, dbName).collection<T>(collectionName)
 }
 
 export const __mongoClients = clients

package/src/index.ts

@@ -7,6 +7,7 @@ export * from './auth'
 export * from './chunk'
 export * from './env'
 export * from './parser'
+export * from './pub'
 export * from './regex'
 export * from './retry'
 export * from './secrets'

package/src/pub.ts

@@ -0,0 +1,41 @@
+// src/pub.ts
+import { PubSub } from '@google-cloud/pubsub'
+
+const pubsubCache = new Map<string, PubSub>()
+
+function getPubSub(projectId: string): PubSub {
+  if (!projectId) throw new Error('projectId is required')
+  let ps = pubsubCache.get(projectId)
+  if (!ps) {
+    ps = new PubSub({ projectId })
+    pubsubCache.set(projectId, ps)
+  }
+  return ps
+}
+
+export async function publishMessage(
+  projectId: string,
+  topicName: string,
+  envelope: Record<string, unknown>
+): Promise<string> {
+  if (!projectId) throw new Error('projectId is required')
+  if (!topicName) throw new Error('topicName is required')
+  if (envelope === undefined) throw new Error('envelope is required')
+
+  try {
+    const pubsub = getPubSub(projectId)
+    const topic = pubsub.topic(topicName)
+    const data = Buffer.from(JSON.stringify(envelope))
+    const messageId = await topic.publishMessage({
+      data
+    })
+
+    console.info(
+      `INFO: Pub/Sub publish project=${projectId} topic=${topicName} msg_id=${messageId}`
+    )
+    return messageId
+  } catch (err) {
+    console.error('ERROR: publish failed:', err)
+    throw err
+  }
+}

package/tests/db/mongo.test.ts

@@ -1,9 +1,7 @@
-import { connectToMongo, connectToMongoWithUri, getCollection, getDb } from '../../src/db/mongo'
+import { connectToMongo, getCollection, getDb } from '../../src/db/mongo'
 import { MongoClient, Db } from 'mongodb'
-import * as secretsModule from '../../src/secrets'
 
 jest.mock('mongodb')
-jest.mock('../../src/secrets')
 
 const mockDb = {
   collection: jest.fn()
@@ -17,28 +15,26 @@ const mockClient = {
 
 beforeEach(() => {
   jest.clearAllMocks()
-  ;(secretsModule.getSecret as jest.Mock).mockResolvedValue('mongodb://mock-uri')
   ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
 })
 
 describe('Mongo Utils', () => {
   it('should connect to MongoDB and store client/db', async () => {
-    await connectToMongo('test-project', 'mongo-uri-secret', 'test-db')
+    await connectToMongo('mongo-uri', 'test-db')
 
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', 'mongo-uri-secret')
     expect(mockConnect).toHaveBeenCalled()
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
   })
 
   it('should return a collection when db is initialized', async () => {
-    await connectToMongo('test-project', 'mongo-uri-secret', 'test-db')
+    await connectToMongo('mongo-uri', 'test-db')
     getCollection('users')
 
     expect(mockDb.collection).toHaveBeenCalledWith('users')
   })
 
   it('getDb should return the initialized Db instance', async () => {
-    await connectToMongo('test-project', 'mongo-uri-secret', 'test-db')
+    await connectToMongo('mongo-uri', 'test-db')
     const got = getDb()
     expect(got).toBe(mockDb)
   })
@@ -53,30 +49,3 @@ describe('Mongo Utils', () => {
     })
   })
 })
-
-describe('Mongo Utils 2', () => {
-  it('should connect to MongoDB and store client/db with URI helper', async () => {
-    // isolate modules so connect state is fresh for this test
-    await jest.isolateModulesAsync(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 (connectToMongoWithUri)', async () => {
-    await connectToMongoWithUri('mongo-uri', 'test-db')
-    getCollection('users')
-
-    expect(mockDb.collection).toHaveBeenCalledWith('users')
-  })
-
-  it('getDb should return the initialized Db instance after connectToMongoWithUri', async () => {
-    await connectToMongoWithUri('mongo-uri', 'test-db')
-    const got = getDb()
-    expect(got).toBe(mockDb)
-  })
-})

package/tests/db/mongo2.test.ts

@@ -1,14 +1,7 @@
-import {
-  connectToMongo2,
-  getDb2,
-  getCollection2,
-  connectToMongoWithUri2
-} from '../../src/db/mongo2'
+import { connectToMongo2, getDb2, getCollection2 } from '../../src/db/mongo2'
 import { MongoClient, Db } from 'mongodb'
-import * as secretsModule from '../../src/secrets'
 
 jest.mock('mongodb')
-jest.mock('../../src/secrets')
 
 const mockDb = {
   collection: jest.fn()
@@ -22,20 +15,18 @@ const mockClient = {
 
 beforeEach(() => {
   jest.clearAllMocks()
-  ;(secretsModule.getSecret as jest.Mock).mockResolvedValue('mongodb://mock-uri')
   ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
 })
 
 describe('Mongo Utils', () => {
   it('should connect to MongoDB and store client', async () => {
-    await connectToMongo2('test-project', 'mongo-uri-secret')
+    await connectToMongo2('mongo-uri')
 
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', 'mongo-uri-secret')
     expect(mockConnect).toHaveBeenCalled()
   })
 
   it('should return a Db instance when client is initialized', async () => {
-    await connectToMongo2('test-project', 'mongo-uri-secret')
+    await connectToMongo2('mongo-uri')
 
     const db = getDb2('test-db')
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
@@ -43,7 +34,7 @@ describe('Mongo Utils', () => {
   })
 
   it('should return a collection when client is initialized', async () => {
-    await connectToMongo2('test-project', 'mongo-uri-secret')
+    await connectToMongo2('mongo-uri')
 
     getCollection2('test-db', 'users')
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
@@ -66,31 +57,3 @@ 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,14 +3,11 @@ import {
   getDb3,
   getCollection3,
   __mongoClients,
-  __connectPromises,
-  connectToMongoWithUri3
+  __connectPromises
 } from '../../src/db/mongo3'
 import { MongoClient, Db } from 'mongodb'
-import * as secretsModule from '../../src/secrets'
 
 jest.mock('mongodb')
-jest.mock('../../src/secrets')
 
 const mockDb = {
   collection: jest.fn()
@@ -26,54 +23,41 @@ beforeEach(() => {
   jest.clearAllMocks()
   __mongoClients.clear()
   __connectPromises.clear()
-  ;(secretsModule.getSecret as jest.Mock).mockResolvedValue('mongodb://mock-uri')
   ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
 })
 
 describe('MongoClientManager (multi-cluster)', () => {
-  const clusterASecret = 'clusterA-uri-secret'
-  const clusterBSecret = 'clusterB-uri-secret'
+  const clusterAUri = 'clusterA-uri'
+  const clusterBUri = 'clusterB-uri'
 
   it('should connect and cache client for a single cluster', async () => {
-    await connectToMongo3('test-project', clusterASecret)
+    await connectToMongo3(clusterAUri)
 
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret)
     expect(mockConnect).toHaveBeenCalled()
 
-    const db = getDb3(clusterASecret, 'test-db')
+    const db = getDb3(clusterAUri, 'test-db')
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
     expect(db).toBe(mockDb)
   })
 
   it('should reuse client if already connected', async () => {
-    await connectToMongo3('test-project', clusterASecret)
-    await connectToMongo3('test-project', clusterASecret)
+    await connectToMongo3(clusterAUri)
+    await connectToMongo3(clusterAUri)
 
-    // getSecret and connect should only happen once
-    expect(secretsModule.getSecret).toHaveBeenCalledTimes(1)
     expect(mockConnect).toHaveBeenCalledTimes(1)
   })
 
   it('should connect and cache separate clients for multiple clusters', async () => {
-    // Mock different URIs for 2 clusters
-    ;(secretsModule.getSecret as jest.Mock)
-      .mockResolvedValueOnce('mongodb://mock-uri-A')
-      .mockResolvedValueOnce('mongodb://mock-uri-B')
-
-    await connectToMongo3('test-project', clusterASecret)
-    await connectToMongo3('test-project', clusterBSecret)
-
-    // Should call getSecret + connect twice (for 2 clusters)
-    expect(secretsModule.getSecret).toHaveBeenCalledTimes(2)
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret)
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterBSecret)
+    await connectToMongo3(clusterAUri)
+    await connectToMongo3(clusterBUri)
+
     expect(mockConnect).toHaveBeenCalledTimes(2)
   })
 
   it('should return a collection when client is initialized', async () => {
-    await connectToMongo3('test-project', clusterASecret)
+    await connectToMongo3(clusterAUri)
 
-    getCollection3(clusterASecret, 'test-db', 'users')
+    getCollection3(clusterAUri, 'test-db', 'users')
 
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
     expect(mockDb.collection).toHaveBeenCalledWith('users')
@@ -83,9 +67,7 @@ describe('MongoClientManager (multi-cluster)', () => {
     jest.isolateModules(() => {
       // eslint-disable-next-line @typescript-eslint/no-require-imports
       const { getDb3 } = require('../../src/db/mongo3')
-      expect(() => getDb3('unknown-uri-secret', 'some-db')).toThrow(
-        'Mongo client for secret "unknown-uri-secret" not initialized'
-      )
+      expect(() => getDb3('unknown-uri', 'some-db')).toThrow('Mongo client not initialized')
     })
   })
 
@@ -93,57 +75,9 @@ describe('MongoClientManager (multi-cluster)', () => {
     jest.isolateModules(() => {
       // eslint-disable-next-line @typescript-eslint/no-require-imports
       const { getCollection3 } = require('../../src/db/mongo3')
-      expect(() => getCollection3('unknown-uri-secret', 'some-db', 'users')).toThrow(
-        'Mongo client for secret "unknown-uri-secret" not initialized'
+      expect(() => getCollection3('unknown-uri', 'some-db', 'users')).toThrow(
+        'Mongo client not initialized'
       )
     })
   })
 })
-
-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')
-  })
-})

package/tests/pub.test.ts

@@ -0,0 +1,85 @@
+// tests/pub.test.ts
+jest.mock('@google-cloud/pubsub', () => {
+  const instances: any[] = []
+
+  class PubSub {
+    opts: any
+    topics = new Map<string, any>()
+    constructor(opts?: any) {
+      this.opts = opts
+      instances.push(this)
+    }
+    topic(name: string) {
+      if (!this.topics.has(name)) {
+        const publishMessage = jest.fn(({ data }: { data: Buffer }) =>
+          Promise.resolve(`${this.opts?.projectId}-${name}`)
+        )
+        this.topics.set(name, { publishMessage })
+      }
+      return this.topics.get(name)
+    }
+  }
+
+  return { PubSub, __instances: instances }
+})
+
+const path = '../src/pub'
+
+describe('publishMessage', () => {
+  beforeEach(() => {
+    // Ensure a fresh module load so the mocked PubSub and src/pub share the same mock instance
+    jest.resetModules()
+  })
+
+  test('publishes and returns messageId, sends JSON buffer', async () => {
+    const mockPubsub = require('@google-cloud/pubsub')
+    const { publishMessage } = require(path)
+    const envelope = { hello: 'world' }
+
+    const msgId = await publishMessage('project-1', 'topic-a', envelope)
+    expect(msgId).toBe('project-1-topic-a')
+
+    const instance = mockPubsub.__instances[0]
+    expect(instance).toBeDefined()
+
+    const publishMock = instance.topics.get('topic-a').publishMessage
+    expect(publishMock).toHaveBeenCalledTimes(1)
+
+    const callArg = publishMock.mock.calls[0][0]
+    expect(callArg).toHaveProperty('data')
+    expect(callArg.data.toString()).toBe(JSON.stringify(envelope))
+  })
+
+  test('throws on missing arguments', async () => {
+    const { publishMessage } = require(path)
+    await expect(publishMessage('', 't', {})).rejects.toThrow('projectId is required')
+    await expect(publishMessage('p', '', {})).rejects.toThrow('topicName is required')
+    await expect(publishMessage('p', 't', undefined as any)).rejects.toThrow('envelope is required')
+  })
+
+  test('caches one PubSub instance per project', async () => {
+    const mockPubsub = require('@google-cloud/pubsub')
+    const { publishMessage } = require(path)
+
+    await publishMessage('project-1', 'topic-x', { a: 1 })
+    await publishMessage('project-1', 'topic-x', { b: 2 })
+
+    const instances = mockPubsub.__instances
+    expect(instances.length).toBe(1)
+    const publishMock = instances[0].topics.get('topic-x').publishMessage
+    expect(publishMock).toHaveBeenCalledTimes(2)
+  })
+
+  test('creates separate PubSub instances for different projects', async () => {
+    const mockPubsub = require('@google-cloud/pubsub')
+    const { publishMessage } = require(path)
+
+    await publishMessage('project-A', 't1', { x: 1 })
+    await publishMessage('project-B', 't2', { y: 2 })
+
+    const instances = mockPubsub.__instances
+    expect(instances.length).toBe(2)
+    expect(instances[0].opts).toEqual({ projectId: 'project-A' })
+    expect(instances[1].opts).toEqual({ projectId: 'project-B' })
+  })
+})