@digigov/form 2.0.0-daaf7bdf → 2.0.0-e7d30530

package/src/validators/index.ts

@@ -1,6 +1,4 @@
 import { MutableRefObject, useMemo } from 'react';
-import dayjs from 'dayjs';
-import customParseFormat from 'dayjs/plugin/customParseFormat';
 import * as yup from 'yup';
 import { AnyObjectSchema, StringSchema } from 'yup';
 import { RequiredArraySchema } from 'yup/lib/array';
@@ -13,6 +11,7 @@ import { ValidatorSchema } from '@digigov/form/validators/types';
 import {
   getYupObjectShape,
   AFM_VALIDATOR,
+  AMKA_VALIDATOR,
   FILE_MAX_SIZE_VALIDATOR,
   IBAN_VALIDATOR,
   OTP_VALIDATOR,
@@ -22,24 +21,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 +47,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 +84,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',
@@ -100,24 +123,43 @@ export const getYUPTypeMap = (): Record<string, any> => {
     number: (): MixedSchema =>
       yup
         .mixed()
-        .transform((_, val) => (val !== '' ? Number(val) : null))
+        .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 => {
@@ -134,11 +176,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,
@@ -150,70 +198,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;
 };
@@ -225,7 +237,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/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,126 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import { FieldSpec } from '@digigov/form/types';
+import { ValidatorSchema } from '@digigov/form/validators/types';
+
+dayjs.extend(customParseFormat);
+
+const VALID_DATE_FORMATS = ['DD/MM/YYYY'];
+const DATE_CACHE = {};
+
+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 yearNum = parseInt(year);
+    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();
+  },
+};

package/src/validators/utils/datetime.ts

@@ -0,0 +1,217 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import { FieldSpec } from '@digigov/form/types';
+import { ValidatorSchema } from '@digigov/form/validators/types';
+
+dayjs.extend(customParseFormat);
+
+const VALID_DATETIME_FORMATS = ['DD/MM/YYYY HH:mm'];
+const DATETIME_CACHE = {};
+
+const getDateTime = (v: string) => {
+  return DATETIME_CACHE[v]
+    ? DATETIME_CACHE[v]
+    : dayjs(v, VALID_DATETIME_FORMATS, true);
+};
+
+const getDaysInMonth = (month: number, year: number): number => {
+  return dayjs(`${year}-${month}-01`).daysInMonth(); // e.g. 29 for Feb 2024
+};
+
+const checkPartialDateTime = (value: string) => {
+  const [datePart, timePart] = value.split(' ');
+  const [day, month, year] = datePart?.split('/') ?? [];
+  const [hours, minutes] = timePart?.split(':') ?? [];
+
+  const hasDay = Boolean(day);
+  const hasMonth = Boolean(month);
+  const hasYear = Boolean(year);
+  const hasHours = Boolean(hours);
+  const hasMinutes = Boolean(minutes);
+
+  if (hasDay && !hasMonth && !hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_month_year_hours_minutes';
+  }
+  if (!hasDay && hasMonth && !hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_day_year_hours_minutes';
+  }
+  if (!hasDay && !hasMonth && hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_day_month_hours_minutes';
+  }
+  if (hasDay && hasMonth && !hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_year_hours_minutes';
+  }
+  if (hasDay && !hasMonth && hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_month_hours_minutes';
+  }
+  if (!hasDay && hasMonth && hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_day_hours_minutes';
+  }
+  if (hasDay && hasMonth && hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid__hours_minutes';
+  }
+  if (hasDay && hasMonth && hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_minutes';
+  }
+  if (hasDay && hasMonth && hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_hours';
+  }
+  if (hasDay && !hasMonth && !hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_month_year_minutes';
+  }
+  if (hasDay && !hasMonth && !hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_month_year_hours';
+  }
+  if (hasDay && !hasMonth && !hasYear && hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_month_year';
+  }
+  if (!hasDay && hasMonth && !hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_day_year_minutes';
+  }
+  if (!hasDay && hasMonth && !hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day_year_hours';
+  }
+  if (!hasDay && hasMonth && !hasYear && hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day_year';
+  }
+  if (!hasDay && !hasMonth && hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_day_month_minutes';
+  }
+  if (!hasDay && !hasMonth && hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day_month_hours';
+  }
+  if (!hasDay && !hasMonth && hasYear && hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day_month';
+  }
+  if (!hasDay && !hasMonth && !hasYear && hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day_month_year';
+  }
+  if (!hasDay && !hasMonth && !hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day_month_year_hours';
+  }
+  if (hasDay && hasMonth && !hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_year_minutes';
+  }
+  if (hasDay && hasMonth && !hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_year_hours';
+  }
+  if (hasDay && hasMonth && !hasYear && hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_year';
+  }
+  if (hasDay && !hasMonth && hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_month_minutes';
+  }
+  if (hasDay && !hasMonth && hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_month_hours';
+  }
+  if (hasDay && !hasMonth && hasYear && hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_month';
+  }
+  if (!hasDay && hasMonth && hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_day_minutes';
+  }
+  if (!hasDay && hasMonth && hasYear && !hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day_hours';
+  }
+  if (!hasDay && hasMonth && hasYear && hasHours && hasMinutes) {
+    return 'form.error.datetime.invalid_day';
+  }
+  if (!hasDay && !hasMonth && !hasYear && hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_day_month_year_minutes';
+  }
+  if (hasDay && hasMonth && hasYear && !hasHours && !hasMinutes) {
+    return 'form.error.datetime.invalid_hours_minutes';
+  }
+  if (day && month) {
+    const dayNum = parseInt(day);
+    const monthNum = parseInt(month);
+    const yearNum = parseInt(year);
+    const maxDay = getDaysInMonth(monthNum, yearNum);
+    if (dayNum < 1 || dayNum > maxDay) {
+      return {
+        key: 'form.error.datetime.invalid_day_range',
+        context: {
+          maxDay: maxDay,
+        },
+      };
+    }
+    if (monthNum < 1 || monthNum > 12) {
+      return 'form.error.datetime.invalid_month_range';
+    }
+  }
+  if (hours && minutes) {
+    const hoursNum = parseInt(hours);
+    const minutesNum = parseInt(minutes);
+    if (hoursNum < 0 || hoursNum > 23) {
+      return 'form.error.datetime.invalid_hours_range';
+    }
+    if (minutesNum < 0 || minutesNum > 59) {
+      return 'form.error.datetime.invalid_minutes_range';
+    }
+  }
+  return 'form.error.datetime.invalid';
+};
+
+export const LATER_THAN_DATETIME_VALIDATOR = (
+  field: FieldSpec
+): ValidatorSchema => {
+  let minDateTime;
+  const params = field.extra || {};
+  if (params.min === 'now') {
+    minDateTime = dayjs();
+  } else {
+    minDateTime = getDateTime(params.min);
+  }
+  return {
+    name: 'later-than-datetime',
+    message: {
+      key: 'form.error.datetime.later_than',
+      context: {
+        minDateTime: minDateTime.format('DD/MM/YYYY HH:mm'),
+      },
+    },
+    test: function (value: string) {
+      if (!value) return true;
+      const datetime = getDateTime(value);
+      return datetime.isValid() && datetime.isAfter(minDateTime);
+    },
+  };
+};
+
+export const EARLIER_THAN_DATETIME_VALIDATOR = (
+  field: FieldSpec
+): ValidatorSchema => {
+  let maxDateTime;
+  const params = field.extra || {};
+  if (params.max === 'now') {
+    maxDateTime = dayjs();
+  } else {
+    maxDateTime = getDateTime(params.max);
+  }
+  return {
+    name: 'earlier-than-datetime',
+    message: {
+      key: 'form.error.datetime.earlier_than',
+      context: {
+        maxDateTime: maxDateTime.format('DD/MM/YYYY HH:mm'),
+      },
+    },
+    test: function (value: string) {
+      if (!value) return true;
+      const datetime = getDateTime(value);
+      return datetime.isValid() && datetime.isBefore(maxDateTime);
+    },
+  };
+};
+
+export const DATETIME_VALIDATOR = {
+  name: 'datetime-validator',
+  message: (v): string | object => {
+    return checkPartialDateTime(v.value);
+  },
+  test: function (value: string) {
+    if (!value) return true;
+    const datetime = getDateTime(value);
+    return datetime.isValid();
+  },
+};