@knime/hub-features 1.26.2 → 1.28.0

package/src/analytics/schema/code-generator.js

@@ -0,0 +1,158 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const schemaPath = path.join(__dirname, "schema.json");
+const editorOutputPath = path.join(__dirname, "editor-event-functions.ts");
+const cloudHomeOutputPath = path.join(
+  __dirname,
+  "cloudhome-event-functions.ts",
+);
+
+const schema = JSON.parse(fs.readFileSync(schemaPath, "utf8"));
+const events = schema.properties.events.properties;
+
+const TYPE_HELPERS = {
+  analyticsEvent: "AnalyticsEvent",
+  defaultContext: "DefaultContext",
+  fnParams: "EventFunctionArgs",
+  generatedStaticFields: "GeneratedStaticFields",
+  schemaStaticFields: "SchemaStaticFields",
+};
+
+const HEADER_LINES = [
+  "/* eslint-disable max-lines */",
+  "/* eslint-disable camelcase */",
+  "/* eslint-disable @typescript-eslint/no-explicit-any */",
+  "// AUTO-GENERATED FILE. DO NOT EDIT.",
+  `import type { ${Object.values(TYPE_HELPERS).join(", ")} } from "../types";`,
+  'import { toSnakeCaseDeep } from "../utils/toSnakeCaseDeep";',
+];
+const editorResult = [];
+const cloudHomeResult = [];
+
+/**
+ * Generic event definition, read from the schema.json.
+ * @typedef {{
+ * 	properties: {
+ * 		data: { $ref?: string };
+ * 		[key: string]: any;
+ *  };
+ *  $comment?: string;
+ * }} EventDefinition
+ */
+
+/**
+ * Generate the JSDoc string for the generated event function, if it has a `$comment` field
+ * in the schema
+ * @param {EventDefinition} eventDef
+ * @returns {String}
+ */
+const generateJSDocComment = (eventDef) => {
+  // eslint-disable-next-line no-useless-concat
+  const jsdoc = "/**\n" + ` * ${eventDef.$comment}\n` + " */";
+  return jsdoc;
+};
+
+/**
+ * Resolves the const value from a property, handling both direct `const` and
+ * `allOf`-based patterns like `{ allOf: [{ $ref: "..." }, { const: "value" }] }`
+ * @param {{ const?: any; allOf?: Array<{ const?: any }> }} prop
+ * @returns {any | undefined}
+ */
+const resolveConst = (prop) => {
+  if (prop.const !== undefined) {
+    return prop.const;
+  }
+  if (Array.isArray(prop.allOf)) {
+    return prop.allOf.find((s) => s.const !== undefined)?.const;
+  }
+  return undefined;
+};
+
+/**
+ * Generates an event function for an event based on its name and definition
+ * @param {String} fnName
+ * @param {EventDefinition} eventDef
+ * @param {Boolean} isPayloadRequired whether the function requires a data payload
+ * @returns {String} function as a string to be added to the generated file
+ */
+const generateEventFunction = (fnName, eventDef, isPayloadRequired = true) => {
+  const params = isPayloadRequired
+    ? `eventData: ${TYPE_HELPERS.fnParams}<"${fnName}">`
+    : "";
+
+  let fn =
+    // function header
+    `export const ${fnName} = <T extends ${TYPE_HELPERS.defaultContext}>(ctx: T) => (${params}): ${TYPE_HELPERS.analyticsEvent} => {\n` +
+    // open object for static data and add properties that are static but generated at runtime
+    "  const staticData = {\n" +
+    "    ...toSnakeCaseDeep(ctx),\n" +
+    "    unique_event_id: crypto.randomUUID(),\n" +
+    "    timestamp: new Date().toISOString(),\n";
+
+  for (const [key, prop] of Object.entries(eventDef.properties)) {
+    // add properties that are static and whose values come from the schema
+    const constValue = resolveConst(prop);
+    if (constValue !== undefined) {
+      fn += `    ${key}: "${constValue}",\n`;
+    } else if (prop.type === "object" && prop.properties) {
+      // nested object (e.g. action): emit only sub-properties that have const values
+      fn += `    ${key}: {\n`;
+      for (const [subKey, subProp] of Object.entries(prop.properties)) {
+        const subConstValue = resolveConst(subProp);
+        if (subConstValue !== undefined) {
+          fn += `      ${subKey}: "${subConstValue}",\n`;
+        }
+      }
+      fn += "    },\n";
+    }
+  }
+
+  // close object for staticData
+  fn += `  } satisfies ${TYPE_HELPERS.schemaStaticFields} & ${TYPE_HELPERS.generatedStaticFields};\n\n`;
+
+  const payload = isPayloadRequired
+    ? "{ ...staticData, payload: { ...toSnakeCaseDeep(eventData as Record<string, any>) } }"
+    : "{ ...staticData }";
+
+  fn += `  const event = { id: staticData.event_name, data: ${payload} };\n\n`;
+  fn += "  return event;\n";
+  fn += "};\n\n";
+
+  return fn;
+};
+
+/**
+ * Checks whether the given event definition has an empty payload or requires data
+ * @param {EventDefinition} eventDef
+ * @returns
+ */
+const hasEmptyPayload = (eventDef) => {
+  return Boolean(eventDef.properties.payload?.$ref?.includes("EmptyPayload"));
+};
+
+for (const [fnName, eventDef] of Object.entries(events)) {
+  const isPayloadRequired = !hasEmptyPayload(eventDef);
+  let fn = generateEventFunction(fnName, eventDef, isPayloadRequired);
+
+  if (eventDef.$comment) {
+    const jsdoc = generateJSDocComment(eventDef);
+    fn = `${jsdoc}\n${fn}`;
+  }
+
+  if (eventDef.properties.event_source.const === "editor") {
+    editorResult.push(fn);
+  } else if (eventDef.properties.event_source.const === "cloudhome") {
+    cloudHomeResult.push(fn);
+  }
+}
+
+const editorFileContent = `${HEADER_LINES.join("\n")}\n\n${editorResult.join("")}`;
+const cloudHomeFileContent = `${HEADER_LINES.join("\n")}\n\n${cloudHomeResult.join("")}`;
+
+fs.writeFileSync(editorOutputPath, editorFileContent, "utf8");
+fs.writeFileSync(cloudHomeOutputPath, cloudHomeFileContent, "utf8");
+// eslint-disable-next-line no-console
+console.log("Generated static data based on the Events JSON Schema.");