opticedge-cloud-utils 1.1.18 → 1.1.19

package/dist/pub.js

@@ -3,16 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.publishMessage = publishMessage;
 // src/pub.ts
 const pubsub_1 = require("@google-cloud/pubsub");
-const pubsubCache = new Map();
+let cachedPubSub = null;
 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);
+    if (!cachedPubSub) {
+        cachedPubSub = new pubsub_1.PubSub({ projectId });
     }
-    return ps;
+    return cachedPubSub;
 }
 async function publishMessage(projectId, topicName, envelope) {
     if (!projectId)
@@ -28,7 +26,7 @@ async function publishMessage(projectId, topicName, envelope) {
         const messageId = await topic.publishMessage({
             data
         });
-        console.info(`INFO: Pub/Sub publish project=${projectId} topic=${topicName} msg_id=${messageId}`);
+        console.info(`INFO: Pub/Sub publish topic=${topicName} msg_id=${messageId}`);
         return messageId;
     }
     catch (err) {

package/package.json

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

package/src/pub.ts

@@ -1,16 +1,16 @@
 // src/pub.ts
 import { PubSub } from '@google-cloud/pubsub'
 
-const pubsubCache = new Map<string, PubSub>()
+let cachedPubSub: PubSub | null = null
 
 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)
+
+  if (!cachedPubSub) {
+    cachedPubSub = new PubSub({ projectId })
   }
-  return ps
+
+  return cachedPubSub
 }
 
 export async function publishMessage(
@@ -30,9 +30,7 @@ export async function publishMessage(
       data
     })
 
-    console.info(
-      `INFO: Pub/Sub publish project=${projectId} topic=${topicName} msg_id=${messageId}`
-    )
+    console.info(`INFO: Pub/Sub publish topic=${topicName} msg_id=${messageId}`)
     return messageId
   } catch (err) {
     console.error('ERROR: publish failed:', err)

package/tests/pub.test.ts

@@ -27,8 +27,17 @@ const path = '../src/pub'
 
 describe('publishMessage', () => {
   beforeEach(() => {
-    // Ensure a fresh module load so the mocked PubSub and src/pub share the same mock instance
+    // ensure fresh module state between tests
     jest.resetModules()
+    // clear any existing mock instances array if present
+    try {
+      const mockPubsub = require('@google-cloud/pubsub')
+      if (mockPubsub && Array.isArray(mockPubsub.__instances)) {
+        mockPubsub.__instances.length = 0
+      }
+    } catch {
+      // ignore if not loaded yet
+    }
   })
 
   test('publishes and returns messageId, sends JSON buffer', async () => {
@@ -57,7 +66,7 @@ describe('publishMessage', () => {
     await expect(publishMessage('p', 't', undefined as any)).rejects.toThrow('envelope is required')
   })
 
-  test('caches one PubSub instance per project', async () => {
+  test('caches one PubSub instance across multiple calls for the same project', async () => {
     const mockPubsub = require('@google-cloud/pubsub')
     const { publishMessage } = require(path)
 
@@ -70,16 +79,49 @@ describe('publishMessage', () => {
     expect(publishMock).toHaveBeenCalledTimes(2)
   })
 
-  test('creates separate PubSub instances for different projects', async () => {
+  test('reuses the same PubSub instance even when called with a different projectId', async () => {
     const mockPubsub = require('@google-cloud/pubsub')
     const { publishMessage } = require(path)
 
+    // first call creates instance with project-A
     await publishMessage('project-A', 't1', { x: 1 })
+    // second call passes a different project id but module currently reuses the cached instance
     await publishMessage('project-B', 't2', { y: 2 })
 
     const instances = mockPubsub.__instances
-    expect(instances.length).toBe(2)
+    // because src/pub.ts caches a single PubSub instance, only one instance should exist
+    expect(instances.length).toBe(1)
+    // the created instance was constructed with the first project id
     expect(instances[0].opts).toEqual({ projectId: 'project-A' })
-    expect(instances[1].opts).toEqual({ projectId: 'project-B' })
+
+    // ensure both publishes were invoked on the same instance (different topics)
+    expect(instances[0].topics.get('t1').publishMessage).toHaveBeenCalledTimes(1)
+    expect(instances[0].topics.get('t2').publishMessage).toHaveBeenCalledTimes(1)
+  })
+
+  test('logs error and rethrows when publish fails', async () => {
+    const mockPubsub = require('@google-cloud/pubsub')
+
+    // Override the mock PubSub.topic to return a publishMessage that rejects
+    mockPubsub.PubSub.prototype.topic = function (name: string) {
+      if (!this.topics.has(name)) {
+        const publishMessage = jest.fn(() => Promise.reject(new Error('boom')))
+        this.topics.set(name, { publishMessage })
+      }
+      return this.topics.get(name)
+    }
+
+    const { publishMessage } = require(path)
+
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    await expect(publishMessage('project-err', 'topic-err', { fail: true })).rejects.toThrow('boom')
+
+    expect(consoleErrorSpy).toHaveBeenCalled()
+    const firstArg = consoleErrorSpy.mock.calls[0][0]
+    expect(typeof firstArg).toBe('string')
+    expect(firstArg).toContain('ERROR: publish failed:')
+
+    consoleErrorSpy.mockRestore()
   })
 })