chore: refactoring + tests

Author: k0stik

package-lock.json

@@ -48,7 +48,7 @@
         "@babel/preset-react": "7.16.7",
         "@babel/register": "^7.16.0",
         "@babel/runtime-corejs3": "7.16.8",
-        "@exabyte-io/esse.js": "github:Exabyte-io/esse#b5516137e018dd35a060fce519dcd058eeff70c9",
+        "@exabyte-io/esse.js": "2022.7.28-1",
         "crypto-js": "^4.1.1",
         "json-schema-merge-allof": "^0.8.1",
         "lodash": "^4.17.21",

package.json

@@ -1,15 +1,15 @@
 import { schemas } from "@exabyte-io/esse.js/schemas";
 import mergeAllOf from "json-schema-merge-allof";
 
-const schemaCache = new Map();
-
-export const JSONSchemasInterface = {
-    schemas() {
-        return schemas;
-    },
-
-    schemaById(schemaId) {
-        if (!schemaCache.has(schemaId)) {
+const schemasCache = new Map();
+export class JSONSchemasInterface {
+    /**
+     *
+     * @param {string} schemaId id of JSON schema from ESSE
+     * @returns {Object.<string, any>} resolved JSON schema
+     */
+    static schemaById(schemaId) {
+        if (!schemasCache.has(schemaId)) {
             const originalSchema = schemas.find((schema) => schema.schemaId === schemaId);
 
             const schema = mergeAllOf(originalSchema, {
@@ -18,15 +18,11 @@ export const JSONSchemasInterface = {
                 },
             });
 
-            schemaCache.set(schemaId, schema);
+            schemasCache.set(schemaId, schema);
         }
 
-        return schemaCache.get(schemaId);
-    },
-
-    resolvedSchemaById(schemaId) {
-        return this.schemaById(schemaId);
-    },
+        return schemasCache.get(schemaId);
+    }
 
     /**
      * @example <caption>Search by schemaId regex</caption>
@@ -49,13 +45,13 @@ export const JSONSchemasInterface = {
      * @param  {Object} query - An object containing mongo-like search query
      * @returns {Object|null} JSON schema
      */
-    matchSchema(query) {
+    static matchSchema(query) {
         const searchFields = Object.keys(query);
         return schemas.find((schema) => {
             return searchFields.every((field) => {
                 const { $regex } = query[field];
                 return new RegExp($regex).test(schema[field]);
             });
         });
-    },
-};
+    }
+}

src/JSONSchemasInterface.js

@@ -1,10 +1,9 @@
-import lodash from "lodash";
 import mergeAllOf from "json-schema-merge-allof";
+import lodash from "lodash";
 
 // import { ESSE } from "@exabyte-io/esse.js";
 import { deepClone } from "../utils/clone";
-import { getSchemaByClassName, getMixSchemasByClassName } from "../utils/schemas";
-
+import { getMixSchemasByClassName, getSchemaByClassName } from "../utils/schemas";
 
 // TODO: https://exabyte.atlassian.net/browse/SOF-5946
 // const schemas = new ESSE().schemas;
@@ -175,36 +174,61 @@ export class InMemoryEntity {
         return filtered[0];
     }
 
+    /**
+     * @summary If there any nested in-memory entities, first resolve them
+     *          and then mix with original schema in baseJSONSchema()
+     * @returns {Object.<string,InMemoryEntity>|null}
+     * @example
+     * class Workflow extends InMemoryEntity {
+     *     get customJsonSchemaProperties() {
+     *         return {
+     *             subworkflows: {
+     *                  type: 'array',
+     *                  items: Subworkflow.jsonSchema
+     *              }
+     *         };
+     *     }
+     * }
+     */
     static get customJsonSchemaProperties() {
         return null;
     }
 
-    static getMainJsonSchema() {
-        const originalSchema = getSchemaByClassName(this.name);
-
+    /**
+     * Returns original ESSE schema with nested properties from customJsonSchemaProperties
+     * @see customJsonSchemaProperties
+     * @returns {Object} schema
+     */
+    static get baseJSONSchema() {
         if (!this.customJsonSchemaProperties) {
-            return originalSchema;
+            return getSchemaByClassName(this.name);
         }
 
+        const { properties, ...schema } = getSchemaByClassName(this.name);
+
         return {
-            ...originalSchema,
+            ...schema,
             properties: {
-                ...originalSchema.properties,
-                ...this.customJsonSchemaProperties
-            }
-        }
+                ...properties,
+                ...this.customJsonSchemaProperties,
+            },
+        };
     }
 
+    /**
+     * Returns resolved JSON schema with custom properties and all mixes from schemas.js
+     * @returns {Object} schema
+     */
     static get jsonSchema() {
-        return mergeAllOf({
-            allOf: [
-                this.getMainJsonSchema(),
-                ...getMixSchemasByClassName(this.name)
-            ]
-        }, {
-            resolvers: {
-                defaultResolver: mergeAllOf.options.resolvers.title
-            }
-        });
-	}
+        return mergeAllOf(
+            {
+                allOf: [this.baseJSONSchema, ...getMixSchemasByClassName(this.name)],
+            },
+            {
+                resolvers: {
+                    defaultResolver: mergeAllOf.options.resolvers.title,
+                },
+            },
+        );
+    }
 }

src/entity/in_memory.js

@@ -1,6 +1,6 @@
 import { JSONSchemasInterface } from "../JSONSchemasInterface";
 
-const mainSchemas = {
+export const mainSchemas = {
     Material: "material",
     Entity: "system-entity",
     BankMaterial: "material",
@@ -50,7 +50,7 @@ const flavorMix = ["system-is-multi-material"];
 
 const systemEntityMix = ["system-entity"];
 
-const mixSchemas = {
+export const mixSchemas = {
     Entity: [...entityMix],
     Material: [...entityMix],
     BankMaterial: [...entityMix, ...bankMaterialMix],

src/utils/schemas.js

@@ -1,11 +1,33 @@
 import { expect } from "chai";
-import { JSONSchemasInterface } from './../src/JSONSchemasInterface';
+
+import { JSONSchemasInterface } from "../src/JSONSchemasInterface";
+import { mainSchemas, mixSchemas } from "../src/utils/schemas";
 
 describe("JSONSchemasInterface", () => {
+    it("can find main schema", () => {
+        Object.values(mainSchemas).forEach((schemaId) => {
+            const schema = JSONSchemasInterface.schemaById(schemaId);
+            expect(schema).to.be.an("object");
+        });
+    });
 
-    it("can find schema", () => {
-        const schema = JSONSchemasInterface.schemaById('workflow');
-        expect(schema).to.be.an('object');
+    it("can find mix schemas", () => {
+        Object.values(mixSchemas).forEach((schemaIds) => {
+            schemaIds.forEach((schemaId) => {
+                const schema = JSONSchemasInterface.schemaById(schemaId);
+                expect(schema).to.be.an("object");
+            });
+        });
     });
 
+    it("can match schemas", () => {
+        const schemaId = Object.values(mainSchemas)[0];
+        const schema = JSONSchemasInterface.matchSchema({
+            schemaId: {
+                $regex: schemaId,
+            },
+        });
+
+        expect(schema).to.be.an("object");
+    });
 });

tests/JSONSchemasInterface.tests.js

@@ -45,4 +45,19 @@ describe("InMemoryEntity", () => {
         const entity = new InMemoryEntity(obj);
         expect(JSON.stringify(entity.toJSON())).to.be.equal(JSON.stringify(obj));
     });
+
+    it("jsonSchema returns correct schema", () => {
+        class Entity extends InMemoryEntity {
+            static get customJsonSchemaProperties() {
+                return {
+                    nested: {
+                        type: "string",
+                    },
+                };
+            }
+        }
+        expect(Entity.jsonSchema).to.be.an("object");
+        expect(Entity.jsonSchema).to.have.nested.property("properties.isDefault"); // check mix schemas
+        expect(Entity.jsonSchema).to.have.nested.property("properties.nested.type"); // check custom properties
+    });
 });