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

package/lib/clean/index.test.js

@@ -1,482 +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"));
-test('autoconverts values', async () => {
-    const schema = {
-        number: {
-            type: Number
-        },
-        string: {
-            type: String
-        },
-        string2: {
-            type: String
-        }
-    };
-    const doc = {
-        number: '12',
-        string: 12,
-        string2: 'string '
-    };
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({
-        number: 12,
-        string: '12',
-        string2: 'string'
-    });
-});
-test('dont autoConvert values', async () => {
-    const schema = {
-        number: {
-            type: 'number'
-        },
-        string: {
-            type: String
-        },
-        string2: {
-            type: String
-        }
-    };
-    const doc = {
-        number: '12',
-        string: 12,
-        string2: 'string '
-    };
-    const cleaned = await (0, index_1.default)(schema, doc, { autoConvert: false, trimStrings: false });
-    expect(cleaned).toEqual({
-        number: '12',
-        string: 12,
-        string2: 'string '
-    });
-});
-test('dont remove null values', async () => {
-    const schema = {
-        string: {
-            type: String
-        }
-    };
-    const doc = {
-        string: null
-    };
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({
-        string: null
-    });
-});
-test('cleans boolean correctly', async () => {
-    const type = { type: Boolean };
-    const schema = {
-        a: type,
-        b: type,
-        c: type,
-        d: type,
-        e: type
-    };
-    const doc = {
-        a: 1,
-        b: 'true',
-        c: 0,
-        d: true,
-        e: 'false',
-        f: true
-    };
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({
-        a: true,
-        b: true,
-        c: false,
-        d: true,
-        e: false
-    });
-});
-test('trims strings and filter them', async () => {
-    const type = { type: String };
-    const schema = {
-        aString: type,
-        otherString: type
-    };
-    const doc = {
-        aString: ' 123 321 \n 123 \n\t d\t',
-        otherString: ' '
-    };
-    const cleaned = await (0, index_1.default)(schema, doc, { trimStrings: true, removeEmptyStrings: true });
-    expect(cleaned).toEqual({
-        aString: '123 321 \n 123 \n\t d'
-    });
-});
-test('filter fields not in schema', async () => {
-    const type = { type: String };
-    const schema = {
-        a: type,
-        b: type
-    };
-    const doc = {
-        b: 'hi',
-        c: 'hello'
-    };
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({
-        b: 'hi'
-    });
-});
-test('runs autovalues with arrays', async () => {
-    const schema = {
-        texts: {
-            type: [String],
-            autoValue(values) {
-                return values.map(val => val + ' world');
-            }
-        }
-    };
-    const doc = {
-        texts: ['hello', 'good bye']
-    };
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({
-        texts: ['hello world', 'good bye world']
-    });
-});
-test('run autovalue when field is not present', async () => {
-    const schema = {
-        text: {
-            type: String,
-            autoValue() {
-                return 'a value';
-            }
-        }
-    };
-    const doc = {};
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({ text: 'a value' });
-});
-test('returns the default values', async () => {
-    const schema = {
-        text: {
-            type: String,
-            defaultValue: 'hello',
-            autoValue(value) {
-                return value + ' world';
-            }
-        },
-        text1: {
-            type: String,
-            defaultValue: 'text1'
-        },
-        text2: {
-            type: String,
-            defaultValue: 'text2'
-        },
-        text3: {
-            type: String
-        },
-        text4: {
-            type: String,
-            defaultValue() {
-                return 'afunc';
-            }
-        }
-    };
-    const doc = { text1: 'pass' };
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({
-        text: 'hello world',
-        text1: 'pass',
-        text2: 'text2',
-        text4: 'afunc'
-    });
-});
-test('run deep autovalues', async () => {
-    const deep = {
-        s: {
-            type: String,
-            autoValue() {
-                return 'no';
-            }
-        }
-    };
-    const schema = {
-        text: {
-            type: deep,
-            autoValue(text) {
-                return { ...text, type: 'text' };
-            }
-        },
-        texts: {
-            type: [deep],
-            autoValue(texts) {
-                return [texts[0], 'yes'];
-            }
-        }
-    };
-    const doc = {
-        text: { s: 'objecttext' },
-        texts: [{ s: 'arraytext' }, { s: 'noa' }]
-    };
-    const cleaned = await (0, index_1.default)(schema, doc);
-    expect(cleaned).toEqual({
-        text: { s: 'no' },
-        texts: [{ s: 'no' }, 'yes']
-    });
-});
-test('perform custom cleaning from clean option in field', async () => {
-    const person = {
-        name: {
-            type: String,
-            async clean(value) {
-                if (value === 'Joaquin') {
-                    return 'Roberto';
-                }
-                else {
-                    return value;
-                }
-            }
-        }
-    };
-    const schema = {
-        persons: {
-            type: [person]
-        }
-    };
-    const cleaned = await (0, index_1.default)(schema, {
-        persons: [{ name: 'Nicolás' }, { name: 'Joaquin' }]
-    });
-    expect(cleaned).toEqual({
-        persons: [{ name: 'Nicolás' }, { name: 'Roberto' }]
-    });
-});
-test('perform custom cleaning', async () => {
-    const person = {
-        name: {
-            type: String
-        },
-        async __clean(value) {
-            if (value.name === 'Joaquin') {
-                return { name: 'Roberto' };
-            }
-            else {
-                return value;
-            }
-        }
-    };
-    const schema = {
-        persons: {
-            type: [person]
-        }
-    };
-    // TODO: Check why the __clean method is being used here instead of clean
-    const cleaned = await (0, index_1.default)(schema, {
-        persons: [{ name: 'Nicolás' }, { name: 'Joaquin' }]
-    });
-    expect(cleaned).toEqual({
-        persons: [{ name: 'Nicolás' }, { name: 'Roberto' }]
-    });
-});
-test('perform non deep custom cleaning', async () => {
-    const schema = {
-        name: {
-            type: String
-        },
-        async __clean(value) {
-            if (value.name === 'Joaquin') {
-                return { name: 'Roberto' };
-            }
-            else {
-                return value;
-            }
-        }
-    };
-    // TODO: Check why the __clean method is being used here instead of clean
-    const cleaned = await (0, index_1.default)(schema, { name: 'Joaquin' });
-    expect(cleaned).toEqual({ name: 'Roberto' });
-});
-test('Handle errors while cleaning', async () => {
-    const schema = {
-        name: {
-            type: String,
-            async autoValue() {
-                throw new Error('an error');
-            }
-        }
-    };
-    try {
-        await (0, index_1.default)(schema, { name: 'Joaquin' });
-    }
-    catch (error) {
-        expect(error.message).toBe('Error cleaning field name, error: an error');
-    }
-});
-test('pass currentDoc cleaning arrays', async () => {
-    const aItem = { name: 'Nicolás' };
-    const doc = { items: [aItem] };
-    const item = {
-        name: {
-            type: String,
-            async autoValue(name, { currentDoc }) {
-                expect(currentDoc).toBe(aItem);
-                return name;
-            }
-        }
-    };
-    const schema = {
-        items: {
-            type: [item],
-            async autoValue(items, { currentDoc }) {
-                expect(currentDoc).toBe(doc);
-                return items;
-            }
-        }
-    };
-    expect.assertions(2);
-    await (0, index_1.default)(schema, doc);
-});
-test('omit undefined items in array', async () => {
-    const doc = { items: [{ name: 'Nicolás' }] };
-    const item = {
-        name: {
-            type: String
-        },
-        __clean() {
-            return undefined;
-        }
-    };
-    const schema = {
-        items: {
-            type: [item]
-        }
-    };
-    // TODO: Check why the __clean method is being used here instead of clean
-    const result = await (0, index_1.default)(schema, doc);
-    expect(result).toEqual({ items: [] });
-});
-test('passes extra arguments to clean', async () => {
-    const doc = {
-        name: 'Nicolás'
-    };
-    const schema = {
-        name: {
-            type: String,
-            autoValue(name, info, arg1, arg2) {
-                expect(arg1).toBe(1);
-                expect(arg2).toBe(2);
-                return name;
-            }
-        }
-    };
-    expect.assertions(2);
-    await (0, index_1.default)(schema, doc, null, 1, 2);
-});
-test('throws error when cleaning field with no type', async () => {
-    const schema = {
-        name: {
-            type: null,
-            autoValue() {
-                return 'Nicolás';
-            }
-        }
-    };
-    expect.assertions(1);
-    try {
-        await (0, index_1.default)(schema, {});
-    }
-    catch (error) {
-        expect(error.message).toBe('Error cleaning field name, error: Cleaning field with no type');
-    }
-});
-test('cleans when no argument is passed', async () => {
-    const schema = {
-        name: {
-            type: String,
-            autoValue() {
-                return 'Nicolás';
-            }
-        }
-    };
-    const result = await (0, index_1.default)(schema, {});
-    expect(result).toEqual({ name: 'Nicolás' });
-});
-test('pass currentDoc cleaning 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 autoValue(value, { currentDoc }) {
-                expect(value).toEqual(aCar.brand);
-                expect(currentDoc).toEqual(aCar);
-                return value;
-            }
-        },
-        async __clean(value, info) {
-            expect(value).toEqual(aMom.car);
-            expect(info.currentDoc).toEqual(aMom);
-            return value;
-        }
-    };
-    const mom = {
-        name: {
-            type: String,
-            async autoValue(value, { currentDoc }) {
-                expect(value).toEqual(aMom.name);
-                expect(currentDoc).toEqual(aMom);
-                return value;
-            }
-        },
-        car: {
-            type: car,
-            async autoValue(value, { currentDoc }) {
-                expect(value).toEqual(aMom.car);
-                expect(currentDoc).toEqual(aMom);
-                return value;
-            }
-        }
-    };
-    const item = {
-        name: {
-            type: String,
-            async autoValue(value, { currentDoc }) {
-                expect(value).toEqual(aItem.name);
-                expect(currentDoc).toEqual(aItem);
-                return value;
-            }
-        },
-        mom: {
-            type: mom,
-            async autoValue(value, { currentDoc }) {
-                expect(value).toEqual(aItem.mom);
-                expect(currentDoc).toEqual(aItem);
-                return value;
-            }
-        }
-    };
-    const schema = {
-        items: {
-            type: [item],
-            async autoValue(value, { currentDoc }) {
-                expect(value).toEqual(doc.items);
-                expect(currentDoc).toEqual(doc);
-                return value;
-            }
-        }
-    };
-    expect.assertions(14);
-    // TODO: Check why the __clean method is being used here instead of clean
-    await (0, index_1.default)(schema, doc);
-});
-test('On blackbox allow use of custom clean', async () => {
-    const schema = {
-        info: {
-            type: 'blackbox',
-            optional: true,
-            async clean() {
-                return { hello: 'world' };
-            }
-        }
-    };
-    const result = await (0, index_1.default)(schema, { info: { hello: 'night' } });
-    expect(result).toEqual({ info: { hello: 'world' } });
-});

package/lib/clean/recursiveClean.d.ts

@@ -1,3 +0,0 @@
-import { CurrentNodeInfo } from '../types/schema';
-declare const clean: (info: CurrentNodeInfo) => Promise<any>;
-export default clean;

package/lib/clean/recursiveClean.js

@@ -1,89 +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 isUndefined_1 = __importDefault(require("lodash/isUndefined"));
-const isArray_1 = __importDefault(require("lodash/isArray"));
-const cleanType_1 = __importDefault(require("./cleanType"));
-const isNil_1 = __importDefault(require("lodash/isNil"));
-const getObjectNode_1 = __importDefault(require("./getObjectNode"));
-const convertTypedModel_1 = require("../getValidationErrors/convertTypedModel");
-const cleanObjectFields = async function ({ schema, value, ...other }) {
-    const keys = Object.keys(schema.type).filter(key => !key.startsWith('__'));
-    const newDoc = {};
-    for (const key of keys) {
-        try {
-            const cleanOptions = {
-                ...other,
-                schema: schema.type[key],
-                value: value[key],
-                currentDoc: value
-            };
-            const newValue = await clean(cleanOptions);
-            if (!(0, isUndefined_1.default)(newValue)) {
-                newDoc[key] = newValue;
-            }
-        }
-        catch (error) {
-            throw new Error(`Error cleaning field ${key}, error: ${error.message}`);
-        }
-    }
-    return newDoc;
-};
-const cleanArrayItems = async function ({ schema, value, ...other }) {
-    // clean array items
-    const schemaType = schema.type[0];
-    const promises = value.map(async (item, index) => {
-        const newValue = await clean({
-            ...other,
-            schema: {
-                type: schemaType
-            },
-            value: item,
-            currentDoc: value
-        });
-        return newValue;
-    });
-    const result = await Promise.all(promises);
-    return result.filter(value => !(0, isUndefined_1.default)(value));
-};
-function getArrayNode(schema, value) {
-    if ((0, isArray_1.default)(schema.type) && !(0, isNil_1.default)(value)) {
-        const result = schema;
-        return result;
-    }
-    return null;
-}
-const clean = async function (info) {
-    (0, convertTypedModel_1.convertTypedModel)(info);
-    let { schema, args = [], value } = info;
-    const currSchema = schema.type === undefined ? { type: schema } : schema;
-    const objectSchema = (0, getObjectNode_1.default)(currSchema, value);
-    if (objectSchema) {
-        const newDoc = await cleanObjectFields({
-            ...info,
-            schema: objectSchema,
-            value: value
-        });
-        const result = await (0, cleanType_1.default)('plainObject', objectSchema, newDoc, info, ...args);
-        return result;
-    }
-    const arraySchema = getArrayNode(currSchema, value);
-    if (arraySchema) {
-        let updatedValue = value;
-        if (!(0, isArray_1.default)(value) && !Array.isArray(value)) {
-            updatedValue = [value];
-        }
-        const newDoc = await cleanArrayItems({
-            ...info,
-            schema: arraySchema,
-            value: updatedValue
-        });
-        const result = await (0, cleanType_1.default)('array', arraySchema, newDoc, info, ...args);
-        return result;
-    }
-    const result = await (0, cleanType_1.default)(currSchema.type, currSchema, value, info, ...args);
-    return result;
-};
-exports.default = clean;

package/lib/cleanKey.d.ts

@@ -1 +0,0 @@
-export default function (schema: any, key: any, value: any, passedOptions?: {}, ...args: any[]): Promise<any>;

package/lib/cleanKey.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 clean_1 = __importDefault(require("./clean"));
-const dotGetSchema_1 = __importDefault(require("./dotGetSchema"));
-const defaultOptions = {
-    filter: true
-};
-async function default_1(schema, key, value, passedOptions = {}, ...args) {
-    const options = { ...defaultOptions, ...passedOptions };
-    const keySchema = (0, dotGetSchema_1.default)(schema, key);
-    if (!keySchema) {
-        if (options.filter) {
-            return;
-        }
-        else {
-            return value;
-        }
-    }
-    const result = await (0, clean_1.default)({ clean: keySchema }, { clean: value }, options, ...args);
-    return result.clean;
-}
-exports.default = default_1;

package/lib/cleanKey.test.d.ts

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