Merge pull request #53 from Exabyte-io/epic/SOF-6009

Epic/SOF-6009

Author: azech-hqs

package-lock.json

@@ -56,7 +56,7 @@
         "@babel/preset-react": "7.16.7",
         "@babel/register": "^7.16.0",
         "@babel/runtime-corejs3": "7.16.8",
-        "@exabyte-io/esse.js": "2023.8.30-0",
+        "@exabyte-io/esse.js": "2023.8.31-0",
         "@types/chai": "^4.3.5",
         "@types/crypto-js": "^4.1.1",
         "@types/js-yaml": "^4.0.5",
@@ -77,6 +77,7 @@
         "mixwith": "^0.1.1",
         "nunjucks": "^3.2.4",
         "react-jsonschema-form": "^1.8.1",
+        "semver": "^7.5.3",
         "ts-node": "^10.9.1",
         "typescript": "^4.5.5",
         "underscore": "^1.13.3",

package.json

@@ -6,7 +6,7 @@ interface PathObject {
 }
 
 // Filter conditions
-interface FilterObject {
+export interface FilterObject {
     path?: string;
     regex?: RegExp;
 }
@@ -57,6 +57,7 @@ export function filterEntityList({
     filterObjects = [],
     multiPathSeparator = "",
 }: FilterEntityListProps) {
+    if (!filterObjects || !filterObjects.length) return [];
     const filterObjects_ = filterObjects.map((o) => (o.regex ? { regex: new RegExp(o.regex) } : o));
 
     let filtered;

src/utils/filter.ts

@@ -31,6 +31,7 @@ import { getSchemaWithDependencies } from "./schemas";
 import { getSearchQuerySelector } from "./selector";
 import {
     convertArabicToRoman,
+    findPreviousVersion,
     randomAlphanumeric,
     removeCommentsFromSourceCode,
     removeEmptyLinesFromString,
@@ -89,4 +90,5 @@ export {
     getFilesInDirectory,
     getDirectories,
     createObjectPathFromFilePath,
+    findPreviousVersion,
 };

src/utils/index.ts

@@ -10,6 +10,7 @@ import omit from "lodash/omit";
 
 import { AnyObject } from "../entity/in_memory";
 import { NameResultSchema } from "../types";
+import { safeMakeArray } from "./array";
 import { deepClone } from "./clone";
 
 /**
@@ -248,6 +249,7 @@ function isTreeObject<T>(value: unknown): value is Tree<T> {
  * mergeTerminalNodes(tree); // ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']
  */
 export function mergeTerminalNodes<T = string>(tree: Tree<T>, unique = false): T[] {
+    if (!isTreeObject<T>(tree)) return safeMakeArray(tree);
     const terminalValues = Object.values(tree).reduce((accumulator: T[], value) => {
         if (isTreeObject<T>(value)) {
             return accumulator.concat(mergeTerminalNodes(value));

src/utils/object.ts

@@ -1,6 +1,5 @@
 import { JSONSchema } from "@exabyte-io/esse.js/schema";
 import forEach from "lodash/forEach";
-import getValue from "lodash/get";
 import hasProperty from "lodash/has";
 import isEmpty from "lodash/isEmpty";
 
@@ -10,19 +9,26 @@ export * from "@exabyte-io/esse.js/lib/js/esse/schemaUtils";
 
 export const schemas: { [key: string]: string } = {};
 
+interface SubstitutionMap {
+    [key: string]: string;
+}
+
+interface Parameter {
+    key: string;
+    values: string[] | boolean[];
+    namesMap?: SubstitutionMap;
+}
+
 interface Node {
-    dataSelector: {
+    data: {
         key: string;
         value: string;
         name: string;
     };
+    staticOptions: Parameter[];
     children?: Node[];
 }
 
-function isNodeWithChildren(node: Node): node is Required<Node> {
-    return Boolean(node.children?.length);
-}
-
 /**
  * Returns previously registered schema for InMemoryEntity
  * @returns
@@ -52,53 +58,67 @@ export function typeofSchema(schema: JSONSchema) {
     }
 }
 
-function getEnumValues(nodes: Node[]) {
-    if (!nodes.length) return {};
+function extractEnumOptions(nodes?: Node[]) {
+    if (!nodes || !nodes.length) return {};
     return {
-        enum: nodes.map((node) => getValue(node, node.dataSelector.value)),
+        enum: nodes.map((node) => node.data.value),
+        enumNames: nodes.map((node) => node.data.name),
     };
 }
 
-function getEnumNames(nodes: Node[]) {
-    if (!nodes.length) return {};
-    return {
-        enumNames: nodes.map((node) => getValue(node, node.dataSelector.name)),
-    };
+function substituteName(value: unknown, mapping?: SubstitutionMap) {
+    if (typeof value !== "string") {
+        return JSON.stringify(value);
+    }
+    return mapping ? mapping[value] : value;
+}
+
+function createStaticFields(node: Node) {
+    if (!node.staticOptions) return {};
+    const fields: { [key: string]: { enum: string[] | boolean[]; enumNames: string[] } } = {};
+    node.staticOptions
+        .filter((o) => o.key && o.values)
+        .forEach((o) => {
+            fields[o.key] = {
+                enum: o.values,
+                enumNames: o.values.map((v) => substituteName(v, o.namesMap)),
+            };
+        });
+    return fields;
 }
 
 /**
  * @summary Recursively generate `dependencies` for RJSF schema based on tree.
  * @param {Object[]} nodes - Array of nodes (e.g. `[tree]` or `node.children`)
  * @returns {{}|{dependencies: {}}}
  */
-export function buildDependencies(nodes: Node[]): JSONSchema {
-    if (nodes.length === 0 || nodes.every((n) => !n.children?.length)) return {};
-
-    const nodesWithChildren = nodes.filter(isNodeWithChildren);
-    const parentKey = nodesWithChildren[0].dataSelector.key;
-    const childKey = nodesWithChildren[0].children[0].dataSelector.key;
-
-    return {
-        dependencies: {
-            [parentKey]: {
-                oneOf: nodesWithChildren.map((node) => {
-                    return {
-                        properties: {
-                            [parentKey]: {
-                                ...getEnumValues([node]),
-                                ...getEnumNames([node]),
-                            },
-                            [childKey]: {
-                                ...getEnumValues(node.children),
-                                ...getEnumNames(node.children),
-                            },
-                        },
-                        ...buildDependencies(node.children),
-                    };
-                }),
+export function buildDependencies(nodes?: Node[]): JSONSchema {
+    const isEveryTerminal = nodes && nodes.every((node) => !node.children?.length);
+    const isWithStaticOptions = nodes && nodes.some((node) => node?.staticOptions);
+    if (!nodes || !nodes.length || !nodes[0].data) return {};
+    const parentKey = nodes[0].data.key;
+
+    const cases = nodes.map((node) => {
+        const childKey = node.children?.length && node.children[0].data.key;
+        return {
+            properties: {
+                [parentKey]: extractEnumOptions([node]),
+                ...(childKey ? { [childKey]: extractEnumOptions(node.children) } : {}),
+                ...createStaticFields(node),
             },
-        },
-    };
+            ...buildDependencies(node.children),
+        };
+    });
+
+    return cases.length && (!isEveryTerminal || isWithStaticOptions)
+        ? {
+              dependencies: {
+                  [parentKey]: {
+                      oneOf: cases,
+                  },
+              },
+          }
+        : {};
 }
 
 interface Props {
@@ -131,9 +151,8 @@ export function getSchemaWithDependencies({
     // RJSF does not automatically render dropdown widget if `enum` is not present
     if (modifyProperties && nodes.length) {
         const mod = {
-            [nodes[0].dataSelector.key]: {
-                ...getEnumNames(nodes),
-                ...getEnumValues(nodes),
+            [nodes[0].data.key]: {
+                ...extractEnumOptions(nodes),
             },
         };
         forEach(mod, (extraFields, key) => {

src/utils/schemas.ts

@@ -1,5 +1,8 @@
 import lodash from "lodash";
 import nunjucks from "nunjucks";
+import semverCoerce from "semver/functions/coerce";
+import semverLt from "semver/functions/lt";
+import semverRcompare from "semver/functions/rcompare";
 import _ from "underscore";
 
 export function removeNewLinesAndExtraSpaces(str) {
@@ -124,3 +127,18 @@ export function renderTextWithSubstitutes(template, data, substitutionMap = {})
     substituteNested(renderData);
     return nunjucks.renderString(template, renderData);
 }
+
+/**
+ * Find the next smallest version from a list of semantic version strings.
+ * @param {string[]} versions - Array of semantic version strings.
+ * @param {string} inputVersion - Version to compare to.
+ * @returns {string | undefined}
+ */
+export function findPreviousVersion(versions, inputVersion) {
+    const version = semverCoerce(inputVersion);
+    const versions_ = versions
+        .map((v) => ({ raw: v, coerced: semverCoerce(v) }))
+        .sort((a, b) => semverRcompare(a.coerced, b.coerced));
+    const prev = versions_.find((o) => semverLt(o.coerced, version));
+    return prev?.raw;
+}

src/utils/str.js

@@ -90,17 +90,30 @@ function readFromYaml(ref) {
  *   - `key`: name or path of parameter, e.g. `job.workflow`
  *   - `values`: list of values (use either `ref` or `values`)
  *   - `ref`: reference to values in another YAML file.
+ *   - `exclude`: regular expression for excluding items.
  *   - `isOptional`: whether parameter is optional (adds `null` to values array)
+ *   - `merge`: arrays or values from other sources to merge
  * See the tests for example usage.
  */
 export const parameterType = new yaml.Type("!parameter", {
     kind: "mapping",
     construct(data) {
-        const { key, values = [], ref, exclude, isOptional = false, ...otherProps } = data;
+        const {
+            key,
+            values = [],
+            ref,
+            exclude,
+            isOptional = false,
+            merge = [],
+            ...otherProps
+        } = data;
 
         try {
             let values_ = ref && !values.length ? readFromYaml(ref) : values;
             values_ = safeMakeArray(values_);
+            if (Array.isArray(merge)) {
+                values_ = values_.concat(merge.flat());
+            }
             if (exclude) {
                 const regex = new RegExp(exclude);
                 values_ = values_.filter((v) => !regex.test(v));