@palmares/schemas 0.0.1 → 0.1.0

package/dist/esm/src/schema/union.js

@@ -1,16 +1,19 @@
 import Schema from './schema';
-import { getDefaultAdapter } from '../conf';
 import { defaultTransform, defaultTransformToAdapter, transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas } from '../utils';
 import { unionValidation } from '../validators/union';
 import Validator from '../validators/utils';
 export default class UnionSchema extends Schema {
+    __type = {
+        message: 'Invalid type',
+        check: (value)=>Array.from(this.__schemas).some((schema)=>schema['__type'].check(value))
+    };
     __schemas = new Set();
     constructor(schemas){
         super();
         this.__schemas = new Set(schemas);
     }
-    async _transformToAdapter(options) {
-        return await defaultTransformToAdapter(async (adapter)=>{
+    async __transformToAdapter(options) {
+        return defaultTransformToAdapter(async (adapter)=>{
             const promises = [];
             const shouldBeHighPriorityFallback = adapter.union === undefined;
             const transformedSchemasAsString = [];
@@ -36,6 +39,7 @@ export default class UnionSchema extends Schema {
             await Promise.all(promises);
             return defaultTransform('union', this, adapter, adapter.union, (isStringVersion)=>({
                     nullable: this.__nullable,
+                    type: this.__type,
                     optional: this.__optional,
                     schemas: isStringVersion ? transformedSchemasAsString : transformedSchemas,
                     parsers: {
@@ -45,12 +49,12 @@ export default class UnionSchema extends Schema {
                 }), {}, {
                 shouldAddStringVersion: options.shouldAddStringVersion,
                 fallbackIfNotSupported: async ()=>{
-                    if (options.appendFallbacksBeforeAdapterValidation) options.appendFallbacksBeforeAdapterValidation('union', async (adapter, fieldAdapter, schema, translatedSchemas, value, path, options)=>{
+                    if (options.appendFallbacksBeforeAdapterValidation) options.appendFallbacksBeforeAdapterValidation(this, 'union', async (adapter, fieldAdapter, schema, translatedSchemas, value, path, options)=>{
                         const parsedValues = {
                             parsed: value,
                             errors: []
                         };
-                        //                    const initialErrorsAsHashedSet = new Set(Array.from(options.errorsAsHashedSet || []));
+                        // const initialErrorsAsHashedSet = new Set(Array.from(options.errorsAsHashedSet || []));
                         for (const translatedSchema of translatedSchemas){
                             //options.errorsAsHashedSet = initialErrorsAsHashedSet;
                             const { parsed, errors } = await schema.__validateByAdapter(adapter, fieldAdapter, translatedSchema, value, path, options);
@@ -69,14 +73,14 @@ export default class UnionSchema extends Schema {
                     });
                     const transformedSchemasAsPromises = [];
                     for (const schema of this.__schemas)transformedSchemasAsPromises.push(schema.__transformToAdapter(options));
-                    console.log((await Promise.all(transformedSchemasAsPromises)).flat());
                     return (await Promise.all(transformedSchemasAsPromises)).flat();
                 }
             });
-        }, this.__transformedSchemas, options, 'union');
+        }, this, this.__transformedSchemas, options, 'union');
     }
     /**
-   * This let's you refine the schema with custom validations. This is useful when you want to validate something that is not supported by default by the schema adapter.
+   * This let's you refine the schema with custom validations. This is useful when you want to validate something that
+   * is not supported by default by the schema adapter.
    *
    * @example
    * ```typescript
@@ -88,7 +92,8 @@ export default class UnionSchema extends Schema {
    *
    * const { errors, parsed } = await numberSchema.parse(-1);
    *
-   * console.log(errors); // [{ isValid: false, code: 'invalid_number', message: 'The number should be greater than 0', path: [] }]
+   * // [{ isValid: false, code: 'invalid_number', message: 'The number should be greater than 0', path: [] }]
+   * console.log(errors);
    * ```
    *
    * @param refinementCallback - The callback that will be called to validate the value.
@@ -124,8 +129,25 @@ export default class UnionSchema extends Schema {
         return super.optional(options);
     }
     /**
-   * Allows the value to be null and ONLY null. You can also use this function to set a custom message when the value is NULL by setting
-   * the { message: 'Your custom message', allow: false } on the options.
+   * Just adds a message when the value is undefined. It's just a syntax sugar for
+   *
+   * ```typescript
+   * p.string().optional({ message: 'This value cannot be null', allow: false })
+   * ```
+   *
+   * @param options - The options of nonOptional function
+   * @param options.message - A custom message if the value is undefined.
+   *
+   * @returns - The schema.
+   */ nonOptional(options) {
+        return super.optional({
+            message: options?.message,
+            allow: false
+        });
+    }
+    /**
+   * Allows the value to be null and ONLY null. You can also use this function to set a custom message when the value
+   * is NULL by setting the { message: 'Your custom message', allow: false } on the options.
    *
    * @example
    * ```typescript
@@ -151,14 +173,33 @@ export default class UnionSchema extends Schema {
         return super.nullable(options);
     }
     /**
-   * This method will remove the value from the representation of the schema. If the value is undefined it will keep that way
+   * Just adds a message when the value is null. It's just a syntax sugar for
+   *
+   * ```typescript
+   * p.string().nullable({ message: 'This value cannot be null', allow: false })
+   * ```
+   *
+   * @param options - The options of nonNullable function
+   * @param options.message - A custom message if the value is null.
+   *
+   * @returns - The schema.
+   */ nonNullable(options) {
+        return super.nullable({
+            message: options?.message || '',
+            allow: false
+        });
+    }
+    /**
+   * This method will remove the value from the representation of the schema. If the value is undefined it will keep
+   * that way
    * otherwise it will set the value to undefined after it's validated.
    * This is used in conjunction with the {@link data} function, the {@link parse} function or {@link validate}
    * function. This will remove the value from the representation of the schema.
    *
-   * By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
-   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
-   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   * By default, the value will be removed just from the representation, in other words, when you call the {@link data}
+   * function. But if you want to remove the value from the internal representation, you can pass the argument
+   * `toInternal` as true. Then if you still want to remove the value from the representation, you will need to pass
+   * the argument `toRepresentation` as true as well.
    *
    * @example
    * ```typescript
@@ -180,18 +221,19 @@ export default class UnionSchema extends Schema {
    * ```
    *
    *
-   * @param args - By default, the value will be removed just from the representation, in other words, when you call the {@link data} function.
-   * But if you want to remove the value from the internal representation, you can pass the argument `toInternal` as true.
-   * Then if you still want to remove the value from the representation, you will need to pass the argument `toRepresentation` as true as well.
+   * @param args - By default, the value will be removed just from the representation, in other words, when you call
+   * the {@link data} function. But if you want to remove the value from the internal representation, you can pass
+   * the argument `toInternal` as true. Then if you still want to remove the value from the representation, you
+   * will need to pass the argument `toRepresentation` as true as well.
    *
    * @returns The schema.
    */ omit(args) {
         return super.omit(args);
     }
     /**
-   * This function is used in conjunction with the {@link validate} function. It's used to save a value to an external source
-   * like a database. You should always return the schema after you save the value, that way we will always have the correct type
-   * of the schema after the save operation.
+   * This function is used in conjunction with the {@link validate} function. It's used to save a value to an external
+   * source like a database. You should always return the schema after you save the value, that way we will always
+   * have the correct type of the schema after the save operation.
    *
    * You can use the {@link toRepresentation} function to transform and clean the value it returns after the save.
    *
@@ -233,7 +275,8 @@ export default class UnionSchema extends Schema {
         return super.onSave(callback);
     }
     /**
-   * This function is used to add a default value to the schema. If the value is either undefined or null, the default value will be used.
+   * This function is used to add a default value to the schema. If the value is either undefined or null, the default
+   * value will be used.
    *
    * @example
    * ```typescript
@@ -249,8 +292,47 @@ export default class UnionSchema extends Schema {
         return super.default(defaultValueOrFunction);
     }
     /**
-   * This function let's you customize the schema your own way. After we translate the schema on the adapter we call this function to let you customize
-   * the custom schema your own way. Our API does not support passthrough? No problem, you can use this function to customize the zod schema.
+   * This function is used to transform the value to the representation without validating it.
+   * This is useful when you want to return a data from a query directly to the user. But for example
+   * you are returning the data of a user, you can clean the password or any other sensitive data.
+   *
+   * @example
+   * ```typescript
+   * import * as p from '@palmares/schemas';
+   *
+   * const userSchema = p.object({
+   *   id: p.number().optional(),
+   *   name: p.string(),
+   *   email: p.string().email(),
+   *   password: p.string().optional()
+   * }).toRepresentation(async (value) => {
+   *   return {
+   *    id: value.id,
+   *    name: value.name,
+   *   email: value.email
+   *  }
+   * });
+   *
+   * const user = await userSchema.data({
+   *   id: 1,
+   *   name: 'John Doe',
+   *   email: 'john@gmail.com',
+   *   password: '123456'
+   * });
+   * ```
+   */ async data(value) {
+        const parsedValue = await super.data(value);
+        for (const schema of Array.from(this.__schemas)){
+            if (schema['__optional'].allow && value === undefined) return schema.data(parsedValue);
+            if (schema['__nullable'].allow && value === null) return schema.data(parsedValue);
+            if (schema['__type'].check(parsedValue)) return schema.data(parsedValue);
+        }
+        return parsedValue;
+    }
+    /**
+   * This function let's you customize the schema your own way. After we translate the schema on the adapter we call
+   * this function to let you customize the custom schema your own way. Our API does not support passthrough?
+   * No problem, you can use this function to customize the zod schema.
    *
    * @example
    * ```typescript
@@ -262,21 +344,22 @@ export default class UnionSchema extends Schema {
    *
    * const { errors, parsed } = await numberSchema.parse(-1);
    *
-   * console.log(errors); // [{ isValid: false, code: 'nonnegative', message: 'The number should be nonnegative', path: [] }]
+   * // [{ isValid: false, code: 'nonnegative', message: 'The number should be nonnegative', path: [] }]
+   * console.log(errors);
    * ```
    *
    * @param callback - The callback that will be called to customize the schema.
-   * @param toStringCallback - The callback that will be called to transform the schema to a string when you want to compile the underlying schema
-   * to a string so you can save it for future runs.
+   * @param toStringCallback - The callback that will be called to transform the schema to a string when you want
+   * to compile the underlying schema to a string so you can save it for future runs.
    *
    * @returns The schema.
    */ extends(callback, toStringCallback) {
         return super.extends(callback, toStringCallback);
     }
     /**
-   * This function is used to transform the value to the representation of the schema. When using the {@link data} function. With this function you have full
-   * control to add data cleaning for example, transforming the data and whatever. Another use case is when you want to return deeply nested recursive data.
-   * The schema maps to itself.
+   * This function is used to transform the value to the representation of the schema. When using the {@link data}
+   * function. With this function you have full control to add data cleaning for example, transforming the data and
+   * whatever. Another use case is when you want to return deeply nested recursive data. The schema maps to itself.
    *
    * @example
    * ```typescript
@@ -319,8 +402,9 @@ export default class UnionSchema extends Schema {
         return super.toRepresentation(toRepresentationCallback);
     }
     /**
-   * This function is used to transform the value to the internal representation of the schema. This is useful when you want to transform the value
-   * to a type that the schema adapter can understand. For example, you might want to transform a string to a date. This is the function you use.
+   * This function is used to transform the value to the internal representation of the schema. This is useful when you
+   * want to transform the value to a type that the schema adapter can understand. For example, you might want to
+   * transform a string to a date. This is the function you use.
    *
    * @example
    * ```typescript
@@ -353,8 +437,9 @@ export default class UnionSchema extends Schema {
         return super.toInternal(toInternalCallback);
     }
     /**
-   * Called before the validation of the schema. Let's say that you want to validate a date that might receive a string, you can convert that string to a date
-   * here BEFORE the validation. This pretty much transforms the value to a type that the schema adapter can understand.
+   * Called before the validation of the schema. Let's say that you want to validate a date that might receive a string,
+   * you can convert that string to a date here BEFORE the validation. This pretty much transforms the value to a type
+   * that the schema adapter can understand.
    *
    * @example
    * ```
@@ -376,12 +461,6 @@ export default class UnionSchema extends Schema {
     }
     static new(schemas) {
         const returnValue = new UnionSchema(schemas);
-        const adapterInstance = getDefaultAdapter();
-        returnValue.__transformedSchemas[adapterInstance.constructor.name] = {
-            transformed: false,
-            adapter: adapterInstance,
-            schemas: []
-        };
         return returnValue;
     }
 }

package/dist/esm/src/types.js

@@ -1 +1,14 @@
-export { };
+/**
+ * Retrieve the typescript type of a schema.
+ *
+ * First generic is `typeof myCustomSchema`.
+ *
+ * Second generic is:
+ * - 'input' - The data passed to `.parse` and `.validate` functions. Defaults to this.
+ * - 'output' - (use `'representation'` to get the data format you are
+ * passing to the user) The data passed to `.data` function to return to the
+ * user.
+ * - 'representation' - The data after `toRepresentation`, usually, use this over 'output'
+ * - 'internal' - The data after it's transformed for the `toSave` callback.
+ * - 'validate' - The data for `toValidate` callback.
+ */ export { };

package/dist/esm/src/utils.js

@@ -1,8 +1,11 @@
+import SchemaAdapter from './adapter';
+import { getDefaultAdapter } from './conf';
 import { checkType, nullable, optional } from './validators/schema';
 import Validator from './validators/utils';
 /**
- * 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 {
     fallbackFor;
     transformedSchema;
@@ -14,8 +17,9 @@ import Validator from './validators/utils';
     }
 }
 /**
- * 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.
  *
@@ -33,18 +37,22 @@ export function parseErrorsFactory(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.
  */ export async function defaultTransform(type, schema, adapter, fieldAdapter, getValidationData, fallbackFunctions, options) {
@@ -78,19 +86,22 @@ export function parseErrorsFactory(schemaAdapter) {
             for (const fallback of validatorsIfFallbackOrNotSupported)Validator.createAndAppendFallback(schema, fallback);
         }
     };
-    const hasFallbacks = schemaWithPrivateFields.__rootFallbacksValidator instanceof Validator;
+    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));
+        }
+    };
     const isFieldAdapterNotSupportedForThatFieldType = fieldAdapter === undefined;
-    if (hasFallbacks) {
-        Validator.createAndAppendFallback(schema, optional(schemaWithPrivateFields.__optional));
-        Validator.createAndAppendFallback(schema, nullable(schemaWithPrivateFields.__nullable));
-        Validator.createAndAppendFallback(schema, checkType(schemaWithPrivateFields.__type));
-    }
     if (options.fallbackIfNotSupported !== undefined && isFieldAdapterNotSupportedForThatFieldType) {
         const existingFallbacks = Object.keys(fallbackFunctions);
         const allParsers = Object.keys(validationData['parsers']);
         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.');
@@ -107,6 +118,7 @@ export function parseErrorsFactory(schemaAdapter) {
             checkIfShouldUseParserAndAppend(fallback);
         }
         const [extendedOrNotSchema, extendedOrNotSchemaString] = getExtendedOrNotSchemaAndString(translatedSchemaOrWithFallback.transformedSchema, stringVersion);
+        appendRequiredFallbacks();
         return [
             {
                 transformed: extendedOrNotSchema,
@@ -123,9 +135,18 @@ export function parseErrorsFactory(schemaAdapter) {
     ];
 }
 /**
- * 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, transformedSchemas, options, type) {
+ * 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, schema, transformedSchemas, options, type) {
+    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
     transformedSchemas[schemaAdapterNameToUse] === undefined && options.schemaAdapter !== undefined;
@@ -143,22 +164,27 @@ export function parseErrorsFactory(schemaAdapter) {
     transformedSchemas[schemaAdapterNameToUse].transformed = true;
     return transformedSchemas[schemaAdapterNameToUse].schemas;
 }
-export async function formatErrorFromParseMethod(adapter, fieldAdapter, error, path, errorsAsHashedSet) {
-    const formattedError = await fieldAdapter.formatError(adapter, fieldAdapter, error);
+export async function formatErrorFromParseMethod(adapter, fieldAdapter, error, received, schema, path, errorsAsHashedSet) {
+    const formattedError = await fieldAdapter.formatError(adapter, adapter.field, schema, error);
     formattedError.path = Array.isArray(formattedError.path) ? [
         ...path,
         ...formattedError.path
     ] : path;
     const formattedErrorAsParseResultError = formattedError;
     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, options) {
     const schemaWithProtected = schema;
-    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;
     const doesKeyHaveToInternal = typeof schemaWithProtected.__toInternal === 'function';
@@ -173,3 +199,6 @@ export async function formatErrorFromParseMethod(adapter, fieldAdapter, error, p
         shouldAddFallbackValidation
     ];
 }
+export function shouldRunDataOnComplexSchemas(schema) {
+    return typeof schema['__parsersToTransformValue'] === 'function' || typeof schema['__runBeforeParseAndData'] === 'function' || typeof schema['__toRepresentation'] === 'function' || typeof schema['__defaultFunction'] === 'function';
+}

package/dist/esm/src/validators/array.js

@@ -1,5 +1,6 @@
 export function arrayValidation(isTuple, schemas) {
     return {
+        name: 'array',
         type: 'medium',
         callback: async (value, path, options)=>{
             const isNotAnArray = Array.isArray(value) === false;
@@ -30,7 +31,8 @@ export function arrayValidation(isTuple, schemas) {
                 ]
             };
             const errorsOfArray = [];
-            // 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();
             let parsedValues = [];
@@ -72,6 +74,7 @@ export function arrayValidation(isTuple, schemas) {
 }
 export function minLength(args) {
     return {
+        name: 'minLength',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
@@ -93,6 +96,7 @@ export function minLength(args) {
 }
 export function maxLength(args) {
     return {
+        name: 'maxLength',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
@@ -114,6 +118,7 @@ export function maxLength(args) {
 }
 export function nonEmpty(args) {
     return {
+        name: 'nonEmpty',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{

package/dist/esm/src/validators/boolean.js

@@ -1,5 +1,6 @@
 export function booleanValidation() {
     return {
+        name: 'boolean',
         type: 'medium',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
@@ -22,6 +23,7 @@ export function booleanValidation() {
 }
 export function allowStringParser() {
     return {
+        name: 'allowString',
         type: 'high',
         // eslint-disable-next-line ts/require-await
         callback: async (value, _path, _options)=>{

package/dist/esm/src/validators/datetime.js

@@ -1,5 +1,6 @@
 export function datetimeValidation() {
     return {
+        name: 'datetime',
         type: 'medium',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
@@ -22,6 +23,7 @@ export function datetimeValidation() {
 }
 export function allowStringParser() {
     return {
+        name: 'allowString',
         type: 'high',
         // eslint-disable-next-line ts/require-await
         callback: async (value, _path, _options)=>{
@@ -43,6 +45,7 @@ export function allowStringParser() {
 }
 export function below(args) {
     return {
+        name: 'below',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
@@ -64,6 +67,7 @@ export function below(args) {
 }
 export function above(args) {
     return {
+        name: 'above',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{

package/dist/esm/src/validators/number.js

@@ -1,5 +1,6 @@
 export function numberValidation() {
     return {
+        name: 'number',
         type: 'medium',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
@@ -20,6 +21,7 @@ export function numberValidation() {
 }
 export function max(args) {
     return {
+        name: 'max',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path, _options)=>{
@@ -52,6 +54,7 @@ export function max(args) {
 }
 export function min(args) {
     return {
+        name: 'min',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path)=>{
@@ -80,39 +83,20 @@ export function min(args) {
         }
     };
 }
-export function negative(args) {
+export function integer(args) {
     return {
+        name: 'integer',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path)=>{
-            const isValid = args.allowZero ? value < 0 : value <= 0;
+            const isValid = Number.isInteger(value);
             return {
                 parsed: value,
                 errors: isValid ? [] : [
                     {
                         isValid: isValid,
                         message: args.message,
-                        code: 'negative',
-                        path: path || []
-                    }
-                ]
-            };
-        }
-    };
-}
-export function positive(args) {
-    return {
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            const isValid = args.allowZero ? value > 0 : value >= 0;
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: isValid,
-                        message: args.message,
-                        code: 'positive',
+                        code: 'integer',
                         path: path || []
                     }
                 ]
@@ -122,6 +106,7 @@ export function positive(args) {
 }
 export function maxDigits(args) {
     return {
+        name: 'maxDigits',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path)=>{
@@ -142,6 +127,7 @@ export function maxDigits(args) {
 }
 export function decimalPlaces(args) {
     return {
+        name: 'decimalPlaces',
         type: 'low',
         // eslint-disable-next-line ts/require-await
         callback: async (value, path)=>{

package/dist/esm/src/validators/object.js

@@ -1,5 +1,6 @@
 export function objectValidation(keysToFallback) {
     return {
+        name: 'object',
         type: 'low',
         callback: async (value, path, options)=>{
             const isNotAnObject = typeof value !== 'object' && Array.isArray(value) === false && value !== null;