fix: conflicts

Author: k0stik

package.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": "git+https://github.com/Exabyte-io/esse.git#9745f43ab21c1b5774da6ce7601b017ff92d03b0",
+        "@exabyte-io/esse.js": "2022.10.21-1",
         "crypto-js": "^4.1.1",
         "json-schema-merge-allof": "^0.8.1",
         "lodash": "^4.17.21",

src/JSONSchemasInterface.js

@@ -2,6 +2,43 @@ import { schemas } from "@exabyte-io/esse.js/schemas";
 import mergeAllOf from "json-schema-merge-allof";
 
 const schemasCache = new Map();
+
+/**
+ * We assume that each schema in the application has its own unique schemaId
+ * Unfortunately, mergeAllOf keeps schemaId after merging, and this results in multiple different schemas with the same schemaId
+ * Hence this function
+ */
+function removeSchemaIdsAfterAllOf(schema, clean = false) {
+    if (clean) {
+        const { schemaId, ...restSchema } = schema;
+
+        return restSchema;
+    }
+
+    if (Array.isArray(schema)) {
+        return schema.map((item) => removeSchemaIdsAfterAllOf(item));
+    }
+
+    if (typeof schema !== "object") {
+        return schema;
+    }
+
+    if (schema.allOf) {
+        const { allOf, ...restSchema } = schema;
+
+        return {
+            allOf: allOf.map((innerSchema) => removeSchemaIdsAfterAllOf(innerSchema, true)),
+            ...restSchema,
+        };
+    }
+
+    return Object.fromEntries(
+        Object.entries(schema).map(([key, value]) => {
+            return [key, removeSchemaIdsAfterAllOf(value)];
+        }),
+    );
+}
+
 export class JSONSchemasInterface {
     /**
      *
@@ -16,13 +53,7 @@ export class JSONSchemasInterface {
                 throw new Error(`Schema not found: ${schemaId}`);
             }
 
-            const schema = mergeAllOf(originalSchema, {
-                resolvers: {
-                    defaultResolver: mergeAllOf.options.resolvers.title,
-                },
-            });
-
-            schemasCache.set(schemaId, schema);
+            this.registerSchema(originalSchema);
         }
 
         return schemasCache.get(schemaId);
@@ -32,8 +63,16 @@ export class JSONSchemasInterface {
      *
      * @param {Object} - external schema
      */
-    static registerSchema(schema) {
+    static registerSchema(originalSchema) {
+        const schema = mergeAllOf(removeSchemaIdsAfterAllOf(originalSchema), {
+            resolvers: {
+                defaultResolver: mergeAllOf.options.resolvers.title,
+            },
+        });
+
         schemasCache.set(schema.schemaId, schema);
+
+        return schema;
     }
 
     /**

tests/JSONSchemasInterface.tests.js

@@ -1,4 +1,4 @@
-import { expect } from "chai";
+import { assert, expect } from "chai";
 
 import { JSONSchemasInterface } from "../src/JSONSchemasInterface";
 
@@ -18,17 +18,74 @@ describe("JSONSchemasInterface", () => {
         expect(schema).to.be.an("object");
     });
 
-    it("can find registered schemas", () => {
+    it("can find registered schemas; the schema is merged and clean", () => {
         JSONSchemasInterface.registerSchema({
-            schemaId: "test-schema-id",
+            schemaId: "system/in-set",
+            $schema: "http://json-schema.org/draft-04/schema#",
+            title: "System in-set schema",
             properties: {
-                testProp: {
+                inSet: {
+                    type: "array",
+                    items: {
+                        allOf: [
+                            {
+                                schemaId: "system/entity-reference",
+                                $schema: "http://json-schema.org/draft-04/schema#",
+                                title: "entity reference schema",
+                                properties: {
+                                    _id: {
+                                        description: "entity identity",
+                                        type: "string",
+                                    },
+                                    cls: {
+                                        description: "entity class",
+                                        type: "string",
+                                    },
+                                    slug: {
+                                        description: "entity slug",
+                                        type: "string",
+                                    },
+                                },
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                    },
+                                    index: {
+                                        type: "number",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+                valueMapFunction: {
+                    description: "Specifies the function to convert the currentValue in UI.",
                     type: "string",
+                    enum: [
+                        "toString",
+                        "toContactUs",
+                        "toPlusMinusSign",
+                        "toUnlimited",
+                        "toSupportSeverity",
+                    ],
+                    default: "toString",
                 },
             },
         });
 
-        const schema = JSONSchemasInterface.schemaById("test-schema-id");
+        const schema = JSONSchemasInterface.schemaById("system/in-set");
+
         expect(schema).to.be.an("object");
+        assert(schema.schemaId, "system/in-set");
+        expect(schema.properties.inSet.items.schemaId).to.be.an("undefined");
+        expect(schema.properties.inSet.items.properties).to.be.an("object");
+        expect(schema.properties.valueMapFunction.enum[0]).to.be.an("string");
+        expect(schema.properties.valueMapFunction.enum[1]).to.be.an("string");
+        expect(schema.properties.valueMapFunction.enum[2]).to.be.an("string");
+        expect(schema.properties.valueMapFunction.enum[3]).to.be.an("string");
+        expect(schema.properties.valueMapFunction.enum[4]).to.be.an("string");
     });
 });