@orion-js/typed-model 3.0.32 → 3.0.38

package/lib/factories/getModelForClass.js

@@ -5,6 +5,7 @@ exports.getModelForClass = void 0;
 const models_1 = require("@orion-js/models");
 const metadataStorage_1 = require("../storage/metadataStorage");
 const processSchemaForProp_1 = require("./helpers/processSchemaForProp");
+const modelCache = new Map();
 function processModelSchemaForProp(prop) {
     if (prop.type?.__isModel === true) {
         return prop;
@@ -12,6 +13,10 @@ function processModelSchemaForProp(prop) {
     return (0, processSchemaForProp_1.processSchemaForProp)(prop);
 }
 function getModelForClass(target) {
+    const schemaId = target.__schemaId;
+    if (modelCache.has(schemaId)) {
+        return modelCache.get(schemaId);
+    }
     const schema = {};
     const resolverMap = {};
     let parent = target;
@@ -29,10 +34,12 @@ function getModelForClass(target) {
         });
         parent = Object.getPrototypeOf(parent);
     }
-    return (0, models_1.createModel)({
+    const model = (0, models_1.createModel)({
         name: target.name,
         schema,
         resolvers: resolverMap
     });
+    modelCache.set(schemaId, model);
+    return model;
 }
 exports.getModelForClass = getModelForClass;

package/lib/index.test.js

@@ -552,6 +552,19 @@ describe('typed-schema e2e tests', () => {
             expect((0, index_1.getModelForClass)(Spec).name).toEqual(expected.name);
             expect((0, index_1.getModelForClass)(Spec).getCleanSchema()).toEqual(expected.getCleanSchema());
         });
+        it('Should return the same object when calling getModelForClass multiple times', () => {
+            let Spec = class Spec {
+            };
+            __decorate([
+                (0, index_1.Prop)(),
+                __metadata("design:type", String)
+            ], Spec.prototype, "name", void 0);
+            Spec = __decorate([
+                (0, index_1.TypedModel)()
+            ], Spec);
+            const model = (0, index_1.getModelForClass)(Spec);
+            expect((0, index_1.getModelForClass)(Spec)).toBe(model);
+        });
     });
     describe('using resolvers', () => {
         it('allows passing resolvers to the model', () => {

package/lib/schema.test.d.ts

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

package/lib/schema.test.js

@@ -0,0 +1,94 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/typed-model",
-  "version": "3.0.32",
+  "version": "3.0.38",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -17,10 +17,10 @@
     "test": "jest --config jest.config.js"
   },
   "dependencies": {
-    "@orion-js/helpers": "^3.0.31",
-    "@orion-js/models": "^3.0.32",
-    "@orion-js/resolvers": "^3.0.32",
-    "@orion-js/schema": "^3.0.32",
+    "@orion-js/helpers": "^3.0.36",
+    "@orion-js/models": "^3.0.38",
+    "@orion-js/resolvers": "^3.0.37",
+    "@orion-js/schema": "^3.0.37",
     "lodash": "^4.17.21",
     "reflect-metadata": "0.1.13"
   },
@@ -39,5 +39,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8d6dfbbd6fbf5aed082e9d67df81d09db580b015"
+  "gitHead": "00903f1488b72e13b7d5031a916eb897d0d80e0c"
 }