@revenexx/studio-integrations 2.0.0 → 2.2.0

package/dist/runtime/utils/workflowFile.js

@@ -0,0 +1,192 @@
+import { deepClone } from "./deepClone.js";
+export const WORKFLOW_FILE_KIND = "revenexx.workflow";
+export const WORKFLOW_FILE_VERSION = 1;
+const BLOB_VERSION = "v0-draft";
+export function withoutCredentials(blob, fieldsFor, credentialIds = /* @__PURE__ */ new Set()) {
+  const out = deepClone(blob);
+  for (const node of out.nodes ?? []) {
+    if (!node.config || typeof node.config !== "object") continue;
+    const fields = fieldsFor(node);
+    if (fields) stripDeclared(fields, node.config);
+    if (credentialIds.size) node.config = stripValues(node.config, credentialIds);
+  }
+  return out;
+}
+function stripDeclared(fields, values) {
+  for (const field of fields) {
+    if (!field?.key || !(field.key in values)) continue;
+    const value = values[field.key];
+    if (field.type === "credentials-ref") {
+      delete values[field.key];
+    } else if (field.type === "object" && field.properties && isRecord(value)) {
+      stripDeclared(field.properties, value);
+    } else if (field.type === "array" && field.items && Array.isArray(value)) {
+      const items = field.items;
+      if (items.type === "credentials-ref") {
+        values[field.key] = [];
+      } else if (items.type === "object" && items.properties) {
+        for (const row of value) if (isRecord(row)) stripDeclared(items.properties, row);
+      }
+    }
+  }
+}
+function stripValues(value, ids) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => !(typeof v === "string" && ids.has(v))).map((v) => stripValues(v, ids));
+  }
+  if (isRecord(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (typeof v === "string" && ids.has(v)) continue;
+      out[k] = stripValues(v, ids);
+    }
+    return out;
+  }
+  return value;
+}
+function isRecord(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+const ENVIRONMENT_TRIGGER_KEYS = ["inbound", "secretRef"];
+function withoutEnvironment(trigger) {
+  const config = { ...trigger.config ?? {} };
+  for (const key of ENVIRONMENT_TRIGGER_KEYS) delete config[key];
+  return { ...trigger, config };
+}
+export function toWorkflowFile(wf, fieldsFor, credentialIds) {
+  const blob = withoutCredentials(wf.blob, fieldsFor, credentialIds);
+  blob.triggers = (blob.triggers ?? []).map(withoutEnvironment);
+  return {
+    kind: WORKFLOW_FILE_KIND,
+    version: WORKFLOW_FILE_VERSION,
+    workflow: {
+      name: wf.name,
+      description: wf.description ?? null,
+      executionMode: wf.execution_mode ?? "async_only",
+      blobDefinitionVersion: wf.blob_definition_version ?? BLOB_VERSION,
+      blob
+    }
+  };
+}
+export function hasVariableValues(blob) {
+  return Object.values(blob.variables ?? {}).some((v) => v?.default !== void 0 && v.default !== null && v.default !== "");
+}
+export function workflowFileName(name) {
+  const slug = name.normalize("NFKD").replace(/\p{Mn}/gu, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${slug || "workflow"}.workflow.json`;
+}
+export function parseWorkflowFile(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "unreadable" };
+  }
+  if (!isRecord(raw)) return { ok: false, reason: "unreadable" };
+  if (raw.kind !== WORKFLOW_FILE_KIND) return { ok: false, reason: "kind" };
+  if (raw.version !== WORKFLOW_FILE_VERSION) return { ok: false, reason: "version" };
+  const wf = raw.workflow;
+  if (!isRecord(wf) || !isRecord(wf.blob)) return { ok: false, reason: "unreadable" };
+  if ((wf.blobDefinitionVersion ?? BLOB_VERSION) !== BLOB_VERSION) return { ok: false, reason: "definition" };
+  const blob = wf.blob;
+  const nodes = blob.nodes;
+  const edges = blob.edges ?? [];
+  const triggers = blob.triggers ?? [];
+  if (!Array.isArray(nodes) || !nodes.every(isNode)) return { ok: false, reason: "unreadable" };
+  if (!Array.isArray(edges) || !edges.every(isEdge)) return { ok: false, reason: "unreadable" };
+  if (!Array.isArray(triggers) || !triggers.every(isTrigger)) return { ok: false, reason: "unreadable" };
+  if (hasDuplicates([...nodes.map((n) => n.id), ...triggers.map((tr) => tr.id)])) return { ok: false, reason: "unreadable" };
+  return {
+    ok: true,
+    file: {
+      kind: WORKFLOW_FILE_KIND,
+      version: WORKFLOW_FILE_VERSION,
+      workflow: {
+        name: typeof wf.name === "string" ? wf.name : "",
+        description: typeof wf.description === "string" ? wf.description : null,
+        executionMode: isExecutionMode(wf.executionMode) ? wf.executionMode : "async_only",
+        blobDefinitionVersion: BLOB_VERSION,
+        blob: {
+          ...blob,
+          nodes: nodes.map((n) => ({ ...n, config: isRecord(n.config) ? n.config : {} })),
+          edges,
+          triggers: triggers.map((tr) => ({ ...tr, config: isRecord(tr.config) ? tr.config : {} }))
+        }
+      }
+    }
+  };
+}
+function hasDuplicates(ids) {
+  return new Set(ids).size !== ids.length;
+}
+function isNode(v) {
+  return isRecord(v) && typeof v.id === "string" && typeof v.nodeSlug === "string";
+}
+function isEdge(v) {
+  return isRecord(v) && isRecord(v.from) && typeof v.from.nodeId === "string" && isRecord(v.to) && typeof v.to.nodeId === "string";
+}
+function isTrigger(v) {
+  return isRecord(v) && typeof v.id === "string" && typeof v.type === "string";
+}
+function isExecutionMode(v) {
+  return v === "async_only" || v === "sync_only" || v === "caller_decides";
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function assignTriggerHandles(blob, taken, keep) {
+  const out = deepClone(blob);
+  const handleMap = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const trigger of out.triggers ?? []) {
+    const keepable = UUID.test(trigger.id) && !taken.has(trigger.id) && !used.has(trigger.id);
+    if (!keepable && !(keep?.(trigger) && !used.has(trigger.id))) {
+      const fresh = crypto.randomUUID();
+      handleMap.set(trigger.id, fresh);
+      trigger.id = fresh;
+    }
+    used.add(trigger.id);
+  }
+  if (!handleMap.size) return out;
+  for (const edge of out.edges ?? []) {
+    const mapped = handleMap.get(edge.from.nodeId);
+    if (mapped) edge.from.nodeId = mapped;
+  }
+  if (out.triggerPositions) {
+    const rekeyed = {};
+    for (const [handle, pos] of Object.entries(out.triggerPositions)) rekeyed[handleMap.get(handle) ?? handle] = pos;
+    out.triggerPositions = rekeyed;
+  }
+  for (const group of out.groups ?? []) {
+    group.nodeIds = (group.nodeIds ?? []).map((id) => handleMap.get(id) ?? id);
+  }
+  return out;
+}
+export function pausedTriggers(blob) {
+  return { ...blob, triggers: (blob.triggers ?? []).map((t) => ({ ...t, active: false })) };
+}
+export function blobForNewWorkflow(file, fieldsFor, tenantHandles, credentialIds = /* @__PURE__ */ new Set()) {
+  const clean = withoutCredentials(file.workflow.blob, fieldsFor, credentialIds);
+  clean.triggers = (clean.triggers ?? []).map(withoutEnvironment);
+  return pausedTriggers(assignTriggerHandles(clean, tenantHandles));
+}
+export function overwritePlan(target, file, fieldsFor, otherHandles, credentialIds = /* @__PURE__ */ new Set()) {
+  const clean = withoutCredentials(file.workflow.blob, fieldsFor, credentialIds);
+  const existing = new Map((target.triggers ?? []).map((t) => [t.id, t]));
+  const same = (t) => existing.get(t.id)?.type === t.type;
+  clean.triggers = (clean.triggers ?? []).map((t) => {
+    const mine = same(t) ? existing.get(t.id) : null;
+    const incoming = withoutEnvironment(t);
+    if (!mine) return { ...incoming, active: false };
+    const config = { ...incoming.config };
+    for (const key of ENVIRONMENT_TRIGGER_KEYS) {
+      if (mine.config?.[key] !== void 0) config[key] = mine.config[key];
+    }
+    return { ...incoming, config, active: mine.active };
+  });
+  const taken = /* @__PURE__ */ new Set([...otherHandles, ...[...existing.values()].map((t) => t.id)]);
+  const blob = assignTriggerHandles(clean, taken, same);
+  return {
+    blob,
+    replaced: { nodes: target.nodes?.length ?? 0, triggers: target.triggers?.length ?? 0 },
+    incoming: { nodes: blob.nodes.length, triggers: blob.triggers?.length ?? 0 }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {
@@ -28,6 +28,7 @@
     "@nuxt/kit": "^4.0.0",
     "@revenexx/studio-shared": "^0.3.2",
     "@solar-icons/nuxt": "^1.2.0",
+    "@solar-icons/vue": "^1.2.0",
     "marked": "^18.0.5"
   },
   "peerDependencies": {
@@ -52,12 +53,15 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/kit": "^4.0.0",
     "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.0.0",
     "@playwright/test": "^1.57.0",
-    "@nuxt/kit": "^4.0.0",
     "@revenexx/talkback-js": "^0.3.0",
-    "@nuxt/schema": "^4.0.0",
+    "eslint": "^10.11.0",
     "nuxt": "^4.2.2",
+    "typescript": "5.9.3",
     "vitest": "^3.2.0",
     "vue": "^3.5.26",
     "vue-tsc": "^2.2.0"
@@ -68,6 +72,7 @@
     "test": "vitest run",
     "test:e2e": "playwright test",
     "typecheck": "node scripts/typecheck.mjs",
+    "lint": "eslint . --max-warnings=0",
     "spec:check": "node scripts/spec-check.mjs",
     "changeset": "changeset",
     "version-packages": "changeset version"