Merge pull request #14 from Exabyte-io/featute/SOF-6144

SOF-6144: JSON Schemas features for InMemoryEntity

Author: timurbazhirov

.gitignore

@@ -4,4 +4,4 @@ node_modules/
 .eslintcache
 .nyc_output/
 .idea/
-
+*.DS_Store

package-lock.json

@@ -48,7 +48,9 @@
         "@babel/preset-react": "7.16.7",
         "@babel/register": "^7.16.0",
         "@babel/runtime-corejs3": "7.16.8",
+        "@exabyte-io/esse.js": "2022.7.28-1",
         "crypto-js": "^4.1.1",
+        "json-schema-merge-allof": "^0.8.1",
         "lodash": "^4.17.21",
         "mathjs": "^3.9.0",
         "mixwith": "^0.1.1",

package.json

@@ -0,0 +1,57 @@
+import { schemas } from "@exabyte-io/esse.js/schemas";
+import mergeAllOf from "json-schema-merge-allof";
+
+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, {
+                resolvers: {
+                    defaultResolver: mergeAllOf.options.resolvers.title,
+                },
+            });
+
+            schemasCache.set(schemaId, schema);
+        }
+
+        return schemasCache.get(schemaId);
+    }
+
+    /**
+     * @example <caption>Search by schemaId regex</caption>
+     * JSONSchemasInterface.matchSchema({
+     *   schemaId: {
+     *     $regex: 'software-application'
+     *   }
+     * })
+     *
+     * @example <caption>Search by schemaId and title regex</caption>
+     * JSONSchemasInterface.matchSchema({
+     *   schemaId: {
+     *     $regex: 'software-application'
+     *   },
+     *   title: {
+     *     $regex: 'application'
+     *   }
+     * })
+     *
+     * @param  {Object} query - An object containing mongo-like search query
+     * @returns {Object|null} JSON schema
+     */
+    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,7 +1,9 @@
+import mergeAllOf from "json-schema-merge-allof";
 import lodash from "lodash";
 
 // import { ESSE } from "@exabyte-io/esse.js";
 import { deepClone } from "../utils/clone";
+import { getMixSchemasByClassName, getSchemaByClassName } from "../utils/schemas";
 
 // TODO: https://exabyte.atlassian.net/browse/SOF-5946
 // const schemas = new ESSE().schemas;
@@ -171,4 +173,62 @@ 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;
+    }
+
+    /**
+     * Returns original ESSE schema with nested properties from customJsonSchemaProperties
+     * @see customJsonSchemaProperties
+     * @returns {Object} schema
+     */
+    static get baseJSONSchema() {
+        if (!this.customJsonSchemaProperties) {
+            return getSchemaByClassName(this.name);
+        }
+
+        const { properties, ...schema } = getSchemaByClassName(this.name);
+
+        return {
+            ...schema,
+            properties: {
+                ...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.baseJSONSchema, ...getMixSchemasByClassName(this.name)],
+            },
+            {
+                resolvers: {
+                    defaultResolver: mergeAllOf.options.resolvers.title,
+                },
+            },
+        );
+    }
 }

src/entity/in_memory.js

@@ -0,0 +1,85 @@
+import { JSONSchemasInterface } from "../JSONSchemasInterface";
+
+export const baseSchemas = {
+    Material: "material",
+    Entity: "system-entity",
+    BankMaterial: "material",
+    Workflow: "workflow",
+    Subworkflow: "workflow-subworkflow",
+    BankWorkflow: "workflow",
+    Job: "job",
+    Application: "software-application",
+    Executable: "software-executable",
+    Flavor: "software-flavor",
+    Template: "software-template",
+    AssertionUnit: "workflow-unit-assertion",
+    AssignmentUnit: "workflow-unit-assignment",
+    ConditionUnit: "workflow-unit-condition",
+    ExecutionUnit: "workflow-unit-execution",
+    IOUnit: "workflow-unit-io",
+    MapUnit: "workflow-unit-map",
+    ProcessingUnit: "workflow-unit-processing",
+    ReduceUnit: "workflow-unit-reduce",
+    SubworkflowUnit: "workflow-unit",
+    Unit: "workflow-unit",
+};
+
+const entityMix = [
+    "system-description-object",
+    "system-base-entity-set",
+    "system-sharing",
+    "system-metadata",
+    "system-defaultable",
+];
+
+const subWorkflowMix = ["system-system-name", "system-is-multi-material"];
+
+const workflowMix = ["workflow-base-flow", "system-history", "system-is-outdated"];
+
+const bankMaterialMix = ["material-conventional", "system-creator-account"];
+
+const bankWorkflowMix = ["system-creator-account"];
+
+const jobMix = ["system-status", "system-job-extended"];
+
+const unitMix = ["system-unit-extended", "system-status", "workflow-unit-runtime-runtime-items"];
+
+const assignmentUnitMix = ["system-scope"];
+
+const flavorMix = ["system-is-multi-material"];
+
+const systemEntityMix = ["system-entity"];
+
+export const mixSchemas = {
+    Entity: [...entityMix],
+    Material: [...entityMix],
+    BankMaterial: [...entityMix, ...bankMaterialMix],
+    Workflow: [...entityMix, ...subWorkflowMix, ...workflowMix],
+    Subworkflow: [...subWorkflowMix],
+    BankWorkflow: [...entityMix, ...subWorkflowMix, ...workflowMix, ...bankWorkflowMix],
+    Job: [...entityMix, ...jobMix],
+    Application: [...entityMix, ...systemEntityMix],
+    Executable: [...entityMix, ...systemEntityMix],
+    Flavor: [...entityMix, ...flavorMix, ...systemEntityMix],
+    Template: [...entityMix, ...systemEntityMix],
+    AssertionUnit: [...unitMix],
+    AssignmentUnit: [...unitMix, ...assignmentUnitMix],
+    ConditionUnit: [...unitMix],
+    ExecutionUnit: [...unitMix],
+    IOUnit: [...unitMix],
+    MapUnit: [...unitMix],
+    ProcessingUnit: [...unitMix],
+    ReduceUnit: [...unitMix],
+    SubworkflowUnit: [...unitMix],
+    Unit: [...unitMix],
+};
+
+export function getSchemaByClassName(className) {
+    return baseSchemas[className] ? JSONSchemasInterface.schemaById(baseSchemas[className]) : null;
+}
+
+export function getMixSchemasByClassName(className) {
+    return mixSchemas[className]
+        ? mixSchemas[className].map((schemaId) => JSONSchemasInterface.schemaById(schemaId))
+        : [];
+}

src/utils/schemas.js

@@ -0,0 +1,33 @@
+import { expect } from "chai";
+
+import { JSONSchemasInterface } from "../src/JSONSchemasInterface";
+import { baseSchemas, mixSchemas } from "../src/utils/schemas";
+
+describe("JSONSchemasInterface", () => {
+    it("can find main schema", () => {
+        Object.values(baseSchemas).forEach((schemaId) => {
+            const schema = JSONSchemasInterface.schemaById(schemaId);
+            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(baseSchemas)[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
+    });
 });