@palmares/schemas 0.0.1 → 0.1.0

package/src/validators/string.ts

@@ -1,11 +1,18 @@
+import { type ValidationFallbackReturnType } from '../schema/types';
+
 import type Schema from '../schema/schema';
 import type StringSchema from '../schema/string';
-import { type ValidationFallbackReturnType } from '../schema/types';
 
 export function stringValidation(): ValidationFallbackReturnType {
   return {
+    name: 'string',
     type: 'medium',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       return {
         parsed: value,
         errors:
@@ -15,20 +22,27 @@ export function stringValidation(): ValidationFallbackReturnType {
                 {
                   isValid: typeof value === 'string',
                   code: 'string',
+                  // eslint-disable-next-line ts/no-unnecessary-condition
                   path: path || [],
-                  message: 'The value must be a string. Received: ' + typeof value,
-                },
-              ],
+                  message: 'The value must be a string. Received: ' + typeof value
+                }
+              ]
       };
-    },
+    }
   };
 }
 
-export function maxLength(args: StringSchema['__maxLength']): ValidationFallbackReturnType {
+export function maxLength(args: NonNullable<StringSchema['__maxLength']>): ValidationFallbackReturnType {
   return {
+    name: 'maxLength',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
-      const isValid = args.inclusive ? value.length <= args.value : value.length < args.value;
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
+      const isValid = value.length <= args.value;
 
       return {
         parsed: value,
@@ -38,20 +52,27 @@ export function maxLength(args: StringSchema['__maxLength']): ValidationFallback
               {
                 isValid: false,
                 code: 'maxLength',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function minLength(args: StringSchema['__maxLength']): ValidationFallbackReturnType {
+export function minLength(args: NonNullable<StringSchema['__maxLength']>): ValidationFallbackReturnType {
   return {
+    name: 'minLength',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
-      const isValid = args.inclusive ? value.length >= args.value : value.length > args.value;
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
+      const isValid = value.length >= args.value;
 
       return {
         parsed: value,
@@ -61,19 +82,26 @@ export function minLength(args: StringSchema['__maxLength']): ValidationFallback
               {
                 isValid: false,
                 code: 'minLength',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function endsWith(args: StringSchema['__endsWith']): ValidationFallbackReturnType {
+export function endsWith(args: NonNullable<StringSchema['__endsWith']>): ValidationFallbackReturnType {
   return {
+    name: 'endsWith',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = value.endsWith(args.value);
 
       return {
@@ -84,19 +112,26 @@ export function endsWith(args: StringSchema['__endsWith']): ValidationFallbackRe
               {
                 isValid: false,
                 code: 'endsWith',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function startsWith(args: StringSchema['__startsWith']): ValidationFallbackReturnType {
+export function startsWith(args: NonNullable<StringSchema['__startsWith']>): ValidationFallbackReturnType {
   return {
+    name: 'startsWith',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = value.startsWith(args.value);
 
       return {
@@ -107,19 +142,26 @@ export function startsWith(args: StringSchema['__startsWith']): ValidationFallba
               {
                 isValid: false,
                 code: 'startsWith',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function includes(args: StringSchema['__includes']): ValidationFallbackReturnType {
+export function includes(args: NonNullable<StringSchema['__includes']>): ValidationFallbackReturnType {
   return {
+    name: 'includes',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = value.includes(args.value);
 
       return {
@@ -130,19 +172,26 @@ export function includes(args: StringSchema['__includes']): ValidationFallbackRe
               {
                 isValid: false,
                 code: 'includes',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function regex(args: StringSchema['__regex']): ValidationFallbackReturnType {
+export function regex(args: NonNullable<StringSchema['__regex']>): ValidationFallbackReturnType {
   return {
+    name: 'regex',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = args.value.test(value);
 
       return {
@@ -153,23 +202,29 @@ export function regex(args: StringSchema['__regex']): ValidationFallbackReturnTy
               {
                 isValid: false,
                 code: 'regex',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
-    },
+    }
   };
 }
 
-export function uuid(args: StringSchema['__uuid']): ValidationFallbackReturnType {
+export function uuid(args: NonNullable<StringSchema['__uuid']>): ValidationFallbackReturnType {
   // const uuidRegex =
   //   /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
-  const uuidRegex =
-    /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
+  const uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
   return {
+    name: 'uuid',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = uuidRegex.test(value);
 
       return {
@@ -180,20 +235,28 @@ export function uuid(args: StringSchema['__uuid']): ValidationFallbackReturnType
               {
                 isValid: false,
                 code: 'uuid',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
     }
-  }
+  };
 }
 
-export function email(args: StringSchema['__email']): ValidationFallbackReturnType {
+export function email(args: NonNullable<StringSchema['__email']>): ValidationFallbackReturnType {
   const emailRegex = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;
+  console.log('aquiiiiii');
   return {
+    name: 'email',
     type: 'low',
-    callback: async (value: any, path: (string | number)[], _options: Parameters<Schema['__transformToAdapter']>[0]) => {
+    // eslint-disable-next-line ts/require-await
+    callback: async (
+      value: any,
+      path: (string | number)[],
+      _options: Parameters<Schema['__transformToAdapter']>[0]
+    ) => {
       const isValid = emailRegex.test(value);
 
       return {
@@ -204,12 +267,12 @@ export function email(args: StringSchema['__email']): ValidationFallbackReturnTy
               {
                 isValid: false,
                 code: 'email',
+                // eslint-disable-next-line ts/no-unnecessary-condition
                 path: path || [],
-                message: args.message,
-              },
-            ],
+                message: args.message
+              }
+            ]
       };
     }
-  }
+  };
 }
-

package/src/validators/union.ts

@@ -5,11 +5,12 @@ export function unionValidation(
   schemas: readonly [Schema<any, any>, Schema<any, any>, ...Schema<any, any>[]]
 ): ValidationFallbackReturnType {
   return {
-    type: 'high',
+    name: 'union',
+    type: 'medium',
     callback: async (value, path, options) => {
       const parsedValues: Awaited<ReturnType<Schema['__parse']>> = {
         parsed: value,
-        errors: [],
+        errors: []
       };
       const startingToInternalBubbleUpLength = options.toInternalToBubbleUp?.length || 0;
 
@@ -31,22 +32,21 @@ export function unionValidation(
         if (hasNoErrorsSoItsAValidSchemaAndShouldResetOldErrors) {
           return {
             parsed: parsedValues.parsed,
-            errors: [],
+            errors: []
           };
         } else if (startingToInternalBubbleUpLength < (options.toInternalToBubbleUp?.length || 0)) {
-          // If there is a new toInternalToBubbleUp we should remove the ones that we added since this is not a valid schema,
-          // we shouldn't be calling the `toInternal` on that schemas.
+          // If there is a new toInternalToBubbleUp we should remove the ones that we added since this is not a
+          // valid schema, we shouldn't be calling the `toInternal` on that schemas.
           const numberOfElementsToRemove =
             (options.toInternalToBubbleUp?.length || 0) - startingToInternalBubbleUpLength;
           options.toInternalToBubbleUp?.splice(startingToInternalBubbleUpLength, numberOfElementsToRemove);
         }
       }
-
       return {
         parsed: parsedValues.parsed,
         // eslint-disable-next-line ts/no-unnecessary-condition
-        errors: parsedValues.errors ? parsedValues.errors : [],
+        errors: Array.isArray(parsedValues.errors) ? parsedValues.errors : []
       };
-    },
+    }
   };
 }

package/src/validators/utils.ts

@@ -4,13 +4,13 @@ import type Schema from '../schema/schema';
 import type {
   ValidationFallbackCallbackReturnType,
   ValidationFallbackCallbackType,
-  ValidationFallbackReturnType,
+  ValidationFallbackReturnType
 } from '../schema/types';
 
 const priorityByType = {
   low: 0,
   medium: 1,
-  high: 2,
+  high: 2
 };
 
 const typeByPriority = Object.entries(priorityByType).reduce(
@@ -22,24 +22,30 @@ const typeByPriority = Object.entries(priorityByType).reduce(
 );
 
 /**
- * Okay, so what is this? This is a validator class, it represents a Node on a linked list. The linked list has lower priority validators on the end of the list and higher
- * priority validators on the start of the list. Maybe in the future we can change that to a binary tree, but for now this is enough.
+ * Okay, so what is this? This is a validator class, it represents a Node on a linked list. The linked list
+ * has lower priority validators on the end of the list and higher priority validators on the start of the
+ * list. Maybe in the future we can change that to a binary tree, but for now this is enough.
  *
- * Why did we choose this approach? Because what i was doing was that i saw myself repeating the same code 3 times on the schema in order to make the validation work. Each validator had
- * a different return type, i didn't like that. I wanted to add more power and control on the validator, not on the schema. So i created this class. So pretty much, over here and
- * on each validator we can define the type it is. It can actually be three: `low`, `medium` and `high`. The `low` validators are the ones that are going to be executed last, the `high` validators
- * are the ones that are going to be executed first. High validators validate if the value is null or undefined, if it allows that. It can stop the execution of the other validators if it wants to.
+ * Why did we choose this approach? Because what i was doing was that i saw myself repeating the same code 3
+ * times on the schema in order to make the validation work. Each validator had  a different return type, i
+ * didn't like that. I wanted to add more power and control on the validator, not on the schema. So i created
+ * this class. So pretty much, over here and on each validator we can define the type it is. It can actually
+ * be three: `low`, `medium` and `high`. The `low` validators are the ones that are going to be executed last,
+ * The `high` validators are the ones that are going to be executed first. High validators validate if the value
+ * is null or undefined, if it allows that. It can stop the execution of the other validators if it wants to.
  *
- * Example: Let's say that the value is null, if the value is null, is there a reason to check if it's a number? No, right? So the high validator can stop the execution of the other validators.
- * Same as before, if the value is not a number, is there a reason to check if it's value is greater than the `max` allowed 10? No, right? So the medium validator can stop the execution of
- * the other validators.
+ * Example: Let's say that the value is null, if the value is null, is there a reason to check if it's a number?
+ * No, right? So the high validator can stop the execution of the other validators.
+ * Same as before, if the value is not a number, is there a reason to check if it's value is greater than the
+ * `max` allowed 10? No, right? So the medium validator can stop the execution of the other validators.
  *
- * That's what this solve, it's a better approach than repeating the same code 3 times on the schema. It's also more powerful, because if we need to add any extra priorities we can do that easily
- * without changing the schema.
+ * That's what this solve, it's a better approach than repeating the same code 3 times on the schema. It's also
+ * more powerful, because if we need to add any extra priorities we can do that easily without changing the schema.
  */
 export default class Validator {
   child?: Validator;
   parent?: Validator;
+  fallbackNamesAdded = new Set();
   priority: number;
   fallbacks: ((
     value: any,
@@ -57,19 +63,27 @@ export default class Validator {
   }>)[] = [];
 
   constructor(type: ValidatorTypes) {
+    this.fallbackNamesAdded = new Set();
+    this.fallbacks = [];
     this.priority = priorityByType[type];
   }
 
   /**
-   * We create all of the validators on the schema in order, i actually didn't want to go on that route but i found it easier to do so.
+   * We create all of the validators on the schema in order, i actually didn't want to go on that route but i
+   * found it easier to do so.
    *
-   * The logic here is simple, if it's not the same priority we will walk on the linked list until we find a validator that matches the priority we are expecting. If we can't walk anymore, we create
-   * the next priority validator and append it to the linked list. Be aware that it's a double linked list, so we can walk both ways, from the end to the start and from the start to the end.
-   * So you don't really need to start from the root, the linked list can start from anywhere and it will find it's way through.
+   * The logic here is simple, if it's not the same priority we will walk on the linked list until we find
+   * a validator that matches the priority we are expecting. If we can't walk anymore, we create the next
+   * priority validator and append it to the linked list. Be aware that it's a double linked list, so we
+   * can walk both ways, from the end to the start and from the start to the end.
+   * So you don't really need to start from the root, the linked list can start from anywhere and it will
+   * find it's way through.
    *
-   * I know there are better ways to do this instead of walking through the linked list, but like i explained before, this is enough for now.
+   * I know there are better ways to do this instead of walking through the linked list, but like i explained
+   * before, this is enough for now.
    *
-   * If the priority is higher than the current priority saved on the schema, we should substitute the rootValidator on the schema with the new one.
+   * If the priority is higher than the current priority saved on the schema, we should substitute the
+   * rootValidator on the schema with the new one.
    *
    * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema.
    * @param type - The type of the fallback that we are adding.
@@ -80,14 +94,15 @@ export default class Validator {
   private checkAppendOrCreate(
     schema: Schema,
     type: ValidatorTypes,
+    fallbackName: string,
     fallback: ValidationFallbackCallbackType,
     childOrParent: 'child' | 'parent',
     options?: Parameters<(typeof Validator)['createAndAppendFallback']>[2]
   ) {
-
     const schemaWithProtected = schema as Schema & { __rootFallbacksValidator?: Schema['__rootFallbacksValidator'] };
 
-    if (this[childOrParent]) (this as any)[childOrParent].addFallback(schemaWithProtected, type, fallback, options);
+    if (this[childOrParent])
+      (this as any)[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
     else {
       const nextPriority = childOrParent === 'child' ? this.priority - 1 : this.priority + 1;
       if (Object.keys(typeByPriority).includes(String(nextPriority))) {
@@ -96,7 +111,7 @@ export default class Validator {
         const validatorInstance = new Validator(nextType);
         this[childOrParent] = validatorInstance;
         (this as any)[childOrParent][childOrParent === 'parent' ? 'child' : 'parent'] = this;
-        (this as any)[childOrParent].addFallback(schemaWithProtected, type, fallback, options);
+        (this as any)[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
         if (nextPriority > schemaWithProtected.__rootFallbacksValidator.priority)
           schemaWithProtected.__rootFallbacksValidator = validatorInstance;
       }
@@ -106,23 +121,29 @@ export default class Validator {
   addFallback(
     schema: Schema,
     type: ValidatorTypes,
+    fallbackName: string,
     fallback: ValidationFallbackCallbackType,
     options?: Parameters<(typeof Validator)['createAndAppendFallback']>[2]
   ) {
+    if (this.fallbackNamesAdded.has(fallbackName) && options?.removeCurrent !== true) return;
+    this.fallbackNamesAdded.add(fallbackName);
     const priority = priorityByType[type];
     if (this.priority === priority) {
       if (typeof options?.at === 'number')
         this.fallbacks.splice(options.at, options.removeCurrent === true ? 1 : 0, fallback);
       else this.fallbacks.push(fallback);
-    } else if (priority > this.priority) this.checkAppendOrCreate(schema, type, fallback, 'parent', options);
-    else if (priority < this.priority) this.checkAppendOrCreate(schema, type, fallback, 'child', options);
+    } else if (priority > this.priority)
+      this.checkAppendOrCreate(schema, type, fallbackName, fallback, 'parent', options);
+    else if (priority < this.priority) this.checkAppendOrCreate(schema, type, fallbackName, fallback, 'child', options);
   }
 
   /**
-   * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest priority to the lowest priority.
-   * A validator can stop the execution of the other validators if it feels like so. Like on the example of a value being null or undefined.
+   * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest
+   * priority to the lowest priority. A validator can stop the execution of the other validators if it feels
+   * like so. Like on the example of a value being null or undefined.
    *
-   * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is used to avoid duplicated errors.
+   * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is
+   * used to avoid duplicated errors.
    * @param path - The path that we are validating right now.
    * @param parseResult - The result of the parsing, it contains the parsed value and the errors that we found.
    * @param options - The options that we are passing to the fallback.
@@ -143,34 +164,38 @@ export default class Validator {
       parseResult.parsed = parsed;
       for (const error of errors) {
         if (error.isValid === false) {
-          const hashedError = JSON.stringify(error);
+          const sortedError = Object.fromEntries(Object.entries(error).sort(([a], [b]) => a.localeCompare(b)));
+
+          const hashedError = JSON.stringify(sortedError);
           if (errorsAsHashedSet.has(hashedError)) continue;
+          errorsAsHashedSet.add(hashedError);
           if (!Array.isArray(parseResult.errors)) parseResult.errors = [];
-          parseResult.errors.push(error);
+          parseResult.errors.push({
+            ...error,
+            received: parseResult.parsed
+          });
         }
       }
       doesItShouldPreventChildValidation = doesItShouldPreventChildValidation || preventChildValidation || false;
     }
 
     if (this.child && doesItShouldPreventChildValidation === false)
-      return this.child.validate(
-        errorsAsHashedSet,
-        path,
-        parseResult,
-        options
-      );
+      return await this.child.validate(errorsAsHashedSet, path, parseResult, options);
 
     return parseResult as unknown as Promise<ValidationFallbackCallbackReturnType>;
   }
 
   /**
-   * This static method takes care of everything for you. This means that you should only call this method for appending new fallbacks, it takes care of creating the root validator
-   * and making sure that the rootValidator on the schema is the highest priority one.
+   * This static method takes care of everything for you. This means that you should only call this method
+   * for appending new fallbacks, it takes care of creating the root validator and making sure that the
+   * rootValidator on the schema is the highest priority one.
    *
-   * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema. We automatically define the rootValidator on the schema
-   * so you don't need to worry about that.
-   * @param fallback - The fallback that we are adding. This is an object that contains the type of the fallback and the callback that we are adding.
-   * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent` are passed to the `addFallback` method.
+   * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific
+   * schema. We automatically define the rootValidator on the schema so you don't need to worry about that.
+   * @param fallback - The fallback that we are adding. This is an object that contains the type of the
+   * fallback and the callback that we are adding.
+   * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent`
+   * are passed to the `addFallback` method.
    */
   static createAndAppendFallback(
     schema: Schema<any, any>,
@@ -188,7 +213,7 @@ export default class Validator {
       validatorInstance = new Validator(fallback.type);
       schemaWithProtected.__rootFallbacksValidator = validatorInstance;
     }
-    validatorInstance.addFallback(schema, fallback.type, fallback.callback, options);
+    validatorInstance.addFallback(schema, fallback.type, fallback.name, fallback.callback, options);
     return validatorInstance;
   }