@digigov/form 2.0.0-8de46296 → 2.0.0-a0ac149e

package/src/utils.ts

@@ -1,6 +1,7 @@
 import { validateFieldsNatively } from '@hookform/resolvers';
-import { appendErrors, FieldError } from 'react-hook-form';
-import * as Yup from 'yup';
+import type { FieldError } from 'react-hook-form';
+import { appendErrors } from 'react-hook-form';
+import type * as Yup from 'yup';
 
 /**
  * Why `path!` ? because it could be `undefined` in some case
@@ -13,6 +14,7 @@ const parseErrorSchema = (
   return (error.inner || []).reduce<Record<string, FieldError>>(
     (previous, error) => {
       error.path = error.path?.replace(/\[([0-9]+)\]/g, '.$1');
+      // error.path = error.path?.replace(/\["(.*?)"\]/g, '$1');
       if (!previous[error.path!]) {
         previous[error.path!] = { message: error.message, type: error.type! };
       }
@@ -37,42 +39,63 @@ const parseErrorSchema = (
     {}
   );
 };
+function isPlainObject(obj) {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    Object.prototype.toString.call(obj) === '[object Object]'
+  );
+}
+function flattenObject(obj, prefix = '') {
+  return Object.keys(obj).reduce((acc, key) => {
+    const prefixedKey = prefix ? `${prefix}.${key}` : key;
 
-export const yupResolver = (
-  schema: any,
-  schemaOptions: any = {},
-  resolverOptions: any = {}
-) => async (values, context, options) => {
-  try {
-    if (schemaOptions.context && process.env.NODE_ENV === 'development') {
-      // eslint-disable-next-line no-console
-      console.warn(
-        "You should not used the yup options context. Please, use the 'useForm' context object instead"
-      );
+    if (isPlainObject(obj[key])) {
+      Object.assign(acc, flattenObject(obj[key], prefixedKey));
+    } else {
+      acc[prefixedKey] = obj[key];
     }
 
-    const result = await schema[
-      resolverOptions.mode === 'sync' ? 'validateSync' : 'validate'
-    ](values, Object.assign({ abortEarly: false }, schemaOptions, { context }));
+    return acc;
+  }, {});
+}
 
-    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+export const yupResolver =
+  (schema: any, schemaOptions: any = {}, resolverOptions: any = {}) =>
+  async (values, context, options) => {
+    try {
+      if (schemaOptions.context && process.env.NODE_ENV === 'development') {
+        console.warn(
+          "You should not used the yup options context. Please, use the 'useForm' context object instead"
+        );
+      }
 
-    return {
-      values: resolverOptions.rawValues ? values : result,
-      errors: {},
-    };
-  } catch (e) {
-    if (!e.inner) {
-      throw e;
-    }
+      const result = await schema[
+        resolverOptions.mode === 'sync' ? 'validateSync' : 'validate'
+      ](
+        flattenObject(values),
+        Object.assign({ abortEarly: false }, schemaOptions, { context })
+      );
 
-    const parsed = parseErrorSchema(
-      e,
-      !options.shouldUseNativeValidation && options.criteriaMode === 'all'
-    );
-    return {
-      values: {},
-      errors: parsed,
-    };
-  }
-};
+      if (options.shouldUseNativeValidation)
+        validateFieldsNatively({}, options);
+
+      return {
+        values: resolverOptions.rawValues ? values : result,
+        errors: {},
+      };
+    } catch (e) {
+      if (!e.inner) {
+        throw e;
+      }
+
+      return {
+        values: {},
+        errors: parseErrorSchema(
+          e,
+          !options.shouldUseNativeValidation && options.criteriaMode === 'all'
+        ),
+        options,
+      };
+    }
+  };

package/src/validators/index.ts

@@ -1,18 +1,18 @@
-import { MutableRefObject, useMemo } from 'react';
-import dayjs from 'dayjs';
-import customParseFormat from 'dayjs/plugin/customParseFormat';
+import type { MutableRefObject } from 'react';
+import { useMemo } from 'react';
 import * as yup from 'yup';
-import { AnyObjectSchema, StringSchema } from 'yup';
-import { RequiredArraySchema } from 'yup/lib/array';
-import Lazy from 'yup/lib/Lazy';
-import { MixedSchema } from 'yup/lib/mixed';
-import { TypeOfShape, AssertsShape } from 'yup/lib/object';
-import { AnyObject } from 'yup/lib/types';
-import { FieldSpec } from '@digigov/form/types';
-import { ValidatorSchema } from '@digigov/form/validators/types';
+import type { AnyObjectSchema, StringSchema } from 'yup';
+import type { RequiredArraySchema } from 'yup/lib/array';
+import type Lazy from 'yup/lib/Lazy';
+import type { MixedSchema } from 'yup/lib/mixed';
+import type { TypeOfShape, AssertsShape } from 'yup/lib/object';
+import type { AnyObject } from 'yup/lib/types';
+import type { FieldSpec } from '@digigov/form/types';
+import type { ValidatorSchema } from '@digigov/form/validators/types';
 import {
   getYupObjectShape,
   AFM_VALIDATOR,
+  AMKA_VALIDATOR,
   FILE_MAX_SIZE_VALIDATOR,
   IBAN_VALIDATOR,
   OTP_VALIDATOR,
@@ -22,24 +22,25 @@ import {
   POSTALCODE_VALIDATOR,
   UUID4_VALIDATOR,
   IMAGE_DIMENSION_VALIDATOR,
+  DATE_VALIDATOR,
+  LATER_THAN_VALIDATOR,
+  EARLIER_THAN_VALIDATOR,
+  DATETIME_VALIDATOR,
+  LATER_THAN_DATETIME_VALIDATOR,
+  EARLIER_THAN_DATETIME_VALIDATOR,
 } from '@digigov/form/validators/utils';
 import { INT_VALIDATOR } from '@digigov/form/validators/utils/int';
 import { NUMBER_VALIDATOR } from '@digigov/form/validators/utils/number';
-dayjs.extend(customParseFormat);
 
-const VALID_DATE_FORMATS = ['DD/MM/YYYY'];
-const DATE_CACHE = {};
-const getDate = (v) => {
-  return DATE_CACHE[v] ? DATE_CACHE[v] : dayjs(v, VALID_DATE_FORMATS, true);
-};
-
-export const getYUPTypeMap = (): Record<string, any> => {
+export const getYUPTypeMap = (
+  validatorRegistry?: Record<string, any>
+): Record<string, any> => {
   const yupTypeMap = {
     file: (field): MixedSchema => {
       return yup
         .mixed()
         .transform((value) => {
-          if (!value.length) {
+          if (!value || value.length === 0) {
             return null;
           }
           return value;
@@ -47,8 +48,28 @@ export const getYUPTypeMap = (): Record<string, any> => {
         .nullable()
         .test(FILE_MAX_SIZE_VALIDATOR(field));
     },
-    string: yup.string,
-    boolean: yup.boolean,
+    string: (field): yup.StringSchema => {
+      if (field.trim) {
+        return yup.string().trim();
+      } else {
+        return yup.string();
+      }
+    },
+    boolean: (): yup.BooleanSchema<
+      boolean | null | undefined,
+      AnyObject,
+      boolean | null | undefined
+    > => {
+      return yup
+        .boolean()
+        .nullable()
+        .transform((value) => {
+          if (value === '' || typeof value === 'string') return null;
+          if (typeof value === 'boolean') return value;
+          if (value === 0 || value === 1) return Boolean(value);
+          return value;
+        });
+    },
     object: (
       field
     ):
@@ -64,10 +85,13 @@ export const getYUPTypeMap = (): Record<string, any> => {
       if (typeof field.extra.of === 'object') {
         // else if the field is an object then it is a scalar type
         // eg. number, string etc.
+        if (field.required) {
+          field.extra.min = 1;
+        }
         let arrayValidator = yup
           .array()
-          .of(yupTypeMap[field.extra.of.type](field.extra.of))
-          .required(field.required);
+          .nullable()
+          .of(yupTypeMap[field.extra.of.type](field.extra.of));
         if (field.extra.length)
           arrayValidator = arrayValidator.length(field.extra.length, {
             key: 'form.error.array.length',
@@ -97,22 +121,46 @@ export const getYUPTypeMap = (): Record<string, any> => {
         return yup.array().of(yup.string());
       }
     },
+    number: (): MixedSchema =>
+      yup
+        .mixed()
+        .transform((_, val) => (val !== '' ? Number(val) : undefined))
+        .test(NUMBER_VALIDATOR()),
     int: (): MixedSchema =>
       yup
         .mixed()
-        .transform((_, val) => (val !== '' ? Number(val) : null))
+        .transform((_, val) => (val !== '' ? Number(val) : undefined))
         .test(NUMBER_VALIDATOR())
         .test(INT_VALIDATOR()),
-    email: (): yup.StringSchema => yup.string().email('form.error.email'),
-    afm: (): yup.StringSchema => yup.string().test(AFM_VALIDATOR),
-    uuid4: (): yup.StringSchema => yup.string().test(UUID4_VALIDATOR),
-    iban: (field): yup.StringSchema => yup.string().test(IBAN_VALIDATOR(field)),
-    otp: (field): yup.StringSchema => yup.string().test(OTP_VALIDATOR(field)),
+    email: (field): yup.StringSchema =>
+      field.trim
+        ? yup.string().trim().email('form.error.email')
+        : yup.string().email('form.error.email'),
+    afm: (field): yup.StringSchema =>
+      field.trim
+        ? yup.string().trim().test(AFM_VALIDATOR)
+        : yup.string().test(AFM_VALIDATOR),
+    amka: (field): yup.StringSchema =>
+      field.trim
+        ? yup.string().trim().test(AMKA_VALIDATOR)
+        : yup.string().test(AMKA_VALIDATOR),
+    uuid4: (field): yup.StringSchema =>
+      field.trim
+        ? yup.string().trim().test(UUID4_VALIDATOR)
+        : yup.string().test(UUID4_VALIDATOR),
+    iban: (field): yup.StringSchema =>
+      field.trim
+        ? yup.string().trim().test(IBAN_VALIDATOR(field))
+        : yup.string().trim().test(IBAN_VALIDATOR(field)),
+    otp: (field): yup.StringSchema =>
+      yup.string().trim().test(OTP_VALIDATOR(field)),
     text: (field): yup.StringSchema => {
       if (field?.extra?.limit?.max || !!field?.extra?.limit?.min) {
-        return yup.string().test(TEXT_LIMIT_VALIDATOR(field));
+        return field.trim
+          ? yup.string().trim().test(TEXT_LIMIT_VALIDATOR(field))
+          : yup.string().test(TEXT_LIMIT_VALIDATOR(field));
       } else {
-        return yup.string();
+        return field.trim ? yup.string().trim() : yup.string();
       }
     },
     image: (field): MixedSchema => {
@@ -129,11 +177,17 @@ export const getYUPTypeMap = (): Record<string, any> => {
         .test(IMAGE_DIMENSION_VALIDATOR(field));
     },
     postal_code: (field): yup.StringSchema =>
-      yup.string().test(POSTALCODE_VALIDATOR(field)),
-    mobile_phone: (): yup.StringSchema =>
-      yup.string().test(MOBILE_PHONE_VALIDATOR),
+      field.trim
+        ? yup.string().trim().test(POSTALCODE_VALIDATOR(field))
+        : yup.string().test(POSTALCODE_VALIDATOR(field)),
+    mobile_phone: (field): yup.StringSchema =>
+      field.trim
+        ? yup.string().trim().test(MOBILE_PHONE_VALIDATOR)
+        : yup.string().test(MOBILE_PHONE_VALIDATOR),
     phone_number: (field): yup.StringSchema =>
-      yup.string().test(PHONE_NUMBER_VALIDATOR(field)),
+      field.trim
+        ? yup.string().trim().test(PHONE_NUMBER_VALIDATOR(field))
+        : yup.string().test(PHONE_NUMBER_VALIDATOR(field)),
     'choice:multiple': (): yup.ArraySchema<
       yup.StringSchema<string | undefined, AnyObject, string | undefined>,
       AnyObject,
@@ -145,70 +199,34 @@ export const getYUPTypeMap = (): Record<string, any> => {
       AnyObject,
       string | null | undefined
     > => yup.string().nullable(),
-    date: (field) => {
-      let simpleDate = yup
-        .string()
-        .nullable(true)
-        .test('date', 'form.error.date.invalid', function (value) {
-          if (!value) return true;
-          const date = getDate(value);
-          return date.isValid();
-        });
-      const params = field.extra || {};
-      if (params.max) {
-        let maxDate;
-        if (params.max === 'now') {
-          const today = new Date();
-          maxDate = new Date(today);
-        } else {
-          maxDate = getDate(params.max).toDate();
-        }
-        const maxNextDate = new Date(maxDate);
-        maxNextDate.setDate(maxDate.getDate() + 1);
-        simpleDate = simpleDate.test({
-          name: 'earlier-than',
-          message: {
-            key: 'form.error.date.earlier_than',
-            context: {
-              maxDate: maxNextDate.toLocaleDateString(),
-            },
-          },
-          test: function (value) {
-            if (!value) return true;
-            const date = getDate(value);
-            const isValid = +date.toDate() < +maxDate;
-            return isValid;
-          },
-        });
+    date: (
+      field
+    ): yup.StringSchema<
+      string | null | undefined,
+      AnyObject,
+      string | null | undefined
+    > => {
+      let schema = yup.string().nullable();
+      if (field?.extra?.min) {
+        schema = schema.test(LATER_THAN_VALIDATOR(field));
       }
-      if (params.min) {
-        let minDate;
-        if (params.min === 'now') {
-          const today = new Date();
-          minDate = new Date(today);
-        } else {
-          minDate = getDate(params.min).toDate();
-        }
-        const minPreviousDate = new Date(minDate);
-        minPreviousDate.setDate(minDate.getDate() - 1);
-        simpleDate = simpleDate.test({
-          name: 'later-than',
-          message: {
-            key: 'form.error.date.later_than',
-            context: {
-              minDate: minPreviousDate.toLocaleDateString(),
-            },
-          },
-          test: function (value) {
-            if (!value) return true;
-            const date = getDate(value);
-            const isValid = +date.toDate() > +minDate;
-            return isValid;
-          },
-        });
+      if (field?.extra?.max) {
+        schema = schema.test(EARLIER_THAN_VALIDATOR(field));
+      } else {
+        schema = schema.test(DATE_VALIDATOR);
+      }
+      return schema;
+    },
+    datetime: (field): yup.StringSchema => {
+      if (field?.extra?.min) {
+        return yup.string().test(LATER_THAN_DATETIME_VALIDATOR(field));
+      }
+      if (field?.extra?.max) {
+        return yup.string().test(EARLIER_THAN_DATETIME_VALIDATOR(field));
       }
-      return simpleDate;
+      return yup.string().test(DATETIME_VALIDATOR);
     },
+    ...validatorRegistry,
   };
   return yupTypeMap;
 };
@@ -220,7 +238,7 @@ export function useValidationSchema(
   validatorRegistry?: Record<string, ValidatorSchema[]>
 ): Lazy<any, unknown> | AnyObjectSchema | void {
   return useMemo(() => {
-    const yupTypeMap = getYUPTypeMap();
+    const yupTypeMap = getYUPTypeMap(validatorRegistry);
     return getYupObjectShape(fields, yupTypeMap, validatorRegistry);
-  }, []);
+  }, [fields, validatorRegistry]);
 }

package/src/validators/types.ts

@@ -1,2 +1,2 @@
-import * as yup from 'yup';
+import type * as yup from 'yup';
 export type ValidatorSchema = yup.TestConfig;

package/src/validators/utils/amka.ts

@@ -0,0 +1,39 @@
+function digitSum(number) {
+  const sum = number > 9 ? 1 : 0;
+  return sum + (number % 10);
+}
+
+export function validateAMKA(amka: string): boolean {
+  // Validate that the last digit is the correct check digit (created using the
+  // Luhn algorithm https://en.wikipedia.org/wiki/Luhn_algorithm).
+  amka = String(amka);
+  const checkDigitIndex = amka.length - 1;
+  let sum = 0;
+  amka
+    .substring(0, checkDigitIndex)
+    .split('')
+    .reverse()
+    .forEach(function (value, index) {
+      const weight = ((index + 1) % 2) + 1;
+      sum += digitSum(parseInt(value, 10) * weight);
+    });
+  const sumMod10 = sum % 10;
+  if (sumMod10 === 0) {
+    return amka.substring(checkDigitIndex) === '0';
+  } else {
+    return amka.substring(checkDigitIndex) === 10 - sumMod10 + '';
+  }
+}
+
+export const AMKA_VALIDATOR = {
+  name: 'amka-validator',
+  message: 'form.error.amka',
+  test: (value): boolean => {
+    if (!value) return true;
+    const AMKA_REGEX = /^[0-9]{11}$/;
+    if (!AMKA_REGEX.test(value) || value === '00000000000') {
+      return false;
+    }
+    return validateAMKA(value);
+  },
+};

package/src/validators/utils/date.ts

@@ -0,0 +1,131 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import type { FieldSpec } from '@digigov/form/types';
+import type { ValidatorSchema } from '@digigov/form/validators/types';
+
+dayjs.extend(customParseFormat);
+
+const VALID_DATE_FORMATS = ['DD/MM/YYYY'];
+const DATE_CACHE = {};
+const onlyNumbersRegex = /^\d+$/;
+
+const getDate = (v: string) => {
+  return DATE_CACHE[v] ? DATE_CACHE[v] : dayjs(v, VALID_DATE_FORMATS, true);
+};
+
+const getDaysInMonth = (month: number, year: number): number => {
+  return dayjs(`${year}-${month}-01`).daysInMonth(); // e.g. 29 for Feb 2024
+};
+
+// Function to check partial date completion
+const checkPartialDate = (value: string) => {
+  const [day, month, year] = value.split('/');
+  if (day && !month && !year) {
+    return 'form.error.date.invalid_month_year';
+  }
+  if (!day && month && !year) {
+    return 'form.error.date.invalid_day_year';
+  }
+  if (!day && !month && year) {
+    return 'form.error.date.invalid_day_month';
+  }
+  if (day && month && !year) {
+    return 'form.error.date.invalid_year';
+  }
+  if (day && !month && year) {
+    return 'form.error.date.invalid_month';
+  }
+  if (!day && month && year) {
+    return 'form.error.date.invalid_day';
+  }
+  if (day && month) {
+    const dayNum = parseInt(day);
+    const monthNum = parseInt(month);
+    const validYear = onlyNumbersRegex.test(year) ? year : undefined;
+    if (!validYear || year.length < 4) {
+      return 'form.error.date.invalid';
+    }
+    const yearNum = parseInt(validYear);
+    const maxDay = getDaysInMonth(monthNum, yearNum);
+    if (dayNum < 1 || dayNum > maxDay) {
+      return {
+        key: 'form.error.date.invalid_day_range',
+        context: {
+          maxDay: maxDay,
+        },
+      };
+    }
+    if (monthNum < 1 || monthNum > 12) {
+      return 'form.error.datetime.invalid_month_range';
+    }
+  }
+  return 'form.error.date.invalid';
+};
+
+export const LATER_THAN_VALIDATOR = (field: FieldSpec): ValidatorSchema => {
+  let minDate;
+  const params = field.extra || {};
+  if (params.min === 'now') {
+    const today = new Date();
+    minDate = new Date(today);
+  } else {
+    minDate = getDate(params.min).toDate();
+  }
+  const minPreviousDate = new Date(minDate);
+  minPreviousDate.setDate(minDate.getDate() - 1);
+  return {
+    name: 'later-than',
+    message: {
+      key: 'form.error.date.later_than',
+      context: {
+        minDate: minPreviousDate.toLocaleDateString(),
+      },
+    },
+    test: function (value: string) {
+      if (!value) return true;
+      const date = getDate(value);
+      const isValid = +date.toDate() > +minDate;
+      return isValid;
+    },
+  };
+};
+
+export const EARLIER_THAN_VALIDATOR = (field: FieldSpec): ValidatorSchema => {
+  let maxDate;
+  const params = field.extra || {};
+  if (params.max === 'now') {
+    const today = new Date();
+    maxDate = new Date(today);
+  } else {
+    maxDate = getDate(params.max).toDate();
+  }
+  const maxNextDate = new Date(maxDate);
+  maxNextDate.setDate(maxDate.getDate() + 1);
+  return {
+    name: 'earlier-than',
+    message: {
+      key: 'form.error.date.earlier_than',
+      context: {
+        maxDate: maxNextDate.toLocaleDateString(),
+      },
+    },
+    test: function (value: string) {
+      if (!value) return true;
+      const date = getDate(value);
+      const isValid = +date.toDate() < +maxDate;
+      return isValid;
+    },
+  };
+};
+
+export const DATE_VALIDATOR = {
+  name: 'date-validator',
+  message: (v): string | object => {
+    return checkPartialDate(v.value);
+  },
+  test: function (value: string) {
+    if (!value) return true;
+    const date = getDate(value);
+    return date.isValid();
+  },
+};