feat : Add Phone Number Module : [ATLAS-24]

src/common/errorBoundary/index.ts

@@ -18,13 +18,14 @@
  * @param fn utility that is wrapped in error boundary
  * @returns {Function} returns the function wrapped in try/catch block
  */
 export const withErrorBoundary = <T extends (...args: unknown[]) => unknown>(
   fn: T,
 ): ((...args: Parameters<T>) => ReturnType<T>) => {
   return function (...rest: Parameters<T>) {
     try {
       return fn.call(this, ...rest);
     } catch (err) {
+      console.warn('[I18N Error]: ', err);
       // Currently, we are throwing the error as it is to consumers.
       // In the future, this can be modified as per our requirement, like an error logging service.
       throw new I18nifyError(err);

src/modules/phoneNumber/__tests__/cleanPhoneNumber.test.ts

@@ -0,0 +1,43 @@
+import { cleanPhoneNumber } from '../utils';
+
+describe('cleanPhoneNumber', () => {
+  it('should remove non-numeric characters from a phone number', () => {
+    const phoneNumber = '+1 (123)-456-7890'; // Phone number with various non-numeric characters
+
+    const cleanedNumber = cleanPhoneNumber(phoneNumber);
+
+    expect(cleanedNumber).toBe('+11234567890'); // Expecting only numeric characters and '+' at the start
+  });
+
+  it('should handle an already clean phone number without non-numeric characters', () => {
+    const phoneNumber = '+9876543210'; // Clean phone number without non-numeric characters
+
+    const cleanedNumber = cleanPhoneNumber(phoneNumber);
+
+    expect(cleanedNumber).toBe('+9876543210'); // Expecting no change in the phone number
+  });
+
+  it('should handle an empty phone number string', () => {
+    const phoneNumber = '';
+
+    const cleanedNumber = cleanPhoneNumber(phoneNumber);
+
+    expect(cleanedNumber).toBe('');
+  });
+
+  it('should handle a phone number starting with non-numeric characters', () => {
+    const phoneNumber = 'abc+123456789'; // Phone number starting with non-numeric characters
+
+    const cleanedNumber = cleanPhoneNumber(phoneNumber);
+
+    expect(cleanedNumber).toBe('123456789'); // Expecting non-numeric characters at the start to be removed, will also remove + as it is not the starting character
+  });
+
+  it('should handle a phone number with only non-numeric characters', () => {
+    const phoneNumber = '---'; // Phone number with only non-numeric characters
+
+    const cleanedNumber = cleanPhoneNumber(phoneNumber);
+
+    expect(cleanedNumber).toBe('');
+  });
+});

src/modules/phoneNumber/__tests__/detectCountryCodeFromDialCode.test.ts

@@ -0,0 +1,13 @@
+import { detectCountryCodeFromDialCode } from '../utils';
+
+describe('detectCountryCodeFromDialCode', () => {
+  it('should detect country code for valid phone numbers', () => {
+    expect(detectCountryCodeFromDialCode('+919876543210')).toBe('IN');
+    expect(detectCountryCodeFromDialCode('60123456789')).toBe('MY');
+    expect(detectCountryCodeFromDialCode('+12125551234')).toBe('US');
+  });
+
+  it('should throw an error for invalid phone numbers', () => {
+    expect(detectCountryCodeFromDialCode('123')).toBe('');
+  });
+});

src/modules/phoneNumber/__tests__/formatPhoneNumber.test.ts

@@ -0,0 +1,32 @@
+import formatPhoneNumber from '../formatPhoneNumber';
+
+describe('formatPhoneNumber', () => {
+  it('should format an Indian phone number', () => {
+    const phoneNumber = '+917394926646';
+    const countryCode = 'IN';
+    const formatted = formatPhoneNumber(phoneNumber, countryCode);
+    expect(formatted).toBe('+91 7394 926646');
+  });
+
+  it('should format a Malaysian phone number', () => {
+    const phoneNumber = '+60123456789';
+    const countryCode = 'MY';
+    const formatted = formatPhoneNumber(phoneNumber, countryCode);
+    expect(formatted).toBe('+60 12 34567 89');
+  });
+
+  it('should handle a invalid country code and detect it from phone number to format', () => {
+    const phoneNumber = '+917394926646';
+    const countryCode = 'XYZ';
+    const formatted = formatPhoneNumber(phoneNumber, countryCode);
+    expect(formatted).toBe('+91 7394 926646');
+  });
+
+  it('should handle a missing phoneNumber', () => {
+    const phoneNumber = '';
+    const countryCode = 'MY';
+    expect(() => formatPhoneNumber(phoneNumber, countryCode)).toThrow(
+      'Parameter `phoneNumber` is invalid!',
+    );
+  });
+});

src/modules/phoneNumber/__tests__/isValidPhoneNumber.test.ts

@@ -0,0 +1,47 @@
+import isValidPhoneNumber from '../isValidPhoneNumber';
+
+describe('isValidPhoneNumber', () => {
+  const validTestDataSet = [
+    { countryCode: 'IN', phoneNumber: '+917394926646' },
+    { countryCode: 'MY', phoneNumber: '+60123456789' },
+  ];
+
+  const invalidTestDataSet = [
+    { countryCode: 'IN', phoneNumber: '1234' },
+    { countryCode: 'MY', phoneNumber: '60123' },
+  ];
+
+  validTestDataSet.map((dataset) => {
+    it(`should validate a valid phone number for ${dataset.countryCode}`, () => {
+      const isValid = isValidPhoneNumber(
+        dataset.phoneNumber,
+        dataset.countryCode,
+      );
+      expect(isValid).toBe(true);
+    });
+  });
+
+  invalidTestDataSet.map((dataset) => {
+    it(`should reject an invalid phone number for ${dataset.countryCode}`, () => {
+      const isValid = isValidPhoneNumber(
+        dataset.phoneNumber,
+        dataset.countryCode,
+      );
+      expect(isValid).toBe(false);
+    });
+  });
+
+  it('should handle a invalid country code and detect it from phone number to validate it', () => {
+    const phoneNumber = '1234567890';
+    const countryCode = 'XYZ';
+    const isValid = isValidPhoneNumber(phoneNumber, countryCode);
+    expect(isValid).toBe(true);
+  });
+
+  it('should handle a missing phoneNumber', () => {
+    const phoneNumber = '';
+    const countryCode = 'MY';
+    const isValid = isValidPhoneNumber(phoneNumber, countryCode);
+    expect(isValid).toBe(false);
+  });
+});

src/modules/phoneNumber/__tests__/parsePhoneNumber.test.ts

@@ -0,0 +1,39 @@
+import parsePhoneNumber from '../parsePhoneNumber';
+
+describe('parsePhoneNumber function', () => {
+  it('should correctly parse a valid phone number with country code', () => {
+    const phoneNumber = '+15853042806';
+    const country = 'US';
+
+    const parsedInfo = parsePhoneNumber(phoneNumber, country);
+
+    expect(parsedInfo).toEqual({
+      countryCode: 'US',
+      dialCode: '+1',
+      formattedPhoneNumber: '+1 585-304-2806',
+      formatTemplate: 'xxx-xxx-xxxx',
+    });
+  });
+
+  it('should correctly parse a valid phone number without specifying country', () => {
+    const phoneNumber = '+447123456789';
+
+    const parsedInfo = parsePhoneNumber(phoneNumber);
+
+    expect(parsedInfo.countryCode).toBe('GB');
+    expect(parsedInfo.dialCode).toBe('+44');
+    expect(parsedInfo.formattedPhoneNumber).toBe('+44 7123 456 789');
+    expect(parsedInfo.formatTemplate).toBe('xxxx xxx xxx');
+  });
+
+  it('should return unformatted number for invalid phone number', () => {
+    const phoneNumber = '+1969123456789';
+
+    const parsedInfo = parsePhoneNumber(phoneNumber);
+
+    expect(parsedInfo.countryCode).toBe('');
+    expect(parsedInfo.dialCode).toBe('');
+    expect(parsedInfo.formattedPhoneNumber).toBe('+1969123456789');
+    expect(parsedInfo.formatTemplate).toBe('');
+  });
+});