core-services-sdk 1.3.10 → 1.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
@@ -25,6 +25,7 @@
     "amqplib": "^0.10.8",
     "dot": "^1.1.3",
     "fastify": "^5.4.0",
+    "google-libphonenumber": "^3.2.42",
     "http-status": "^2.1.0",
     "mongodb": "^6.18.0",
     "node-fetch": "^3.3.2",

package/src/core/index.js

@@ -3,3 +3,4 @@ export * from './otp-generators.js'
 export * from './sanitize-objects.js'
 export * from './normalize-to-array.js'
 export * from './combine-unique-arrays.js'
+export * from './normalize-phone-number.js'

package/src/core/normalize-phone-number.js

@@ -0,0 +1,93 @@
+// src/core/phone-validate.js
+// Validate & normalize using google-libphonenumber
+
+import { PhoneNumberUtil, PhoneNumberFormat } from 'google-libphonenumber'
+
+const phoneUtil = PhoneNumberUtil.getInstance()
+
+/**
+ * Trim and remove invisible RTL markers that can sneak in from copy/paste.
+ * @param {string} input
+ * @returns {string}
+ */
+function clean(input) {
+  return String(input)
+    .trim()
+    .replace(/[\u200e\u200f]/g, '')
+}
+
+/**
+ * Convert a parsed libphonenumber object into a normalized result.
+ * @param {import('google-libphonenumber').PhoneNumber} parsed
+ * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
+ */
+function toResult(parsed) {
+  return {
+    e164: phoneUtil.format(parsed, PhoneNumberFormat.E164),
+    national: phoneUtil.format(parsed, PhoneNumberFormat.NATIONAL),
+    international: phoneUtil.format(parsed, PhoneNumberFormat.INTERNATIONAL),
+    regionCode: phoneUtil.getRegionCodeForNumber(parsed),
+    type: phoneUtil.getNumberType(parsed),
+  }
+}
+
+/**
+ * Parse & validate an international number (must start with '+').
+ * Throws on invalid input.
+ *
+ * @param {string} input - International number, e.g. "+972541234567"
+ * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
+ * @throws {Error} If the number is invalid
+ */
+export function normalizePhoneOrThrowIntl(input) {
+  try {
+    const parsed = phoneUtil.parseAndKeepRawInput(clean(input))
+    if (!phoneUtil.isValidNumber(parsed)) throw new Error('x')
+    return toResult(parsed)
+  } catch {
+    throw new Error('Invalid phone number')
+  }
+}
+
+/**
+ * Parse & validate a national number using a region hint.
+ * Throws on invalid input.
+ *
+ * @param {string} input - National number, e.g. "054-123-4567"
+ * @param {string} defaultRegion - ISO region like "IL" or "US"
+ * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
+ * @throws {Error} If the number is invalid
+ */
+export function normalizePhoneOrThrowWithRegion(input, defaultRegion) {
+  try {
+    const parsed = phoneUtil.parseAndKeepRawInput(clean(input), defaultRegion)
+    if (!phoneUtil.isValidNumber(parsed)) throw new Error('x')
+    return toResult(parsed)
+  } catch {
+    throw new Error('Invalid phone number')
+  }
+}
+
+/**
+ * Smart normalization:
+ * - If input starts with '+', parse as international.
+ * - Otherwise require a defaultRegion and parse as national.
+ * Throws on invalid input or when defaultRegion is missing for non-international numbers.
+ *
+ * @param {string} input
+ * @param {{ defaultRegion?: string }} [opts]
+ * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
+ * @throws {Error} If invalid or defaultRegion is missing for non-international input
+ */
+export function normalizePhoneOrThrow(input, opts = {}) {
+  const cleaned = clean(input)
+  if (/^\+/.test(cleaned)) {
+    return normalizePhoneOrThrowIntl(cleaned)
+  }
+  const { defaultRegion } = opts
+  if (!defaultRegion) {
+    // keep this one specific; your test relies on a different message here
+    throw new Error('defaultRegion is required for non-international numbers')
+  }
+  return normalizePhoneOrThrowWithRegion(cleaned, defaultRegion)
+}

package/tests/core/normalize-phone-number.unit.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest'
+import { PhoneNumberUtil, PhoneNumberFormat } from 'google-libphonenumber'
+
+import {
+  normalizePhoneOrThrow,
+  normalizePhoneOrThrowIntl,
+  normalizePhoneOrThrowWithRegion,
+} from '../../src/core/normalize-phone-number.js'
+
+const phoneUtil = PhoneNumberUtil.getInstance()
+
+/**
+ * Get a valid example number for a given region from libphonenumber.
+ * This keeps tests stable across environments and avoids fake numbers.
+ * @param {string} region - e.g. "IL", "US"
+ */
+function exampleForRegion(region) {
+  const ex = phoneUtil.getExampleNumber(region)
+  return {
+    e164: phoneUtil.format(ex, PhoneNumberFormat.E164),
+    national: phoneUtil.format(ex, PhoneNumberFormat.NATIONAL),
+    region,
+  }
+}
+
+describe('phone normalization helpers', () => {
+  it('normalizePhoneOrThrowIntl: parses a valid international number (US)', () => {
+    const us = exampleForRegion('US')
+    const out = normalizePhoneOrThrowIntl(us.e164)
+    expect(out.e164).toBe(us.e164)
+    expect(out.regionCode).toBe('US')
+    expect(out.international).toMatch(/^\+1\b/)
+  })
+
+  it('normalizePhoneOrThrowWithRegion: parses a national number with region (IL)', () => {
+    const il = exampleForRegion('IL')
+    // introduce some separators/spaces to mimic user input
+    const dirty = `  ${il.national.replace(/\s/g, '-')}  `
+    const out = normalizePhoneOrThrowWithRegion(dirty, 'IL')
+    expect(out.e164).toBe(il.e164)
+    expect(out.regionCode).toBe('IL')
+    expect(out.international).toMatch(/^\+972/)
+  })
+
+  it('normalizePhoneOrThrow (smart): international path without region', () => {
+    const us = exampleForRegion('US')
+    const out = normalizePhoneOrThrow(us.e164)
+    expect(out.e164).toBe(us.e164)
+    expect(out.regionCode).toBe('US')
+  })
+
+  it('normalizePhoneOrThrow (smart): national path requires defaultRegion', () => {
+    const il = exampleForRegion('IL')
+    const dirty = il.national.replace(/\s/g, ' - ')
+    const out = normalizePhoneOrThrow(dirty, { defaultRegion: 'IL' })
+    expect(out.e164).toBe(il.e164)
+    expect(out.regionCode).toBe('IL')
+  })
+
+  it('normalizePhoneOrThrow (smart): throws if national with no defaultRegion', () => {
+    expect(() => normalizePhoneOrThrow('054-123-4567')).toThrow(
+      /defaultRegion is required/i,
+    )
+  })
+
+  it('all helpers: throw on truly invalid numbers', () => {
+    expect(() => normalizePhoneOrThrowIntl('++972')).toThrow(
+      /Invalid phone number/i,
+    )
+    expect(() => normalizePhoneOrThrowWithRegion('123', 'IL')).toThrow(
+      /Invalid phone number/i,
+    )
+    expect(() => normalizePhoneOrThrow('++972')).toThrow(
+      /Invalid phone number/i,
+    )
+  })
+
+  it('should normalize a valid international number', () => {
+    const result = normalizePhoneOrThrowIntl('+972523444444')
+
+    expect(result).toMatchObject({
+      e164: '+972523444444',
+      national: expect.stringContaining('052'),
+      international: expect.stringContaining('+972'),
+      regionCode: 'IL',
+      type: expect.any(Number), // e.g. 1 = MOBILE
+    })
+  })
+})
+
+describe('phone normalization — no region (international) & with region', () => {
+  // Valid full international IL mobile number (E.164)
+  const intlIl = '+972523444444' // 052-344-4444
+
+  it('normalizePhoneOrThrowIntl: accepts full international number without region', () => {
+    const out = normalizePhoneOrThrowIntl(intlIl)
+    expect(out.e164).toBe(intlIl)
+    expect(out.regionCode).toBe('IL')
+    expect(out.international).toMatch(/^\+972/)
+    expect(typeof out.type).toBe('number')
+  })
+
+  it('normalizePhoneOrThrow (smart): accepts +972... without defaultRegion', () => {
+    const out = normalizePhoneOrThrow(intlIl) // no opts.defaultRegion
+    expect(out.e164).toBe(intlIl)
+    expect(out.regionCode).toBe('IL')
+  })
+
+  it('normalizePhoneOrThrowWithRegion: accepts national number with region', () => {
+    const out = normalizePhoneOrThrowWithRegion('052-344-4444', 'IL')
+    expect(out.e164).toBe(intlIl)
+    expect(out.regionCode).toBe('IL')
+    expect(out.national).toMatch(/052/)
+  })
+})