chore: fix merge conflicts

Author: k0stik

package-lock.json

@@ -24,6 +24,14 @@ export class JSONSchemasInterface {
         return schemasCache.get(schemaId);
     }
 
+    /**
+     *
+     * @param {Object} - external schema
+     */
+    static registerSchema(schema) {
+        schemasCache.set(schema.schemaId, schema);
+    }
+
     /**
      * @example <caption>Search by schemaId regex</caption>
      * JSONSchemasInterface.matchSchema({

src/JSONSchemasInterface.js

@@ -1,26 +1,32 @@
 import { JSONSchemaFormDataProvider } from "./json_schema_provider";
 import {
-    ApplicationContextMixinBuilder,
+    ApplicationContextMixin,
     JobContextMixin,
-    MaterialContextMixinBuilder,
-    MaterialsContextMixinBuilder,
+    MaterialContextMixin,
+    MaterialsContextMixin,
     MaterialsSetContextMixin,
     MethodDataContextMixin,
     WorkflowContextMixin,
 } from "./mixins";
 import { JobContextPickKeysForMixin, WorkflowContextPickKeysForMixin } from "./pickers";
 import { ContextProvider } from "./provider";
-import { ContextProviderRegistryContainer } from "./registry";
+import {
+    ContextProviderRegistryContainer,
+    createAndPatchRegistry,
+    extendAndPatchRegistry,
+} from "./registry";
 
 export {
     ContextProvider,
     ContextProviderRegistryContainer,
+    extendAndPatchRegistry,
+    createAndPatchRegistry,
     JobContextPickKeysForMixin,
     JSONSchemaFormDataProvider,
     WorkflowContextPickKeysForMixin,
-    ApplicationContextMixinBuilder,
-    MaterialContextMixinBuilder,
-    MaterialsContextMixinBuilder,
+    ApplicationContextMixin,
+    MaterialContextMixin,
+    MaterialsContextMixin,
     MaterialsSetContextMixin,
     MethodDataContextMixin,
     JobContextMixin,

src/context/index.js

@@ -3,28 +3,31 @@ import CryptoJS from "crypto-js";
 
 import { compareEntitiesInOrderedSetForSorting } from "../entity/set/ordered/utils";
 
-export const ApplicationContextMixinBuilder = (applicationCls) => (superclass) =>
+export const ApplicationContextMixin = (superclass) =>
     class extends superclass {
         constructor(config) {
             super(config);
-            if (!applicationCls)
-                throw Error("ApplicationContextMixinBuilder: applicationCls is undefined");
+            if (!this.constructor.Application)
+                throw Error("ApplicationContextMixin: Application is undefined");
             this._application =
-                (config.context && config.context.application) || applicationCls.createDefault();
+                (config.context && config.context.application) ||
+                this.constructor.Application.createDefault();
         }
 
         get application() {
             return this._application;
         }
     };
 
-export const MaterialContextMixinBuilder = (materialCls) => (superclass) =>
+export const MaterialContextMixin = (superclass) =>
     class extends superclass {
         constructor(config) {
             super(config);
-            if (!materialCls) throw Error("MaterialContextMixinBuilder: materialCls is undefined");
+            if (!this.constructor.Material) {
+                throw Error("MaterialContextMixin: Material is undefined");
+            }
             this._material = config.context && config.context.material;
-            if (!this._material) this._material = materialCls.createDefault();
+            if (!this._material) this._material = this.constructor.Material.createDefault();
             this.updateMaterialHash();
         }
 
@@ -74,14 +77,18 @@ export const MaterialsSetContextMixin = (superclass) =>
         }
     };
 
-export const MaterialsContextMixinBuilder = (materialCls) => (superclass) =>
+export const MaterialsContextMixin = (superclass) =>
     class extends superclass {
         constructor(config) {
             super(config);
             const materials = this.config.context && this.config.context.materials;
-            if (!materialCls) throw Error("MaterialsContextMixinBuilder: materialCls is undefined");
+            if (!this.constructor.Material) {
+                throw Error("MaterialsContextMixin: Material is undefined");
+            }
             this._materials =
-                materials && materials.length ? materials : [materialCls.createDefault()];
+                materials && materials.length
+                    ? materials
+                    : [this.constructor.Material.createDefault()];
         }
 
         get materials() {

src/context/mixins.js

@@ -31,3 +31,42 @@ export class ContextProviderRegistryContainer {
         this.providers = this.providers.filter((p) => p.name === name);
     }
 }
+
+/** Extends an existing context provider registry container and patches static class variables if applicable.
+ *
+ * @param {ContextProviderRegistryContainer} registryContainer
+ * @param {Object} classConfigMap
+ * @param {Object} classesToPatch
+ * @example
+ * const classConfigMap = {
+ *     PlanewaveCutoffDataManager: {
+ *         providerCls: PlanewaveCutoffsContextProvider,
+ *         config: _makeImportant({ name: "cutoffs", entityName: "subworkflow" })
+ *     },
+ * };
+ *
+ */
+export const extendAndPatchRegistry = (registryContainer, classConfigMap, classesToPatch = {}) => {
+    Object.entries(classConfigMap).forEach(([name, { providerCls, config }]) => {
+        Object.entries(classesToPatch).forEach(([clsName, cls]) => {
+            if (providerCls[clsName]) {
+                providerCls[clsName] = cls;
+            }
+        });
+        registryContainer.addProvider({
+            instance: providerCls.getConstructorConfig(config),
+            name,
+        });
+    });
+    return registryContainer;
+};
+
+/** Creates a new context provider registry container and patches static class variables if applicable.
+ *
+ * @param {Object} classConfigMap
+ * @param {{Material: SpecificMockMaterial}} classesToPatch
+ */
+export const createAndPatchRegistry = (classConfigMap, classesToPatch = {}) => {
+    const registryContainer = new ContextProviderRegistryContainer();
+    return extendAndPatchRegistry(registryContainer, classConfigMap, classesToPatch);
+};

src/context/registry.js

@@ -24,31 +24,35 @@ export const baseSchemas = {
     Unit: "workflow/unit",
 };
 
-const entityMix = [
+export const entityMix = [
     "system/description-object",
     "system/base-entity-set",
     "system/sharing",
     "system/metadata",
     "system/defaultable",
 ];
 
-const subWorkflowMix = ["system/system-name", "system/is-multi-material"];
+export const subWorkflowMix = ["system/system-name", "system/is-multi-material"];
 
-const workflowMix = ["workflow/base-flow", "system/history", "system/is-outdated"];
+export const workflowMix = ["workflow/base-flow", "system/history", "system/is-outdated"];
 
-const bankMaterialMix = ["material/conventional", "system/creator-account"];
+export const bankMaterialMix = ["material/conventional", "system/creator-account"];
 
-const bankWorkflowMix = ["system/creator-account"];
+export const bankWorkflowMix = ["system/creator-account"];
 
-const jobMix = ["system/status", "system/job-extended"];
+export const jobMix = ["system/status", "system/job-extended"];
 
-const unitMix = ["system/unit-extended", "system/status", "workflow/unit/runtime/runtime-items"];
+export const unitMix = [
+    "system/unit-extended",
+    "system/status",
+    "workflow/unit/runtime/runtime-items",
+];
 
-const assignmentUnitMix = ["system/scope"];
+export const assignmentUnitMix = ["system/scope"];
 
-const flavorMix = ["system/is-multi-material"];
+export const flavorMix = ["system/is-multi-material"];
 
-const systemEntityMix = ["system/entity"];
+export const systemEntityMix = ["system/entity"];
 
 export const mixSchemas = {
     Entity: [...entityMix],
@@ -83,3 +87,14 @@ export function getMixSchemasByClassName(className) {
         ? mixSchemas[className].map((schemaId) => JSONSchemasInterface.schemaById(schemaId))
         : [];
 }
+
+/**
+ * Register additional Entity classes to be resolved with jsonSchema property
+ * @param {String} className - class name derived from InMemoryEntity
+ * @param {String} classBaseSchema - base schemaId
+ * @param {Array} classMixSchemas - array of schemaId to mix
+ */
+export function registerClassName(className, classBaseSchema, classMixSchemas) {
+    baseSchemas[className] = classBaseSchema;
+    mixSchemas[className] = classMixSchemas;
+}

src/utils/schemas.js

@@ -30,4 +30,18 @@ describe("JSONSchemasInterface", () => {
 
         expect(schema).to.be.an("object");
     });
+
+    it("can find registered schemas", () => {
+        JSONSchemasInterface.registerSchema({
+            schemaId: "test-schema-id",
+            properties: {
+                testProp: {
+                    type: "string",
+                },
+            },
+        });
+
+        const schema = JSONSchemasInterface.schemaById("test-schema-id");
+        expect(schema).to.be.an("object");
+    });
 });

tests/JSONSchemasInterface.tests.js

@@ -0,0 +1,91 @@
+import { expect } from "chai";
+import { mix } from "mixwith";
+
+import {
+    ApplicationContextMixin,
+    ContextProvider,
+    createAndPatchRegistry,
+    MaterialContextMixin,
+} from "../src/context";
+
+class MockMaterial {
+    static createDefault() {
+        return "defaultMockMaterial";
+    }
+}
+
+class SpecificMockMaterial {
+    static createDefault() {
+        return "defaultSpecificMockMaterial";
+    }
+}
+
+class MockApplication {
+    static createDefault() {
+        return "defaultMockApplication";
+    }
+}
+
+class SpecificMockApplication {
+    static createDefault() {
+        return "defaultSpecificMockApplication";
+    }
+}
+
+class ProviderEntity extends mix(ContextProvider).with(
+    MaterialContextMixin,
+    ApplicationContextMixin,
+) {
+    static Material = MockMaterial;
+
+    static Application = MockApplication;
+}
+
+class DerivedProviderEntity extends ProviderEntity {
+    static Material = SpecificMockMaterial;
+
+    static Application = SpecificMockApplication;
+}
+
+class ApplicationContextProvider extends mix(ContextProvider).with(ApplicationContextMixin) {
+    static Application = SpecificMockApplication;
+}
+
+describe("Material & Application ContextMixin", () => {
+    const config = {};
+
+    it("uses static entity class", () => {
+        const provider = new ProviderEntity(config);
+        expect(provider.material).to.be.equal("defaultMockMaterial");
+        expect(provider.application).to.be.equal("defaultMockApplication");
+    });
+
+    it("uses static entity class from derived class", () => {
+        const provider = new DerivedProviderEntity(config);
+        expect(provider.material).to.be.equal("defaultSpecificMockMaterial");
+        expect(provider.application).to.be.equal("defaultSpecificMockApplication");
+    });
+});
+
+describe("ContextProviderRegistryContainer", () => {
+    const classConfigObj = {
+        DataManager: {
+            providerCls: ProviderEntity,
+            config: { name: "example1", domain: "important" },
+        },
+        ApplicationDataManager: {
+            providerCls: ApplicationContextProvider,
+            config: { name: "example2", domain: "important" },
+        },
+    };
+
+    it("can be created and patched", () => {
+        const registry = createAndPatchRegistry(classConfigObj, { Material: SpecificMockMaterial });
+        const _dataProvider = registry.findProviderInstanceByName("DataManager");
+        const dataProvider = new _dataProvider.constructor(_dataProvider.config);
+        const _appProvider = registry.findProviderInstanceByName("ApplicationDataManager");
+        const appProvider = new _appProvider.constructor(_appProvider.config);
+        expect(dataProvider.material).to.be.equal("defaultSpecificMockMaterial");
+        expect(appProvider.application).to.be.equal("defaultSpecificMockApplication");
+    });
+});

tests/context.tests.js

@@ -1,6 +1,8 @@
+/* eslint-disable max-classes-per-file */
 import { expect } from "chai";
 
 import { InMemoryEntity } from "../src/entity/in_memory";
+import { entityMix, registerClassName } from "../src/utils/schemas";
 
 describe("InMemoryEntity", () => {
     const obj = {
@@ -60,4 +62,22 @@ describe("InMemoryEntity", () => {
         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
     });
+
+    it("jsonSchema returns correct registered schema", () => {
+        class RegisteredEntity extends InMemoryEntity {
+            static get customJsonSchemaProperties() {
+                return {
+                    nested: {
+                        type: "string",
+                    },
+                };
+            }
+        }
+
+        registerClassName(RegisteredEntity.name, "system/entity", entityMix);
+
+        expect(RegisteredEntity.jsonSchema).to.be.an("object");
+        expect(RegisteredEntity.jsonSchema).to.have.nested.property("properties.isDefault"); // check mix schemas
+        expect(RegisteredEntity.jsonSchema).to.have.nested.property("properties.nested.type"); // check custom properties
+    });
 });