opticedge-cloud-utils 1.1.17 → 1.1.19

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,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishMessage = publishMessage;
+// src/pub.ts
+const pubsub_1 = require("@google-cloud/pubsub");
+let cachedPubSub = null;
+function getPubSub(projectId) {
+    if (!projectId)
+        throw new Error('projectId is required');
+    if (!cachedPubSub) {
+        cachedPubSub = new pubsub_1.PubSub({ projectId });
+    }
+    return cachedPubSub;
+}
+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 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.17",
+  "version": "1.1.19",
   "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/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,39 @@
+// src/pub.ts
+import { PubSub } from '@google-cloud/pubsub'
+
+let cachedPubSub: PubSub | null = null
+
+function getPubSub(projectId: string): PubSub {
+  if (!projectId) throw new Error('projectId is required')
+
+  if (!cachedPubSub) {
+    cachedPubSub = new PubSub({ projectId })
+  }
+
+  return cachedPubSub
+}
+
+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 topic=${topicName} msg_id=${messageId}`)
+    return messageId
+  } catch (err) {
+    console.error('ERROR: publish failed:', err)
+    throw err
+  }
+}

package/tests/pub.test.ts

@@ -0,0 +1,127 @@
+// 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 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 () => {
+    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 across multiple calls for the same 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('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
+    // 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' })
+
+    // 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()
+  })
+})