SOF-6535: new JSONSchema logic

package.json

@@ -28,7 +28,9 @@
         "./dist/utils": "./dist/utils/index.js",
         "./dist/constants": "./dist/constants.js",
         "./dist/math": "./dist/math.js",
-        "./dist/JSONSchemasInterface": "./dist/JSONSchemasInterface.js"
+        "./dist/utils/schemas": "./dist/utils/schemas.js",
+        "./dist/JSONSchemasInterface": "./dist/JSONSchemasInterface.js",
+        "./dist/bin/compileTS": "./dist/bin/compileTS.js"
     },
     "files": [
         "/dist",
@@ -42,6 +44,7 @@
     "license": "Apache-2.0",
     "homepage": "https://github.com/Exabyte-io/code.js",
     "dependencies": {
+        "json-schema-deref-sync": "0.14.0",
         "@babel/cli": "7.16.0",
         "@babel/core": "7.16.0",
         "@babel/eslint-parser": "7.16.3",
@@ -50,11 +53,12 @@
         "@babel/preset-react": "7.16.7",
         "@babel/register": "^7.16.0",
         "@babel/runtime-corejs3": "7.16.8",
-        "@exabyte-io/esse.js": "2023.7.14-0",
+        "@exabyte-io/esse.js": "2023.7.28-0",
         "ajv": "4.1.7",
         "crypto-js": "^4.1.1",
         "js-yaml": "^4.1.0",
         "json-schema-merge-allof": "^0.8.1",
+        "json-schema-to-typescript": "^13.0.2",
         "lodash": "^4.17.21",
         "mathjs": "^3.9.0",
         "mixwith": "^0.1.1",

src/JSONSchemasInterface.js

@@ -1,7 +1,10 @@
-import { schemas } from "@exabyte-io/esse.js/schemas";
+import baseSchema from "@exabyte-io/esse.js/schema";
 import Ajv from "ajv";
+import deref from "json-schema-deref-sync";
 import mergeAllOf from "json-schema-merge-allof";
 
+export const esseSchema = baseSchema;
+
 const schemasCache = new Map();
 
 /**
@@ -41,20 +44,16 @@ function removeSchemaIdsAfterAllOf(schema, clean = false) {
 }
 
 export class JSONSchemasInterface {
+    _schema = null;
+
     /**
      *
      * @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);
-
-            if (!originalSchema) {
-                throw new Error(`Schema not found: ${schemaId}`);
-            }
-
-            this.registerSchema(originalSchema);
+        if (schemasCache.size === 0) {
+            JSONSchemasInterface.registerGlobalSchema(esseSchema);
         }
 
         return schemasCache.get(schemaId);
@@ -64,16 +63,28 @@ export class JSONSchemasInterface {
      *
      * @param {Object} - external schema
      */
-    static registerSchema(originalSchema) {
-        const schema = mergeAllOf(removeSchemaIdsAfterAllOf(originalSchema), {
-            resolvers: {
-                defaultResolver: mergeAllOf.options.resolvers.title,
-            },
-        });
+    static registerGlobalSchema(globalSchema) {
+        if (JSONSchemasInterface._schema === globalSchema) {
+            // performance optimization:
+            // skip resolving as we already did it for the same globalSchema object
+            return;
+        }
 
-        schemasCache.set(schema.schemaId, schema);
+        JSONSchemasInterface._schema = globalSchema;
 
-        return schema;
+        const { definitions } = deref(globalSchema);
+
+        schemasCache.clear();
+
+        Object.values(definitions).forEach((originalSchema) => {
+            const schema = mergeAllOf(removeSchemaIdsAfterAllOf(originalSchema), {
+                resolvers: {
+                    defaultResolver: mergeAllOf.options.resolvers.title,
+                },
+            });
+
+            schemasCache.set(schema.schemaId, schema);
+        });
     }
 
     /**
@@ -99,7 +110,8 @@ export class JSONSchemasInterface {
      */
     static matchSchema(query) {
         const searchFields = Object.keys(query);
-        return schemas.find((schema) => {
+
+        return Array.from(schemasCache.values()).find((schema) => {
             return searchFields.every((field) => {
                 const { $regex } = query[field];
                 return new RegExp($regex).test(schema[field]);

src/bin/compileTS.js

@@ -0,0 +1,62 @@
+import { makeFlatSchemaKey, makeFlatSchemaRef } from "@exabyte-io/esse.js/lib/js/esse/schemaUtils";
+import fs from "fs/promises";
+import { compile } from "json-schema-to-typescript";
+
+/**
+ * Compiles ESSE JSON schemas to TypeScript interfaces/types
+ * @param {Object} globalSchema
+ * @param {String} savePath
+ * @returns {Promise<void>}
+ * @example
+ * await compileTS(esseSchema, "./dist/types.ts");
+ */
+export async function compileTS(globalSchema, savePath) {
+    const preparedDefinitions = Object.entries(globalSchema.definitions).reduce(
+        (newDefinitions, [key, schema]) => {
+            if (schema.allOf && schema.properties) {
+                /**
+                 * The current version of json-schema-to-typescript ignores properties if there is allOf array in the schema.
+                 * To fix the issue here we are creating a separate schema from properties and add it to the allOf array
+                 */
+                return [
+                    ...newDefinitions,
+                    [
+                        key,
+                        {
+                            ...schema,
+                            allOf: [
+                                ...schema.allOf,
+                                makeFlatSchemaRef(`${schema.schemaId}-properties`),
+                            ],
+                            properties: null,
+                        },
+                    ],
+                    [
+                        makeFlatSchemaKey(`${schema.schemaId}-properties`),
+                        {
+                            schemaId: `${schema.schemaId}-properties`,
+                            type: "object",
+                            properties: schema.properties,
+                        },
+                    ],
+                ];
+            }
+
+            return [...newDefinitions, [key, schema]];
+        },
+        [],
+    );
+
+    const compiled = await compile(
+        {
+            ...globalSchema,
+            definitions: Object.fromEntries(preparedDefinitions),
+        },
+        "",
+        {
+            unreachableDefinitions: true,
+        },
+    );
+
+    await fs.writeFile(savePath, compiled);
+}

src/entity/in_memory.js

@@ -1,6 +1,5 @@
 import lodash from "lodash";
 
-// import { ESSE } from "@exabyte-io/esse.js";
 import { clone, deepClone } from "../utils/clone";
 import { getSchemaByClassName } from "../utils/schemas";
 
@@ -191,45 +190,13 @@ 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 class JSON schema
      * @returns {Object} schema
      */
     static get jsonSchema() {
         try {
-            if (!this.customJsonSchemaProperties) {
-                return getSchemaByClassName(this.name);
-            }
-
-            const { properties, ...schema } = getSchemaByClassName(this.name);
-
-            return {
-                ...schema,
-                properties: {
-                    ...properties,
-                    ...this.customJsonSchemaProperties,
-                },
-            };
+            return getSchemaByClassName(this.name);
         } catch (e) {
             console.error(e.stack);
             throw e;