Merge pull request #70 from Exabyte-io/feat/SOF-6923

feat/SOF-6923

Author: seankwarren

src/utils/index.ts

@@ -27,7 +27,7 @@ import {
     sortKeysDeepForObject,
     stringifyObject,
 } from "./object";
-import { getSchemaWithDependencies } from "./schemas";
+import { getSchemaWithDependencies, buildNamedEntitySchema } from "./schemas";
 import { getSearchQuerySelector } from "./selector";
 import {
     convertArabicToRoman,
@@ -90,5 +90,6 @@ export {
     getFilesInDirectory,
     getDirectories,
     createObjectPathFromFilePath,
+    buildNamedEntitySchema,
     findPreviousVersion,
 };

src/utils/schemas.ts

@@ -3,6 +3,8 @@ import forEach from "lodash/forEach";
 import hasProperty from "lodash/has";
 import isEmpty from "lodash/isEmpty";
 
+import { JSONSchema7Definition } from "json-schema";
+
 import { JSONSchemasInterface } from "../JSONSchemasInterface";
 
 export * from "@exabyte-io/esse.js/lib/js/esse/schemaUtils";
@@ -170,3 +172,123 @@ export function getSchemaWithDependencies({
         ...buildDependencies(nodes),
     };
 }
+
+const DEFAULT_GENERATIVE_KEYS = ["name"];
+
+interface NamedEntity {
+    name: string;
+}
+
+const baseSchema = (definitionName: string, enforceUnique = true): JSONSchema => {
+    return {
+        type: "array",
+        items: {
+            $ref: `#/definitions/${definitionName}`,
+        },
+        uniqueItems: enforceUnique,
+    };
+};
+
+const defaultNamedEntitySchema = (name: string) => {
+    return {
+        properties: {
+            name: {
+                type: "string",
+                enum: [name],
+            },
+        },
+    } as JSONSchema;
+};
+
+/**
+ * Retrieves an RJSF schema with an id matching the provided name
+ */
+export const schemaByNamedEntityName = (name: string): JSONSchema | undefined => {
+    const translatedName = name.replace(/_/g, "-");
+    const schema = JSONSchemasInterface.matchSchema({
+        $id: {
+            $regex: `${translatedName}$`,
+        },
+    });
+    return schema;
+};
+
+/*
+ * Filters an RJSF schema for all the properties used to generate a new schema
+ */
+const filterForGenerativeProperties = (schema: JSONSchema) => {
+    if (!schema.properties || typeof schema.properties !== "object") return {};
+    const generativeFilter = ([propertyKey, property]: [string, JSONSchema7Definition]) => {
+        return (
+            (typeof property === "object" && // JSONSchema7Definition type allows for boolean
+                property?.$comment &&
+                property.$comment.includes("isGenerative:true")) ||
+            DEFAULT_GENERATIVE_KEYS.includes(propertyKey)
+        );
+    };
+    // @ts-ignore : JSONSchema6 and JSONSchema7 are incompatible
+    const generativeProperties = Object.entries(schema.properties).filter(generativeFilter);
+    const properties = Object.fromEntries(generativeProperties);
+    return { properties, required: Object.keys(properties) } as JSONSchema; // all included fields are required based on isGenerative flag
+};
+
+/*
+ * Filters an RJSF schema for all the properties used to generate a new schema
+ */
+const buildNamedEntitiesDependencies = (entities: NamedEntity[]) => {
+    return {
+        dependencies: {
+            name: {
+                oneOf: entities.map((entity) => {
+                    const schema =
+                        schemaByNamedEntityName(entity.name) ||
+                        defaultNamedEntitySchema(entity.name);
+                    return {
+
+                        ...filterForGenerativeProperties(schema),
+                    };
+                }),
+            },
+        },
+    };
+};
+
+/**
+ * Generates an RJSF definition with a list of subschemas as enumerated options
+ */
+const buildNamedEntitiesDefinitions = (
+    entities: NamedEntity[],
+    defaultEntity: NamedEntity,
+    entityType: string,
+) => {
+    if (!Array.isArray(entities) || entities.length < 1) return {};
+    return {
+        definitions: {
+            [entityType]: {
+                properties: {
+                    name: {
+                        type: "string",
+                        enum: entities.map((entity) => entity.name),
+                        default: defaultEntity.name || entities[0].name,
+                    },
+                },
+                ...buildNamedEntitiesDependencies(entities),
+            },
+        },
+    };
+};
+
+/*
+ * Generates an RJSF scheme with a list of subschemas as enumerated options
+ */
+export const buildNamedEntitySchema = (
+    entities: NamedEntity[],
+    defaultEntity: NamedEntity,
+    entityType: string,
+    enforceUnique = true,
+): JSONSchema => {
+    return {
+        ...buildNamedEntitiesDefinitions(entities, defaultEntity, entityType),
+        ...baseSchema(entityType, enforceUnique),
+    } as JSONSchema;
+};