opticedge-cloud-utils 1.1.18 → 1.1.20

package/dist/tests/tw/utils.test.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../src/tw/utils");
+const crypto_1 = __importDefault(require("crypto"));
+describe('isValidWebhookSignature', () => {
+    const secret = 'test_secret';
+    const body = '{"message":"hello"}';
+    it('returns true for a valid signature', () => {
+        const validSignature = crypto_1.default.createHmac('sha256', secret).update(body).digest('hex');
+        expect((0, utils_1.isValidWebhookSignature)(secret, body, validSignature)).toBe(true);
+    });
+    it('returns false for an invalid signature', () => {
+        const invalidSignature = 'invalidsignature123';
+        expect((0, utils_1.isValidWebhookSignature)(secret, body, invalidSignature)).toBe(false);
+    });
+    it('returns false if body or secret is tampered', () => {
+        const originalSignature = crypto_1.default.createHmac('sha256', secret).update(body).digest('hex');
+        // wrong body
+        expect((0, utils_1.isValidWebhookSignature)(secret, '{"message":"tampered"}', originalSignature)).toBe(false);
+        // wrong secret
+        expect((0, utils_1.isValidWebhookSignature)('wrong_secret', body, originalSignature)).toBe(false);
+    });
+});

package/dist/tests/tw/wallet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/tw/wallet.test.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/tw/wallet.test.ts
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const axios_1 = __importDefault(require("axios"));
+const wallet_1 = require("../../src/tw/wallet");
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+function makeAxiosError(message, status, noResponse = false) {
+    const err = new Error(message);
+    err.isAxiosError = true;
+    if (!noResponse) {
+        err.response = {
+            status: typeof status === 'number' ? status : 500,
+            data: { message: `mocked ${status ?? 500}` }
+        };
+    }
+    else {
+        // simulate network error (no response)
+        delete err.response;
+    }
+    return err;
+}
+function makeSuccessResponse(data) {
+    return { data, status: 200 };
+}
+describe('pregenerateInAppWallet (current signature)', () => {
+    const mockClientId = 'test-client-id';
+    const mockSecretKey = 'test-secret-key';
+    const mockEmail = 'user@example.com';
+    const mockWalletAddress = '0xabc123';
+    const realMathRandom = Math.random;
+    const realWarn = console.warn;
+    const realError = console.error;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // make retry jitter deterministic (so delays don't interfere)
+        Math.random = jest.fn(() => 0);
+        // axios.isAxiosError helper
+        jest
+            .spyOn(axios_1.default, 'isAxiosError')
+            .mockImplementation((e) => Boolean(e && e.isAxiosError));
+        // silence logs during tests but keep spies
+        console.warn = jest.fn();
+        console.error = jest.fn();
+    });
+    afterEach(() => {
+        Math.random = realMathRandom;
+        console.warn = realWarn;
+        console.error = realError;
+    });
+    it('returns null and logs if params missing', async () => {
+        const res = await (0, wallet_1.pregenerateInAppWallet)('', mockSecretKey, mockEmail);
+        expect(mockedAxios.post).not.toHaveBeenCalled();
+        expect(res).toBeNull();
+        expect(console.error.mock.calls.length).toBeGreaterThanOrEqual(1);
+        expect(console.error.mock.calls[0][0]).toEqual('Missing client id or secret or email');
+    });
+    it('retries on 500 then succeeds and returns address', async () => {
+        // first: 500, then success
+        mockedAxios.post
+            .mockRejectedValueOnce(makeAxiosError('server error', 500))
+            .mockResolvedValueOnce({ data: { wallet: { address: mockWalletAddress } } });
+        const result = await (0, wallet_1.pregenerateInAppWallet)(mockClientId, mockSecretKey, mockEmail);
+        expect(mockedAxios.post).toHaveBeenCalledTimes(2);
+        expect(result).toBe(mockWalletAddress);
+        expect(console.warn.mock.calls.length).toBeGreaterThanOrEqual(1);
+    });
+    it('does NOT retry on 400 and returns null immediately', async () => {
+        mockedAxios.post.mockRejectedValue(makeAxiosError('bad request', 400));
+        const result = await (0, wallet_1.pregenerateInAppWallet)(mockClientId, mockSecretKey, mockEmail);
+        expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+        expect(result).toBeNull();
+        // no retry log
+        expect(console.warn.mock.calls.length).toBe(0);
+    });
+    it('retries on network/no-response errors and then succeeds', async () => {
+        mockedAxios.post
+            .mockRejectedValueOnce(makeAxiosError('network down', undefined, true))
+            .mockResolvedValueOnce({ data: { wallet: { address: mockWalletAddress } } });
+        const result = await (0, wallet_1.pregenerateInAppWallet)(mockClientId, mockSecretKey, mockEmail);
+        expect(mockedAxios.post).toHaveBeenCalledTimes(2);
+        expect(result).toBe(mockWalletAddress);
+    });
+    it('exhausts retries on repeated 500s and returns null', async () => {
+        mockedAxios.post.mockRejectedValue(makeAxiosError('server error', 500));
+        const result = await (0, wallet_1.pregenerateInAppWallet)(mockClientId, mockSecretKey, mockEmail);
+        // retry behavior is implementation-dependent; assert at least one call and final null
+        expect(mockedAxios.post.mock.calls.length).toBeGreaterThanOrEqual(1);
+        expect(result).toBeNull();
+        expect(console.error.mock.calls.length).toBeGreaterThanOrEqual(1);
+    });
+    it('logs invalid wallet shape and returns null when wallet.address missing (2xx response)', async () => {
+        mockedAxios.post.mockResolvedValueOnce(makeSuccessResponse({ wallet: {} }));
+        const result = await (0, wallet_1.pregenerateInAppWallet)(mockClientId, mockSecretKey, mockEmail);
+        expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+        expect(result).toBeNull();
+        // ensure we logged the invalid shape (the implementation logs then throws)
+        expect(console.error.mock.calls.length).toBeGreaterThanOrEqual(1);
+        const firstArg = console.error.mock.calls[0][0];
+        expect(firstArg).toEqual('Invalid wallet response shape');
+        const secondArg = console.error.mock.calls[0][1];
+        expect(secondArg).toEqual(expect.objectContaining({ status: 200, data: { wallet: {} } }));
+    });
+});

package/dist/tests/validator.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/validator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// isValidEmail.test.ts
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+(0, globals_1.describe)('isValidEmail', () => {
+    (0, globals_1.it)('returns true for simple valid emails', () => {
+        (0, globals_1.expect)((0, src_1.isValidEmail)('test@example.com')).toBe(true);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user.name@domain.co')).toBe(true);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user_name+tag@sub.domain.org')).toBe(true);
+    });
+    (0, globals_1.it)('returns false for missing parts', () => {
+        (0, globals_1.expect)((0, src_1.isValidEmail)('')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('plainaddress')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('@no-local-part.com')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('username@')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user@domain')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('username@.com')).toBe(false);
+    });
+    (0, globals_1.it)('handles whitespace correctly', () => {
+        (0, globals_1.expect)((0, src_1.isValidEmail)('   test@example.com   ')).toBe(true); // trims input
+        (0, globals_1.expect)((0, src_1.isValidEmail)('\nuser@domain.com\t')).toBe(true);
+    });
+    (0, globals_1.it)('rejects invalid characters or formats', () => {
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user@@domain.com')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user@domain,com')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user@domain..com')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user@.domain.com')).toBe(false);
+        (0, globals_1.expect)((0, src_1.isValidEmail)('user@domain com')).toBe(false);
+    });
+    (0, globals_1.it)('accepts minimal valid domain structures', () => {
+        (0, globals_1.expect)((0, src_1.isValidEmail)('x@y.z')).toBe(true); // still valid
+    });
+});

package/package.json

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

package/src/number.ts

@@ -0,0 +1,3 @@
+export function round1(v: number): number {
+  return Math.round((v + Number.EPSILON) * 10) / 10
+}

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/number.test.ts

@@ -0,0 +1,34 @@
+import { round1 } from '../src/number'
+
+describe('round1', () => {
+  it('rounds down correctly', () => {
+    expect(round1(4.21)).toBe(4.2)
+    expect(round1(4.24)).toBe(4.2)
+  })
+
+  it('rounds up correctly', () => {
+    expect(round1(4.25)).toBe(4.3)
+    expect(round1(4.26)).toBe(4.3)
+  })
+
+  it('handles floating point precision issues', () => {
+    expect(round1(1.005)).toBe(1.0) // classic float issue
+    expect(round1(2.675)).toBe(2.7)
+  })
+
+  it('handles negative numbers', () => {
+    expect(round1(-4.24)).toBe(-4.2)
+    expect(round1(-4.25)).toBe(-4.2) // JS rounds toward +∞ for halves
+    expect(round1(-4.26)).toBe(-4.3)
+  })
+
+  it('handles zero', () => {
+    expect(round1(0)).toBe(0)
+    expect(round1(0.04)).toBe(0)
+    expect(round1(0.05)).toBe(0.1)
+  })
+
+  it('handles large numbers', () => {
+    expect(round1(123456.789)).toBe(123456.8)
+  })
+})

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()
   })
 })

package/tsconfig.json

@@ -12,6 +12,6 @@
     "forceConsistentCasingInFileNames": true,
     "types": ["node", "jest"]
   },
-  "include": ["src"],
+  "include": ["src", "tests"],
   "exclude": ["node_modules", "dist"]
 }