@orion-js/schema 3.11.8 → 4.0.0-alpha.2

package/lib/getValidationErrors/getError/index.d.ts

@@ -1,2 +0,0 @@
-import { CurrentNodeInfo } from '../../types/schema';
-export default function getValidationErrors(params: CurrentNodeInfo): Promise<object | string | void>;

package/lib/getValidationErrors/getError/index.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const isNil_1 = __importDefault(require("lodash/isNil"));
-const getFieldValidator_1 = __importDefault(require("./getFieldValidator"));
-const fieldTypes_1 = __importDefault(require("../../fieldTypes"));
-const Errors_1 = __importDefault(require("../../Errors"));
-async function getValidationErrors(params) {
-    const { schema, doc, currentDoc, value, currentSchema, keys, options = {}, args = [] } = params;
-    const info = { schema, doc, currentDoc, keys, currentSchema, options };
-    if ((0, isNil_1.default)(value)) {
-        if (!currentSchema.optional && !options.omitRequired) {
-            return Errors_1.default.REQUIRED;
-        }
-    }
-    else {
-        const validatorKey = (0, getFieldValidator_1.default)(currentSchema.type);
-        const validator = validatorKey === 'custom' ? currentSchema.type : fieldTypes_1.default[validatorKey];
-        const error = await validator.validate(value, info, ...args);
-        if (error) {
-            return error;
-        }
-    }
-    // to not deprecate yet custom field
-    if (currentSchema.custom)
-        currentSchema.validate = currentSchema.custom;
-    if (currentSchema.validate) {
-        const customError = await currentSchema.validate(value, info, ...args);
-        if (customError) {
-            return customError;
-        }
-    }
-    const type = currentSchema.type;
-    if (type.__validate) {
-        const typeError = await type.__validate(value, info, ...args);
-        if (typeError) {
-            return typeError;
-        }
-    }
-    return null;
-}
-exports.default = getValidationErrors;

package/lib/getValidationErrors/getError/index.test.d.ts

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

package/lib/getValidationErrors/getError/index.test.js

@@ -1,52 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = __importDefault(require("./index"));
-const Errors_1 = __importDefault(require("../../Errors"));
-const fieldType_1 = __importDefault(require("../../fieldType"));
-test('pass a simple string validation', async () => {
-    const error = await (0, index_1.default)({ value: 'A valid string', currentSchema: { type: String } });
-    expect(error).toBeNull();
-});
-test('detect required field when value is null', async () => {
-    const error = await (0, index_1.default)({ value: null, currentSchema: { type: String } });
-    expect(error).toBe(Errors_1.default.REQUIRED);
-});
-test('dont detect required field when value is null and omit required is passed', async () => {
-    const error = await (0, index_1.default)({
-        options: { omitRequired: true },
-        value: null,
-        currentSchema: { type: String }
-    });
-    expect(error).toBeNull();
-});
-test('run custom validation if passed', async () => {
-    const customType = (0, fieldType_1.default)({
-        name: 'customValidator',
-        validate(value) {
-            return 'hello';
-        }
-    });
-    const error = await (0, index_1.default)({
-        value: 'A string',
-        currentSchema: { type: customType }
-    });
-    expect(error).toBe('hello');
-});
-test('run async custom validation', async () => {
-    const customType = (0, fieldType_1.default)({
-        name: 'customAsyncValidator',
-        async validate(value) {
-            const sleep = time => new Promise(resolve => setTimeout(resolve, time));
-            await sleep(1);
-            return 'hello';
-        }
-    });
-    const error = await (0, index_1.default)({
-        value: 'A string',
-        currentSchema: { type: customType }
-    });
-    expect(error).toBe('hello');
-});

package/lib/getValidationErrors/getValidationErrorsObject.d.ts

@@ -1,4 +0,0 @@
-export default function getValidationErrorsObject(validationErrors: {
-    key: string;
-    code: string;
-}[]): any;

package/lib/getValidationErrors/getValidationErrorsObject.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const dot_object_1 = __importDefault(require("dot-object"));
-const dot = new dot_object_1.default('.', false, true, false);
-function getValidationErrorsObject(validationErrors) {
-    if (validationErrors.length === 0)
-        return null;
-    const errors = {};
-    for (const validationError of validationErrors) {
-        errors[validationError.key] = validationError.code;
-    }
-    return dot.dot(errors);
-}
-exports.default = getValidationErrorsObject;

package/lib/getValidationErrors/index.d.ts

@@ -1,2 +0,0 @@
-import { Schema } from '../types/schema';
-export default function getValidationErrors(schema: Schema | Function, doc: any, passedOptions?: {}, ...args: any[]): Promise<any>;

package/lib/getValidationErrors/index.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const getSchemaFromTypedModel_1 = require("../getSchemaFromTypedModel");
-const doValidation_1 = __importDefault(require("./doValidation"));
-const getValidationErrorsObject_1 = __importDefault(require("./getValidationErrorsObject"));
-const defaultOptions = {
-    omitRequired: false
-};
-async function getValidationErrors(schema, doc, passedOptions = {}, ...args) {
-    schema = (0, getSchemaFromTypedModel_1.getSchemaFromTypedModel)(schema);
-    const options = { ...defaultOptions, ...passedOptions };
-    const errors = [];
-    const addError = function (keys, code) {
-        errors.push({
-            key: keys.join('.'),
-            code
-        });
-    };
-    await (0, doValidation_1.default)({
-        schema,
-        doc,
-        currentDoc: doc,
-        value: doc,
-        currentSchema: { type: schema },
-        addError,
-        options,
-        args
-    });
-    return (0, getValidationErrorsObject_1.default)(errors);
-}
-exports.default = getValidationErrors;

package/lib/getValidationErrors/index.test.d.ts

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

package/lib/getValidationErrors/index.test.js

@@ -1,416 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = __importDefault(require("./index"));
-const Errors_1 = __importDefault(require("../Errors"));
-const friend = {
-    firstName: {
-        type: String
-    }
-};
-const car = {
-    brand: {
-        type: String
-    },
-    model: {
-        type: String
-    }
-};
-const schema = {
-    firstName: {
-        type: String
-    },
-    lastName: {
-        type: String,
-        optional: true
-    },
-    friends: {
-        type: [friend]
-    },
-    car: {
-        type: car,
-        optional: true
-    }
-};
-test('returns null when object is valid', async () => {
-    const errors = await (0, index_1.default)(schema, {
-        firstName: 'Nicolás',
-        lastName: 'López',
-        friends: [{ firstName: 'Roberto' }, { firstName: 'Joaquin' }],
-        car: {
-            brand: 'Nissan',
-            model: 'Kicks'
-        }
-    });
-    expect(errors).toBeNull();
-});
-test('returns an array with the respective errors', async () => {
-    const errors = await (0, index_1.default)(schema, {
-        lastName: 'López',
-        friends: [{ lastName: 'Zibert' }, { firstName: 'Joaquin' }]
-    });
-    expect(errors).toEqual({
-        firstName: Errors_1.default.REQUIRED,
-        'friends.0.firstName': Errors_1.default.REQUIRED,
-        'friends.0.lastName': Errors_1.default.NOT_IN_SCHEMA
-    });
-});
-test('omits required if specified', async () => {
-    const errors = await (0, index_1.default)(schema, {
-        lastName: 'López',
-        friends: [{}, { firstName: 'Joaquin' }]
-    }, { omitRequired: true });
-    expect(errors).toBeNull();
-});
-test('gives error when a document field is not present in schema', async () => {
-    const errors = await (0, index_1.default)({
-        name: {
-            type: String
-        }
-    }, {
-        name: 'Nicolás López',
-        age: 25
-    });
-    expect(errors).toEqual({
-        age: Errors_1.default.NOT_IN_SCHEMA
-    });
-});
-test('dont give error when array is optional and its not passed', async () => {
-    const schema = {
-        name: {
-            type: String
-        },
-        tags: {
-            type: [String],
-            optional: true
-        }
-    };
-    const errors = await (0, index_1.default)(schema, {
-        name: 'Nicolás López',
-        tags: []
-    });
-    expect(errors).toBeNull();
-});
-test('gives an error if a optional object is present and has missing values', async () => {
-    const errors = await (0, index_1.default)(schema, {
-        firstName: 'Nicolás',
-        lastName: 'López',
-        friends: [{ firstName: 'Joaquin' }],
-        car: {
-            brand: 'Nissan'
-        }
-    });
-    expect(errors).toEqual({
-        'car.model': Errors_1.default.REQUIRED
-    });
-});
-test('can check errors in deeply nested keys', async () => {
-    const children = {
-        name: {
-            type: String
-        },
-        car: {
-            type: car,
-            optional: true
-        }
-    };
-    const mother = {
-        name: {
-            type: String
-        },
-        children: {
-            type: [children]
-        },
-        car: {
-            type: car
-        }
-    };
-    const family = {
-        name: {
-            type: String
-        },
-        mother: {
-            type: mother
-        }
-    };
-    const deepSchema = {
-        name: {
-            type: String
-        },
-        family: {
-            type: family
-        }
-    };
-    const errors = await (0, index_1.default)(deepSchema, {
-        name: 'Nicolás',
-        family: {
-            name: 'López',
-            mother: {
-                name: 'Paula',
-                car: {
-                    model: 'Wrangler'
-                },
-                children: [
-                    {
-                        name: 'Paula',
-                        car: {
-                            brand: 'Citroën'
-                        }
-                    },
-                    {
-                        name: 'Diego',
-                        age: 21
-                    }
-                ]
-            }
-        }
-    });
-    expect(errors).toEqual({
-        'family.mother.car.brand': Errors_1.default.REQUIRED,
-        'family.mother.children.0.car.model': Errors_1.default.REQUIRED,
-        'family.mother.children.1.age': Errors_1.default.NOT_IN_SCHEMA
-    });
-});
-test('run validate validation when field is optional and no value is passed', async () => {
-    const person = {
-        name: {
-            type: String,
-            optional: true,
-            validate(value) {
-                return 'No';
-            }
-        },
-        __validate: async (value) => {
-            if (!value)
-                return 'No object';
-        }
-    };
-    const schema = {
-        person: {
-            type: person,
-            optional: true
-        },
-        number: {
-            type: Number,
-            validate() {
-                return 'No';
-            }
-        }
-    };
-    expect(await (0, index_1.default)(schema, {
-        person: { name: null }
-    })).toEqual({
-        number: Errors_1.default.REQUIRED,
-        'person.name': 'No'
-    });
-    expect(await (0, index_1.default)(schema, {
-        person: null,
-        number: null
-    })).toEqual({
-        number: Errors_1.default.REQUIRED,
-        person: 'No object'
-    });
-    expect(await (0, index_1.default)(schema, {
-        number: 123
-    })).toEqual({
-        number: 'No',
-        person: 'No object'
-    });
-});
-test('can validate object type with validate validation', async () => {
-    const person = {
-        name: {
-            type: String
-        },
-        async __validate(value) {
-            return value.name === 'Nicolás' ? null : 'no';
-        }
-    };
-    const schema = {
-        person: {
-            type: person
-        }
-    };
-    expect(await (0, index_1.default)(schema, {
-        person: { name: 'Nicolás' }
-    })).toBeNull();
-    expect(await (0, index_1.default)(schema, {
-        person: { name: 'Joaquin' }
-    })).toEqual({
-        person: 'no'
-    });
-});
-test('skip child validation if specified', async () => {
-    const person = {
-        firstName: {
-            type: String
-        },
-        lastName: {
-            type: String
-        },
-        async __skipChildValidation(value) {
-            return value.firstName === 'Nicolás';
-        }
-    };
-    const schema = {
-        persons: {
-            type: [person]
-        }
-    };
-    expect(await (0, index_1.default)(schema, {
-        persons: [{ firstName: 'Nicolás' }]
-    })).toBeNull();
-    const errors = await (0, index_1.default)(schema, {
-        persons: [{ firstName: 'Joaquin' }]
-    });
-    expect(errors).toEqual({
-        'persons.0.lastName': Errors_1.default.REQUIRED
-    });
-});
-test('run custom validation with custom key', async () => {
-    const schema = {
-        name: {
-            type: String,
-            async custom(value) {
-                return value;
-            }
-        }
-    };
-    const errors = await (0, index_1.default)(schema, { name: 'error' });
-    expect(errors).toEqual({
-        name: 'error'
-    });
-});
-test('allow custom validation to pass an error object', async () => {
-    const schema = {
-        person: {
-            type: 'blackbox',
-            async validate(person) {
-                return {
-                    name: 'required',
-                    lastName: 'tooShort'
-                };
-            }
-        }
-    };
-    const errors = await (0, index_1.default)(schema, { person: { lastName: 'López' } });
-    expect(errors).toEqual({
-        'person.name': 'required',
-        'person.lastName': 'tooShort'
-    });
-});
-test('allow to set type any', async () => {
-    const schema = {
-        person: {
-            type: 'any'
-        }
-    };
-    const errors = await (0, index_1.default)(schema, { person: { lastName: 'López' } });
-    expect(errors).toEqual(null);
-});
-test('allow custom validation to pass an complex error object', async () => {
-    const schema = {
-        person: {
-            type: 'blackbox',
-            async validate(person) {
-                return {
-                    name: 'required',
-                    'car.name': 'required',
-                    friends: [{ name: 'required' }]
-                };
-            }
-        }
-    };
-    const errors = await (0, index_1.default)(schema, { person: { lastName: 'López' } });
-    expect(errors).toEqual({
-        'person.name': 'required',
-        'person.car.name': 'required',
-        'person.friends.0.name': 'required'
-    });
-});
-test('pass currentDoc validating arrays', async () => {
-    const aItem = { name: 'Nicolás' };
-    const doc = { items: [aItem] };
-    const item = {
-        name: {
-            type: String,
-            async validate(name, { currentDoc }) {
-                expect(currentDoc).toBe(aItem);
-            }
-        }
-    };
-    const schema = {
-        items: {
-            type: [item],
-            async validate(items, { currentDoc }) {
-                expect(currentDoc).toBe(doc);
-            }
-        }
-    };
-    expect.assertions(2);
-    await (0, index_1.default)(schema, doc);
-});
-test('pass currentDoc validating complex schemas', async () => {
-    const aCar = { brand: 'Jeep' };
-    const aMom = { name: 'Paula', car: aCar };
-    const aItem = { name: 'Nicolás', mom: aMom };
-    const doc = { items: [aItem] };
-    const car = {
-        brand: {
-            type: String,
-            async validate(value, { currentDoc }) {
-                expect(value).toEqual(aCar.brand);
-                expect(currentDoc).toEqual(aCar);
-            }
-        },
-        async __validate(value, info) {
-            expect(value).toEqual(aMom.car);
-            expect(info.currentDoc).toEqual(aMom);
-        }
-    };
-    const mom = {
-        name: {
-            type: String,
-            async validate(value, { currentDoc }) {
-                expect(value).toEqual(aMom.name);
-                expect(currentDoc).toEqual(aMom);
-            }
-        },
-        car: {
-            type: car,
-            async validate(value, { currentDoc, doc }) {
-                expect(value).toEqual(aMom.car);
-                expect(currentDoc).toEqual(aMom);
-            }
-        }
-    };
-    const item = {
-        name: {
-            type: String,
-            async validate(value, { currentDoc }) {
-                expect(value).toEqual(aItem.name);
-                expect(currentDoc).toEqual(aItem);
-            }
-        },
-        mom: {
-            type: mom,
-            async validate(value, { currentDoc }) {
-                expect(value).toEqual(aItem.mom);
-                expect(currentDoc).toEqual(aItem);
-            }
-        }
-    };
-    const schema = {
-        items: {
-            type: [item],
-            async validate(value, { currentDoc }) {
-                expect(value).toEqual(doc.items);
-                expect(currentDoc).toEqual(doc);
-            }
-        }
-    };
-    expect.assertions(14);
-    await (0, index_1.default)(schema, doc);
-});

package/lib/index.d.ts

@@ -1,13 +0,0 @@
-import validate from './validate';
-import ValidationError from './ValidationError';
-import getValidationErrors from './getValidationErrors';
-import isValid from './isValid';
-import getFieldType from './getValidationErrors/getError/getFieldType';
-import clean from './clean';
-import cleanKey from './cleanKey';
-import validateKey from './validateKey';
-import dotGetSchema from './dotGetSchema';
-import createEnum from './fieldTypes/enum';
-export { validate, ValidationError, getValidationErrors, isValid, getFieldType, clean, cleanKey, dotGetSchema, validateKey, createEnum };
-export * from './types';
-export * from './fieldType';

package/lib/index.js

@@ -1,42 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEnum = exports.validateKey = exports.dotGetSchema = exports.cleanKey = exports.clean = exports.getFieldType = exports.isValid = exports.getValidationErrors = exports.ValidationError = exports.validate = void 0;
-const validate_1 = __importDefault(require("./validate"));
-exports.validate = validate_1.default;
-const ValidationError_1 = __importDefault(require("./ValidationError"));
-exports.ValidationError = ValidationError_1.default;
-const getValidationErrors_1 = __importDefault(require("./getValidationErrors"));
-exports.getValidationErrors = getValidationErrors_1.default;
-const isValid_1 = __importDefault(require("./isValid"));
-exports.isValid = isValid_1.default;
-const getFieldType_1 = __importDefault(require("./getValidationErrors/getError/getFieldType"));
-exports.getFieldType = getFieldType_1.default;
-const clean_1 = __importDefault(require("./clean"));
-exports.clean = clean_1.default;
-const cleanKey_1 = __importDefault(require("./cleanKey"));
-exports.cleanKey = cleanKey_1.default;
-const validateKey_1 = __importDefault(require("./validateKey"));
-exports.validateKey = validateKey_1.default;
-const dotGetSchema_1 = __importDefault(require("./dotGetSchema"));
-exports.dotGetSchema = dotGetSchema_1.default;
-const enum_1 = __importDefault(require("./fieldTypes/enum"));
-exports.createEnum = enum_1.default;
-__exportStar(require("./types"), exports);
-__exportStar(require("./fieldType"), exports);

package/lib/isValid.d.ts

@@ -1,2 +0,0 @@
-import { Schema } from './types/schema';
-export default function isValid(schema: Schema, doc: any, passedOptions?: {}, ...args: any[]): Promise<boolean>;

package/lib/isValid.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const getValidationErrors_1 = __importDefault(require("./getValidationErrors"));
-async function isValid(schema, doc, passedOptions = {}, ...args) {
-    const validationErrors = await (0, getValidationErrors_1.default)(schema, doc, passedOptions, ...args);
-    return !validationErrors;
-}
-exports.default = isValid;

package/lib/isValid.test.d.ts

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

package/lib/isValid.test.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const isValid_1 = __importDefault(require("./isValid"));
-const schema = {
-    firstName: {
-        type: String
-    },
-    lastName: {
-        type: String,
-        optional: true
-    }
-};
-const validObject = { firstName: 'Nicolás', lastName: 'López' };
-const invalidObject = { lastName: 'López' };
-test('returns true when object is valid', async () => {
-    const result = await (0, isValid_1.default)(schema, validObject);
-    expect(result).toBe(true);
-});
-test('returns false when object is invalid', async () => {
-    const result = await (0, isValid_1.default)(schema, invalidObject);
-    expect(result).toBe(false);
-});