@revenexx/studio-integrations 1.4.1 → 2.1.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": "1.4.1",
+  "version": "2.1.0",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {
@@ -26,13 +26,14 @@
   },
   "dependencies": {
     "@nuxt/kit": "^4.0.0",
-    "@revenexx/studio-shared": "^0.3.0",
+    "@revenexx/studio-shared": "^0.3.2",
     "@solar-icons/nuxt": "^1.2.0",
+    "@solar-icons/vue": "^1.2.0",
     "marked": "^18.0.5"
   },
   "peerDependencies": {
     "@dagrejs/dagre": "^3.0.0",
-    "@revenexx/studio": "*",
+    "@revenexx/studio": "^0.2.3",
     "@tiptap/core": "^3.28.0",
     "@tiptap/extension-document": "^3.28.0",
     "@tiptap/extension-history": "^3.28.0",
@@ -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"

package/dist/runtime/utils/errorPathAdvice.d.ts

@@ -1,60 +0,0 @@
-import type { WorkflowBlob } from '../types/integrations.js';
-/**
- * Nodes that route failures to an error output nothing is connected to
- * (specs/workflow-advice.md).
- *
- * A step that fails on a path its author drew is handled. A step that fails on a
- * path nobody drew is not: the engine ends the run there
- * (`specs/node-failure-handling.md` AC-8 in the service repository), and before
- * it did, the failure vanished and the run reported success. Either way the
- * author never chose it — they simply never saw the port.
- *
- * ## Why this is advice and not a finding
- *
- * The backend's validation findings feed the activation gate AND an
- * unconditional refusal to start a run. A finding here would therefore stop
- * every workflow with an unwired error port from running at all — turning
- * "delivers nothing quietly" into "does not start", for authors who never asked
- * for either. Computing it in the editor makes that impossible rather than
- * merely unlikely: there is no value for a blocking consumer to read.
- *
- * What the client cannot do is be authoritative — the catalogue may not be
- * loaded, and a workflow built through the API never passes here at all. For
- * advice that is the right trade; for a gate it would not be, which is why the
- * gate stays where the manifests are.
- *
- * ## Deliberately not in `validationFindings.ts`
- *
- * Everything there is a backend finding addressed by blob path, and the node
- * card counts those as *incomplete settings*. An unwired port is neither. Sent
- * through `groupFindingsByNode` it would type-check perfectly and quietly
- * corrupt two counts — the banner's and the card badge's.
- */
-export interface ErrorPathAdvice {
-    /** Blob node id — not an index, so it survives a node being added or removed. */
-    nodeId: string;
-    /** The error output with nothing attached. */
-    port: string;
-}
-/**
- * Every unwired error output in the blob, in node order.
- *
- * Runs against the blob the author is *editing*, not the saved one, so wiring a
- * port clears its line in the same tick — no save, and no second copy of this
- * rule to decide when the advice went stale.
- *
- * **Resolved against whichever manifest version the catalogue has.**
- * `findManifest` falls back to another version of the same slug when the pinned
- * one is absent, and that fallback is accepted here: a node pinned to a version
- * nobody serves any more is better described by a sibling version than by
- * silence. The cost is real though — where the versions disagree about their
- * ports, the advice describes the sibling's, so a port could be named that the
- * author's own node does not have.
- *
- * **Reads the manifest's static outputs only.** A node whose ports are named at
- * author time (`sourceFromConfig` / `resolveOutputs`) cannot be judged from the
- * declaration alone, so nothing is claimed about it — the same forbearance the
- * engine shows. No shipped node has a dynamic error port today; if one appears,
- * this is where it would silently escape notice.
- */
-export declare function unwiredErrorPorts(blob: Pick<WorkflowBlob, 'nodes' | 'edges'>): ErrorPathAdvice[];

package/dist/runtime/utils/errorPathAdvice.js

@@ -1,19 +0,0 @@
-import { findManifest } from "../data/integrationNodeCatalog.js";
-export function unwiredErrorPorts(blob) {
-  const advice = [];
-  for (const node of blob.nodes) {
-    const manifest = findManifest(node.nodeSlug, node.nodeVersion);
-    if (!manifest) continue;
-    const errorPorts = (manifest.outputs ?? []).filter((o) => o.kind === "error" && o.name).map((o) => o.name);
-    if (!errorPorts.length) continue;
-    if (!isReachable(node, blob, errorPorts)) continue;
-    for (const port of errorPorts) {
-      const wired = blob.edges.some((e) => e.from.nodeId === node.id && e.from.output === port);
-      if (!wired) advice.push({ nodeId: node.id, port });
-    }
-  }
-  return advice;
-}
-function isReachable(node, blob, errorPorts) {
-  return blob.edges.some((e) => e.to.nodeId === node.id) || blob.edges.some((e) => e.from.nodeId === node.id && !errorPorts.includes(e.from.output));
-}