@palmares/schemas 0.1.24 → 0.1.26

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

@@ -1,140 +0,0 @@
-export function arrayValidation(isTuple, schemas) {
-    return {
-        name: 'array',
-        type: 'medium',
-        callback: async (value, path, options)=>{
-            const isNotAnArray = Array.isArray(value) === false;
-            if (isNotAnArray) return {
-                parsed: value,
-                preventChildValidation: true,
-                errors: [
-                    {
-                        isValid: false,
-                        code: 'array',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: 'The value must be an array. Received: ' + typeof value
-                    }
-                ]
-            };
-            if (isTuple && value.length !== schemas.length) return {
-                parsed: value,
-                preventChildValidation: true,
-                errors: [
-                    {
-                        isValid: false,
-                        code: 'tuple',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: 'The tuple must have exactly ' + schemas.length + ' elements. Received: ' + value.length
-                    }
-                ]
-            };
-            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,
-            // if the value is a number we can skip checking at index 0.
-            const schemaIndexByTypeof = new Map();
-            let parsedValues = [];
-            parsedValues = await Promise.all(value.map(async (element, index)=>{
-                let errorsToAppendAfterLoopIfNoSchemaMatched = [];
-                const typeofElement = typeof element;
-                const schemaIndex = schemaIndexByTypeof.get(typeofElement);
-                const existsASchemaIndex = typeof schemaIndex === 'number';
-                const schemasToValidateAgainst = isTuple ? [
-                    schemas[index]
-                ] : existsASchemaIndex ? [
-                    schemas[schemaIndex]
-                ] : schemas;
-                for(let indexOfSchema = 0; indexOfSchema < schemasToValidateAgainst.length; indexOfSchema++){
-                    const schemaToValidate = schemasToValidateAgainst[indexOfSchema];
-                    const schemaWithProtected = schemaToValidate;
-                    const { parsed, errors } = await schemaWithProtected.__parse(element, [
-                        ...path,
-                        index
-                    ], options);
-                    if (schemaWithProtected.__toInternal && options.toInternalToBubbleUp) options.toInternalToBubbleUp.push(async ()=>parsedValues[indexOfSchema] = await schemaWithProtected.__toInternal?.(parsed));
-                    // eslint-disable-next-line ts/no-unnecessary-condition
-                    if ((errors || []).length <= 0) {
-                        errorsToAppendAfterLoopIfNoSchemaMatched = [];
-                        schemaIndexByTypeof.set(typeofElement, indexOfSchema);
-                        return parsed;
-                    }
-                    errorsToAppendAfterLoopIfNoSchemaMatched.push(...errors);
-                }
-                errorsOfArray.push(...errorsToAppendAfterLoopIfNoSchemaMatched);
-                return element;
-            }));
-            return {
-                parsed: parsedValues,
-                errors: errorsOfArray
-            };
-        }
-    };
-}
-export function minLength(args) {
-    return {
-        name: 'minLength',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = args.inclusive ? value.length >= args.value : 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 maxLength(args) {
-    return {
-        name: 'maxLength',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = args.inclusive ? value.length <= args.value : 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 nonEmpty(args) {
-    return {
-        name: 'nonEmpty',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = value.length > 0;
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: false,
-                        code: 'nonEmpty',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: args.message
-                    }
-                ]
-            };
-        }
-    };
-}

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

@@ -1,37 +0,0 @@
-export function booleanValidation() {
-    return {
-        name: 'boolean',
-        type: 'medium',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = typeof value === 'boolean';
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: false,
-                        code: 'boolean',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: 'Value is not a boolean'
-                    }
-                ],
-                preventChildValidation: true
-            };
-        }
-    };
-}
-export function allowStringParser() {
-    return {
-        name: 'allowString',
-        type: 'high',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, _path, _options)=>{
-            const parsed = Boolean(value);
-            return {
-                parsed: parsed,
-                errors: []
-            };
-        }
-    };
-}

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

@@ -1,89 +0,0 @@
-export function datetimeValidation() {
-    return {
-        name: 'datetime',
-        type: 'medium',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = value instanceof Date && !isNaN(value.getTime());
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: false,
-                        code: 'datetime',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: 'Value is not a date'
-                    }
-                ],
-                preventChildValidation: true
-            };
-        }
-    };
-}
-export function allowStringParser() {
-    return {
-        name: 'allowString',
-        type: 'high',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, _path, _options)=>{
-            if (typeof value === 'string') {
-                const parsed = new Date(value);
-                if (parsed instanceof Date && !isNaN(parsed.getTime())) {
-                    return {
-                        parsed: parsed,
-                        errors: []
-                    };
-                }
-            }
-            return {
-                parsed: value,
-                errors: []
-            };
-        }
-    };
-}
-export function below(args) {
-    return {
-        name: 'below',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = args.inclusive ? value <= args.value : value < args.value;
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: false,
-                        code: 'below',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: args.message
-                    }
-                ]
-            };
-        }
-    };
-}
-export function above(args) {
-    return {
-        name: 'above',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = args.inclusive ? value <= args.value : value < args.value;
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: false,
-                        code: 'above',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: args.message
-                    }
-                ]
-            };
-        }
-    };
-}

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

@@ -1,148 +0,0 @@
-export function numberValidation() {
-    return {
-        name: 'number',
-        type: 'medium',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            return {
-                parsed: value,
-                errors: [
-                    {
-                        isValid: typeof value === 'number',
-                        code: 'number',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: 'The value must be a number. Received: ' + typeof value
-                    }
-                ]
-            };
-        }
-    };
-}
-export function max(args) {
-    return {
-        name: 'max',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            if (args.inclusive) return {
-                parsed: value,
-                errors: [
-                    {
-                        isValid: value <= args.value,
-                        code: 'max',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: args.message
-                    }
-                ]
-            };
-            return {
-                parsed: value,
-                errors: [
-                    {
-                        isValid: value < args.value,
-                        code: 'max',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: args.message
-                    }
-                ]
-            };
-        }
-    };
-}
-export function min(args) {
-    return {
-        name: 'min',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            if (args.inclusive) return {
-                parsed: value,
-                errors: [
-                    {
-                        isValid: value >= args.value,
-                        message: args.message,
-                        code: 'min',
-                        path: path || []
-                    }
-                ]
-            };
-            return {
-                parsed: value,
-                errors: [
-                    {
-                        isValid: value > args.value,
-                        message: args.message,
-                        code: 'min',
-                        path: path || []
-                    }
-                ]
-            };
-        }
-    };
-}
-export function integer(args) {
-    return {
-        name: 'integer',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            const isValid = Number.isInteger(value);
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: isValid,
-                        message: args.message,
-                        code: 'integer',
-                        path: path || []
-                    }
-                ]
-            };
-        }
-    };
-}
-export function maxDigits(args) {
-    return {
-        name: 'maxDigits',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            const isValid = value.toString().replace('.', '').length <= args.value;
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: isValid,
-                        message: args.message,
-                        code: 'maxDigits',
-                        path: path || []
-                    }
-                ]
-            };
-        }
-    };
-}
-export function decimalPlaces(args) {
-    return {
-        name: 'decimalPlaces',
-        type: 'low',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            const isValid = value.toString().split('.')[1]?.length <= args.value;
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: isValid,
-                        message: args.message,
-                        code: 'decimalPlaces',
-                        path: path || []
-                    }
-                ]
-            };
-        }
-    };
-}

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

@@ -1,39 +0,0 @@
-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;
-            if (isNotAnObject) return {
-                parsed: value,
-                preventChildValidation: true,
-                errors: [
-                    {
-                        isValid: false,
-                        code: 'object',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: 'The value must be an object. Received: ' + typeof value
-                    }
-                ]
-            };
-            const errors = {};
-            const toValidateEntries = Object.entries(keysToFallback);
-            await Promise.all(toValidateEntries.map(async ([key, schema])=>{
-                const schemaWithProtected = schema;
-                const { parsed, errors: parseErrors } = await schemaWithProtected.__parse(value[key], [
-                    ...path,
-                    key
-                ], options);
-                if (Array.isArray(parseErrors) && parseErrors.length > 0) errors[key] = parseErrors;
-                else value[key] = parsed;
-                // We append the toInternalToBubbleUp to the parent toInternalToBubbleUp
-                if (schemaWithProtected.__toInternal && options.toInternalToBubbleUp) options.toInternalToBubbleUp.push(async ()=>value[key] = await schema.__toInternal(parsed));
-            }));
-            return {
-                parsed: value,
-                errors: Object.values(errors).flat()
-            };
-        }
-    };
-}

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

@@ -1,118 +0,0 @@
-export function optional(args) {
-    return {
-        name: 'optional',
-        type: 'high',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            if (value === undefined) {
-                if (args.allow === true) return {
-                    parsed: value,
-                    errors: [],
-                    preventChildValidation: true
-                };
-                return {
-                    parsed: value,
-                    errors: [
-                        {
-                            isValid: false,
-                            message: args.message,
-                            code: 'required',
-                            // eslint-disable-next-line ts/no-unnecessary-condition
-                            path: path || []
-                        }
-                    ],
-                    preventChildValidation: true
-                };
-            }
-            return {
-                parsed: value,
-                errors: [],
-                preventChildValidation: false
-            };
-        }
-    };
-}
-export function nullable(args) {
-    return {
-        name: 'nullable',
-        type: 'high',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            if (value === null) {
-                if (args.allow === true) return {
-                    parsed: value,
-                    errors: [],
-                    preventChildValidation: true
-                };
-                return {
-                    parsed: value,
-                    errors: [
-                        {
-                            isValid: false,
-                            message: args.message,
-                            code: 'null',
-                            // eslint-disable-next-line ts/no-unnecessary-condition
-                            path: path || []
-                        }
-                    ],
-                    preventChildValidation: true
-                };
-            }
-            return {
-                parsed: value,
-                errors: [],
-                preventChildValidation: false
-            };
-        }
-    };
-}
-export function checkType(args) {
-    return {
-        name: 'checkType',
-        type: 'medium',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path)=>{
-            if (args.check(value)) return {
-                parsed: value,
-                errors: [],
-                preventChildValidation: false
-            };
-            return {
-                parsed: value,
-                errors: [
-                    {
-                        isValid: false,
-                        message: args.message,
-                        code: 'invalid_type',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || []
-                    }
-                ],
-                preventChildValidation: true
-            };
-        }
-    };
-}
-export function is(args) {
-    return {
-        name: 'is',
-        type: 'medium',
-        // eslint-disable-next-line ts/require-await
-        callback: async (value, path, _options)=>{
-            const isValid = Array.isArray(args.value) ? args.value.includes(value) : value === args.value;
-            return {
-                parsed: value,
-                errors: isValid ? [] : [
-                    {
-                        isValid: false,
-                        code: 'is',
-                        // eslint-disable-next-line ts/no-unnecessary-condition
-                        path: path || [],
-                        message: 'Value is not a boolean'
-                    }
-                ],
-                preventChildValidation: true
-            };
-        }
-    };
-}