@orion-js/typed-model 3.11.8 → 3.12.0

package/lib/schema.test.js

@@ -1,94 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const models_1 = require("@orion-js/models");
-const schema_1 = require("@orion-js/schema");
-const _1 = require(".");
-describe('Test typed model with Schema', () => {
-    it('Should allow passing a typed model to schema', async () => {
-        let Point = class Point {
-        };
-        __decorate([
-            (0, _1.Prop)(),
-            __metadata("design:type", Number)
-        ], Point.prototype, "latitude", void 0);
-        __decorate([
-            (0, _1.Prop)(),
-            __metadata("design:type", Number)
-        ], Point.prototype, "longitude", void 0);
-        Point = __decorate([
-            (0, _1.TypedModel)()
-        ], Point);
-        const schema = {
-            points: {
-                type: [Point]
-            }
-        };
-        const result = await (0, schema_1.clean)(schema, { points: [{ latitude: '1', longitude: 2 }] });
-        expect(result).toEqual({ points: [{ latitude: 1, longitude: 2 }] });
-        await (0, schema_1.validate)(schema, { points: [{ latitude: 1, longitude: 2 }] });
-    });
-    it('Should allow passing a typed model to a model', async () => {
-        let Point = class Point {
-        };
-        __decorate([
-            (0, _1.Prop)(),
-            __metadata("design:type", Number)
-        ], Point.prototype, "latitude", void 0);
-        __decorate([
-            (0, _1.Prop)(),
-            __metadata("design:type", Number)
-        ], Point.prototype, "longitude", void 0);
-        Point = __decorate([
-            (0, _1.TypedModel)()
-        ], Point);
-        const Item = (0, models_1.createModel)({
-            name: 'Item',
-            schema: {
-                points: {
-                    type: [Point]
-                }
-            }
-        });
-        const result = await Item.clean({ points: [{ latitude: '1', longitude: 2 }] });
-        expect.assertions(2);
-        expect(result).toEqual({ points: [{ latitude: 1, longitude: 2 }] });
-        try {
-            await Item.validate({ points: [{ latitude: '1', longitude: 2 }] });
-        }
-        catch (error) {
-            expect(error.message).toBe('Validation Error: {points.0.latitude: notANumber}');
-        }
-    });
-    it('Should allow cleaning and validating just the typed model', async () => {
-        let Point = class Point {
-        };
-        __decorate([
-            (0, _1.Prop)(),
-            __metadata("design:type", Number)
-        ], Point.prototype, "latitude", void 0);
-        __decorate([
-            (0, _1.Prop)(),
-            __metadata("design:type", Number)
-        ], Point.prototype, "longitude", void 0);
-        Point = __decorate([
-            (0, _1.TypedModel)()
-        ], Point);
-        const result = await (0, schema_1.clean)(Point, { latitude: '1', longitude: 2 });
-        expect(result).toEqual({ latitude: 1, longitude: 2 });
-        try {
-            await (0, schema_1.validate)(Point, { latitude: '1', longitude: 2 });
-        }
-        catch (error) {
-            expect(error.message).toBe('Validation Error: {latitude: notANumber}');
-        }
-    });
-});

package/lib/storage/metadataStorage.d.ts

@@ -1,28 +0,0 @@
-import { PropOptions } from '..';
-import { ModelResolversMap } from '@orion-js/models';
-import { ModelResolver, ModelResolverResolve } from '@orion-js/resolvers';
-export declare type PropertiesMap = {
-    [key: string]: PropOptions;
-};
-export declare type TypedModelOptions = Record<string, never>;
-export declare class MetadataStorageHandler {
-    private schemas;
-    private getSchema;
-    addSchemaMetadata({ target, options }: {
-        target: any;
-        options?: TypedModelOptions;
-    }): void;
-    addPropMetadata({ target, propertyKey, options }: {
-        target: any;
-        propertyKey: string;
-        options: PropOptions;
-    }): void;
-    addResolverMetadata({ target, propertyKey, options }: {
-        target: any;
-        propertyKey: string;
-        options: ModelResolver<ModelResolverResolve>;
-    }): void;
-    getSchemaProps(target: any): PropertiesMap | undefined;
-    getSchemaResolvers(target: any): ModelResolversMap | undefined;
-}
-export declare const MetadataStorage: MetadataStorageHandler;

package/lib/storage/metadataStorage.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataStorage = exports.MetadataStorageHandler = void 0;
-const errors_1 = require("../errors");
-const helpers_1 = require("@orion-js/helpers");
-class MetadataStorageHandler {
-    constructor() {
-        this.schemas = new Map();
-    }
-    getSchema(target) {
-        const schema = this.schemas.get(target.__schemaId);
-        if (schema)
-            return schema;
-        const schemaId = (0, helpers_1.generateId)();
-        target.__schemaId = schemaId;
-        const newSchema = {
-            schema: target,
-            options: {},
-            properties: {},
-            resolvers: {}
-        };
-        this.schemas.set(target.__schemaId, newSchema);
-        return newSchema;
-    }
-    addSchemaMetadata({ target, options }) {
-        const schema = this.getSchema(target);
-        schema.options = options;
-    }
-    addPropMetadata({ target, propertyKey, options }) {
-        const schema = this.getSchema(target);
-        const currProp = schema.properties[propertyKey];
-        if (currProp) {
-            throw new errors_1.PropertyAlreadyExistsError(target.name, propertyKey);
-        }
-        schema.properties[propertyKey] = options;
-    }
-    addResolverMetadata({ target, propertyKey, options }) {
-        const schema = this.getSchema(target);
-        const currResolver = schema.resolvers[propertyKey];
-        if (currResolver) {
-            throw new errors_1.PropertyAlreadyExistsError(target.name, propertyKey);
-        }
-        schema.resolvers[propertyKey] = options;
-    }
-    getSchemaProps(target) {
-        const schema = this.getSchema(target);
-        return schema.properties;
-    }
-    getSchemaResolvers(target) {
-        const schema = this.getSchema(target);
-        return schema.resolvers;
-    }
-}
-exports.MetadataStorageHandler = MetadataStorageHandler;
-exports.MetadataStorage = new MetadataStorageHandler();

package/lib/utils/interfaces.d.ts

@@ -1,3 +0,0 @@
-export interface Constructor<T> extends Function {
-    new (...args: unknown[]): T;
-}

package/lib/utils/interfaces.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/isClass.d.ts

@@ -1 +0,0 @@
-export declare const isClass: (type: Function) => boolean;

package/lib/utils/isClass.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClass = void 0;
-// eslint-disable-next-line @typescript-eslint/ban-types
-const isClass = (type) => /^class\s/.test(Function.prototype.toString.call(type));
-exports.isClass = isClass;