@palmares/schemas 0.1.20 → 0.1.22

package/src/validators/string.ts

@@ -1,278 +0,0 @@
-import { type ValidationFallbackReturnType } from '../schema/types';
-
-import type { Schema } from '../schema/schema';
-import type { StringSchema } from '../schema/string';
-
-export function stringValidation(): ValidationFallbackReturnType {
-  return {
-    name: 'string',
-    type: 'medium',
-    // eslint-disable-next-line ts/require-await
-    callback: async (
-      value: any,
-      path: (string | number)[],
-      _options: Parameters<Schema['__transformToAdapter']>[0]
-    ) => {
-      return {
-        parsed: value,
-        errors:
-          typeof value === 'string'
-            ? []
-            : [
-                {
-                  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
-                }
-              ]
-      };
-    }
-  };
-}
-
-export function maxLength(args: NonNullable<StringSchema['__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]
-    ) => {
-      const isValid = value.length <= args.value;
-
-      return {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'maxLength',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}
-
-export function minLength(args: NonNullable<StringSchema['__maxLength']>): 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]
-    ) => {
-      const isValid = value.length >= args.value;
-
-      return {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'minLength',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}
-
-export function endsWith(args: NonNullable<StringSchema['__endsWith']>): ValidationFallbackReturnType {
-  return {
-    name: 'endsWith',
-    type: 'low',
-    // 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 {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'endsWith',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}
-
-export function startsWith(args: NonNullable<StringSchema['__startsWith']>): ValidationFallbackReturnType {
-  return {
-    name: 'startsWith',
-    type: 'low',
-    // 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 {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'startsWith',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}
-
-export function includes(args: NonNullable<StringSchema['__includes']>): ValidationFallbackReturnType {
-  return {
-    name: 'includes',
-    type: 'low',
-    // 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 {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'includes',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}
-
-export function regex(args: NonNullable<StringSchema['__regex']>): ValidationFallbackReturnType {
-  return {
-    name: 'regex',
-    type: 'low',
-    // 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 {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'regex',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}
-
-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;
-  return {
-    name: 'uuid',
-    type: 'low',
-    // 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 {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'uuid',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}
-
-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',
-    // 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 {
-        parsed: value,
-        errors: isValid
-          ? []
-          : [
-              {
-                isValid: false,
-                code: 'email',
-                // eslint-disable-next-line ts/no-unnecessary-condition
-                path: path || [],
-                message: args.message
-              }
-            ]
-      };
-    }
-  };
-}

package/src/validators/types.ts

@@ -1 +0,0 @@
-export type ValidatorTypes = 'low' | 'medium' | 'high';

package/src/validators/union.ts

@@ -1,52 +0,0 @@
-import type { Schema } from '../schema/schema';
-import type { ValidationFallbackReturnType } from '../schema/types';
-
-export function unionValidation(
-  schemas: readonly [Schema<any, any>, Schema<any, any>, ...Schema<any, any>[]]
-): ValidationFallbackReturnType {
-  return {
-    name: 'union',
-    type: 'medium',
-    callback: async (value, path, options) => {
-      const parsedValues: Awaited<ReturnType<Schema['__parse']>> = {
-        parsed: value,
-        errors: []
-      };
-      const startingToInternalBubbleUpLength = options.toInternalToBubbleUp?.length || 0;
-
-      // eslint-disable-next-line ts/prefer-for-of
-      for (let i = 0; i < schemas.length; i++) {
-        const schemaWithProtected = schemas[i] as Schema & {
-          __parse: Schema['__parse'];
-          __toInternal: Schema['__toInternal'];
-        };
-        const parsedData = await schemaWithProtected.__parse(value, path, options);
-        parsedValues.parsed = parsedData.parsed;
-        if (Array.isArray(parsedData.errors))
-          if (Array.isArray(parsedValues.errors)) parsedValues.errors.push(...parsedData.errors);
-          else parsedValues.errors = parsedData.errors;
-
-        const hasNoErrorsSoItsAValidSchemaAndShouldResetOldErrors =
-          // eslint-disable-next-line ts/no-unnecessary-condition
-          parsedData.errors === undefined || (parsedData.errors || []).length === 0;
-        if (hasNoErrorsSoItsAValidSchemaAndShouldResetOldErrors) {
-          return {
-            parsed: parsedValues.parsed,
-            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.
-          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: Array.isArray(parsedValues.errors) ? parsedValues.errors : []
-      };
-    }
-  };
-}

package/src/validators/utils.ts

@@ -1,225 +0,0 @@
-import type { ValidatorTypes } from './types';
-import type { ErrorCodes } from '../adapter/types';
-import type { Schema } from '../schema/schema';
-import type {
-  ValidationFallbackCallbackReturnType,
-  ValidationFallbackCallbackType,
-  ValidationFallbackReturnType
-} from '../schema/types';
-
-const priorityByType = {
-  low: 0,
-  medium: 1,
-  high: 2
-};
-
-const typeByPriority = Object.entries(priorityByType).reduce(
-  (acc, [key, value]) => {
-    acc[value] = key as ValidatorTypes;
-    return acc;
-  },
-  {} as { [key: number]: ValidatorTypes }
-);
-
-/**
- * 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.
- *
- * 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.
- */
-export class Validator {
-  child?: Validator;
-  parent?: Validator;
-  fallbackNamesAdded = new Set();
-  priority: number;
-  fallbacks: ((
-    value: any,
-    path: (string | number)[],
-    options: Parameters<Schema['__transformToAdapter']>[0]
-  ) => Promise<{
-    parsed: any;
-    errors: {
-      isValid: boolean;
-      code: ErrorCodes;
-      message: string;
-      path: (string | number)[];
-    }[];
-    preventChildValidation?: boolean;
-  }>)[] = [];
-
-  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.
-   *
-   * 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.
-   *
-   * 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.
-   * @param fallback - The fallback function that we are adding.
-   * @param childOrParent - If we are adding a fallback to the child or to the parent.
-   * @param options - The options that we are passing to the fallback.
-   */
-  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, fallbackName, fallback, options);
-    else {
-      const nextPriority = childOrParent === 'child' ? this.priority - 1 : this.priority + 1;
-      if (Object.keys(typeByPriority).includes(String(nextPriority))) {
-        const nextType = typeByPriority[nextPriority];
-
-        const validatorInstance = new Validator(nextType);
-        this[childOrParent] = validatorInstance;
-        (this as any)[childOrParent][childOrParent === 'parent' ? 'child' : 'parent'] = this;
-        (this as any)[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
-        if (nextPriority > schemaWithProtected.__rootFallbacksValidator.priority)
-          schemaWithProtected.__rootFallbacksValidator = validatorInstance;
-      }
-    }
-  }
-
-  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, 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.
-   *
-   * @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.
-   */
-  async validate(
-    errorsAsHashedSet: Set<string>,
-    path: ValidationFallbackCallbackReturnType['errors'][number]['path'],
-    parseResult: {
-      errors: undefined | ValidationFallbackCallbackReturnType['errors'];
-      parsed: any;
-    },
-    options: Parameters<Schema['__transformToAdapter']>[0]
-  ): Promise<ValidationFallbackCallbackReturnType> {
-    let doesItShouldPreventChildValidation = false;
-
-    for (const fallback of this.fallbacks) {
-      const { parsed, errors, preventChildValidation } = await fallback(parseResult.parsed, path, options);
-      parseResult.parsed = parsed;
-      for (const error of errors) {
-        if (error.isValid === false) {
-          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,
-            received: parseResult.parsed
-          });
-        }
-      }
-      doesItShouldPreventChildValidation = doesItShouldPreventChildValidation || preventChildValidation || false;
-    }
-
-    if (this.child && doesItShouldPreventChildValidation === false)
-      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.
-   *
-   * @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>,
-    fallback: ValidationFallbackReturnType,
-    options?: {
-      at?: number;
-      removeCurrent?: boolean;
-    }
-  ) {
-    const schemaWithProtected = schema as Schema & { __rootFallbacksValidator?: Schema['__rootFallbacksValidator'] };
-
-    let validatorInstance = schemaWithProtected.__rootFallbacksValidator;
-    // eslint-disable-next-line ts/no-unnecessary-condition
-    if (schemaWithProtected.__rootFallbacksValidator === undefined) {
-      validatorInstance = new Validator(fallback.type);
-      schemaWithProtected.__rootFallbacksValidator = validatorInstance;
-    }
-    validatorInstance.addFallback(schema, fallback.type, fallback.name, fallback.callback, options);
-    return validatorInstance;
-  }
-
-  toString(ident = 0): string {
-    return `Priority: ${this.priority}\nFallbacks: ${this.fallbacks.length}\n${
-      this.child ? `Children:\n${this.child.toString(ident + 2)}` : ''
-    }`;
-  }
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "outDir": "./dist",
-    "types": ["node"]
-  },
-  "include": ["src/**/*"]
-}

package/tsconfig.types.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../build/tsconfig.types.json",
-  "compilerOptions": {
-    "declaration": true, /* Generate d.ts files */
-    "rootDir": "./src",
-    "outDir": "./dist/cjs/types",
-    "types": ["node"]
-  },
-  "include": ["src/**/*"]
-}