opticedge-cloud-utils 1.1.31 → 1.1.33

package/dist/pricecharting.d.ts

@@ -2,6 +2,10 @@ type CardParts = {
     name: string;
     number: string | null;
 };
+interface ParsedVariantName {
+    name: string;
+    variant: string;
+}
 /**
  * Split a card label into `{ name, number }`.
  *
@@ -15,4 +19,6 @@ 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 parseCardVariant(value: string): ParsedVariantName;
+export declare function productExists(productId: number, token: string, fetchTimeoutMs: number): Promise<boolean | null>;
 export {};

package/dist/pricecharting.js

@@ -1,7 +1,13 @@
 "use strict";
+// src/pricecharting.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitNameAndNumber = splitNameAndNumber;
+exports.parseCardVariant = parseCardVariant;
+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 +54,96 @@ function splitNameAndNumber(input, realNumber) {
         return { name: s, number: null };
     return { name: namePart, number: numberPart };
 }
+function parseCardVariant(value) {
+    const trimmedValue = value.trim();
+    // Matches names ending with a bracketed variant:
+    // Arcanine [Reverse Holo]
+    const match = trimmedValue.match(/^(.*?)\s+\[([^\]]+)\]\s*$/);
+    if (!match) {
+        return {
+            name: trimmedValue,
+            variant: 'Regular'
+        };
+    }
+    return {
+        name: match[1].trim(),
+        variant: match[2].trim()
+    };
+}
+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.31",
-  "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.33",
+  "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/pricecharting.ts

@@ -1,7 +1,24 @@
+// 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
+}
+
+interface ParsedVariantName {
+  name: string
+  variant: 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 +66,112 @@ export function splitNameAndNumber(input: string, realNumber?: string | null): C
 
   return { name: namePart, number: numberPart }
 }
+
+export function parseCardVariant(value: string): ParsedVariantName {
+  const trimmedValue = value.trim()
+
+  // Matches names ending with a bracketed variant:
+  // Arcanine [Reverse Holo]
+  const match = trimmedValue.match(/^(.*?)\s+\[([^\]]+)\]\s*$/)
+
+  if (!match) {
+    return {
+      name: trimmedValue,
+      variant: 'Regular'
+    }
+  }
+
+  return {
+    name: match[1].trim(),
+    variant: match[2].trim()
+  }
+}
+
+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/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()
+  })
+})