@revenexx/studio-integrations 0.5.1 → 0.7.0

package/dist/runtime/data/integrationTemplates.d.ts

@@ -3,9 +3,57 @@ import type { WorkflowTemplate } from '../types/integrations.js';
  * Category lens config for the Templates catalogue. The templates themselves
  * come live from the Integrations registry (`GET /templates`) — there is no
  * mock catalogue; an empty registry is an empty catalogue.
+ *
+ * The two categories that templates actually ship with today are `commerce` and
+ * `sales`: the eight templates in `@revenexx/integrations-nodes-core` are all
+ * `commerce`, the two in the Business Central package `sales`. Neither was named
+ * here, so both were shown by the fallback rather than by a label — the studio's
+ * one list of categories described none of the catalogue it had. The other six
+ * are named on spec and nothing publishes them yet.
  */
 export declare const TEMPLATE_CATEGORIES: Array<{
     key: WorkflowTemplate['category'];
     label: string;
     color: string;
 }>;
+/**
+ * What a template's category is called, wherever the studio shows one.
+ *
+ * Four surfaces draw a category chip — the gallery, a template's own page, the
+ * dashboard's template panel and the start-from-a-template list in the dialog that
+ * creates a workflow — and each worked the name out for itself: a lookup with a
+ * capitalisation fallback, the raw registry key, and two separate capitalisations.
+ * They agreed only by coincidence, because every label in `TEMPLATE_CATEGORIES`
+ * above happens to be its key capitalised.
+ *
+ * That coincidence ends with the first category whose name is not a capitalisation
+ * — `crm`, `b2b`, `erp` — and categories arrive with node packages rather than with
+ * a release of the studio, so it is a matter of when. Every chip goes through here
+ * instead.
+ *
+ * The fallback is the catalogue's own promise (`specs/templates.md` AC-2): a
+ * category the studio has never been taught still gets a chip, named as well as it
+ * can be rather than dropped. That guarantee held on the gallery alone before; it
+ * now holds on all four.
+ *
+ * `specs/templates.md` AC-8 splits this in two: the first half — a category the
+ * studio *does* have a name for — is the studio's own word, and can follow the
+ * reader's language; the second half — the registry's own key, capitalised — never
+ * can, because a bare key carries no text to read in any language. Only the first
+ * half goes through `useIntegrationsT()`. A message missing from the catalogue
+ * (this key not merged into `messages/*.json` yet) falls back to the same English
+ * word `TEMPLATE_CATEGORIES` always carried, so the label degrades to "correct but
+ * unlocalised" rather than to the raw key.
+ */
+export declare function templateCategoryLabel(key: string): string;
+/**
+ * The integration a template ships with, as a card badges it — and as the
+ * gallery's search matches it. The core toolbox stays unbadged: every template
+ * would carry it, so it would say nothing.
+ *
+ * It lives here for the same reason `templateCategoryLabel` does. The gallery
+ * both shows this label and searches by it, so a copy inside the card component
+ * would be a second implementation of a name — the exact duplication PO-243
+ * removes.
+ */
+export declare function templatePackageLabel(tpl: Pick<WorkflowTemplate, 'package'>): string | null;

package/dist/runtime/data/integrationTemplates.js

@@ -1,5 +1,8 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
 export const TEMPLATE_CATEGORIES = [
   // Uniform muted pill — the label carries the meaning, no rainbow needed.
+  { key: "commerce", label: "Commerce", color: "bg-slate-100 text-slate-700" },
+  { key: "sales", label: "Sales", color: "bg-slate-100 text-slate-700" },
   { key: "sync", label: "Sync", color: "bg-slate-100 text-slate-700" },
   { key: "notification", label: "Notification", color: "bg-slate-100 text-slate-700" },
   { key: "fulfilment", label: "Fulfilment", color: "bg-slate-100 text-slate-700" },
@@ -7,3 +10,21 @@ export const TEMPLATE_CATEGORIES = [
   { key: "finance", label: "Finance", color: "bg-slate-100 text-slate-700" },
   { key: "reporting", label: "Reporting", color: "bg-slate-100 text-slate-700" }
 ];
+export function templateCategoryLabel(key) {
+  if (!key) return "";
+  const known = TEMPLATE_CATEGORIES.find((c) => c.key === key);
+  if (known) {
+    const t = useIntegrationsT();
+    const messageKey = `integration.templates.category.${known.key}`;
+    const translated = t(messageKey);
+    return translated === messageKey ? known.label : translated;
+  }
+  return key.charAt(0).toUpperCase() + key.slice(1);
+}
+export function templatePackageLabel(tpl) {
+  const pkg = tpl.package;
+  if (!pkg) return null;
+  const tail = (pkg.name.split("/").pop() ?? pkg.name).replace(/^integrations-nodes-/, "");
+  if (tail === "core") return null;
+  return pkg.label ?? tail.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" ");
+}

package/dist/runtime/data/integrationWorkflowSamples.js

@@ -137,7 +137,7 @@ export const SAMPLE_WORKFLOWS = [
         }
       ],
       variables: {
-        source: { type: "string", default: "primary", required: false }
+        source: { type: "string", default: "primary" }
       },
       nodes: [
         {

package/dist/runtime/data/nodeIcons.d.ts

@@ -0,0 +1,2 @@
+/** Resolve a manifest icon name to a Lucide component (Box as last resort). */
+export declare function nodeIcon(name?: string | null): unknown;

package/dist/runtime/data/nodeIcons.js

@@ -0,0 +1,73 @@
+import * as Lucide from "lucide-vue-next";
+const MDI_TO_LUCIDE = {
+  "account-group-outline": "Users",
+  "account-outline": "User",
+  "account-plus-outline": "UserPlus",
+  "alert-octagon": "OctagonAlert",
+  "api": "Webhook",
+  "book-open-outline": "BookOpen",
+  "bullseye-arrow": "Target",
+  "calendar-check-outline": "CalendarCheck",
+  "card-account-details-outline": "IdCard",
+  "cart-outline": "ShoppingCart",
+  "cart-plus": "ShoppingBasket",
+  "circle-outline": "Circle",
+  "clock-outline": "Clock",
+  "cloud-download": "CloudDownload",
+  "cloud-upload": "CloudUpload",
+  "cloud-upload-outline": "CloudUpload",
+  "code-brackets": "Brackets",
+  "code-json": "Braces",
+  "code-tags": "Code",
+  "compare-horizontal": "ArrowLeftRight",
+  "currency-eur": "Euro",
+  "database-cog-outline": "Database",
+  "database-export-outline": "HardDriveUpload",
+  "database-import-outline": "HardDriveDownload",
+  "domain": "Building2",
+  "email-send": "Send",
+  "file-edit-outline": "FilePen",
+  "file-export-outline": "FileOutput",
+  "file-import-outline": "FileInput",
+  "file-move-outline": "FileSymlink",
+  "file-plus": "FilePlus",
+  "file-question-outline": "FileQuestion",
+  "file-remove-outline": "FileX",
+  "filter": "Filter",
+  "find-replace": "Replace",
+  "folder-download-outline": "FolderDown",
+  "folder-plus-outline": "FolderPlus",
+  "folder-search-outline": "FolderSearch",
+  "folder-upload-outline": "FolderUp",
+  "folder-zip-outline": "FolderArchive",
+  "format-list-bulleted-type": "List",
+  "handshake": "Handshake",
+  "handshake-outline": "Handshake",
+  "link-lock": "Link2",
+  "magnify": "Search",
+  "office-building-outline": "Building",
+  "pencil-box-outline": "SquarePen",
+  "pipe": "Workflow",
+  "receipt-outline": "Receipt",
+  "receipt-text-outline": "ReceiptText",
+  "regex": "Regex",
+  "repeat": "Repeat",
+  "ruler": "Ruler",
+  "source-branch": "GitBranch",
+  "tag-multiple-outline": "Tags",
+  "transfer": "ArrowRightLeft",
+  "translate": "Languages",
+  "truck-outline": "Truck",
+  "web": "Globe",
+  "xml": "CodeXml"
+};
+export function nodeIcon(name) {
+  if (!name) return Lucide.Box;
+  const bare = name.includes(":") ? name.split(":").pop() : name;
+  const mapped = MDI_TO_LUCIDE[bare];
+  if (mapped && Lucide[mapped]) {
+    return Lucide[mapped];
+  }
+  const pascal = bare.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+  return Lucide[pascal] || Lucide.Box;
+}

package/dist/runtime/data/nodeInputData.d.ts

@@ -27,11 +27,23 @@ export interface PortEntry {
     /** Declared payload fields of this port (schema; may be empty). */
     fields: FieldEntry[];
 }
+/**
+ * A manifest declaring zero output ports describes a TERMINAL node (PO-201):
+ * the run ends there, so it gets no output handle and no edge may leave it.
+ *
+ * The distinction that matters is **declared empty vs. not known**. An absent
+ * manifest — a node that is not installed — is not terminal; we simply cannot
+ * work out its ports, and it has to stay wirable. Same for a `sourceFromConfig`
+ * or `resolveOutputs` set that expands to nothing: unresolved, not terminal.
+ * Only an explicit `[]` is the node making a statement about itself.
+ */
+export declare function isTerminalManifest(manifest: NodeManifest | null | undefined): boolean;
 /**
  * The output ports one upstream node exposes, mirroring the canvas port
- * derivation: named ports map straight over, `sourceFromConfig` ports expand
- * from the node's config values (plus the optional fallback), and a node
- * without any resolvable port still gets its `default`. Server-resolved
- * dynamic outputs, when present, replace the manifest's static list.
+ * derivation in `WorkflowNodeView.vue`. Named ports map straight over,
+ * `sourceFromConfig` ports expand from the node's config values (plus the
+ * optional fallback), and a node whose ports could not be worked out still
+ * gets its `default`. Server-resolved dynamic outputs, when present, replace
+ * the manifest's static list.
  */
 export declare function portsForNode(node: WorkflowNode, manifest: NodeManifest | null, resolvedOutputs?: NodeManifestOutput[]): PortEntry[];

package/dist/runtime/data/nodeInputData.js

@@ -44,7 +44,11 @@ function fieldEntries(raw) {
   }
   return [];
 }
+export function isTerminalManifest(manifest) {
+  return !!manifest && Array.isArray(manifest.outputs) && !manifest.outputs.length;
+}
 export function portsForNode(node, manifest, resolvedOutputs) {
+  if (isTerminalManifest(manifest)) return [];
   const list = resolvedOutputs?.length ? resolvedOutputs : manifest?.outputs ?? [];
   const ports = [];
   for (const o of list) {

package/dist/runtime/data/payloadForm.d.ts

@@ -16,8 +16,15 @@ export interface PayloadField {
     path: string;
     label: string;
 }
-/** Scan the blob's node configs and derive the payload form fields. */
-export declare function payloadFieldsFromBlob(blob: Pick<WorkflowBlob, 'nodes'>): PayloadField[];
+/**
+ * Payload form fields: fields DECLARED on a manual trigger come first (the
+ * author's explicit contract, e.g. a file field for a manual import), then
+ * every `${{ trigger.payload.* }}` reference found in node configs that the
+ * declarations don't already cover.
+ */
+export declare function payloadFieldsFromBlob(blob: Pick<WorkflowBlob, 'nodes'> & {
+    triggers?: WorkflowBlob['triggers'];
+}): PayloadField[];
 export declare function setPath(target: Record<string, unknown>, path: string, value: unknown): void;
 export declare function getPath(source: Record<string, unknown>, path: string): unknown;
 export interface AttachedFile {

package/dist/runtime/data/payloadForm.js

@@ -1,3 +1,4 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
 const PAYLOAD_REF_RE = /\$\{\{\s*trigger\.payload\.([a-zA-Z0-9_.-]+)/g;
 const FILE_KEYS = /* @__PURE__ */ new Set(["data", "filename", "contentType", "size"]);
 function collectRefs(value, out) {
@@ -14,9 +15,23 @@ function labelFor(path) {
   return last.replace(/[_-]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
 }
 export function payloadFieldsFromBlob(blob) {
+  const declared = [];
+  for (const t of blob.triggers ?? []) {
+    if (t.type !== "manual") continue;
+    for (const d of t.config?.payloadFields ?? []) {
+      const path = d.path?.trim();
+      if (!path && d.kind !== "file") continue;
+      declared.push({
+        kind: d.kind === "file" ? "file" : "text",
+        path: path ?? "",
+        label: d.label?.trim() || labelFor(path || "file")
+      });
+    }
+  }
   const refs = /* @__PURE__ */ new Set();
   for (const node of blob.nodes ?? []) collectRefs(node.config, refs);
-  if (refs.size === 0) return [];
+  if (refs.size === 0 && declared.length === 0) return [];
+  const declaredPaths = new Set(declared.map((f) => f.path));
   const byPrefix = /* @__PURE__ */ new Map();
   for (const ref of refs) {
     const idx = ref.lastIndexOf(".");
@@ -26,10 +41,16 @@ export function payloadFieldsFromBlob(blob) {
     byPrefix.get(prefix).add(leaf);
   }
   const fields = [];
-  const consumed = /* @__PURE__ */ new Set();
+  const consumed = new Set(declaredPaths);
   for (const [prefix, leaves] of byPrefix) {
     if (leaves.has("data")) {
-      fields.push({ kind: "file", path: prefix, label: prefix === "" ? "File" : labelFor(prefix) });
+      if (declaredPaths.has(prefix)) {
+        for (const leaf of leaves) {
+          if (FILE_KEYS.has(leaf)) consumed.add(prefix === "" ? leaf : `${prefix}.${leaf}`);
+        }
+        continue;
+      }
+      fields.push({ kind: "file", path: prefix, label: prefix === "" ? useIntegrationsT()("integration.common.label.file") : labelFor(prefix) });
       for (const leaf of leaves) {
         if (FILE_KEYS.has(leaf)) consumed.add(prefix === "" ? leaf : `${prefix}.${leaf}`);
       }
@@ -37,9 +58,13 @@ export function payloadFieldsFromBlob(blob) {
   }
   for (const ref of [...refs].sort()) {
     if (consumed.has(ref)) continue;
+    if (declared.some((d) => d.kind === "file" && (d.path === "" ? FILE_KEYS.has(ref) : ref.startsWith(d.path + ".")))) continue;
     fields.push({ kind: "text", path: ref, label: labelFor(ref) });
   }
-  return fields.sort((a, b) => a.kind === b.kind ? a.path.localeCompare(b.path) : a.kind === "file" ? -1 : 1);
+  return [
+    ...declared,
+    ...fields.sort((a, b) => a.kind === b.kind ? a.path.localeCompare(b.path) : a.kind === "file" ? -1 : 1)
+  ];
 }
 export function setPath(target, path, value) {
   if (path === "") {

package/dist/runtime/data/portTone.d.ts

@@ -0,0 +1,17 @@
+import type { OutputKind } from '../types/integrations.js';
+/**
+ * The colour of the dot in front of a port name, wherever a port is listed
+ * rather than drawn on the canvas: the Input panel's upstream trees and the
+ * node's own output schema.
+ *
+ * The legend mirrors `portTone` on the canvas node (PO-197): green = a real,
+ * active output — the normal continuation, including switch cases, iterator
+ * `item` and If/Filter `true`; soft rose = the error output that only runs on
+ * failure; neutral slate for `false` and fallbacks. There is no separate branch
+ * colour — the labels already say "one of several".
+ *
+ * It lives here rather than in a component because two lists render it and they
+ * must never disagree. They did once: the schema list kept a private copy and
+ * silently held the pre-PO-197 palette while the Input panel moved on.
+ */
+export declare function portDotClass(kind: OutputKind, name: string): string;

package/dist/runtime/data/portTone.js

@@ -0,0 +1,7 @@
+export function portDotClass(kind, name) {
+  if (name === "true") return "bg-emerald-500";
+  if (name === "false") return "bg-slate-500";
+  if (name === "error" || kind === "error") return "bg-rose-300";
+  if (name === "done") return "bg-emerald-500";
+  return "bg-emerald-500";
+}

package/dist/runtime/data/webhookAuth.d.ts

@@ -0,0 +1,18 @@
+import type { WorkflowTrigger } from '../types/integrations.js';
+/**
+ * Mapping between the webhook Protection select and the ingress verification
+ * profiles stored on the trigger (`authProfile`/`authConfig`). Bearer is the
+ * token profile with a fixed Authorization + "Bearer " prefix.
+ *
+ * An ABSENT authProfile reads as 'token': that is what the exposure defaults
+ * to server-side (and what every endpoint provisioned before this feature
+ * got), so the select shows the effective behavior. The UI persists the
+ * choice explicitly the moment the public toggle is enabled, so anything
+ * exposed from here on carries what it shows.
+ */
+export type WebhookAuthChoice = 'none' | 'token' | 'bearer' | 'basic';
+type TriggerConfig = WorkflowTrigger['config'];
+export declare function authChoiceFromConfig(config: TriggerConfig | undefined): WebhookAuthChoice;
+/** The config patch that makes a Protection choice stored state. */
+export declare function configPatchForAuthChoice(choice: WebhookAuthChoice): Partial<TriggerConfig>;
+export {};

package/dist/runtime/data/webhookAuth.js

@@ -0,0 +1,19 @@
+export function authChoiceFromConfig(config) {
+  if (config?.authProfile === "none") return "none";
+  if (config?.authProfile === "basic") return "basic";
+  if (config?.authProfile === "token" && config?.authConfig?.prefix === "Bearer ") return "bearer";
+  return "token";
+}
+export function configPatchForAuthChoice(choice) {
+  switch (choice) {
+    case "none":
+      return { authProfile: "none", authConfig: void 0 };
+    case "bearer":
+      return { authProfile: "token", authConfig: { header: "Authorization", prefix: "Bearer " } };
+    case "basic":
+      return { authProfile: "basic", authConfig: void 0 };
+    case "token":
+    default:
+      return { authProfile: "token", authConfig: void 0 };
+  }
+}

package/dist/runtime/data/workflowIconCatalog.js

@@ -37,6 +37,7 @@ import {
   WalletMoney
 } from "#solar-icons";
 import { INTEGRATION_NODE_CATALOG } from "./integrationNodeCatalog.js";
+import { resolveLocalized } from "../utils/localize.js";
 export const WORKFLOW_SOLAR_ICONS = {
   Programming,
   Bolt,
@@ -78,10 +79,6 @@ export const WORKFLOW_SOLAR_ICONS = {
 export function solarIconFor(name) {
   return (name ? WORKFLOW_SOLAR_ICONS[name] : void 0) ?? Programming;
 }
-function loc(v) {
-  if (!v) return "";
-  return typeof v === "string" ? v : v.en ?? Object.values(v)[0] ?? "";
-}
 const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 const IMAGE_URL_ID_RE = new RegExp(`node-packages/images/(${UUID})`, "i");
 const BARE_UUID_RE = new RegExp(`^${UUID}$`, "i");
@@ -102,6 +99,7 @@ export function freshImageSrc(stored) {
   return null;
 }
 export function nodeLogoOptions() {
+  const t = useIntegrationsT();
   const byId = /* @__PURE__ */ new Map();
   for (const m of INTEGRATION_NODE_CATALOG) {
     const imgs = m.images ?? [];
@@ -109,8 +107,8 @@ export function nodeLogoOptions() {
     if (!logo?.src) continue;
     const id = imageIdFromSrc(logo.src) ?? logo.src;
     if (byId.has(id)) continue;
-    const label = m.__package?.label || (m.groups?.length ? loc(m.groups[0]) : "") || loc(m.name);
-    byId.set(id, { label: label || "Integration", src: logo.src });
+    const label = m.__package?.label || (m.groups?.length ? resolveLocalized(m.groups[0]) : "") || resolveLocalized(m.name);
+    byId.set(id, { label: label || t("integration.workflows.iconCatalog.label.fallback"), src: logo.src });
   }
   return [...byId.entries()].map(([id, v]) => ({ id, src: v.src, label: v.label })).sort((a, b) => a.label.localeCompare(b.label));
 }