opticedge-cloud-utils 1.1.26 → 1.1.28

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export * from './env';
 export * from './logger';
 export * from './number';
 export * from './parser';
+export * from './pricecharting';
 export * from './pub';
 export * from './regex';
 export * from './retry';

package/dist/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./env"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./number"), exports);
 __exportStar(require("./parser"), exports);
+__exportStar(require("./pricecharting"), exports);
 __exportStar(require("./pub"), exports);
 __exportStar(require("./regex"), exports);
 __exportStar(require("./retry"), exports);

package/dist/pricecharting.d.ts

@@ -0,0 +1,18 @@
+type CardParts = {
+    name: string;
+    number: string | null;
+};
+/**
+ * Split a card label into `{ name, number }`.
+ *
+ * Logic:
+ * 1. If `realNumber` (string) is provided — try to find it as a whole token at the END of `input`.
+ *    Accepts " #123", "# 123", " 123", or "123" at the very end.
+ *    If found, returns `{ name: <before>, number: realNumber }`.
+ *    DOES NOT match numeric suffixes that are part of a larger token (e.g. "X123" won't match "123").
+ * 2. If `realNumber` is `null` or `undefined`, or not found — fallback:
+ *    Use the last `#` to split, as in the legacy logic.
+ * 3. If no valid number found — returns `{ name: original, number: null }`.
+ */
+export declare function splitNameAndNumber(input: string, realNumber?: string | null): CardParts;
+export {};

package/dist/pricecharting.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitNameAndNumber = splitNameAndNumber;
+const regex_1 = require("./regex");
+/**
+ * Split a card label into `{ name, number }`.
+ *
+ * Logic:
+ * 1. If `realNumber` (string) is provided — try to find it as a whole token at the END of `input`.
+ *    Accepts " #123", "# 123", " 123", or "123" at the very end.
+ *    If found, returns `{ name: <before>, number: realNumber }`.
+ *    DOES NOT match numeric suffixes that are part of a larger token (e.g. "X123" won't match "123").
+ * 2. If `realNumber` is `null` or `undefined`, or not found — fallback:
+ *    Use the last `#` to split, as in the legacy logic.
+ * 3. If no valid number found — returns `{ name: original, number: null }`.
+ */
+function splitNameAndNumber(input, realNumber) {
+    const s = (input ?? '').trim();
+    if (!s)
+        return { name: '', number: null };
+    // 1) Try realNumber match at the end (if provided)
+    if (realNumber) {
+        const rn = String(realNumber).trim();
+        if (rn !== '') {
+            const escaped = (0, regex_1.escapeForRegex)(rn);
+            // require either start-of-string or a separator (# or whitespace) before the number,
+            // and anchor to the end to ensure it's at the end of the input.
+            // Examples matched: "... #123", "... # 123", "... 123", "...123" (if preceded by whitespace or start)
+            const re = new RegExp(`(?:^|[\\s#])${escaped}\\s*$`, 'i');
+            const match = re.exec(s);
+            if (match) {
+                // match.index points at start of the (?:^|[\s#]) group
+                let namePart = s.slice(0, match.index);
+                // remove trailing separators (# and whitespace) that preceded the number
+                namePart = namePart.replace(/[#\s]+$/g, '').trim();
+                return { name: namePart, number: rn };
+            }
+            // else fall through to fallback
+        }
+    }
+    // 2) Fallback: use last "#" style split (legacy behaviour)
+    const idx = s.lastIndexOf('#');
+    if (idx === -1)
+        return { name: s, number: null };
+    const namePart = s.slice(0, idx).trim();
+    const numberPart = s.slice(idx + 1).trim();
+    if (numberPart === '')
+        return { name: s, number: null };
+    return { name: namePart, number: numberPart };
+}

package/dist/validator.d.ts

@@ -1,3 +1,4 @@
 /** Basic email validation — good enough for most production use cases */
 declare const isValidEmail: (email: string) => boolean;
-export { isValidEmail };
+declare const isValidObjectId: (id: string) => boolean;
+export { isValidEmail, isValidObjectId };

package/dist/validator.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidEmail = void 0;
+exports.isValidObjectId = exports.isValidEmail = void 0;
+const mongodb_1 = require("mongodb");
 /** Basic email validation — good enough for most production use cases */
 const isValidEmail = (email) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email.trim());
 exports.isValidEmail = isValidEmail;
+const isValidObjectId = (id) => {
+    return mongodb_1.ObjectId.isValid(id) && new mongodb_1.ObjectId(id).toHexString() === id;
+};
+exports.isValidObjectId = isValidObjectId;

package/package.json

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

package/src/index.ts

@@ -9,6 +9,7 @@ export * from './env'
 export * from './logger'
 export * from './number'
 export * from './parser'
+export * from './pricecharting'
 export * from './pub'
 export * from './regex'
 export * from './retry'

package/src/pricecharting.ts

@@ -0,0 +1,51 @@
+import { escapeForRegex } from './regex'
+
+type CardParts = { name: string; number: string | null }
+
+/**
+ * Split a card label into `{ name, number }`.
+ *
+ * Logic:
+ * 1. If `realNumber` (string) is provided — try to find it as a whole token at the END of `input`.
+ *    Accepts " #123", "# 123", " 123", or "123" at the very end.
+ *    If found, returns `{ name: <before>, number: realNumber }`.
+ *    DOES NOT match numeric suffixes that are part of a larger token (e.g. "X123" won't match "123").
+ * 2. If `realNumber` is `null` or `undefined`, or not found — fallback:
+ *    Use the last `#` to split, as in the legacy logic.
+ * 3. If no valid number found — returns `{ name: original, number: null }`.
+ */
+export function splitNameAndNumber(input: string, realNumber?: string | null): CardParts {
+  const s = (input ?? '').trim()
+  if (!s) return { name: '', number: null }
+
+  // 1) Try realNumber match at the end (if provided)
+  if (realNumber) {
+    const rn = String(realNumber).trim()
+    if (rn !== '') {
+      const escaped = escapeForRegex(rn)
+      // require either start-of-string or a separator (# or whitespace) before the number,
+      // and anchor to the end to ensure it's at the end of the input.
+      // Examples matched: "... #123", "... # 123", "... 123", "...123" (if preceded by whitespace or start)
+      const re = new RegExp(`(?:^|[\\s#])${escaped}\\s*$`, 'i')
+      const match = re.exec(s)
+      if (match) {
+        // match.index points at start of the (?:^|[\s#]) group
+        let namePart = s.slice(0, match.index)
+        // remove trailing separators (# and whitespace) that preceded the number
+        namePart = namePart.replace(/[#\s]+$/g, '').trim()
+        return { name: namePart, number: rn }
+      }
+      // else fall through to fallback
+    }
+  }
+
+  // 2) Fallback: use last "#" style split (legacy behaviour)
+  const idx = s.lastIndexOf('#')
+  if (idx === -1) return { name: s, number: null }
+
+  const namePart = s.slice(0, idx).trim()
+  const numberPart = s.slice(idx + 1).trim()
+  if (numberPart === '') return { name: s, number: null }
+
+  return { name: namePart, number: numberPart }
+}

package/src/validator.ts

@@ -1,4 +1,10 @@
+import { ObjectId } from 'mongodb'
+
 /** Basic email validation — good enough for most production use cases */
 const isValidEmail = (email: string) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email.trim())
 
-export { isValidEmail }
+const isValidObjectId = (id: string): boolean => {
+  return ObjectId.isValid(id) && new ObjectId(id).toHexString() === id
+}
+
+export { isValidEmail, isValidObjectId }

package/tests/pricecharting.test.ts

@@ -0,0 +1,75 @@
+// tests/utils.test.ts
+
+import { splitNameAndNumber } from '../src/pricecharting'
+
+describe('splitNameAndNumber (legacy fallback and new realNumber param)', () => {
+  const legacyCases: Array<[string, { name: string; number: string | null }]> = [
+    ['Charizard [1st Edition] #4', { name: 'Charizard [1st Edition]', number: '4' }],
+    ['Pikachu', { name: 'Pikachu', number: null }],
+    ['Mystery #', { name: 'Mystery #', number: null }], // nothing after '#'
+    ['#7', { name: '', number: '7' }], // valid number but empty name
+    ['Name #  123  ', { name: 'Name', number: '123' }], // trims spaces
+    ['X#Y #42', { name: 'X#Y', number: '42' }], // uses last '#'
+    ['   ', { name: '', number: null }], // whitespace-only input
+    ['', { name: '', number: null }] // empty string
+  ]
+
+  test.each(legacyCases)('splitNameAndNumber("%s") -> %j (legacy fallback)', (input, expected) => {
+    expect(splitNameAndNumber(input)).toEqual(expected)
+  })
+
+  test('does not treat an internal "#" before last as separator', () => {
+    const input = 'Foo#bar#999'
+    expect(splitNameAndNumber(input)).toEqual({ name: 'Foo#bar', number: '999' })
+  })
+
+  test('handles undefined / null input gracefully', () => {
+    // @ts-expect-error intentional: testing undefined input
+    expect(splitNameAndNumber(undefined)).toEqual({ name: '', number: null })
+    // @ts-expect-error intentional: testing null input
+    expect(splitNameAndNumber(null)).toEqual({ name: '', number: null })
+  })
+
+  // -----------------------
+  // New tests for realNumber parameter
+  // -----------------------
+  const realNumberCases: Array<
+    [string, string | null | undefined, { name: string; number: string | null }]
+  > = [
+    // exact match with trailing "#"
+    ['test product name #123', '123', { name: 'test product name', number: '123' }],
+
+    // exact match with trailing plain digits
+    ['test product name 123', '123', { name: 'test product name', number: '123' }],
+
+    // realNumber provided and found even when there is a space before the number
+    ['foo bar #  42', '42', { name: 'foo bar', number: '42' }],
+
+    // realNumber provided that appears at the end with no '#'
+    ['Some Card 007', '007', { name: 'Some Card', number: '007' }],
+
+    // realNumber provided but NOT found as a whole token at end -> fallback to last '#' behavior
+    // input ends with "#123abc", realNumber '123' is a suffix of larger token -> fallback to last '#'
+    ['test product name #123abc', '123', { name: 'test product name', number: '123abc' }],
+
+    // multiple #'s; realNumber found at end
+    ['A#B#999', '999', { name: 'A#B', number: '999' }],
+
+    // realNumber is undefined/null -> fallback behavior (legacy)
+    ['Charizard [1st Edition] #4', undefined, { name: 'Charizard [1st Edition]', number: '4' }],
+    ['Charizard [1st Edition] #4', null, { name: 'Charizard [1st Edition]', number: '4' }]
+  ]
+
+  test.each(realNumberCases)(
+    'splitNameAndNumber("%s", realNumber=%s) -> %j (realNumber cases)',
+    (input, realNumber, expected) => {
+      expect(splitNameAndNumber(input, realNumber)).toEqual(expected)
+    }
+  )
+
+  test('when realNumber is provided but not matched as whole token, fallback applies', () => {
+    const input = 'Example #X123'
+    // '123' is part of larger token 'X123' -> should FALLBACK and use last '#' -> number = 'X123'
+    expect(splitNameAndNumber(input, '123')).toEqual({ name: 'Example', number: 'X123' })
+  })
+})

package/tests/validator.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from '@jest/globals'
+import { ObjectId } from 'mongodb'
+import { isValidEmail, isValidObjectId } from '../src'
+
+describe('isValidEmail', () => {
+  it('returns true for simple valid emails', () => {
+    expect(isValidEmail('test@example.com')).toBe(true)
+    expect(isValidEmail('user.name@domain.co')).toBe(true)
+    expect(isValidEmail('user_name+tag@sub.domain.org')).toBe(true)
+  })
+
+  it('returns false for missing parts', () => {
+    expect(isValidEmail('')).toBe(false)
+    expect(isValidEmail('plainaddress')).toBe(false)
+    expect(isValidEmail('@no-local-part.com')).toBe(false)
+    expect(isValidEmail('username@')).toBe(false)
+    expect(isValidEmail('user@domain')).toBe(false)
+    expect(isValidEmail('username@.com')).toBe(false)
+  })
+
+  it('handles whitespace correctly', () => {
+    expect(isValidEmail('   test@example.com   ')).toBe(true)
+    expect(isValidEmail('\nuser@domain.com\t')).toBe(true)
+  })
+
+  it('rejects clearly invalid characters or formats', () => {
+    expect(isValidEmail('user@@domain.com')).toBe(false)
+    expect(isValidEmail('user@domain,com')).toBe(false)
+    expect(isValidEmail('user@domain com')).toBe(false)
+  })
+
+  it('accepts minimal valid domain structures', () => {
+    expect(isValidEmail('x@y.z')).toBe(true)
+  })
+})
+
+describe('isValidObjectId', () => {
+  it('returns true for valid ObjectId strings', () => {
+    const id = new ObjectId().toHexString()
+    expect(isValidObjectId(id)).toBe(true)
+  })
+
+  it('returns false for invalid length', () => {
+    expect(isValidObjectId('123')).toBe(false)
+    expect(isValidObjectId('12345678901234567890123')).toBe(false)
+    expect(isValidObjectId('1234567890123456789012345')).toBe(false)
+  })
+
+  it('returns false for non-hex characters', () => {
+    expect(isValidObjectId('zzzzzzzzzzzzzzzzzzzzzzzz')).toBe(false)
+    expect(isValidObjectId('12345678901234567890123g')).toBe(false)
+  })
+
+  it('rejects 12-byte strings that ObjectId.isValid would accept', () => {
+    expect(isValidObjectId('123456789012')).toBe(false)
+  })
+
+  it('is case-sensitive to exact hex string match', () => {
+    const id = new ObjectId().toHexString()
+    expect(isValidObjectId(id.toUpperCase())).toBe(false)
+  })
+
+  it('returns false for empty or malformed input', () => {
+    expect(isValidObjectId('')).toBe(false)
+    expect(isValidObjectId('   ')).toBe(false)
+    expect(isValidObjectId('null')).toBe(false)
+    expect(isValidObjectId('undefined')).toBe(false)
+  })
+})

package/tests/validator.ts

@@ -1,37 +0,0 @@
-// isValidEmail.test.ts
-import { describe, it, expect } from '@jest/globals'
-import { isValidEmail } from '../src'
-
-describe('isValidEmail', () => {
-  it('returns true for simple valid emails', () => {
-    expect(isValidEmail('test@example.com')).toBe(true)
-    expect(isValidEmail('user.name@domain.co')).toBe(true)
-    expect(isValidEmail('user_name+tag@sub.domain.org')).toBe(true)
-  })
-
-  it('returns false for missing parts', () => {
-    expect(isValidEmail('')).toBe(false)
-    expect(isValidEmail('plainaddress')).toBe(false)
-    expect(isValidEmail('@no-local-part.com')).toBe(false)
-    expect(isValidEmail('username@')).toBe(false)
-    expect(isValidEmail('user@domain')).toBe(false)
-    expect(isValidEmail('username@.com')).toBe(false)
-  })
-
-  it('handles whitespace correctly', () => {
-    expect(isValidEmail('   test@example.com   ')).toBe(true) // trims input
-    expect(isValidEmail('\nuser@domain.com\t')).toBe(true)
-  })
-
-  it('rejects invalid characters or formats', () => {
-    expect(isValidEmail('user@@domain.com')).toBe(false)
-    expect(isValidEmail('user@domain,com')).toBe(false)
-    expect(isValidEmail('user@domain..com')).toBe(false)
-    expect(isValidEmail('user@.domain.com')).toBe(false)
-    expect(isValidEmail('user@domain com')).toBe(false)
-  })
-
-  it('accepts minimal valid domain structures', () => {
-    expect(isValidEmail('x@y.z')).toBe(true) // still valid
-  })
-})