@palmares/schemas 0.0.1 → 0.1.0

package/src/utils.ts

@@ -1,7 +1,8 @@
+import SchemaAdapter from './adapter';
+import { getDefaultAdapter } from './conf';
 import { checkType, nullable, optional } from './validators/schema';
 import Validator from './validators/utils';
 
-import type SchemaAdapter from './adapter';
 import type FieldAdapter from './adapter/fields';
 import type { ValidationDataBasedOnType } from './adapter/types';
 import type Schema from './schema/schema';
@@ -9,8 +10,9 @@ import type { ValidationFallbackCallbackReturnType, ValidationFallbackReturnType
 import type { FallbackFunctionsType, SupportedSchemas } from './types';
 
 /**
- * The usage of this is that imagine that the library doesn't support a specific feature that we support on our schema definition, it can return an instance
- * of this class and with this instance we are able to fallback to our default implementation of the schema validation.
+ * The usage of this is that imagine that the library doesn't support a specific feature that we support on
+ * our schema definition, it can return an instance of this class and with this instance we are able to
+ * fallback to our default implementation of the schema validation.
  */
 export default class WithFallback<TType extends SupportedSchemas> {
   fallbackFor: Set<
@@ -38,8 +40,9 @@ export default class WithFallback<TType extends SupportedSchemas> {
 }
 
 /**
- * Factory function for creating a new instance of WithFallback. We call that function when parsing the schema adapter, and then, inside of the adapter the user will can the inner function
- * to create a new instance of WithFallback.
+ * Factory function for creating a new instance of WithFallback. We call that function when parsing the
+ * schema adapter, and then, inside of the adapter the user will can the inner function to create a new
+ * instance of WithFallback.
  *
  * @param adapterType - The type of the adapter that we are using.
  *
@@ -68,18 +71,22 @@ export function parseErrorsFactory(schemaAdapter: SchemaAdapter) {
 }
 
 /**
- * The default transform function that we use for the schema adapters. This function tries to abstract away the complexity of translating the schema to the adapter.
+ * The default transform function that we use for the schema adapters. This function tries to abstract away
+ * the complexity of translating the schema to the adapter.
  *
- * So first things first, WHAT IS a fallback? A fallback is a function that we call when the user defines a validation that is not supported by the adapter. For example, imagine that
- * for some reason the adapter doesn't support the `max` validation, we can define a fallback for that validation and then, when the user defines that validation, we call the fallback
- * function. So, even if the adapter doesn't support that validation our schema will still be able to validate that.
+ * So first things first, WHAT IS a fallback? A fallback is a function that we call when the user defines a
+ * validation that is not supported by the adapter. For example, imagine that for some reason the adapter
+ * doesn't support the `max` validation, we can define a fallback for that validation and then, when the
+ * user defines that validation, we call the fallback function. So, even if the adapter doesn't support that
+ * validation our schema will still be able to validate that.
  *
- * @param type - The type of the adapter that we are using, can be a number, an object, all of the possible schema adapters.
+ * @param type - The type of the adapter that we are using, can be a number, an object, all of the possible
+ * schema adapters.
  * @param schema - The schema that we are translating.
- * @param validationData - The data that we are using to validate the schema. This means for example, the `max` validation, the `min` validation, etc. The message of the validation when
- * it is not valid, etc.
- * @param fallbackFunctions - The fallback functions that we are using to validate the schema. Those are the functions we fallback to when the user defines a validation that is not
- * supported by the adapter.
+ * @param validationData - The data that we are using to validate the schema. This means for example, the
+ * `max` validation, the `min` validation, etc. The message of the validation when it is not valid, etc.
+ * @param fallbackFunctions - The fallback functions that we are using to validate the schema. Those are
+ * the functions we fallback to when the user defines a validation that is not supported by the adapter.
  *
  * @returns - The translated schema for something that the adapter is able to understand.
  */
@@ -93,18 +100,23 @@ export async function defaultTransform<TType extends SupportedSchemas>(
   options: {
     validatorsIfFallbackOrNotSupported?: ValidationFallbackReturnType | ValidationFallbackReturnType[];
     /**
-     * If the schema is not supported by the adapter, this means, that the adapter hasn't defined an adapter for that field type, we can fallback to a custom implementation.
+     * If the schema is not supported by the adapter, this means, that the adapter hasn't defined an adapter
+     * for that field type, we can fallback to a custom implementation.
      * The problem is that, for example: Unions,
      *
-     * Let's say we have a schema like this: ObjectSchema.new({ age: UnionSchema.new([NumberSchema.new(), StringSchema.new()] )});
+     * Let's say we have a schema like this:
+     * ObjectSchema.new({ age: UnionSchema.new([NumberSchema.new(), StringSchema.new()] )});
      *
-     * The root object will be validated by the adapter so what we need to do is create two schemas on the root object, one where the
-     * value of `age` key is a number and another where the value of `age` key is a string. Now the root object has two schemas memoized on __transformedSchemas, nice,
-     * what's the logic on that case? The ObjectSchema shouldn't take care of that logic. So the Union schema takes control of validating through the adapter. Is adapter 1 without errors?
-     * If yes, return the result, if not, try the second adapter. If the second adapter is without errors, return the result, if not, return the errors.
+     * The root object will be validated by the adapter so what we need to do is create two schemas on the
+     * root object, one where the value of `age` key is a number and another where the value of `age` key is
+     * a string. Now the root object has two schemas memoized on __transformedSchemas, nice, what's the logic
+     * on that case? The ObjectSchema shouldn't take care of that logic. So the Union schema takes control of
+     * validating through the adapter. Is adapter 1 without errors? If yes, return the result, if not, try
+     * the second adapter. If the second adapter is without errors, return the result, if not, return the
+     * errors.
      *
-     * In other words, the `fallbackIfNotSupported` function on Unions should return the two schemas saved on it on that case, that way the root ObjectSchema will
-     * create those two schemas on the array.
+     * In other words, the `fallbackIfNotSupported` function on Unions should return the two schemas saved on
+     * it on that case, that way the root ObjectSchema will create those two schemas on the array.
      */
     fallbackIfNotSupported?: () => ReturnType<Schema['__transformToAdapter']>;
   } & Pick<Parameters<Schema['__transformToAdapter']>[0], 'shouldAddStringVersion'>
@@ -124,22 +136,29 @@ export async function defaultTransform<TType extends SupportedSchemas>(
     __extends: Schema['__extends'];
   };
 
-  const checkIfShouldUseParserAndAppend = (parser: Parameters<WithFallback<SupportedSchemas>['fallbackFor']['add']>[0]) => {
+  const checkIfShouldUseParserAndAppend = (
+    parser: Parameters<WithFallback<SupportedSchemas>['fallbackFor']['add']>[0]
+  ) => {
     const isValidationDataAParser = (validationData as any).parsers?.[parser] !== undefined;
-    if (isValidationDataAParser) (schema as unknown as {
-      __parsers: Schema['__parsers'];
-    }).__parsers._fallbacks.add(parser);
-  }
+    if (isValidationDataAParser)
+      (
+        schema as unknown as {
+          __parsers: Schema['__parsers'];
+        }
+      ).__parsers._fallbacks.add(parser);
+  };
 
   const getExtendedOrNotSchemaAndString = (schema: any, toStringVersion: string) => {
-    const extendedOrNotSchema = typeof schemaWithPrivateFields.__extends?.callback === 'function' ?
-    schemaWithPrivateFields.__extends.callback(schema) :
-    schema;
-  const extendedOrNotSchemaString = typeof schemaWithPrivateFields.__extends?.toStringCallback === 'function' ?
-    schemaWithPrivateFields.__extends.toStringCallback(toStringVersion) :
-    toStringVersion;
+    const extendedOrNotSchema =
+      typeof schemaWithPrivateFields.__extends?.callback === 'function'
+        ? schemaWithPrivateFields.__extends.callback(schema)
+        : schema;
+    const extendedOrNotSchemaString =
+      typeof schemaWithPrivateFields.__extends?.toStringCallback === 'function'
+        ? schemaWithPrivateFields.__extends.toStringCallback(toStringVersion)
+        : toStringVersion;
     return [extendedOrNotSchema, extendedOrNotSchemaString];
-  }
+  };
 
   const checkIfShouldAppendFallbackAndAppend = (
     fallback: Parameters<WithFallback<SupportedSchemas>['fallbackFor']['add']>[0]
@@ -160,39 +179,46 @@ export async function defaultTransform<TType extends SupportedSchemas>(
       const validatorsIfFallbackOrNotSupported = Array.isArray(options.validatorsIfFallbackOrNotSupported)
         ? options.validatorsIfFallbackOrNotSupported
         : [options.validatorsIfFallbackOrNotSupported];
+
       for (const fallback of validatorsIfFallbackOrNotSupported) Validator.createAndAppendFallback(schema, fallback);
     }
   };
 
-  const hasFallbacks = schemaWithPrivateFields.__rootFallbacksValidator instanceof Validator;
-  const isFieldAdapterNotSupportedForThatFieldType = fieldAdapter === undefined;
+  const appendRequiredFallbacks = () => {
+    const hasFallbacks = schemaWithPrivateFields.__rootFallbacksValidator instanceof Validator;
+    if (hasFallbacks) {
+      Validator.createAndAppendFallback(schema, optional(schemaWithPrivateFields.__optional));
+      Validator.createAndAppendFallback(schema, nullable(schemaWithPrivateFields.__nullable));
+      Validator.createAndAppendFallback(schema, checkType(schemaWithPrivateFields.__type));
+    }
+  };
 
-  if (hasFallbacks) {
-    Validator.createAndAppendFallback(schema, optional(schemaWithPrivateFields.__optional));
-    Validator.createAndAppendFallback(schema, nullable(schemaWithPrivateFields.__nullable));
-    Validator.createAndAppendFallback(schema, checkType(schemaWithPrivateFields.__type));
-  }
+  const isFieldAdapterNotSupportedForThatFieldType = fieldAdapter === undefined;
 
   if (options.fallbackIfNotSupported !== undefined && isFieldAdapterNotSupportedForThatFieldType) {
     const existingFallbacks = Object.keys(fallbackFunctions) as Parameters<
       WithFallback<SupportedSchemas>['fallbackFor']['add']
     >[0][];
-    const allParsers = Object.keys(validationData['parsers']) as Parameters<WithFallback<SupportedSchemas>['fallbackFor']['add']>[0][];
+    const allParsers = Object.keys(validationData['parsers']) as Parameters<
+      WithFallback<SupportedSchemas>['fallbackFor']['add']
+    >[0][];
 
     appendRootFallback();
 
     for (const fallback of existingFallbacks) checkIfShouldAppendFallbackAndAppend(fallback);
     for (const parser of allParsers) checkIfShouldUseParserAndAppend(parser);
+    appendRequiredFallbacks();
+
     return options.fallbackIfNotSupported();
   }
   if (!fieldAdapter) throw new Error('The field adapter is not supported and no fallback was provided.');
 
-  const translatedSchemaOrWithFallback = (await Promise.resolve(
+  const translatedSchemaOrWithFallback = await Promise.resolve(
     fieldAdapter.translate(adapter.field, {
       withFallback: withFallbackFactory<SupportedSchemas>(type),
-      ...validationData,
+      ...validationData
     })
-  ));
+  );
 
   let stringVersion = '';
   if (options.shouldAddStringVersion)
@@ -209,12 +235,13 @@ export async function defaultTransform<TType extends SupportedSchemas>(
       translatedSchemaOrWithFallback.transformedSchema,
       stringVersion
     );
+    appendRequiredFallbacks();
 
     return [
       {
         transformed: extendedOrNotSchema,
-        asString: extendedOrNotSchemaString,
-      },
+        asString: extendedOrNotSchemaString
+      }
     ];
   }
 
@@ -226,21 +253,33 @@ export async function defaultTransform<TType extends SupportedSchemas>(
   return [
     {
       transformed: extendedOrNotSchema,
-      asString: extendedOrNotSchemaString,
-    },
+      asString: extendedOrNotSchemaString
+    }
   ];
 }
 
 /**
- * This function is used to transform the schema to the adapter. By default it caches the transformed schemas on the schema instance. So on subsequent validations we don't need
- * to transform to the schema again.
+ * This function is used to transform the schema to the adapter. By default it caches the transformed schemas on
+ * the schema instance. So on subsequent validations we don't need to transform to the schema again.
  */
 export async function defaultTransformToAdapter(
   callback: (adapter: SchemaAdapter) => ReturnType<FieldAdapter['translate']>,
+  schema: Schema<any, any>,
   transformedSchemas: Schema['__transformedSchemas'],
   options: Parameters<Schema['__transformToAdapter']>[0],
   type: string
 ) {
+  const isTransformedSchemasEmpty = Object.keys(transformedSchemas).length <= 0;
+  if (isTransformedSchemasEmpty) {
+    const adapterInstanceToUse =
+      options.schemaAdapter instanceof SchemaAdapter ? options.schemaAdapter : getDefaultAdapter();
+    schema['__transformedSchemas'][adapterInstanceToUse.constructor.name] = {
+      transformed: false,
+      adapter: adapterInstanceToUse,
+      schemas: []
+    };
+  }
+
   const schemaAdapterNameToUse = options.schemaAdapter?.constructor.name || Object.keys(transformedSchemas)[0];
   const isACustomSchemaAdapterAndNotYetDefined =
     // eslint-disable-next-line ts/no-unnecessary-condition
@@ -250,7 +289,7 @@ export async function defaultTransformToAdapter(
     transformedSchemas[schemaAdapterNameToUse] = {
       transformed: false,
       adapter: options.schemaAdapter as SchemaAdapter,
-      schemas: [],
+      schemas: []
     };
 
   const shouldTranslate = transformedSchemas[schemaAdapterNameToUse].transformed === false || options.force === true;
@@ -269,27 +308,36 @@ export async function formatErrorFromParseMethod(
   adapter: SchemaAdapter,
   fieldAdapter: FieldAdapter,
   error: any,
+  received: any,
+  schema: any,
   path: ValidationFallbackCallbackReturnType['errors'][number]['path'],
   errorsAsHashedSet: Set<string>
 ) {
-  const formattedError = await fieldAdapter.formatError(adapter, fieldAdapter, error);
+  const formattedError = await fieldAdapter.formatError(adapter, adapter.field, schema, error);
   formattedError.path = Array.isArray(formattedError.path) ? [...path, ...formattedError.path] : path;
+
   const formattedErrorAsParseResultError =
     formattedError as unknown as ValidationFallbackCallbackReturnType['errors'][number];
   formattedErrorAsParseResultError.isValid = false;
-  errorsAsHashedSet.add(JSON.stringify(formattedErrorAsParseResultError));
+  const sortedError = Object.fromEntries(
+    Object.entries(formattedErrorAsParseResultError).sort(([a], [b]) => a.localeCompare(b))
+  );
+  const hashedError = JSON.stringify(sortedError);
+  errorsAsHashedSet.add(JSON.stringify(sortedError));
+  formattedErrorAsParseResultError.received = received;
   return formattedErrorAsParseResultError;
 }
 
 /**
- * Transform the schema and check if we should add a fallback validation for that schema. This is used for complex schemas like Objects, arrays, unions, etc.
+ * Transform the schema and check if we should add a fallback validation for that schema. This is used for complex
+ * schemas like Objects, arrays, unions, etc.
  */
 export async function transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas(
   schema: Schema,
   options: Parameters<Schema['__transformToAdapter']>[0]
 ) {
   const schemaWithProtected = schema as Schema & {
-    __runBeforeParseAndData: Schema['__runBeforeParseAndData']
+    __runBeforeParseAndData: Schema['__runBeforeParseAndData'];
     __toInternal: Schema['__toInternal'];
     __toValidate: Schema['__toValidate'];
     __toRepresentation: Schema['__toRepresentation'];
@@ -299,7 +347,8 @@ export async function transformSchemaAndCheckIfShouldBeHandledByFallbackOnComple
     __parsers: Schema['__parsers'];
   };
 
-  const transformedData = await schemaWithProtected.__transformToAdapter(options); // This should come first because we will get the fallbacks of the field here.
+  // This should come first because we will get the fallbacks of the field here.
+  const transformedData = await schemaWithProtected.__transformToAdapter(options);
 
   // eslint-disable-next-line ts/no-unnecessary-condition
   const doesKeyHaveFallback = schemaWithProtected.__rootFallbacksValidator !== undefined;
@@ -320,3 +369,12 @@ export async function transformSchemaAndCheckIfShouldBeHandledByFallbackOnComple
 
   return [transformedData, shouldAddFallbackValidation] as const;
 }
+
+export function shouldRunDataOnComplexSchemas(schema: Schema<any, any>) {
+  return (
+    typeof schema['__parsersToTransformValue'] === 'function' ||
+    typeof schema['__runBeforeParseAndData'] === 'function' ||
+    typeof schema['__toRepresentation'] === 'function' ||
+    typeof schema['__defaultFunction'] === 'function'
+  );
+}

package/src/validators/array.ts

@@ -4,6 +4,7 @@ import type { ValidationFallbackCallbackReturnType, ValidationFallbackReturnType
 
 export function arrayValidation(isTuple: boolean, schemas: Schema<any, any>[]): ValidationFallbackReturnType {
   return {
+    name: 'array',
     type: 'medium',
     callback: async (value: any, path: (string | number)[], options: Parameters<Schema['__transformToAdapter']>[0]) => {
       const isNotAnArray = Array.isArray(value) === false;
@@ -17,9 +18,9 @@ export function arrayValidation(isTuple: boolean, schemas: Schema<any, any>[]):
               code: 'array',
               // eslint-disable-next-line ts/no-unnecessary-condition
               path: path || [],
-              message: 'The value must be an array. Received: ' + typeof value,
-            },
-          ],
+              message: 'The value must be an array. Received: ' + typeof value
+            }
+          ]
         };
       if (isTuple && value.length !== schemas.length)
         return {
@@ -31,14 +32,15 @@ export function arrayValidation(isTuple: boolean, schemas: Schema<any, any>[]):
               code: 'tuple',
               // eslint-disable-next-line ts/no-unnecessary-condition
               path: path || [],
-              message: 'The tuple must have exactly ' + schemas.length + ' elements. Received: ' + value.length,
-            },
-          ],
+              message: 'The tuple must have exactly ' + schemas.length + ' elements. Received: ' + value.length
+            }
+          ]
         };
 
       const errorsOfArray: ValidationFallbackCallbackReturnType['errors'] = [];
 
-      // To speed things up, we can do a simple type check, if the value is of type number and number is on index 1, and on index 0 is a string,
+      // To speed things up, we can do a simple type check, if the value is of type number and
+      // number is on index 1, and on index 0 is a string,
       // if the value is a number we can skip checking at index 0.
       const schemaIndexByTypeof = new Map<string, number>();
       let parsedValues: any[] = [];
@@ -52,8 +54,8 @@ export function arrayValidation(isTuple: boolean, schemas: Schema<any, any>[]):
           const schemasToValidateAgainst = isTuple
             ? [schemas[index]]
             : existsASchemaIndex
-            ? [schemas[schemaIndex]]
-            : schemas;
+              ? [schemas[schemaIndex]]
+              : schemas;
 
           for (let indexOfSchema = 0; indexOfSchema < schemasToValidateAgainst.length; indexOfSchema++) {
             const schemaToValidate = schemasToValidateAgainst[indexOfSchema];
@@ -64,7 +66,9 @@ export function arrayValidation(isTuple: boolean, schemas: Schema<any, any>[]):
             const { parsed, errors } = await schemaWithProtected.__parse(element, [...path, index], options);
 
             if (schemaWithProtected.__toInternal && options.toInternalToBubbleUp)
-              options.toInternalToBubbleUp.push(async () => (parsedValues[indexOfSchema] = await schemaWithProtected.__toInternal?.(parsed)));
+              options.toInternalToBubbleUp.push(
+                async () => (parsedValues[indexOfSchema] = await schemaWithProtected.__toInternal?.(parsed))
+              );
 
             // eslint-disable-next-line ts/no-unnecessary-condition
             if ((errors || []).length <= 0) {
@@ -82,17 +86,22 @@ export function arrayValidation(isTuple: boolean, schemas: Schema<any, any>[]):
 
       return {
         parsed: parsedValues,
-        errors: errorsOfArray,
+        errors: errorsOfArray
       };
-    },
+    }
   };
 }
 
 export function minLength(args: ArraySchema['__minLength']): ValidationFallbackReturnType {
   return {
+    name: 'minLength',
     type: 'low',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = args.inclusive ? value.length >= args.value : value.length > args.value;
 
       return {
@@ -105,19 +114,24 @@ export function minLength(args: ArraySchema['__minLength']): ValidationFallbackR
                 code: 'minLength',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
 export function maxLength(args: ArraySchema['__maxLength']): ValidationFallbackReturnType {
   return {
+    name: 'maxLength',
     type: 'low',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = args.inclusive ? value.length <= args.value : value.length < args.value;
 
       return {
@@ -130,19 +144,24 @@ export function maxLength(args: ArraySchema['__maxLength']): ValidationFallbackR
                 code: 'maxLength',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
 export function nonEmpty(args: ArraySchema['__nonEmpty']): ValidationFallbackReturnType {
   return {
+    name: 'nonEmpty',
     type: 'low',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = value.length > 0;
 
       return {
@@ -155,10 +174,10 @@ export function nonEmpty(args: ArraySchema['__nonEmpty']): ValidationFallbackRet
                 code: 'nonEmpty',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }

package/src/validators/boolean.ts

@@ -3,9 +3,14 @@ import type { ValidationFallbackReturnType } from '../schema/types';
 
 export function booleanValidation(): ValidationFallbackReturnType {
   return {
+    name: 'boolean',
     type: 'medium',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = typeof value === 'boolean';
 
       return {
@@ -18,17 +23,18 @@ export function booleanValidation(): ValidationFallbackReturnType {
                 code: 'boolean',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: 'Value is not a boolean',
-              },
+                message: 'Value is not a boolean'
+              }
             ],
-        preventChildValidation: true,
+        preventChildValidation: true
       };
-    },
+    }
   };
 }
 
 export function allowStringParser(): ValidationFallbackReturnType {
   return {
+    name: 'allowString',
     type: 'high',
     // eslint-disable-next-line ts/require-await
     callback: async (
@@ -39,8 +45,8 @@ export function allowStringParser(): ValidationFallbackReturnType {
       const parsed = Boolean(value);
       return {
         parsed: parsed,
-        errors: [],
+        errors: []
       };
-    },
+    }
   };
 }

package/src/validators/datetime.ts

@@ -4,9 +4,14 @@ import type { ValidationFallbackReturnType } from '../schema/types';
 
 export function datetimeValidation(): ValidationFallbackReturnType {
   return {
+    name: 'datetime',
     type: 'medium',
     // eslint-disable-next-line ts/require-await
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = value instanceof Date && !isNaN(value.getTime());
 
       return {
@@ -19,17 +24,18 @@ export function datetimeValidation(): ValidationFallbackReturnType {
                 code: 'datetime',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: 'Value is not a date',
-              },
+                message: 'Value is not a date'
+              }
             ],
-        preventChildValidation: true,
+        preventChildValidation: true
       };
-    },
+    }
   };
 }
 
 export function allowStringParser(): ValidationFallbackReturnType {
   return {
+    name: 'allowString',
     type: 'high',
     // eslint-disable-next-line ts/require-await
     callback: async (
@@ -42,20 +48,21 @@ export function allowStringParser(): ValidationFallbackReturnType {
         if (parsed instanceof Date && !isNaN(parsed.getTime())) {
           return {
             parsed: parsed,
-            errors: [],
+            errors: []
           };
         }
       }
       return {
         parsed: value,
-        errors: [],
+        errors: []
       };
-    },
+    }
   };
 }
 
 export function below(args: DatetimeSchema['__below']): ValidationFallbackReturnType {
   return {
+    name: 'below',
     type: 'low',
     // eslint-disable-next-line ts/require-await
     callback: async (
@@ -75,16 +82,17 @@ export function below(args: DatetimeSchema['__below']): ValidationFallbackReturn
                 code: 'below',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
 export function above(args: DatetimeSchema['__above']): ValidationFallbackReturnType {
   return {
+    name: 'above',
     type: 'low',
     // eslint-disable-next-line ts/require-await
     callback: async (
@@ -104,10 +112,10 @@ export function above(args: DatetimeSchema['__above']): ValidationFallbackReturn
                 code: 'above',
                 // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }