@digigov/form 0.10.8 → 0.10.10

package/src/validators/utils/iban.ts

@@ -0,0 +1,119 @@
+import { FieldSpec } from '@digigov/form/types';
+import { ValidatorSchema } from '@digigov/form/validators/types';
+export function validateIban(value: string, countryCode: string): boolean {
+  value = value.replace(/\s/g, '').replace(/-/g, '');
+  if (value.match(/^[0-9]*$/i)) {
+    // this is for greek iban without the country code
+    if (value.length !== 25) {
+      return false;
+    }
+  } else {
+    value = value.toUpperCase();
+    if (countryCode) {
+      if (!value.startsWith(countryCode.toUpperCase())) {
+        return false;
+      }
+      if (value.length === ibanCountryCodesLengths[countryCode.toUpperCase()]) {
+        return true;
+      }
+    }
+    if (value.length !== 27) {
+      // this is for greek iban
+      return false;
+    }
+  }
+  return true;
+}
+
+export const IBAN_VALIDATOR = (field: FieldSpec): ValidatorSchema => {
+  const countryCode = field?.extra?.country;
+  return {
+    name: 'iban-validator',
+    message: 'form.error.iban',
+    test: (value: string): boolean => {
+      if (!value) {
+        return true;
+      }
+      return validateIban(value, countryCode);
+    },
+  };
+};
+
+const ibanCountryCodesLengths = {
+  AD: 24,
+  AT: 20,
+  AZ: 28,
+  BH: 22,
+  BY: 28,
+  BE: 16,
+  BA: 20,
+  BR: 29,
+  BG: 22,
+  CR: 22,
+  HR: 21,
+  CY: 28,
+  CZ: 24,
+  DK: 18,
+  DO: 28,
+  EG: 29,
+  SV: 28,
+  EE: 20,
+  FO: 18,
+  FI: 18,
+  FR: 27,
+  GE: 22,
+  DE: 22,
+  GI: 23,
+  GR: 27,
+  GL: 18,
+  GT: 28,
+  VA: 22,
+  HU: 28,
+  IS: 26,
+  IQ: 23,
+  IE: 22,
+  IL: 23,
+  IT: 27,
+  JO: 30,
+  KZ: 20,
+  XK: 20,
+  KW: 30,
+  LV: 21,
+  LB: 28,
+  LI: 21,
+  LT: 20,
+  LU: 20,
+  MT: 31,
+  MR: 27,
+  MU: 30,
+  MD: 24,
+  MC: 27,
+  ME: 22,
+  NL: 18,
+  MK: 19,
+  NO: 15,
+  PK: 24,
+  PS: 29,
+  PL: 28,
+  PT: 25,
+  QA: 29,
+  RO: 24,
+  LC: 32,
+  SM: 27,
+  ST: 25,
+  SA: 24,
+  RS: 22,
+  SC: 31,
+  SK: 24,
+  SI: 19,
+  ES: 24,
+  SE: 24,
+  CH: 21,
+  TL: 23,
+  TN: 24,
+  TR: 26,
+  UA: 29,
+  AE: 23,
+  GB: 22,
+  VG: 24,
+};

package/src/validators/utils/index.ts

@@ -0,0 +1,94 @@
+import * as yup from 'yup';
+import { FieldSpec } from '@digigov/form/types';
+import { ValidatorSchema } from '@digigov/form/validators/types';
+
+export * from '@digigov/form/validators/utils/afm';
+export * from '@digigov/form/validators/utils/file';
+export * from '@digigov/form/validators/utils/iban';
+export * from '@digigov/form/validators/utils/phone';
+export * from '@digigov/form/validators/utils/postal_code';
+export * from '@digigov/form/validators/utils/uuid4';
+
+export function getYupField(field: FieldSpec, yupTypeMap: Record<string, any>) {
+  const yupField = yupTypeMap[field?.type || 'string'] || yupTypeMap['string'];
+  return yupField(field);
+}
+export function computeShape(
+  fields: FieldSpec[],
+  yupTypeMap: Record<string, ValidatorSchema>,
+  validatorRegistry: Record<string, ValidatorSchema[]> | undefined
+) {
+  const fieldSchemas = {};
+  const objectFields: Record<string, FieldSpec[]> = {};
+  fields.forEach((field) => {
+    let yupField = getYupField(field, yupTypeMap);
+    if (field.condition) {
+      for (const key in field.condition) {
+        let then: any, otherwise: any;
+        if (field.condition[key].then) {
+          if (field.condition[key].then?.required === false) {
+            then = yupField;
+          } else if (field.condition[key].then?.required === true) {
+            then = yupField.required('form.error.required');
+          }
+        }
+        if (field.condition[key].else) {
+          if (field.condition[key].else?.required === false) {
+            otherwise = yupField;
+          } else if (field.condition[key].else?.required === true) {
+            otherwise = yupField.required('form.error.required');
+          }
+        }
+        if (then || otherwise) {
+          yupField = yupField.when(key, {
+            is: field.condition[key].is,
+            then,
+            otherwise,
+          });
+        }
+      }
+    } else if (field.required) {
+      yupField = yupField.required('form.error.required');
+    }
+    if (validatorRegistry && field.type && validatorRegistry[field.type]) {
+      validatorRegistry[field.type].forEach((validator: any) => {
+        yupField = yupField.test(validator);
+      });
+    }
+    if (field.validators) {
+      field.validators.forEach((validator) => {
+        yupField = yupField.test(validator);
+      });
+    }
+    fieldSchemas[field.key] = yupField;
+  });
+  for (const objectKey in objectFields) {
+    fieldSchemas[objectKey] = getYupObjectShape(
+      objectFields[objectKey],
+      yupTypeMap,
+      validatorRegistry
+    );
+  }
+  return fieldSchemas;
+}
+
+export function getYupObjectShape(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  fields: FieldSpec[] | any,
+  yupTypeMap: Record<string, any>,
+  validatorRegistry?: Record<string, ValidatorSchema[]>
+) {
+  if (!fields.current) {
+    const fieldSchemas = computeShape(fields, yupTypeMap, validatorRegistry);
+    return yup.object().shape(fieldSchemas);
+  }
+
+  return yup.lazy(function () {
+    const fieldSchemas = computeShape(
+      Object.values(fields.current),
+      yupTypeMap,
+      validatorRegistry
+    );
+    return yup.object().shape(fieldSchemas);
+  });
+}

package/src/validators/utils/int.ts

@@ -0,0 +1,22 @@
+import { ValidatorSchema } from '@digigov/form/validators/types';
+
+export function validateIntNumber(number: number): boolean {
+  if (number === undefined) {
+    return false;
+  } else {
+    return Number.isInteger(number) && Number(number) > 0;
+  }
+}
+
+export const INT_VALIDATOR = (): ValidatorSchema => {
+  return {
+    name: 'int-validator',
+    message: 'form.error.positive_integer_number',
+    test: (value: number): boolean => {
+      if (value === null) {
+        return true;
+      }
+      return validateIntNumber(value);
+    },
+  };
+};

package/src/validators/utils/number.ts

@@ -0,0 +1,18 @@
+import { ValidatorSchema } from '@digigov/form/validators/types';
+
+export function validateNumber(number: number): boolean {
+  return !Number.isNaN(number);
+}
+
+export const NUMBER_VALIDATOR = (): ValidatorSchema => {
+  return {
+    name: 'number-validator',
+    message: 'form.error.number',
+    test: (value: number): boolean => {
+      if (value === null) {
+        return true;
+      }
+      return validateNumber(value);
+    },
+  };
+};

package/src/validators/utils/phone.ts

@@ -0,0 +1,120 @@
+import * as gPhoneNumber from 'google-libphonenumber';
+import { ValidatorSchema } from '@digigov/form/validators/types';
+import { FieldSpec } from '@digigov/form/types';
+
+export type PhoneNumberType = 'landline' | 'mobile' | null;
+
+export function validatePhoneNumber(
+  phoneNumber: string,
+  countries: Array<string> = ['gr'],
+  typeOfPhoneNumber: PhoneNumberType
+): boolean {
+  const phoneUtil = gPhoneNumber.PhoneNumberUtil.getInstance();
+  if (!countries || countries.length === 0) {
+    return true;
+  }
+  return countries.some((country) => {
+    try {
+      const phone = phoneUtil.parse(phoneNumber, country.toUpperCase());
+      if (phoneUtil.isValidNumber(phone)) {
+        if (typeOfPhoneNumber) {
+          if (matchTypeOfPhoneNumber(phone, typeOfPhoneNumber, phoneUtil)) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return true;
+        }
+      }
+      return false;
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+  });
+}
+const phoneNumberTypes = {
+  0: 'landline',
+  1: 'mobile',
+  2: 'landline_or_mobile',
+};
+export function matchTypeOfPhoneNumber(
+  phone: any,
+  type: string,
+  phoneUtil: any
+): boolean {
+  try {
+    const phoneNumberType = phoneUtil.getNumberType(phone);
+    const numberType = phoneNumberTypes[phoneNumberType];
+    if (numberType === 'landline_or_mobile' || numberType === type) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+}
+function validateMobile(value): boolean {
+  const phoneUtil = gPhoneNumber.PhoneNumberUtil.getInstance();
+  const origValue = value;
+  // probably catch all the cases with a regex instead of gphonenumber
+  if (!value.match(/^((\+|00){0,1}\d{1,3}[- ]?)?\d{10}$/)) {
+    return false;
+  }
+  try {
+    let phone;
+    try {
+      phone = phoneUtil.parse(value);
+    } catch (err) {
+      try {
+        value = '+' + value;
+        phone = phoneUtil.parse(value);
+      } catch (err) {
+        value = '+30' + origValue;
+        phone = phoneUtil.parse(value);
+      }
+    }
+    return phoneUtil.isValidNumber(phone);
+  } catch (err) {
+    console.error(err);
+    return false;
+  }
+}
+
+export const MOBILE_PHONE_VALIDATOR = {
+  name: 'mobile-phone-validator',
+  message: 'form.error.mobile_phone',
+  test: (value): boolean => {
+    if (value) {
+      return validateMobile(value);
+    }
+    return true;
+  },
+};
+
+export const PHONE_NUMBER_VALIDATOR = (field: FieldSpec): ValidatorSchema => {
+  const countryCode = field?.extra?.countries;
+  const typeOfPhone: PhoneNumberType | null = field?.extra?.phoneType;
+  return {
+    name: 'phone-number-validator',
+    message: (): string => {
+      if (typeOfPhone === 'mobile') {
+        return 'form.error.mobile_phone';
+      }
+      if (typeOfPhone === 'landline') {
+        return 'form.error.landline';
+      } else {
+        return 'form.error.phone_number';
+      }
+    },
+    test: (value: string): boolean => {
+      if (!value) {
+        return true;
+      }
+      return validatePhoneNumber(value, countryCode, typeOfPhone);
+    },
+  };
+};

package/src/validators/utils/postal_code.ts

@@ -0,0 +1,33 @@
+import { ValidatorSchema } from '@digigov/form/validators/types';
+import { FieldSpec } from '@digigov/form/types';
+
+const CODE_REGEX = /^[12345678][0-9]{4}$/;
+export function validatePostalCode(
+  number: string,
+  countries: Array<string>
+): boolean {
+  if (!countries) {
+    return false;
+  } else {
+    if (countries.length === 1 && countries[0].toUpperCase() === 'GR') {
+      // Greek postal code must be 5 digits long and shouldn't start with 0 or 9.
+      return CODE_REGEX.test(number);
+    } else {
+      return true;
+    }
+  }
+}
+
+export const POSTALCODE_VALIDATOR = (field: FieldSpec): ValidatorSchema => {
+  const countryCode = field?.extra?.countries;
+  return {
+    name: 'postal-code-validator',
+    message: 'form.error.postalCode',
+    test: (value: string): boolean => {
+      if (!value) {
+        return true;
+      }
+      return validatePostalCode(value, countryCode);
+    },
+  };
+};

package/src/validators/utils/uuid4.ts

@@ -0,0 +1,21 @@
+const UUID4_PATTERN = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
+
+export function validateUUID4(uuid4: string): boolean {
+  if (uuid4.length !== 36) {
+    // This uuid4 should be 36 characters long
+    return false;
+  }
+
+  return UUID4_PATTERN.test(uuid4);
+}
+
+export const UUID4_VALIDATOR = {
+  name: 'uuid4-validator',
+  message: 'form.error.uuid4',
+  test: (value): boolean => {
+    if (value) {
+      return validateUUID4(value);
+    }
+    return true;
+  },
+};

package/src/validators/validators.spec.ts

@@ -0,0 +1,122 @@
+import {
+  validateUUID4,
+  validateIban,
+  validatePostalCode,
+  validatePhoneNumber,
+} from '@digigov/form/validators/utils';
+
+it('validates wrong uuid4 for empty value', () => {
+  expect(validateUUID4('')).toBe(false);
+});
+
+it('validates wrong uuid4 because of length', () => {
+  expect(validateUUID4('9e463bc44a294bab8ee23af6cc3cbbe3')).toBe(false);
+});
+
+it('validates wrong uuid4 with correct length and wrong form', () => {
+  expect(validateUUID4('ab123cd1-1234-ad34-ad45-12345abcdefg')).toBe(false);
+});
+
+it('validates correct uuid4 validator', () => {
+  expect(validateUUID4('9e463bc4-4a29-4bab-8ee2-3af6cc3cbbe3')).toBe(true);
+});
+
+it('validates correct gr iban', () => {
+  expect(validateIban('GR7801100800000008009825202', 'GR')).toBe(true);
+});
+
+it('validates correct iban with spaces and dashes', () => {
+  expect(validateIban('GR 7801-1008 0000-0008 0098-25202', 'GR')).toBe(true);
+});
+
+it('validates correct foreign iban', () => {
+  expect(validateIban('DE75512108001245126199', 'DE')).toBe(true);
+});
+
+it('validates wrong iban for empty value', () => {
+  expect(validateIban('', '')).toBe(false);
+});
+
+it('validates wrong greek iban for wrong length', () => {
+  expect(validateIban('GR78011008000000080098252020', 'gr')).toBe(false);
+});
+
+it('validates wrong iban for non existing country code', () => {
+  expect(validateIban('AAA78011008000000080098252020', 'aaa')).toBe(false);
+});
+
+it('validates correct greek iban whithout country code', () => {
+  expect(validateIban('7801100800000008009825202', '')).toBe(true);
+});
+
+it('validates wrong postal code without country code', () => {
+  expect(validatePostalCode('123', [])).toBe(true);
+});
+
+it('validates wrong postal code with wrong country code', () => {
+  expect(validatePostalCode('123', ['FR'])).toBe(true);
+});
+
+it('validates wrong postal code with greek country code', () => {
+  expect(validatePostalCode('123', ['GR'])).toBe(false);
+});
+
+it('validates postal code with greek country code', () => {
+  expect(validatePostalCode('11143', ['GR'])).toBe(true);
+});
+
+it('validates phone number type landline with greek country code', () => {
+  expect(validatePhoneNumber('2102934896', ['GR'], 'landline')).toBe(true);
+});
+
+it('validates phone number type landline with ch country code', () => {
+  expect(validatePhoneNumber('2102934896', ['CH'], 'landline')).toBe(false);
+});
+
+it('validates phone number type landline with ch  and  gr countries code', () => {
+  expect(validatePhoneNumber('2102934896', ['GR', 'CH'], 'landline')).toBe(
+    true
+  );
+});
+
+it('validatesphone number type landline with ch  and  gr countries code', () => {
+  expect(validatePhoneNumber('41446681800', ['GR', 'CH'], 'landline')).toBe(
+    true
+  );
+});
+
+it('validates phone number type landline with ch  and  gr countries code but phone number is mobile', () => {
+  expect(validatePhoneNumber('2102934896', ['GR', 'CH'], 'mobile')).toBe(false);
+});
+
+it('validates phone number type mobile with ch  and  gr countries code', () => {
+  expect(validatePhoneNumber('6934100982', ['GR', 'CH'], 'mobile')).toBe(true);
+});
+
+it('validates  phone number type mobile with gr country code', () => {
+  expect(validatePhoneNumber('6934100982', ['GR'], 'mobile')).toBe(true);
+});
+
+it('validates  phone number type mobile with ch country code', () => {
+  expect(validatePhoneNumber('6934100982', ['CH'], 'mobile')).toBe(false);
+});
+
+it('validates  phone number with no type and ch country code', () => {
+  expect(validatePhoneNumber('6934100982', ['CH'], null)).toBe(false);
+});
+
+it('validates  phone number with no type and gr country code', () => {
+  expect(validatePhoneNumber('6934100982', ['gr'], null)).toBe(true);
+});
+
+it('validates  phone number with no type and ch country code', () => {
+  expect(validatePhoneNumber('41446681800', ['CH'], null)).toBe(true);
+});
+
+it('validates  phone number with no type and gr country code', () => {
+  expect(validatePhoneNumber('41446681800', ['gr'], null)).toBe(false);
+});
+
+it('validates  phone number with no type and gr and ch countries code', () => {
+  expect(validatePhoneNumber('41446681800', ['gr', 'ch'], null)).toBe(true);
+});