opticedge-cloud-utils 1.0.13 → 1.0.15

package/dist/db/mongo2.d.ts

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToMongo2 = connectToMongo2;
+exports.getDb2 = getDb2;
+exports.getCollection2 = getCollection2;
+// Multi DB safe util
+const mongodb_1 = require("mongodb");
+const secrets_1 = require("../utils/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;
+}
+function getDb2(dbName) {
+    if (!client)
+        throw new Error('Mongo not initialized');
+    return client.db(dbName);
+}
+function getCollection2(dbName, collectionName) {
+    return getDb2(dbName).collection(collectionName);
+}

package/dist/db/mongo2.test.d.ts

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

package/dist/db/mongo2.test.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongo2_1 = require("./mongo2");
+const mongodb_1 = require("mongodb");
+const secretsModule = __importStar(require("../utils/secrets"));
+jest.mock('mongodb');
+jest.mock('../utils/secrets');
+const mockDb = {
+    collection: jest.fn()
+};
+const mockConnect = jest.fn();
+const mockClient = {
+    connect: mockConnect,
+    db: jest.fn().mockReturnValue(mockDb)
+};
+beforeEach(() => {
+    jest.clearAllMocks();
+    secretsModule.getSecret.mockResolvedValue('mongodb://mock-uri');
+    mongodb_1.MongoClient.mockImplementation(() => mockClient);
+});
+describe('Mongo Utils', () => {
+    it('should connect to MongoDB and store client', async () => {
+        await (0, mongo2_1.connectToMongo2)('test-project', 'mongo-uri-secret');
+        expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', 'mongo-uri-secret');
+        expect(mockConnect).toHaveBeenCalled();
+    });
+    it('should return a Db instance when client is initialized', async () => {
+        await (0, mongo2_1.connectToMongo2)('test-project', 'mongo-uri-secret');
+        const db = (0, mongo2_1.getDb2)('test-db');
+        expect(mockClient.db).toHaveBeenCalledWith('test-db');
+        expect(db).toBe(mockDb);
+    });
+    it('should return a collection when client is initialized', async () => {
+        await (0, mongo2_1.connectToMongo2)('test-project', 'mongo-uri-secret');
+        (0, mongo2_1.getCollection2)('test-db', 'users');
+        expect(mockClient.db).toHaveBeenCalledWith('test-db');
+        expect(mockDb.collection).toHaveBeenCalledWith('users');
+    });
+    it('should throw error if client is not initialized (getDb)', () => {
+        jest.isolateModules(() => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { getDb2 } = require('./mongo2');
+            expect(() => getDb2('test-db')).toThrow('Mongo not initialized');
+        });
+    });
+    it('should throw error if client is not initialized (getCollection)', () => {
+        jest.isolateModules(() => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { getCollection2 } = require('./mongo2');
+            expect(() => getCollection2('test-db', 'users')).toThrow('Mongo not initialized');
+        });
+    });
+});

package/dist/db/mongo3.d.ts

@@ -0,0 +1,6 @@
+import { MongoClient, Db, Collection, Document } from 'mongodb';
+export declare function connectToMongo3(projectId: string, uriSecret: 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>;
+export declare const __connectPromises: Map<string, Promise<void>>;

package/dist/db/mongo3.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__connectPromises = exports.__mongoClients = void 0;
+exports.connectToMongo3 = connectToMongo3;
+exports.getDb3 = getDb3;
+exports.getCollection3 = getCollection3;
+// Multi cluster safe util
+const mongodb_1 = require("mongodb");
+const secrets_1 = require("../utils/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);
+}
+function getDb3(uriSecret, dbName) {
+    const client = clients.get(uriSecret);
+    if (!client) {
+        throw new Error(`Mongo client for secret "${uriSecret}" not initialized`);
+    }
+    return client.db(dbName);
+}
+function getCollection3(uriSecret, dbName, collectionName) {
+    return getDb3(uriSecret, dbName).collection(collectionName);
+}
+exports.__mongoClients = clients;
+exports.__connectPromises = connectPromises;

package/dist/db/mongo3.test.d.ts

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

package/dist/db/mongo3.test.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongo3_1 = require("./mongo3");
+const mongodb_1 = require("mongodb");
+const secretsModule = __importStar(require("../utils/secrets"));
+jest.mock('mongodb');
+jest.mock('../utils/secrets');
+const mockDb = {
+    collection: jest.fn()
+};
+const mockConnect = jest.fn();
+const mockClient = {
+    connect: mockConnect,
+    db: jest.fn().mockReturnValue(mockDb)
+};
+beforeEach(() => {
+    jest.clearAllMocks();
+    mongo3_1.__mongoClients.clear();
+    mongo3_1.__connectPromises.clear();
+    secretsModule.getSecret.mockResolvedValue('mongodb://mock-uri');
+    mongodb_1.MongoClient.mockImplementation(() => mockClient);
+});
+describe('MongoClientManager (multi-cluster)', () => {
+    const clusterASecret = 'clusterA-uri-secret';
+    const clusterBSecret = 'clusterB-uri-secret';
+    it('should connect and cache client for a single cluster', async () => {
+        await (0, mongo3_1.connectToMongo3)('test-project', clusterASecret);
+        expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret);
+        expect(mockConnect).toHaveBeenCalled();
+        const db = (0, mongo3_1.getDb3)(clusterASecret, 'test-db');
+        expect(mockClient.db).toHaveBeenCalledWith('test-db');
+        expect(db).toBe(mockDb);
+    });
+    it('should reuse client if already connected', async () => {
+        await (0, mongo3_1.connectToMongo3)('test-project', clusterASecret);
+        await (0, mongo3_1.connectToMongo3)('test-project', clusterASecret);
+        // 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
+            .mockResolvedValueOnce('mongodb://mock-uri-A')
+            .mockResolvedValueOnce('mongodb://mock-uri-B');
+        await (0, mongo3_1.connectToMongo3)('test-project', clusterASecret);
+        await (0, mongo3_1.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);
+        expect(mockConnect).toHaveBeenCalledTimes(2);
+    });
+    it('should return a collection when client is initialized', async () => {
+        await (0, mongo3_1.connectToMongo3)('test-project', clusterASecret);
+        (0, mongo3_1.getCollection3)(clusterASecret, 'test-db', 'users');
+        expect(mockClient.db).toHaveBeenCalledWith('test-db');
+        expect(mockDb.collection).toHaveBeenCalledWith('users');
+    });
+    it('should throw error if client not initialized (getDb)', () => {
+        jest.isolateModules(() => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { getDb3 } = require('./mongo3');
+            expect(() => getDb3('unknown-uri-secret', 'some-db')).toThrow('Mongo client for secret "unknown-uri-secret" not initialized');
+        });
+    });
+    it('should throw error if client not initialized (getCollection)', () => {
+        jest.isolateModules(() => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { getCollection3 } = require('./mongo3');
+            expect(() => getCollection3('unknown-uri-secret', 'some-db', 'users')).toThrow('Mongo client for secret "unknown-uri-secret" not initialized');
+        });
+    });
+});

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './auth/verify';
 export * from './db/mongo';
+export * from './db/mongo2';
+export * from './db/mongo3';
 export * from './types/pokemontcg';
 export * from './utils/env';
 export * from './utils/secrets';

package/dist/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth/verify"), exports);
 __exportStar(require("./db/mongo"), exports);
+__exportStar(require("./db/mongo2"), exports);
+__exportStar(require("./db/mongo3"), exports);
 __exportStar(require("./types/pokemontcg"), exports);
 __exportStar(require("./utils/env"), exports);
 __exportStar(require("./utils/secrets"), exports);

package/dist/types/pokemontcg.d.ts

@@ -122,7 +122,7 @@ export type PokemonTCGCard = {
 export type PokemonPriceHistory = {
     _id: string;
     card_id: string;
-    card_num: string;
+    card_data: Partial<PokemonTCGCard>;
     pricehistory: [
         {
             date: string;

package/package.json

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

package/src/db/mongo2.test.ts

@@ -0,0 +1,63 @@
+import { connectToMongo2, getDb2, getCollection2 } from './mongo2'
+import { MongoClient, Db } from 'mongodb'
+import * as secretsModule from '../utils/secrets'
+
+jest.mock('mongodb')
+jest.mock('../utils/secrets')
+
+const mockDb = {
+  collection: jest.fn()
+} as unknown as Db
+
+const mockConnect = jest.fn()
+const mockClient = {
+  connect: mockConnect,
+  db: jest.fn().mockReturnValue(mockDb)
+} as unknown as MongoClient
+
+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')
+
+    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')
+
+    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 connectToMongo2('test-project', 'mongo-uri-secret')
+
+    getCollection2('test-db', 'users')
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+
+  it('should throw error if client is not initialized (getDb)', () => {
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { getDb2 } = require('./mongo2')
+      expect(() => getDb2('test-db')).toThrow('Mongo not initialized')
+    })
+  })
+
+  it('should throw error if client is not initialized (getCollection)', () => {
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { getCollection2 } = require('./mongo2')
+      expect(() => getCollection2('test-db', 'users')).toThrow('Mongo not initialized')
+    })
+  })
+})

package/src/db/mongo2.ts

@@ -0,0 +1,32 @@
+// Multi DB safe util
+import { MongoClient, Db, Collection, Document } from 'mongodb'
+import { getSecret } from '../utils/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 function getDb2(dbName: string): Db {
+  if (!client) throw new Error('Mongo not initialized')
+  return client.db(dbName)
+}
+
+export function getCollection2<T extends Document = Document>(
+  dbName: string,
+  collectionName: string
+): Collection<T> {
+  return getDb2(dbName).collection<T>(collectionName)
+}

package/src/db/mongo3.test.ts

@@ -0,0 +1,100 @@
+import {
+  connectToMongo3,
+  getDb3,
+  getCollection3,
+  __mongoClients,
+  __connectPromises
+} from './mongo3'
+import { MongoClient, Db } from 'mongodb'
+import * as secretsModule from '../utils/secrets'
+
+jest.mock('mongodb')
+jest.mock('../utils/secrets')
+
+const mockDb = {
+  collection: jest.fn()
+} as unknown as Db
+
+const mockConnect = jest.fn()
+const mockClient = {
+  connect: mockConnect,
+  db: jest.fn().mockReturnValue(mockDb)
+} as unknown as MongoClient
+
+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'
+
+  it('should connect and cache client for a single cluster', async () => {
+    await connectToMongo3('test-project', clusterASecret)
+
+    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret)
+    expect(mockConnect).toHaveBeenCalled()
+
+    const db = getDb3(clusterASecret, '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)
+
+    // 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)
+    expect(mockConnect).toHaveBeenCalledTimes(2)
+  })
+
+  it('should return a collection when client is initialized', async () => {
+    await connectToMongo3('test-project', clusterASecret)
+
+    getCollection3(clusterASecret, 'test-db', 'users')
+
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+
+  it('should throw error if client not initialized (getDb)', () => {
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { getDb3 } = require('./mongo3')
+      expect(() => getDb3('unknown-uri-secret', 'some-db')).toThrow(
+        'Mongo client for secret "unknown-uri-secret" not initialized'
+      )
+    })
+  })
+
+  it('should throw error if client not initialized (getCollection)', () => {
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { getCollection3 } = require('./mongo3')
+      expect(() => getCollection3('unknown-uri-secret', 'some-db', 'users')).toThrow(
+        'Mongo client for secret "unknown-uri-secret" not initialized'
+      )
+    })
+  })
+})

package/src/db/mongo3.ts

@@ -0,0 +1,47 @@
+// Multi cluster safe util
+import { MongoClient, Db, Collection, Document } from 'mongodb'
+import { getSecret } from '../utils/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 function getDb3(uriSecret: string, dbName: string): Db {
+  const client = clients.get(uriSecret)
+  if (!client) {
+    throw new Error(`Mongo client for secret "${uriSecret}" not initialized`)
+  }
+
+  return client.db(dbName)
+}
+
+export function getCollection3<T extends Document = Document>(
+  uriSecret: string,
+  dbName: string,
+  collectionName: string
+): Collection<T> {
+  return getDb3(uriSecret, dbName).collection<T>(collectionName)
+}
+
+export const __mongoClients = clients
+export const __connectPromises = connectPromises

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './auth/verify'
 export * from './db/mongo'
+export * from './db/mongo2'
+export * from './db/mongo3'
 export * from './types/pokemontcg'
 export * from './utils/env'
 export * from './utils/secrets'

package/src/types/pokemontcg.ts

@@ -125,7 +125,7 @@ export type PokemonTCGCard = {
 export type PokemonPriceHistory = {
   _id: string
   card_id: string
-  card_num: string
+  card_data: Partial<PokemonTCGCard>
   pricehistory: [
     {
       date: string