@palmares/schemas 0.0.1

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

@@ -0,0 +1,135 @@
+export function arrayValidation(isTuple, schemas) {
+    return {
+        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 {
+        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 {
+        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 {
+        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

@@ -0,0 +1,35 @@
+export function booleanValidation() {
+    return {
+        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 {
+        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

@@ -0,0 +1,85 @@
+export function datetimeValidation() {
+    return {
+        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 {
+        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 {
+        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 {
+        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

@@ -0,0 +1,162 @@
+export function numberValidation() {
+    return {
+        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 {
+        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 {
+        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 negative(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: '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',
+                        path: path || []
+                    }
+                ]
+            };
+        }
+    };
+}
+export function maxDigits(args) {
+    return {
+        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 {
+        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

@@ -0,0 +1,38 @@
+export function objectValidation(keysToFallback) {
+    return {
+        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

@@ -0,0 +1,114 @@
+export function optional(args) {
+    return {
+        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 {
+        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: 'cannot_be_null',
+                            // eslint-disable-next-line ts/no-unnecessary-condition
+                            path: path || []
+                        }
+                    ],
+                    preventChildValidation: true
+                };
+            }
+            return {
+                parsed: value,
+                errors: [],
+                preventChildValidation: false
+            };
+        }
+    };
+}
+export function checkType(args) {
+    return {
+        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 {
+        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
+            };
+        }
+    };
+}