@palmares/schemas 0.1.25 → 0.2.0

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

@@ -1,202 +0,0 @@
-export function stringValidation() {
-    return {
-        name: 'string',
-        type: 'medium',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            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) {
-    return {
-        name: 'maxLength',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            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) {
-    return {
-        name: 'minLength',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            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) {
-    return {
-        name: 'endsWith',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            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) {
-    return {
-        name: 'startsWith',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            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) {
-    return {
-        name: 'includes',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            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) {
-    return {
-        name: 'regex',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            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) {
-    // 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, path, _options)=>{
-            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) {
-    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, path, _options)=>{
-            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/dist/esm/src/validators/types.js

@@ -1 +0,0 @@
-export { };

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

@@ -1,39 +0,0 @@
-export function unionValidation(schemas) {
-    return {
-        name: 'union',
-        type: 'medium',
-        callback: async (value, path, options)=>{
-            const parsedValues = {
-                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];
-                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/dist/esm/src/validators/utils.js

@@ -1,147 +0,0 @@
-const priorityByType = {
-    low: 0,
-    medium: 1,
-    high: 2
-};
-const typeByPriority = Object.entries(priorityByType).reduce((acc, [key, value])=>{
-    acc[value] = key;
-    return acc;
-}, {});
-/**
- * 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 {
-    $$type = '$PValidator';
-    child;
-    parent;
-    fallbackNamesAdded = new Set();
-    priority;
-    fallbacks = [];
-    constructor(type){
-        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.
-   */ checkAppendOrCreate(schema, type, fallbackName, fallback, childOrParent, options) {
-        const schemaWithProtected = schema;
-        if (this[childOrParent]) this[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[childOrParent][childOrParent === 'parent' ? 'child' : 'parent'] = this;
-                this[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
-                if (nextPriority > schemaWithProtected.__rootFallbacksValidator.priority) schemaWithProtected.__rootFallbacksValidator = validatorInstance;
-            }
-        }
-    }
-    addFallback(schema, type, fallbackName, fallback, options) {
-        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, path, parseResult, options) {
-        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;
-    }
-    /**
-   * 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, fallback, options) {
-        const schemaWithProtected = schema;
-        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) {
-        return `Priority: ${this.priority}\nFallbacks: ${this.fallbacks.length}\n${this.child ? `Children:\n${this.child.toString(ident + 2)}` : ''}`;
-    }
-}