@cleverbrush/schema 0.0.17 → 1.0.0-beta.1

package/dist/validators/validateNumber.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateNumber = void 0;
-const validateNumber = async (obj, schema, validator) => {
-    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;
-    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
-    };
-};
-exports.validateNumber = validateNumber;

package/dist/validators/validateObject.d.ts

@@ -1,2 +0,0 @@
-import { ValidationResult, ObjectSchemaDefinition, ISchemaValidator } from '../index';
-export declare const validateObject: (obj: any, schema: ObjectSchemaDefinition<any>, validator: ISchemaValidator<any, unknown[]>) => Promise<ValidationResult>;

package/dist/validators/validateObject.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateObject = void 0;
-const validateObject = async (obj, schema, validator) => {
-    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) => {
-            if (key === '*')
-                return;
-            if (typeof schema.preprocessors[key] === 'function') {
-                obj[key] = await Promise.resolve(schema.preprocessors[key](obj[key]));
-            }
-            else {
-                const preprocessor = validator.preprocessors.get(schema.preprocessors[key]);
-                if (typeof preprocessor !== 'function') {
-                    throw new Error(`preprocessor '${schema.preprocessors[key]}' is unknown`);
-                }
-                obj[key] = await Promise.resolve(preprocessor(obj[key]));
-            }
-        }));
-        if ('*' in schema.preprocessors) {
-            const objectPreprocessor = schema.preprocessors['*'];
-            if (typeof objectPreprocessor === 'function') {
-                await Promise.resolve(objectPreprocessor(obj));
-            }
-            else {
-                const preprocessor = validator.preprocessors.get(objectPreprocessor);
-                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]) => {
-            const result = await validator.validate(schema, obj[name]);
-            if (result.valid)
-                return result;
-            return {
-                valid: false,
-                errors: (result.errors || []).map((e) => `->${name} ${e}`)
-            };
-        })))
-            .filter((r) => !r.valid)
-            .map((r) => r.errors)
-            .flat(Infinity);
-        if (errors.length) {
-            return {
-                valid: false,
-                errors
-            };
-        }
-    }
-    return {
-        valid: true
-    };
-};
-exports.validateObject = validateObject;

package/dist/validators/validateString.d.ts

@@ -1,2 +0,0 @@
-import { ValidationResult, StringSchemaDefinition, ISchemaValidator } from '../index';
-export declare const validateString: (obj: any, schema: StringSchemaDefinition<any>, validator: ISchemaValidator<any>) => Promise<ValidationResult>;

package/dist/validators/validateString.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateString = void 0;
-const validateString = async (obj, schema, validator) => {
-    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;
-    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
-    };
-};
-exports.validateString = validateString;