@orion-js/models 3.12.0 → 3.13.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Orionjs Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/createModel/clone.d.ts

@@ -0,0 +1,9 @@
+import { CreateModel, CloneOptions, CreateModelOptions } from '../types';
+interface CloneInfo {
+    createModel: CreateModel;
+    getSchema: () => any;
+    getResolvers: () => any;
+    modelOptions: CreateModelOptions;
+}
+declare const clone: (cloneInfo: CloneInfo, options: CloneOptions) => import("../types").Model<any>;
+export default clone;

package/lib/createModel/clone.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const includes_1 = __importDefault(require("lodash/includes"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const clone = (cloneInfo, options) => {
+    const { createModel, getSchema, getResolvers, modelOptions } = cloneInfo;
+    return createModel({
+        name: options.name,
+        clean: modelOptions.clean,
+        validate: modelOptions.validate,
+        resolvers: () => {
+            if (!options.extendResolvers)
+                return getResolvers();
+            return {
+                default: {
+                    ...getResolvers(),
+                    ...options.extendResolvers
+                }
+            };
+        },
+        schema: () => {
+            const oldSchema = (0, cloneDeep_1.default)(getSchema());
+            const newSchema = {};
+            const keys = Object.keys(oldSchema)
+                .filter(key => {
+                if (!options.omitFields)
+                    return true;
+                return !(0, includes_1.default)(options.omitFields, key);
+            })
+                .filter(key => {
+                if (!options.pickFields)
+                    return true;
+                return (0, includes_1.default)(options.pickFields, key);
+            });
+            for (const key of keys) {
+                const field = oldSchema[key];
+                if (options.mapFields) {
+                    newSchema[key] = options.mapFields(field, key);
+                }
+                else {
+                    newSchema[key] = field;
+                }
+            }
+            if (!options.extendSchema)
+                return { default: newSchema };
+            const clonedSchema = {
+                ...newSchema,
+                ...options.extendSchema
+            };
+            return { default: clonedSchema };
+        }
+    });
+};
+exports.default = clone;

package/lib/createModel/clone.test.d.ts

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

package/lib/createModel/clone.test.js

@@ -0,0 +1,49 @@
+"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"));
+describe('Cloning models', () => {
+    it('cloned model should pick fields correctly', async () => {
+        const type = {
+            type: String
+        };
+        const model1 = (0, index_1.default)({
+            name: 'AModel',
+            schema: {
+                a: type,
+                b: type,
+                c: type
+            }
+        });
+        const model2 = model1.clone({
+            name: 'Cloned2',
+            pickFields: ['a', 'b']
+        });
+        const model3 = model2.clone({
+            name: 'Cloned3',
+            omitFields: ['b']
+        });
+        const schema = model3.getSchema();
+        const keys = Object.keys(schema).filter(key => !key.startsWith('__'));
+        expect(keys).toEqual(['a']);
+    });
+    it('should pass __clean and __validate to the cloned model schema', () => {
+        const clean = name => `clean ${name}`;
+        const model1 = (0, index_1.default)({
+            name: 'Model1',
+            schema: {
+                name: { type: String }
+            },
+            clean
+        });
+        const model2 = model1.clone({
+            name: 'Model2'
+        });
+        const schema1 = model1.getSchema();
+        const schema2 = model2.getSchema();
+        expect(schema1.__clean).toBe(clean);
+        expect(schema2.__clean).toBe(clean);
+    });
+});

package/lib/createModel/index.d.ts

@@ -0,0 +1,2 @@
+import { Model, CreateModelOptions } from '../types';
+export default function createModel<TSchema = any>(modelOptions: CreateModelOptions): Model<TSchema>;

package/lib/createModel/index.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const initItem_1 = __importDefault(require("./initItem"));
+const resolveParam_1 = __importDefault(require("./resolveParam"));
+const schema_1 = require("@orion-js/schema");
+const clone_1 = __importDefault(require("./clone"));
+const modelToSchema_1 = require("./modelToSchema");
+function createModel(modelOptions) {
+    const name = modelOptions.name;
+    let resolvedSchema = null;
+    let resolvedCleanSchema = null;
+    let resolvedResolvers = null;
+    const getSchema = () => {
+        if (!modelOptions.schema)
+            return {};
+        if (resolvedSchema)
+            return resolvedSchema;
+        const schema = (0, resolveParam_1.default)(modelOptions.schema);
+        resolvedSchema = (0, modelToSchema_1.modelToSchemaWithModel)(schema, model);
+        if (modelOptions.clean) {
+            resolvedSchema.__clean = modelOptions.clean;
+        }
+        if (modelOptions.validate) {
+            resolvedSchema.__clean = modelOptions.validate;
+        }
+        return resolvedSchema;
+    };
+    const getCleanSchema = () => {
+        if (!modelOptions.schema)
+            return {};
+        if (resolvedCleanSchema)
+            return resolvedCleanSchema;
+        const schema = (0, resolveParam_1.default)(modelOptions.schema);
+        resolvedCleanSchema = (0, modelToSchema_1.modelToSchemaClean)(schema);
+        if (modelOptions.clean) {
+            resolvedCleanSchema.__clean = modelOptions.clean;
+        }
+        if (modelOptions.validate) {
+            resolvedCleanSchema.__clean = modelOptions.validate;
+        }
+        return resolvedCleanSchema;
+    };
+    const getResolvers = () => {
+        if (!modelOptions.resolvers)
+            return {};
+        if (resolvedResolvers)
+            return resolvedResolvers;
+        resolvedResolvers = (0, resolveParam_1.default)(modelOptions.resolvers);
+        return resolvedResolvers;
+    };
+    const modelInitItem = (item) => {
+        const schema = getSchema();
+        const resolvers = getResolvers();
+        return (0, initItem_1.default)({ schema, resolvers, name }, item);
+    };
+    const model = {
+        __isModel: true,
+        name,
+        getSchema,
+        getCleanSchema,
+        getResolvers,
+        initItem: modelInitItem,
+        validate: async (doc) => {
+            const schema = getSchema();
+            return await (0, schema_1.validate)(schema, doc);
+        },
+        clean: async (doc) => {
+            const schema = getSchema();
+            return await (0, schema_1.clean)(schema, doc);
+        },
+        cleanAndValidate: async (doc) => {
+            const schema = getSchema();
+            const cleaned = await (0, schema_1.clean)(schema, doc);
+            await (0, schema_1.validate)(schema, cleaned);
+            return cleaned;
+        },
+        clone: (cloneOptions) => {
+            return (0, clone_1.default)({
+                createModel,
+                getSchema,
+                getResolvers,
+                modelOptions
+            }, cloneOptions);
+        },
+        type: null
+    };
+    return model;
+}
+exports.default = createModel;

package/lib/createModel/initItem.d.ts

@@ -0,0 +1,8 @@
+import { ModelResolversMap } from '../types';
+interface InitItemOptions {
+    name: string;
+    schema: any;
+    resolvers: ModelResolversMap;
+}
+export default function ({ schema, resolvers, name }: InitItemOptions, item: any): any;
+export {};

package/lib/createModel/initItem.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const isNil_1 = __importDefault(require("lodash/isNil"));
+function default_1({ schema, resolvers, name }, item) {
+    if ((0, isNil_1.default)(item)) {
+        return item;
+    }
+    if (!(0, isPlainObject_1.default)(item)) {
+        console.warn(`When initializing an item in ${name} received a non object value`, item);
+        return;
+    }
+    if (resolvers) {
+        for (const key of Object.keys(resolvers)) {
+            const resolver = resolvers[key];
+            item[key] = function (params, viewer) {
+                return resolver.execute({
+                    parent: item,
+                    params,
+                    viewer
+                });
+            };
+        }
+    }
+    if (schema) {
+        const keys = Object.keys(schema).filter(key => !key.startsWith('__'));
+        for (const key of keys) {
+            const fieldSchema = schema[key];
+            if (!fieldSchema.type)
+                continue;
+            const fieldModel = (0, isArray_1.default)(fieldSchema.type) ? fieldSchema.type[0] : fieldSchema.type;
+            if (!fieldModel.__model)
+                continue;
+            if (!item[key])
+                continue;
+            if ((0, isArray_1.default)(fieldSchema.type)) {
+                if (!(0, isArray_1.default)(item[key]))
+                    continue;
+                item[key] = item[key].map(item => fieldModel.__model.initItem(item));
+            }
+            else {
+                item[key] = fieldModel.__model.initItem(item[key]);
+            }
+        }
+    }
+    return item;
+}
+exports.default = default_1;

package/lib/createModel/initItem.test.d.ts

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

package/lib/createModel/initItem.test.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolvers_1 = require("@orion-js/resolvers");
+const _1 = __importDefault(require("."));
+describe('Test init item', () => {
+    // Tests if the resolvers are passed to the item
+    it('Should pass the resolvers to the item', async () => {
+        const Person = (0, _1.default)({
+            name: 'PersonModel',
+            schema: {
+                name: { type: String }
+            },
+            resolvers: {
+                title: (0, resolvers_1.resolver)({
+                    resolve: async (person, { title }) => {
+                        return `${title} ${person.name}`;
+                    }
+                })
+            }
+        });
+        const doc = { name: 'Nico' };
+        const person = Person.initItem(doc);
+        expect(await person.title({ title: 'Mr' })).toBe('Mr Nico');
+    });
+});

package/lib/createModel/modelToSchema.d.ts

@@ -0,0 +1,9 @@
+import { Model, ModelSchema } from '..';
+import { Schema } from '@orion-js/schema';
+export declare function modelToSchema(modelSchema: ModelSchema, { cleanSchema }?: {
+    cleanSchema?: boolean;
+}): Schema;
+export declare function modelToSchemaWithModel(modelSchema: ModelSchema, model?: Model): Schema | {
+    __model: Model<any>;
+};
+export declare function modelToSchemaClean(modelSchema: ModelSchema): Schema;

package/lib/createModel/modelToSchema.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelToSchemaClean = exports.modelToSchemaWithModel = exports.modelToSchema = void 0;
+const isArray_1 = __importDefault(require("lodash/isArray"));
+function isModelSchema(type) {
+    return type && typeof type === 'object' && '__isModel' in type;
+}
+function isModelArraySchema(type) {
+    return type && (0, isArray_1.default)(type) && typeof type[0] === 'object' && '__isModel' in type[0];
+}
+function modelToSchema(modelSchema, { cleanSchema = true } = {}) {
+    const compiledSchema = {};
+    for (const key in modelSchema) {
+        if (key.startsWith('__'))
+            continue;
+        const fieldSchema = modelSchema[key];
+        let currNode;
+        if (isModelSchema(fieldSchema.type)) {
+            currNode = {
+                ...fieldSchema,
+                type: cleanSchema ? fieldSchema.type.getCleanSchema() : fieldSchema.type.getSchema()
+            };
+        }
+        else if (isModelArraySchema(fieldSchema.type)) {
+            currNode = {
+                ...fieldSchema,
+                type: cleanSchema
+                    ? [fieldSchema.type[0].getCleanSchema()]
+                    : [fieldSchema.type[0].getSchema()]
+            };
+        }
+        else {
+            currNode = { ...fieldSchema, type: fieldSchema.type };
+        }
+        compiledSchema[key] = currNode;
+    }
+    return compiledSchema;
+}
+exports.modelToSchema = modelToSchema;
+function modelToSchemaWithModel(modelSchema, model) {
+    const schema = modelToSchema(modelSchema, { cleanSchema: !model });
+    if (!model)
+        return schema;
+    return {
+        ...schema,
+        __model: model
+    };
+}
+exports.modelToSchemaWithModel = modelToSchemaWithModel;
+function modelToSchemaClean(modelSchema) {
+    const schema = modelToSchema(modelSchema, { cleanSchema: true });
+    return schema;
+}
+exports.modelToSchemaClean = modelToSchemaClean;

package/lib/createModel/modelToSchema.test.d.ts

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

package/lib/createModel/modelToSchema.test.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = __importDefault(require("."));
+const schema_1 = require("@orion-js/schema");
+it('should add the __model field when converting to schema', async () => {
+    const model = (0, _1.default)({
+        name: 'test',
+        schema: {
+            name: { type: String },
+            age: { type: Number }
+        }
+    });
+    const schema = model.getSchema();
+    expect(schema.__model.name).toEqual('test');
+});
+it('can clean a schema with nested models', async () => {
+    const model = (0, _1.default)({
+        name: 'AModel',
+        schema: {
+            name: {
+                type: String
+            }
+        },
+        clean: () => ({ name: 'Model Schema' })
+    });
+    const finalModel = (0, _1.default)({
+        name: 'Test',
+        schema: {
+            subModel: {
+                type: model
+            },
+            subModelArray: {
+                type: [model]
+            },
+            primitive: {
+                type: String,
+                clean: () => 'Primitive'
+            }
+        }
+    });
+    const doc = { subModel: { name: 'Joaquin' }, subModelArray: [{ name: 'Roberto' }], primitive: 'hello' };
+    const schema = finalModel.getSchema();
+    expect(await (0, schema_1.clean)(schema, doc)).toEqual({
+        subModel: { name: 'Model Schema' },
+        subModelArray: [{ name: 'Model Schema' }],
+        primitive: 'Primitive'
+    });
+});
+it('Should return a schema with __clean if clean param is passed to model', async () => {
+    const clean = () => ({ name: 'hello' });
+    const model = (0, _1.default)({
+        name: 'test',
+        schema: {
+            name: { type: String },
+            age: { type: Number }
+        },
+        clean
+    });
+    const schema = model.getSchema();
+    expect(await schema.__clean()).toEqual(await clean());
+});

package/lib/createModel/resolveParam.d.ts

@@ -0,0 +1 @@
+export default function (param: any): any;

package/lib/createModel/resolveParam.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(param) {
+    if (typeof param !== 'function')
+        return param;
+    const result = param() || {};
+    if (result.default)
+        return result.default;
+    return result || {};
+}
+exports.default = default_1;

package/lib/createModel/resolvers.test.d.ts

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

package/lib/createModel/resolvers.test.js

@@ -0,0 +1,55 @@
+"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 helpers_1 = require("@orion-js/helpers");
+const resolvers_1 = require("@orion-js/resolvers");
+it('should call the resolver', async () => {
+    let index = 0;
+    const model = (0, index_1.default)({
+        name: 'AModel',
+        schema: {},
+        resolvers: {
+            res: (0, resolvers_1.modelResolver)({
+                private: true,
+                cache: 100,
+                async resolve() {
+                    index++;
+                    return index;
+                }
+            })
+        }
+    });
+    const item = model.initItem({ index: 0 });
+    expect(await item.res({ p: 1 })).toBe(1);
+    expect(await item.res({ p: 2 })).toBe(2);
+    expect(await item.res({ p: 1 })).toBe(1);
+    await (0, helpers_1.sleep)(100);
+    expect(await item.res({ p: 1 })).toBe(3);
+});
+it('should call the custom clean function if present', async () => {
+    const AModel = (0, index_1.default)({
+        name: 'AModel',
+        schema: {
+            someValue: {
+                type: String
+            }
+        },
+        clean: doc => ({ someValue: 'hello world' })
+    });
+    const aResolver = (0, resolvers_1.resolver)({
+        params: {
+            model: {
+                type: AModel
+            }
+        },
+        resolve: ({ model }) => {
+            return model;
+        }
+    });
+    const doc = AModel.initItem({ someValue: 'hello' });
+    const result = await aResolver.resolve({ model: doc });
+    expect(result.someValue).toBe('hello world');
+});

package/lib/createModel/validation.test.d.ts

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

package/lib/createModel/validation.test.js

@@ -0,0 +1,72 @@
+"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 resolvers_1 = require("@orion-js/resolvers");
+it('should validate a schema', async () => {
+    const model = (0, index_1.default)({
+        name: 'AModel',
+        schema: {
+            name: {
+                type: String
+            }
+        }
+    });
+    await model.validate({ name: 'String' });
+});
+it('should allow deep model validation', async () => {
+    const model2 = (0, index_1.default)({
+        name: 'AModel',
+        schema: {
+            firstName: {
+                type: String
+            },
+            lastName: {
+                type: String
+            }
+        }
+    });
+    const model1 = (0, index_1.default)({
+        name: 'AModel2',
+        schema: {
+            data: {
+                type: model2
+            }
+        }
+    });
+    await model1.validate({ data: { firstName: 'Nicolás', lastName: 'López' } });
+    expect.assertions(1);
+    try {
+        await model1.validate({});
+    }
+    catch (error) {
+        expect(error.code).toBe('validationError');
+    }
+});
+it('[regression test]: should allow correct doc cleaning for resolver params', async () => {
+    const Point = (0, index_1.default)({
+        name: 'Point',
+        schema: {
+            latitude: {
+                type: Number
+            },
+            longitude: {
+                type: Number
+            }
+        }
+    });
+    const resolver1 = (0, resolvers_1.resolver)({
+        params: {
+            point: {
+                type: Point
+            }
+        },
+        async resolve({ point }) {
+            return point;
+        }
+    });
+    const doc = await resolver1.resolve({ point: { latitude: '11', longitude: '12' } });
+    expect(doc).toEqual({ latitude: 11, longitude: 12 });
+});

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import createModel from './createModel';
+import { modelToSchema, modelToSchemaWithModel } from './createModel/modelToSchema';
+export { createModel, modelToSchema, modelToSchemaWithModel };
+export * from './types';

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.modelToSchemaWithModel = exports.modelToSchema = exports.createModel = void 0;
+const createModel_1 = __importDefault(require("./createModel"));
+exports.createModel = createModel_1.default;
+const modelToSchema_1 = require("./createModel/modelToSchema");
+Object.defineProperty(exports, "modelToSchema", { enumerable: true, get: function () { return modelToSchema_1.modelToSchema; } });
+Object.defineProperty(exports, "modelToSchemaWithModel", { enumerable: true, get: function () { return modelToSchema_1.modelToSchemaWithModel; } });
+__exportStar(require("./types"), exports);