opticedge-cloud-utils 1.1.30 → 1.1.32

package/dist/db/mongo.d.ts

@@ -2,3 +2,4 @@ import { Db, Collection, Document } from 'mongodb';
 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>;
+export declare function closeMongo(): Promise<void>;

package/dist/db/mongo.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo = connectToMongo;
 exports.getDb = getDb;
 exports.getCollection = getCollection;
+exports.closeMongo = closeMongo;
 const mongodb_1 = require("mongodb");
 let client;
 let db;
@@ -29,3 +30,11 @@ function getCollection(name) {
         throw new Error('Mongo not initialized');
     return db.collection(name);
 }
+async function closeMongo() {
+    if (!client)
+        return;
+    await client.close();
+    client = undefined;
+    db = undefined;
+    connectPromise = undefined;
+}

package/dist/db/mongo2.d.ts

@@ -2,3 +2,4 @@ import { Db, Collection, Document } from 'mongodb';
 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>;
+export declare function closeMongo2(): Promise<void>;

package/dist/db/mongo2.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo2 = connectToMongo2;
 exports.getDb2 = getDb2;
 exports.getCollection2 = getCollection2;
+exports.closeMongo2 = closeMongo2;
 // Multi DB safe util
 const mongodb_1 = require("mongodb");
 let client;
@@ -26,3 +27,10 @@ function getDb2(dbName) {
 function getCollection2(dbName, collectionName) {
     return getDb2(dbName).collection(collectionName);
 }
+async function closeMongo2() {
+    if (!client)
+        return;
+    await client.close();
+    client = undefined;
+    connectPromise = undefined;
+}

package/dist/db/mongo3.d.ts

@@ -2,5 +2,7 @@ import { MongoClient, Db, Collection, Document } from 'mongodb';
 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 function closeMongo3(uri: string): Promise<void>;
+export declare function closeAllMongo3(): Promise<void>;
 export declare const __mongoClients: Map<string, MongoClient>;
 export declare const __connectPromises: Map<string, Promise<void>>;

package/dist/db/mongo3.js

@@ -4,6 +4,8 @@ exports.__connectPromises = exports.__mongoClients = void 0;
 exports.connectToMongo3 = connectToMongo3;
 exports.getDb3 = getDb3;
 exports.getCollection3 = getCollection3;
+exports.closeMongo3 = closeMongo3;
+exports.closeAllMongo3 = closeAllMongo3;
 // Multi cluster safe util
 const mongodb_1 = require("mongodb");
 const clients = new Map();
@@ -30,5 +32,18 @@ function getDb3(uri, dbName) {
 function getCollection3(uri, dbName, collectionName) {
     return getDb3(uri, dbName).collection(collectionName);
 }
+async function closeMongo3(uri) {
+    const client = clients.get(uri);
+    if (client) {
+        await client.close();
+    }
+    clients.delete(uri);
+    connectPromises.delete(uri);
+}
+async function closeAllMongo3() {
+    await Promise.all(Array.from(clients.values()).map(client => client.close()));
+    clients.clear();
+    connectPromises.clear();
+}
 exports.__mongoClients = clients;
 exports.__connectPromises = connectPromises;

package/dist/pricecharting.d.ts

@@ -15,4 +15,5 @@ type CardParts = {
  * 3. If no valid number found — returns `{ name: original, number: null }`.
  */
 export declare function splitNameAndNumber(input: string, realNumber?: string | null): CardParts;
+export declare function productExists(productId: number, token: string, fetchTimeoutMs: number): Promise<boolean | null>;
 export {};

package/dist/pricecharting.js

@@ -1,7 +1,12 @@
 "use strict";
+// src/pricecharting.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitNameAndNumber = splitNameAndNumber;
+exports.productExists = productExists;
+const logger_1 = require("./logger");
 const regex_1 = require("./regex");
+const PRODUCT_NOT_FOUND_MESSAGE = 'no such product';
+const PRODUCT_API_URL = 'https://www.pricecharting.com/api/product';
 /**
  * Split a card label into `{ name, number }`.
  *
@@ -48,3 +53,80 @@ function splitNameAndNumber(input, realNumber) {
         return { name: s, number: null };
     return { name: namePart, number: numberPart };
 }
+async function productExists(productId, token, fetchTimeoutMs) {
+    if (!Number.isInteger(productId) || productId <= 0) {
+        (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] invalid productId', { productId });
+        return null;
+    }
+    if (!token?.trim()) {
+        (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] missing token', { productId });
+        return null;
+    }
+    if (!Number.isFinite(fetchTimeoutMs) || fetchTimeoutMs < 1000) {
+        (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] invalid fetch timeout', {
+            productId,
+            fetchTimeoutMs
+        });
+        return null;
+    }
+    const params = new URLSearchParams({
+        t: token,
+        id: String(productId)
+    });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
+    try {
+        const resp = await fetch(`${PRODUCT_API_URL}?${params.toString()}`, {
+            method: 'GET',
+            signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (resp.status === 404)
+            return false;
+        if (resp.status !== 200) {
+            (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] unexpected status code', {
+                productId,
+                statusCode: resp.status
+            });
+            return null;
+        }
+        let data;
+        try {
+            data = await resp.json();
+        }
+        catch (err) {
+            (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] failed to parse JSON', {
+                productId,
+                traceback: err instanceof Error ? err.stack : String(err)
+            });
+            return null;
+        }
+        if (typeof data !== 'object' || data === null) {
+            (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] unexpected response body', {
+                productId,
+                bodyType: typeof data
+            });
+            return null;
+        }
+        const status = (data.status || '').toLowerCase();
+        const errText = ((data.error || '') + ' ' + (data['error-message'] || '')).toLowerCase();
+        if (status === 'error') {
+            if (errText.includes(PRODUCT_NOT_FOUND_MESSAGE.toLowerCase()))
+                return false;
+            (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] API returned error', { productId, error: errText });
+            return null;
+        }
+        return true;
+    }
+    catch (unknownErr) {
+        const err = unknownErr instanceof Error ? unknownErr : new Error(String(unknownErr));
+        (0, logger_1.log)(logger_1.LogLevel.WARNING, '[productExists] request failed', {
+            productId,
+            traceback: err.stack ?? err.message
+        });
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "opticedge-cloud-utils",
-  "version": "1.1.30",
-  "description": "Common utilities for cloud functions",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "clean": "rimraf dist coverage *.tsbuildinfo",
-    "build": "npm run clean && tsc",
-    "prepare": "npm run build",
-    "test": "jest --coverage",
-    "lint": "eslint . --ext .ts --fix",
-    "format": "prettier --write .",
-    "fix": "npm run lint && npm run format"
-  },
-  "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"
-  },
-  "devDependencies": {
-    "@google-cloud/functions-framework": "*",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.15.23",
-    "@typescript-eslint/eslint-plugin": "^8.33.0",
-    "@typescript-eslint/parser": "^8.33.0",
-    "eslint": "^8.57.1",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-jest": "^28.11.1",
-    "eslint-plugin-prettier": "^5.4.0",
-    "google-auth-library": "*",
-    "jest": "^29.7.0",
-    "mongodb": "*",
-    "prettier": "^3.5.3",
-    "ts-jest": "^29.3.4",
-    "typescript": "^5.8.3"
-  },
-  "peerDependencies": {
-    "@google-cloud/functions-framework": "^5.0.2",
-    "google-auth-library": "^10.6.2",
-    "mongodb": "^7.1.1"
-  }
-}
+{
+  "name": "opticedge-cloud-utils",
+  "version": "1.1.32",
+  "description": "Common utilities for cloud functions",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist coverage *.tsbuildinfo",
+    "build": "npm run clean && tsc",
+    "prepare": "npm run build",
+    "test": "jest --coverage",
+    "lint": "eslint . --ext .ts --fix",
+    "format": "prettier --write .",
+    "fix": "npm run lint && npm run format"
+  },
+  "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"
+  },
+  "devDependencies": {
+    "@google-cloud/functions-framework": "*",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.15.23",
+    "@typescript-eslint/eslint-plugin": "^8.33.0",
+    "@typescript-eslint/parser": "^8.33.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-jest": "^28.11.1",
+    "eslint-plugin-prettier": "^5.4.0",
+    "google-auth-library": "*",
+    "jest": "^29.7.0",
+    "mongodb": "*",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.3.4",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "@google-cloud/functions-framework": "^5.0.2",
+    "google-auth-library": "^10.6.2",
+    "mongodb": "^7.1.1"
+  }
+}

package/src/db/mongo.ts

@@ -1,7 +1,7 @@
 import { MongoClient, Db, Collection, Document } from 'mongodb'
 
-let client: MongoClient
-let db: Db
+let client: MongoClient | undefined
+let db: Db | undefined
 let connectPromise: Promise<void> | undefined
 
 export async function connectToMongo(uri: string, dbName: string) {
@@ -27,3 +27,13 @@ export function getCollection<T extends Document = Document>(name: string): Coll
   if (!db) throw new Error('Mongo not initialized')
   return db.collection<T>(name)
 }
+
+export async function closeMongo(): Promise<void> {
+  if (!client) return
+
+  await client.close()
+
+  client = undefined
+  db = undefined
+  connectPromise = undefined
+}

package/src/db/mongo2.ts

@@ -1,7 +1,7 @@
 // Multi DB safe util
 import { MongoClient, Db, Collection, Document } from 'mongodb'
 
-let client: MongoClient
+let client: MongoClient | undefined
 let connectPromise: Promise<void> | undefined
 
 export async function connectToMongo2(uri: string) {
@@ -28,3 +28,12 @@ export function getCollection2<T extends Document = Document>(
 ): Collection<T> {
   return getDb2(dbName).collection<T>(collectionName)
 }
+
+export async function closeMongo2(): Promise<void> {
+  if (!client) return
+
+  await client.close()
+
+  client = undefined
+  connectPromise = undefined
+}

package/src/db/mongo3.ts

@@ -37,5 +37,23 @@ export function getCollection3<T extends Document = Document>(
   return getDb3(uri, dbName).collection<T>(collectionName)
 }
 
+export async function closeMongo3(uri: string): Promise<void> {
+  const client = clients.get(uri)
+
+  if (client) {
+    await client.close()
+  }
+
+  clients.delete(uri)
+  connectPromises.delete(uri)
+}
+
+export async function closeAllMongo3(): Promise<void> {
+  await Promise.all(Array.from(clients.values()).map(client => client.close()))
+
+  clients.clear()
+  connectPromises.clear()
+}
+
 export const __mongoClients = clients
 export const __connectPromises = connectPromises

package/src/pricecharting.ts

@@ -1,7 +1,19 @@
+// src/pricecharting.ts
+
+import { log, LogLevel } from './logger'
 import { escapeForRegex } from './regex'
 
 type CardParts = { name: string; number: string | null }
 
+interface ProductExistsResponse {
+  status?: string
+  error?: string
+  'error-message'?: string
+}
+
+const PRODUCT_NOT_FOUND_MESSAGE = 'no such product'
+const PRODUCT_API_URL = 'https://www.pricecharting.com/api/product'
+
 /**
  * Split a card label into `{ name, number }`.
  *
@@ -49,3 +61,92 @@ export function splitNameAndNumber(input: string, realNumber?: string | null): C
 
   return { name: namePart, number: numberPart }
 }
+
+export async function productExists(
+  productId: number,
+  token: string,
+  fetchTimeoutMs: number
+): Promise<boolean | null> {
+  if (!Number.isInteger(productId) || productId <= 0) {
+    log(LogLevel.WARNING, '[productExists] invalid productId', { productId })
+    return null
+  }
+
+  if (!token?.trim()) {
+    log(LogLevel.WARNING, '[productExists] missing token', { productId })
+    return null
+  }
+
+  if (!Number.isFinite(fetchTimeoutMs) || fetchTimeoutMs < 1000) {
+    log(LogLevel.WARNING, '[productExists] invalid fetch timeout', {
+      productId,
+      fetchTimeoutMs
+    })
+    return null
+  }
+
+  const params = new URLSearchParams({
+    t: token,
+    id: String(productId)
+  })
+
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs)
+
+  try {
+    const resp = await fetch(`${PRODUCT_API_URL}?${params.toString()}`, {
+      method: 'GET',
+      signal: controller.signal
+    })
+
+    clearTimeout(timeout)
+
+    if (resp.status === 404) return false
+    if (resp.status !== 200) {
+      log(LogLevel.WARNING, '[productExists] unexpected status code', {
+        productId,
+        statusCode: resp.status
+      })
+      return null
+    }
+
+    let data: ProductExistsResponse
+    try {
+      data = await resp.json()
+    } catch (err) {
+      log(LogLevel.WARNING, '[productExists] failed to parse JSON', {
+        productId,
+        traceback: err instanceof Error ? err.stack : String(err)
+      })
+      return null
+    }
+
+    if (typeof data !== 'object' || data === null) {
+      log(LogLevel.WARNING, '[productExists] unexpected response body', {
+        productId,
+        bodyType: typeof data
+      })
+      return null
+    }
+
+    const status = (data.status || '').toLowerCase()
+    const errText = ((data.error || '') + ' ' + (data['error-message'] || '')).toLowerCase()
+
+    if (status === 'error') {
+      if (errText.includes(PRODUCT_NOT_FOUND_MESSAGE.toLowerCase())) return false
+      log(LogLevel.WARNING, '[productExists] API returned error', { productId, error: errText })
+      return null
+    }
+
+    return true
+  } catch (unknownErr: unknown) {
+    const err = unknownErr instanceof Error ? unknownErr : new Error(String(unknownErr))
+    log(LogLevel.WARNING, '[productExists] request failed', {
+      productId,
+      traceback: err.stack ?? err.message
+    })
+    return null
+  } finally {
+    clearTimeout(timeout)
+  }
+}

package/tests/db/mongo.test.ts

@@ -1,4 +1,4 @@
-import { connectToMongo, getCollection, getDb } from '../../src/db/mongo'
+import { connectToMongo, getCollection, getDb, closeMongo } from '../../src/db/mongo'
 import { MongoClient, Db } from 'mongodb'
 
 jest.mock('mongodb')
@@ -8,12 +8,17 @@ const mockDb = {
 } as unknown as Db
 
 const mockConnect = jest.fn()
+const mockClose = jest.fn()
+
 const mockClient = {
   connect: mockConnect,
+  close: mockClose,
   db: jest.fn().mockReturnValue(mockDb)
 } as unknown as MongoClient
 
-beforeEach(() => {
+beforeEach(async () => {
+  await closeMongo()
+
   jest.clearAllMocks()
   ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
 })
@@ -22,10 +27,19 @@ describe('Mongo Utils', () => {
   it('should connect to MongoDB and store client/db', async () => {
     await connectToMongo('mongo-uri', 'test-db')
 
+    expect(MongoClient).toHaveBeenCalledWith('mongo-uri')
     expect(mockConnect).toHaveBeenCalled()
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
   })
 
+  it('should not reconnect if db is already initialized', async () => {
+    await connectToMongo('mongo-uri', 'test-db')
+    await connectToMongo('mongo-uri', 'test-db')
+
+    expect(MongoClient).toHaveBeenCalledTimes(1)
+    expect(mockConnect).toHaveBeenCalledTimes(1)
+  })
+
   it('should return a collection when db is initialized', async () => {
     await connectToMongo('mongo-uri', 'test-db')
     getCollection('users')
@@ -35,17 +49,23 @@ describe('Mongo Utils', () => {
 
   it('getDb should return the initialized Db instance', async () => {
     await connectToMongo('mongo-uri', 'test-db')
-    const got = getDb()
-    expect(got).toBe(mockDb)
+
+    expect(getDb()).toBe(mockDb)
+  })
+
+  it('should throw error if db is not initialized', async () => {
+    await closeMongo()
+
+    expect(() => getCollection('users')).toThrow(/Mongo not initialized/)
+    expect(() => getDb()).toThrow(/Mongo not initialized/)
   })
 
-  it('should throw error if db is not initialized (getCollection/getDb)', () => {
-    jest.isolateModules(() => {
-      // require a fresh copy of the module so module-level state is uninitialized
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const mod = require('../../src/db/mongo')
-      expect(() => mod.getCollection('users')).toThrow(/Mongo not initialized/)
-      expect(() => mod.getDb()).toThrow(/Mongo not initialized/)
-    })
+  it('should close Mongo and reset state', async () => {
+    await connectToMongo('mongo-uri', 'test-db')
+    await closeMongo()
+
+    expect(mockClose).toHaveBeenCalled()
+
+    expect(() => getDb()).toThrow(/Mongo not initialized/)
   })
 })

package/tests/db/mongo2.test.ts

@@ -1,4 +1,4 @@
-import { connectToMongo2, getDb2, getCollection2 } from '../../src/db/mongo2'
+import { connectToMongo2, getDb2, getCollection2, closeMongo2 } from '../../src/db/mongo2'
 import { MongoClient, Db } from 'mongodb'
 
 jest.mock('mongodb')
@@ -8,12 +8,17 @@ const mockDb = {
 } as unknown as Db
 
 const mockConnect = jest.fn()
+const mockClose = jest.fn()
+
 const mockClient = {
   connect: mockConnect,
+  close: mockClose,
   db: jest.fn().mockReturnValue(mockDb)
 } as unknown as MongoClient
 
-beforeEach(() => {
+beforeEach(async () => {
+  await closeMongo2()
+
   jest.clearAllMocks()
   ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
 })
@@ -22,13 +27,23 @@ describe('Mongo Utils', () => {
   it('should connect to MongoDB and store client', async () => {
     await connectToMongo2('mongo-uri')
 
-    expect(mockConnect).toHaveBeenCalled()
+    expect(MongoClient).toHaveBeenCalledWith('mongo-uri')
+    expect(mockConnect).toHaveBeenCalledTimes(1)
+  })
+
+  it('should not reconnect if client is already initialized', async () => {
+    await connectToMongo2('mongo-uri')
+    await connectToMongo2('mongo-uri')
+
+    expect(MongoClient).toHaveBeenCalledTimes(1)
+    expect(mockConnect).toHaveBeenCalledTimes(1)
   })
 
   it('should return a Db instance when client is initialized', async () => {
     await connectToMongo2('mongo-uri')
 
     const db = getDb2('test-db')
+
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
     expect(db).toBe(mockDb)
   })
@@ -37,23 +52,23 @@ describe('Mongo Utils', () => {
     await connectToMongo2('mongo-uri')
 
     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('../../src/db/mongo2')
-      expect(() => getDb2('test-db')).toThrow('Mongo not initialized')
-    })
+  it('should throw error if client is not initialized', async () => {
+    await closeMongo2()
+
+    expect(() => getDb2('test-db')).toThrow('Mongo not initialized')
+    expect(() => getCollection2('test-db', 'users')).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('../../src/db/mongo2')
-      expect(() => getCollection2('test-db', 'users')).toThrow('Mongo not initialized')
-    })
+  it('should close Mongo and reset state', async () => {
+    await connectToMongo2('mongo-uri')
+    await closeMongo2()
+
+    expect(mockClose).toHaveBeenCalledTimes(1)
+    expect(() => getDb2('test-db')).toThrow('Mongo not initialized')
   })
 })

package/tests/db/mongo3.test.ts

@@ -2,6 +2,8 @@ import {
   connectToMongo3,
   getDb3,
   getCollection3,
+  closeMongo3,
+  closeAllMongo3,
   __mongoClients,
   __connectPromises
 } from '../../src/db/mongo3'
@@ -14,12 +16,17 @@ const mockDb = {
 } as unknown as Db
 
 const mockConnect = jest.fn()
+const mockClose = jest.fn()
+
 const mockClient = {
   connect: mockConnect,
+  close: mockClose,
   db: jest.fn().mockReturnValue(mockDb)
 } as unknown as MongoClient
 
-beforeEach(() => {
+beforeEach(async () => {
+  await closeAllMongo3()
+
   jest.clearAllMocks()
   __mongoClients.clear()
   __connectPromises.clear()
@@ -33,9 +40,11 @@ describe('MongoClientManager (multi-cluster)', () => {
   it('should connect and cache client for a single cluster', async () => {
     await connectToMongo3(clusterAUri)
 
-    expect(mockConnect).toHaveBeenCalled()
+    expect(MongoClient).toHaveBeenCalledWith(clusterAUri)
+    expect(mockConnect).toHaveBeenCalledTimes(1)
 
     const db = getDb3(clusterAUri, 'test-db')
+
     expect(mockClient.db).toHaveBeenCalledWith('test-db')
     expect(db).toBe(mockDb)
   })
@@ -44,6 +53,7 @@ describe('MongoClientManager (multi-cluster)', () => {
     await connectToMongo3(clusterAUri)
     await connectToMongo3(clusterAUri)
 
+    expect(MongoClient).toHaveBeenCalledTimes(1)
     expect(mockConnect).toHaveBeenCalledTimes(1)
   })
 
@@ -51,6 +61,7 @@ describe('MongoClientManager (multi-cluster)', () => {
     await connectToMongo3(clusterAUri)
     await connectToMongo3(clusterBUri)
 
+    expect(MongoClient).toHaveBeenCalledTimes(2)
     expect(mockConnect).toHaveBeenCalledTimes(2)
   })
 
@@ -63,21 +74,31 @@ describe('MongoClientManager (multi-cluster)', () => {
     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('../../src/db/mongo3')
-      expect(() => getDb3('unknown-uri', 'some-db')).toThrow('Mongo client not initialized')
-    })
+  it('should throw error if client not initialized', () => {
+    expect(() => getDb3('unknown-uri', 'some-db')).toThrow('Mongo client not initialized')
+    expect(() => getCollection3('unknown-uri', 'some-db', 'users')).toThrow(
+      'Mongo client not initialized'
+    )
+  })
+
+  it('should close one Mongo client and reset only that uri', async () => {
+    await connectToMongo3(clusterAUri)
+    await closeMongo3(clusterAUri)
+
+    expect(mockClose).toHaveBeenCalledTimes(1)
+    expect(__mongoClients.has(clusterAUri)).toBe(false)
+    expect(__connectPromises.has(clusterAUri)).toBe(false)
+    expect(() => getDb3(clusterAUri, 'test-db')).toThrow('Mongo client 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('../../src/db/mongo3')
-      expect(() => getCollection3('unknown-uri', 'some-db', 'users')).toThrow(
-        'Mongo client not initialized'
-      )
-    })
+  it('should close all Mongo clients and reset state', async () => {
+    await connectToMongo3(clusterAUri)
+    await connectToMongo3(clusterBUri)
+
+    await closeAllMongo3()
+
+    expect(mockClose).toHaveBeenCalledTimes(2)
+    expect(__mongoClients.size).toBe(0)
+    expect(__connectPromises.size).toBe(0)
   })
 })

package/tests/pricecharting.test.ts

@@ -1,6 +1,6 @@
-// tests/utils.test.ts
+// tests/pricecharting.test.ts
 
-import { splitNameAndNumber } from '../src/pricecharting'
+import { productExists, splitNameAndNumber } from '../src/pricecharting'
 
 describe('splitNameAndNumber (legacy fallback and new realNumber param)', () => {
   const legacyCases: Array<[string, { name: string; number: string | null }]> = [
@@ -73,3 +73,140 @@ describe('splitNameAndNumber (legacy fallback and new realNumber param)', () =>
     expect(splitNameAndNumber(input, '123')).toEqual({ name: 'Example', number: 'X123' })
   })
 })
+
+describe('productExists', () => {
+  const originalFetch = global.fetch
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.useRealTimers()
+    global.fetch = jest.fn()
+  })
+
+  afterEach(() => {
+    global.fetch = originalFetch
+  })
+
+  function mockFetchResponse(status: number, body: unknown) {
+    ;(global.fetch as jest.Mock).mockResolvedValue({
+      status,
+      json: jest.fn().mockResolvedValue(body)
+    })
+  }
+
+  test('returns null for invalid productId', async () => {
+    const result = await productExists(0, 'token', 30_000)
+
+    expect(result).toBeNull()
+    expect(global.fetch).not.toHaveBeenCalled()
+  })
+
+  test('returns null for missing token', async () => {
+    const result = await productExists(123, '', 30_000)
+
+    expect(result).toBeNull()
+    expect(global.fetch).not.toHaveBeenCalled()
+  })
+
+  test('returns null for invalid timeout', async () => {
+    const result = await productExists(123, 'token', 30)
+
+    expect(result).toBeNull()
+    expect(global.fetch).not.toHaveBeenCalled()
+  })
+
+  test('returns false when API responds with HTTP 404', async () => {
+    mockFetchResponse(404, {
+      error: 'No such product',
+      'error-message': 'No such product',
+      status: 'error'
+    })
+
+    const result = await productExists(123, 'token', 30_000)
+
+    expect(result).toBe(false)
+    expect(global.fetch).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns true when API responds with 200 and non-error body', async () => {
+    mockFetchResponse(200, {
+      status: 'success',
+      product: {
+        id: 123
+      }
+    })
+
+    const result = await productExists(123, 'token', 30_000)
+
+    expect(result).toBe(true)
+    expect(global.fetch).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns false when API responds with status error and no such product message', async () => {
+    mockFetchResponse(200, {
+      status: 'error',
+      error: 'No such product',
+      'error-message': 'No such product'
+    })
+
+    const result = await productExists(123, 'token', 30_000)
+
+    expect(result).toBe(false)
+  })
+
+  test('returns null when API responds with non-200 non-404 status', async () => {
+    mockFetchResponse(500, {
+      status: 'error',
+      error: 'server error'
+    })
+
+    const result = await productExists(123, 'token', 30_000)
+
+    expect(result).toBeNull()
+  })
+
+  test('returns null when JSON parsing fails', async () => {
+    ;(global.fetch as jest.Mock).mockResolvedValue({
+      status: 200,
+      json: jest.fn().mockRejectedValue(new Error('invalid json'))
+    })
+
+    const result = await productExists(123, 'token', 30_000)
+
+    expect(result).toBeNull()
+  })
+
+  test('returns null when response body is not an object', async () => {
+    mockFetchResponse(200, null)
+
+    const result = await productExists(123, 'token', 30_000)
+
+    expect(result).toBeNull()
+  })
+
+  test('returns null when fetch fails', async () => {
+    ;(global.fetch as jest.Mock).mockRejectedValue(new Error('network error'))
+
+    const result = await productExists(123, 'token', 30_000)
+
+    expect(result).toBeNull()
+  })
+
+  test('calls PriceCharting API with token and product id', async () => {
+    mockFetchResponse(200, {
+      status: 'success'
+    })
+
+    await productExists(456, 'test-token', 30_000)
+
+    expect(global.fetch).toHaveBeenCalledTimes(1)
+
+    const [url, options] = (global.fetch as jest.Mock).mock.calls[0]
+
+    expect(url).toContain('https://www.pricecharting.com/api/product')
+    expect(url).toContain('t=test-token')
+    expect(url).toContain('id=456')
+    expect(options.method).toBe('GET')
+    expect(options.signal).toBeDefined()
+  })
+})