@cleverbrush/schema 1.0.0-beta.5 → 1.1.0

package/src/validators/validateFunction.ts

@@ -1,25 +0,0 @@
-import { FunctionSchema, ValidationResult } from '../schema.js';
-
-export const validateFunction = async (
-    obj: any,
-    schema: FunctionSchema
-): Promise<ValidationResult> => {
-    if (
-        typeof obj === 'undefined' &&
-        typeof schema === 'object' &&
-        schema.isRequired === false
-    ) {
-        return {
-            valid: true
-        };
-    }
-    if (typeof obj !== 'function')
-        return {
-            valid: false,
-            errors: [`expected type function, but saw ${typeof obj}`]
-        };
-
-    return {
-        valid: true
-    };
-};

package/src/validators/validateNumber.ts

@@ -1,82 +0,0 @@
-import { NumberSchema, ValidationResult } from '../schema.js';
-
-export const validateNumber = async (
-    obj: any,
-    schema: NumberSchema
-): Promise<ValidationResult> => {
-    if (
-        typeof obj === 'undefined' &&
-        typeof schema === 'object' &&
-        schema.isRequired === false
-    ) {
-        return {
-            valid: true
-        };
-    }
-    if (typeof obj !== 'number')
-        return {
-            valid: false,
-            errors: [`expected type number, but saw ${typeof obj}`]
-        };
-
-    if (typeof schema === 'number') {
-        return obj === schema
-            ? { valid: true }
-            : {
-                  valid: false,
-                  errors: [`should be equal to ${schema}`]
-              };
-    }
-
-    const num = obj as number;
-
-    if (schema.ensureNotNaN && Number.isNaN(num)) {
-        return {
-            valid: false,
-            errors: ['is not expected to be NaN']
-        };
-    }
-
-    if (
-        schema.ensureIsFinite &&
-        !Number.isFinite(num) &&
-        schema.ensureNotNaN &&
-        !Number.isNaN(num)
-    ) {
-        return {
-            valid: false,
-            errors: ['is expected to be a finite number']
-        };
-    }
-
-    if (typeof schema.equals !== 'undefined' && num !== schema.equals) {
-        return {
-            valid: false,
-            errors: [`expected to be equal to ${schema.equals}`]
-        };
-    }
-
-    if (typeof schema.min !== 'undefined') {
-        if (typeof schema.min !== 'number')
-            throw new Error('min constraint should be a number');
-        if (num < schema.min)
-            return {
-                valid: false,
-                errors: [`expected to be at least ${schema.min}`]
-            };
-    }
-
-    if (typeof schema.max !== 'undefined') {
-        if (typeof schema.max !== 'number')
-            throw new Error('max constraint should be a number');
-        if (num > schema.max)
-            return {
-                valid: false,
-                errors: [`expected to be no more than ${schema.max}`]
-            };
-    }
-
-    return {
-        valid: true
-    };
-};

package/src/validators/validateObject.ts

@@ -1,119 +0,0 @@
-import { ObjectSchema, Schema, ValidationResult } from '../schema.js';
-import SchemaRegistry from '../schemaRegistry.js';
-
-export const validateObject = async (
-    obj: any,
-    schema: ObjectSchema<any>,
-    validator: SchemaRegistry<any>
-): Promise<ValidationResult> => {
-    if (
-        typeof obj === 'undefined' &&
-        typeof schema === 'object' &&
-        schema.isRequired === false
-    ) {
-        return {
-            valid: true
-        };
-    }
-    if (typeof obj !== 'object') {
-        return {
-            valid: false,
-            errors: [
-                `expected to have type='object', but saw '${typeof obj}' instead`
-            ]
-        };
-    }
-
-    if (typeof schema.preprocessors === 'object' && schema.preprocessors) {
-        await Promise.all(
-            Object.keys(schema.preprocessors).map(async (key: string) => {
-                if (key === '*') return;
-                if (typeof schema.preprocessors[key] === 'function') {
-                    const res = await Promise.resolve(
-                        (schema.preprocessors[key] as any)(obj[key])
-                    );
-                    if (typeof res !== 'undefined') {
-                        obj[key] = res;
-                    } else {
-                        delete obj[key];
-                    }
-                } else {
-                    const preprocessor = validator.preprocessors.get(
-                        schema.preprocessors[key] as string
-                    );
-                    if (typeof preprocessor !== 'function') {
-                        throw new Error(
-                            `preprocessor '${schema.preprocessors[key]}' is unknown`
-                        );
-                    }
-                    const res = await Promise.resolve(preprocessor(obj[key]));
-                    if (typeof res !== 'undefined') {
-                        obj[key] = res;
-                    } else {
-                        delete obj[key];
-                    }
-                }
-            })
-        );
-        if ('*' in schema.preprocessors) {
-            const objectPreprocessor = schema.preprocessors['*'];
-            if (typeof objectPreprocessor === 'function') {
-                await Promise.resolve((objectPreprocessor as any)(obj));
-            } else {
-                const preprocessor = validator.preprocessors.get(
-                    objectPreprocessor as string
-                );
-                if (typeof preprocessor !== 'function') {
-                    throw new Error(
-                        `preprocessor '${objectPreprocessor}' is unknown`
-                    );
-                }
-                await Promise.resolve(preprocessor(obj));
-            }
-        }
-    }
-
-    if (typeof schema.properties === 'object' && schema.properties) {
-        const errors = [
-            ...(await Promise.all(
-                Object.entries(schema.properties).map(
-                    async ([name, schema]: [string, Schema]) => {
-                        const result = await validator.validate(
-                            schema,
-                            obj[name]
-                        );
-                        if (result.valid) return result;
-                        return {
-                            valid: false,
-                            errors: (result.errors || []).map(
-                                (e) => `->${name} ${e}`
-                            )
-                        };
-                    }
-                )
-            )),
-            ...(schema.noUnknownProperties === false
-                ? []
-                : Object.keys(obj)
-                      .filter((k) => !(k in schema.properties))
-                      .map((k) => ({
-                          valid: false,
-                          errors: [`-> ${k} - unknown field`]
-                      })))
-        ]
-            .filter((r) => !r.valid)
-            .map((r) => r.errors)
-            .flat(Infinity) as string[];
-
-        if (errors.length) {
-            return {
-                valid: false,
-                errors
-            };
-        }
-    }
-
-    return {
-        valid: true
-    };
-};

package/src/validators/validateString.ts

@@ -1,59 +0,0 @@
-import { StringSchema, ValidationResult } from '../schema.js';
-
-export const validateString = async (
-    obj: any,
-    schema: StringSchema
-): Promise<ValidationResult> => {
-    if (
-        typeof obj === 'undefined' &&
-        typeof schema === 'object' &&
-        schema.isRequired === false
-    ) {
-        return {
-            valid: true
-        };
-    }
-    if (typeof obj !== 'string')
-        return {
-            valid: false,
-            errors: [`expected type string, but saw ${typeof obj}`]
-        };
-
-    if (typeof schema === 'string') {
-        return obj === schema
-            ? { valid: true }
-            : {
-                  valid: false,
-                  errors: [`should be equal to ${schema}`]
-              };
-    }
-
-    const str = obj as string;
-
-    if (typeof schema.equals === 'string' && str !== schema.equals) {
-        return {
-            valid: false,
-            errors: [
-                `expected to be equal to '${schema.equals}' but saw '${str}'`
-            ]
-        };
-    }
-
-    if (typeof schema.minLength === 'number' && str.length < schema.minLength) {
-        return {
-            valid: false,
-            errors: [`expected to be at least ${schema.minLength} chars long`]
-        };
-    }
-
-    if (typeof schema.maxLength === 'number' && str.length > schema.maxLength) {
-        return {
-            valid: false,
-            errors: [`expected to be at most ${schema.maxLength} chars long`]
-        };
-    }
-
-    return {
-        valid: true
-    };
-};

package/src/validators/validateUnion.ts

@@ -1,36 +0,0 @@
-import { UnionSchema, ValidationResult } from '../schema.js';
-import SchemaRegistry from '../schemaRegistry.js';
-
-export const validateUnion = async (
-    obj: any,
-    schema: UnionSchema<any>,
-    validator: SchemaRegistry<any>
-): Promise<ValidationResult> => {
-    if (typeof obj === 'undefined' && schema.isRequired === false) {
-        return {
-            valid: true
-        };
-    }
-
-    if (obj === null && schema.isNullable) {
-        return {
-            valid: true
-        };
-    }
-
-    if (Array.isArray(schema.variants) && schema.variants.length > 0) {
-        for (let i = 0; i < schema.variants.length; i++) {
-            const variant = schema.variants[i];
-            const result = await validator.validate(variant, obj);
-            if (result.valid) {
-                return result;
-            }
-        }
-        return {
-            valid: false,
-            errors: ['object does not satisfy any scheme']
-        };
-    }
-
-    throw new Error('variants should be non empty array');
-};

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "declaration": true,
-        "target": "esnext",
-        "module": "CommonJS",
-        "esModuleInterop": true,
-        "allowSyntheticDefaultImports": true,
-        "moduleResolution": "Node"
-    },
-    "files": ["./src/index.ts"],
-    "watchOptions": {
-        "excludeDirectories": ["./dist"]
-    }
-}