@orion-js/models 3.11.15 → 4.0.0-alpha.3

package/package.json

@@ -1,40 +1,45 @@
 {
   "name": "@orion-js/models",
-  "version": "3.11.15",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "version": "4.0.0-alpha.3",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
   "files": [
-    "/lib"
+    "dist"
   ],
   "author": "nicolaslopezj",
   "license": "MIT",
   "scripts": {
-    "test": "jest",
+    "test": "bun test",
     "prepare": "yarn run build",
-    "clean": "rm -rf ./lib",
-    "build": "yarn run clean && tsc",
+    "clean": "rm -rf ./dist",
+    "build": "bun run build.ts",
     "watch": "tsc -w",
-    "upgrade-interactive": "yarn upgrade-interactive"
+    "upgrade-interactive": "yarn upgrade-interactive",
+    "dev": "bun --watch src/index.ts"
   },
   "dependencies": {
-    "@orion-js/helpers": "^3.11.15",
-    "@orion-js/resolvers": "^3.11.15",
-    "@orion-js/schema": "^3.11.8"
+    "@orion-js/helpers": "^4.0.0-alpha.2",
+    "@orion-js/resolvers": "^4.0.0-alpha.2",
+    "@orion-js/schema": "^4.0.0-alpha.2"
   },
   "peerDependencies": {
     "@orion-js/cache": "^3.0.0-alpha.10"
   },
   "devDependencies": {
-    "@orion-js/cache": "^3.11.15",
-    "@shelf/jest-mongodb": "^2.1.0",
-    "@types/jest": "^27.0.2",
+    "@orion-js/cache": "^4.0.0-alpha.2",
     "@types/lodash": "4.14.176",
-    "jest": "27.3.1",
-    "ts-jest": "27.0.7",
-    "typescript": "^4.4.4"
+    "typescript": "^5.4.5",
+    "@types/bun": "^1.2.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a5c95d9fd18f779c834644eb757928cdb840643c"
-}
+  "gitHead": "9fd28b6f6b348cebc9f0dc207805647969277372",
+  "type": "module",
+  "module": "./dist/index.js",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,57 +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 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

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

package/lib/createModel/clone.test.js

@@ -1,49 +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"));
-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

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

package/lib/createModel/index.js

@@ -1,92 +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 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

@@ -1,8 +0,0 @@
-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

@@ -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 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

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

package/lib/createModel/initItem.test.js

@@ -1,28 +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 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

@@ -1,9 +0,0 @@
-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

@@ -1,57 +0,0 @@
-"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

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

package/lib/createModel/modelToSchema.test.js

@@ -1,64 +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 _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

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

package/lib/createModel/resolveParam.js

@@ -1,11 +0,0 @@
-"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

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

package/lib/createModel/resolvers.test.js

@@ -1,55 +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 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

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