@revenexx/studio-integrations 1.1.0 → 1.2.0

package/dist/runtime/utils/nodeDisplayName.js

@@ -0,0 +1,6 @@
+import { findManifest } from "../data/integrationNodeCatalog.js";
+import { resolveDisplayName, resolveLocalized } from "./localize.js";
+export function nodeDisplayName(node) {
+  const manifest = findManifest(node.nodeSlug, node.nodeVersion);
+  return resolveDisplayName(node.name) || resolveLocalized(manifest?.name) || node.nodeSlug;
+}

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

@@ -18,7 +18,6 @@ export declare const toast: ((message: string | (() => string | import("vue").Co
         class?: string | undefined;
         id?: number | string | undefined;
         position?: ("top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center") | undefined;
-        cancel?: (import("vue-sonner").Action | import("vue").Component) | undefined;
         toasterId?: string | undefined;
         component?: import("vue").Component | undefined;
         componentProps?: any;
@@ -28,6 +27,7 @@ export declare const toast: ((message: string | (() => string | import("vue").Co
         dismissible?: boolean | undefined;
         duration?: number | undefined;
         important?: boolean | undefined;
+        cancel?: (import("vue-sonner").Action | import("vue").Component) | undefined;
         onDismiss?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
         onAutoClose?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
         cancelButtonStyle?: import("vue").CSSProperties | undefined;

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

@@ -0,0 +1,31 @@
+/** A run as the API sends it, before anything has been read out of it. */
+export type RunLike = Record<string, unknown>;
+/**
+ * The run out of a single-run response, enveloped or not.
+ *
+ * `GET /workflows/{id}/runs/{runId}` answers the run itself, and the studio's own
+ * mock and some callers wrap it in `{ data: … }`. So the envelope has to be
+ * optional — but unwrapping on the mere presence of a `data` key is wrong: a run
+ * that ever carried one would be unwrapped into it, and the caller would be
+ * handed a field instead of a run. Hence the two guards: a body that already
+ * looks like a run (`status`, `temporal_run_id`) is the run, whatever else it has
+ * on it.
+ *
+ * This is deliberately generous about the *rest* of the shape. It answers "where
+ * is the run in this body", not "is this a usable run" — the caller decides that,
+ * because a caller following a run has to be able to count an unusable answer as
+ * a failed read rather than sit on it.
+ */
+/**
+ * The raw platform statuses a run does not come back from.
+ *
+ * The platform's own words, not the studio's five — the single-run endpoint answers
+ * `completed` where a row would read "succeeded" (`utils/statusStyle.ts` maps one to
+ * the other), and anything reading this is reading the endpoint.
+ */
+export declare const RUN_TERMINAL: Set<string>;
+/** Whether this run has ended, as the platform reports it. */
+export declare function isTerminalRun(run: {
+    status?: unknown;
+} | null | undefined): boolean;
+export declare function unwrapRun(res: unknown): RunLike | null;

package/dist/runtime/utils/runEnvelope.js

@@ -0,0 +1,12 @@
+export const RUN_TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "canceled", "terminated", "timed_out"]);
+export function isTerminalRun(run) {
+  return RUN_TERMINAL.has(String(run?.status ?? "").toLowerCase());
+}
+export function unwrapRun(res) {
+  if (!res || typeof res !== "object") return null;
+  const o = res;
+  if ("data" in o && o.data && typeof o.data === "object" && !("status" in o) && !("temporal_run_id" in o)) {
+    return o.data;
+  }
+  return o;
+}

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

@@ -0,0 +1,135 @@
+import type { RunStatus, TriggerType } from '../types/integrations.js';
+/**
+ * The narrowing of the tenant Runs list, translated for the platform.
+ *
+ * The list narrows on the server now, so the words the studio puts on its filter
+ * have to reach an endpoint that speaks a different vocabulary. The studio draws
+ * five outcomes; the platform accepts six statuses, two of which the studio folds
+ * into one word. Everything here exists to keep that fold from making a filter
+ * contradict the column it sits under — or, as happened once, from asking for a
+ * word the platform refuses outright.
+ *
+ * Kept out of the composable so it can be read on its own — the collapse is the
+ * one piece of this feature that is wrong in a way nothing on screen would show.
+ */
+/**
+ * Every status the platform ACCEPTS in a `status` filter: the six cases of
+ * `RunStatus` in the integrations service (`app/Enums/RunStatus.php`), and
+ * nothing else.
+ *
+ * Copied from the enum, not from prose about it. It was written from a comment
+ * once and carried a seventh value, `timed_out`, which that enum does not have —
+ * so choosing "failed" sent `failed,terminated,timed_out` and the platform
+ * answered `422 The selected status.2 is invalid`. The filter did not narrow
+ * badly; it failed outright.
+ *
+ * This is deliberately NOT "every status a run can carry". `workflow_runs.status`
+ * is an uncast string column and the service's own summary endpoint accounts for
+ * values outside the enum, so a row may arrive carrying one — `mapRunStatus`
+ * therefore stays tolerant about what it READS. Only what is SENT is bounded by
+ * this list.
+ */
+export declare const API_RUN_STATUSES: readonly ["pending", "running", "completed", "failed", "cancelled", "terminated"];
+/**
+ * Platform status → the word the studio draws.
+ *
+ * Tolerant on purpose, and wider than {@link API_RUN_STATUSES}: the status column
+ * is an uncast string on the platform's side, so a row can arrive carrying a word
+ * the enum does not list. `terminated` and `timed_out` are failures to an
+ * operator and the column says so; anything else fails closed for the reason it
+ * does everywhere else — a run the platform cannot classify must never read as a
+ * stuck `running`.
+ */
+export declare function mapRunStatus(status: string): RunStatus;
+/**
+ * The platform statuses behind the studio's words.
+ *
+ * DERIVED from `mapRunStatus` rather than written out beside it. Restating the
+ * collapse would leave two lists to keep in step, and the failure is silent: the
+ * filter would come back short a few rows the column beside it still calls
+ * failed, which reads as runs having disappeared rather than as a narrowing that
+ * is narrower than it says.
+ */
+export declare function apiStatusesFor(words: readonly RunStatus[]): string[];
+/**
+ * The orders this studio can ask `GET /runs` for.
+ *
+ * Three of the four `RunSort` names the service accepts. Two absences are the
+ * platform's: ordering by the workflow's name would need a join on the paging
+ * path, and the trigger kind has four values, so it groups the list rather than
+ * ordering it — the filter beside it answers that question better.
+ *
+ * The third absence is the STUDIO'S, and it is the reason this list is not
+ * simply a mirror of the service's enum. `sort=status` orders by the word the
+ * platform stores — `cancelled`, `completed`, `failed`, `pending`, `running`,
+ * `terminated` — and those are not the words on the rows: the studio draws its
+ * own five, translated, and folds three of the platform's into one of them. A
+ * header reading "Status ↑" over rows ordered by a vocabulary the reader never
+ * sees is a control that cannot do what it says, and in German it would not even
+ * be alphabetical. Ordering by outcome from here needs the platform to order by
+ * something the studio can name, which it cannot: the translation lives in this
+ * repository and the ordering happens in the other one.
+ */
+export declare const RUN_SORTS: readonly ["created_at", "started_at", "duration"];
+export type RunSort = (typeof RUN_SORTS)[number];
+export type RunSortDirection = 'asc' | 'desc';
+/** The order the list opens in, and the one the platform falls back to. */
+export declare const DEFAULT_RUN_SORT: RunSort;
+export declare const DEFAULT_RUN_DIRECTION: RunSortDirection;
+/** What the Runs list is currently asking the platform for. */
+export interface RunFeedQuery {
+    /** 1-based, as the platform pages. */
+    page: number;
+    perPage: number;
+    /** The studio's own outcome words; empty narrows by no outcome. */
+    status: RunStatus[];
+    /** Empty narrows by no trigger kind. */
+    triggerType: TriggerType | '';
+    /** Matched against the workflow's name by the platform, not by the browser. */
+    search: string;
+    /** Which order the page is read in. Not a narrowing — see below. */
+    sort: RunSort;
+    direction: RunSortDirection;
+}
+/**
+ * The query string for `GET /runs` — and for `GET /runs/summary`, which narrows
+ * through the same rules and is where a numbered pager gets its total. Both are
+ * built from one place so the count can never describe a different set of rows
+ * from the page beside it.
+ *
+ * A filter nobody set is left out rather than sent empty: the platform reads an
+ * empty `status` as a value and answers 422.
+ */
+export declare function runFeedQueryString(query: RunFeedQuery): string;
+/**
+ * The narrowing alone, without the paging — what `GET /runs/summary` is read
+ * with so the pager's total describes the same rows as the page beside it.
+ *
+ * Empty when nothing narrows, and callers lean on that: the tenant-wide figures
+ * the dashboard shows come from the same summary state, so an unnarrowed load
+ * may refresh them and a narrowed one may not.
+ *
+ * The ORDER is deliberately absent. The summary counts what matches; a count has
+ * no order, and the endpoint ignores one — sending it would advertise an effect
+ * it does not have, and would make an ordered list look like it had asked for a
+ * differently counted total.
+ */
+export declare function runFeedNarrowingString(query: RunFeedQuery): string;
+/**
+ * Apply a change to the query, returning to the first page whenever the change
+ * is a narrowing rather than a page turn.
+ *
+ * The reset is the point. Page 4 of the old result set is very often past the
+ * end of the narrowed one, and the page that comes back is then empty — which
+ * an operator reads as "nothing matches" when the truth is "nothing matches
+ * this far in". The page size counts as a narrowing here even though it narrows
+ * nothing, because it changes what page 4 refers to.
+ */
+export declare function withRunFeedPatch(query: RunFeedQuery, patch: Partial<RunFeedQuery>): RunFeedQuery;
+/**
+ * How many pages a total spreads over, for the pager's "page 2 of 7".
+ *
+ * Never zero: an empty list is still page 1 of 1, and a pager reading "page 1 of
+ * 0" is a sentence about nothing.
+ */
+export declare function runFeedLastPage(total: number, perPage: number): number;

package/dist/runtime/utils/runFeedQuery.js

@@ -0,0 +1,66 @@
+export const API_RUN_STATUSES = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled",
+  "terminated"
+];
+export function mapRunStatus(status) {
+  switch (status) {
+    case "completed":
+      return "succeeded";
+    case "pending":
+      return "queued";
+    case "terminated":
+      return "failed";
+    case "timed_out":
+      return "failed";
+    case "running":
+      return "running";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "failed";
+  }
+}
+export function apiStatusesFor(words) {
+  if (!words.length) return [];
+  return API_RUN_STATUSES.filter((status) => words.includes(mapRunStatus(status)));
+}
+export const RUN_SORTS = ["created_at", "started_at", "duration"];
+export const DEFAULT_RUN_SORT = "created_at";
+export const DEFAULT_RUN_DIRECTION = "desc";
+export function runFeedQueryString(query) {
+  const params = new URLSearchParams();
+  params.set("page", String(query.page));
+  params.set("per_page", String(query.perPage));
+  for (const [key, value] of narrowingParams(query)) params.set(key, value);
+  if (query.sort !== DEFAULT_RUN_SORT || query.direction !== DEFAULT_RUN_DIRECTION) {
+    params.set("sort", query.sort);
+    params.set("direction", query.direction);
+  }
+  return params.toString();
+}
+export function runFeedNarrowingString(query) {
+  return narrowingParams(query).toString();
+}
+function narrowingParams(query) {
+  const params = new URLSearchParams();
+  const statuses = apiStatusesFor(query.status);
+  if (statuses.length) params.set("status", statuses.join(","));
+  if (query.triggerType) params.set("trigger_type", query.triggerType);
+  const search = query.search.trim();
+  if (search) params.set("search", search);
+  return params;
+}
+export function withRunFeedPatch(query, patch) {
+  const narrowed = "status" in patch || "triggerType" in patch || "search" in patch || "perPage" in patch || "sort" in patch || "direction" in patch;
+  return { ...query, ...patch, ...narrowed ? { page: 1 } : {} };
+}
+export function runFeedLastPage(total, perPage) {
+  if (perPage <= 0) return 1;
+  return Math.max(1, Math.ceil(total / perPage));
+}

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

@@ -0,0 +1,33 @@
+import type { NameableNode } from './nodeDisplayName.js';
+/** One node's share of what a run returned. */
+export interface RunOutput {
+    /** The blob key the value stood under. Kept for addressing, never shown alone. */
+    nodeId: string;
+    /** What that node is called on the canvas. */
+    name: string;
+    value: unknown;
+}
+/** A node as the blob carries it — an id, and enough to name it by. */
+export type OutputNode = NameableNode & {
+    id: string;
+};
+/**
+ * What a run returned, split per node and named the way the canvas names it.
+ *
+ * A run's result is a map keyed by node id — `{"n-1787908672612": {…}}` — which
+ * is the worker's addressing and not a thing to show a person. Split against the
+ * workflow's own nodes it becomes what the author was actually looking at: one
+ * block per node, under the name on the card.
+ *
+ * `null` means "this is not that shape", and the caller shows the value whole
+ * instead of inventing structure for it. That covers three real cases: a result
+ * that is a bare value rather than a map, one keyed by something other than node
+ * ids, and a run of a workflow whose nodes have since changed — where guessing
+ * would put a value under the wrong name, which is worse than not naming it.
+ * An empty result is `null` too: there is nothing to split, and the caller has a
+ * better sentence for it than an empty list.
+ *
+ * Order follows the blob rather than the result's own keys, so two runs of one
+ * workflow read the same way down the page.
+ */
+export declare function splitRunOutputs(result: unknown, nodes: readonly OutputNode[]): RunOutput[] | null;

package/dist/runtime/utils/runOutputs.js

@@ -0,0 +1,10 @@
+import { nodeDisplayName } from "./nodeDisplayName.js";
+export function splitRunOutputs(result, nodes) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return null;
+  const keys = Object.keys(result);
+  if (!keys.length) return null;
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  if (!keys.every((k) => byId.has(k))) return null;
+  const values = result;
+  return nodes.filter((n) => Object.hasOwn(values, n.id)).map((n) => ({ nodeId: n.id, name: nodeDisplayName(n), value: values[n.id] }));
+}

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

@@ -23,6 +23,30 @@ export declare function toneClass(tone: StatusTone): string;
  * order. It used to keep its own copy of the list, so a sixth word added here
  * would have been labelled everywhere and silently missing from that menu. */
 export declare const RUN_STATUS_WORDS: readonly ["running", "succeeded", "failed", "cancelled", "queued"];
+/**
+ * How wide a list draws its Status column, as a grid track.
+ *
+ * A fixed width, and it has to be one: the shared table gives the header row, every
+ * body row and every skeleton row a grid of their own, so a content-sized track
+ * (`max-content`, `auto`, `fit-content`) is resolved per row and a row holding a
+ * longer word would step out of line with the header and with the rows around it.
+ * The `id` column below says the same thing, and this constant was `minmax(136px,
+ * max-content)` for one commit because that warning was read too late.
+ *
+ * So the number is the promise, and it is a floor rather than a measurement. The
+ * column stood at 100px, which fitted every English word with room to spare and let
+ * the German "fehlgeschlagen" — 126px as a rendered badge on the machine this was
+ * measured on — run out of its cell and under the workflow name beside it (PO-362).
+ * 160px is that word plus a quarter, because the rendered width is not ours to know:
+ * a font that failed to load, a browser zoom or a reader's own minimum font size all
+ * move it, and one of those is why a first attempt at 136 was still reported cut.
+ *
+ * What happens when it is still not enough, and why that is survivable: the badge
+ * carries `max-w-full`, so it is clipped inside its own cell rather than drawn over
+ * the column beside it, and the whole word stays readable in its `title`. Raising
+ * this number is the fix at that point — not making the track elastic.
+ */
+export declare const RUN_STATUS_COLUMN_WIDTH = "160px";
 /**
  * Raw API/Temporal run vocabulary → the cockpit's run-status labels, so a run
  * never reads "completed" in one surface and "succeeded" in another. This IS

package/dist/runtime/utils/statusStyle.js

@@ -77,6 +77,7 @@ export function toneClass(tone) {
   return TONE_CLASS[tone];
 }
 export const RUN_STATUS_WORDS = ["running", "succeeded", "failed", "cancelled", "queued"];
+export const RUN_STATUS_COLUMN_WIDTH = "160px";
 const RUN_STATUS_WORD_SET = new Set(RUN_STATUS_WORDS);
 export function normalisedRunStatus(status) {
   if (!status) return "";

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

@@ -38,8 +38,10 @@ export interface FindingNodeGroup {
     /** The node's human label; `null` when `nodeId` is. */
     label: string | null;
     /**
-     * One compact entry per finding, in order and de-duplicated: the config key
-     * the path ends in, falling back to the message when the path carries none.
+     * One compact entry per finding, in order and de-duplicated by config key: the
+     * setting's name as `fieldLabelOf` gives it — the manifest's label for the banner,
+     * the bare key where a caller asks for that — falling back to the message when the
+     * path carries no config key at all.
      * **Empty when `nodeId` is `null`** — read `messages` instead.
      */
     fields: string[];
@@ -53,6 +55,27 @@ export interface FindingNodeGroup {
  * two of them prints `revenexx:business-central-create-customer` at the user.
  */
 export declare function nodeDisplayLabel(node: WorkflowNode): string;
+/**
+ * What a setting is called, for somebody reading *about* it.
+ *
+ * The same lookup {@link nodeDisplayLabel} does for the node, one level down: the
+ * manifest carries a bilingual `label` per config field, and the node's own settings
+ * form already renders it. The banner did not ask, so it printed the blob path's last
+ * segment — `companyId` beside a form that says **Firma**, in an otherwise German
+ * screen, for the same field (PO-401).
+ *
+ * **The key is the fallback and never the wrong answer.** A workflow can outlive the
+ * manifest version it was saved against, and a package can be gone entirely; then there
+ * is no label to resolve, and the raw key is worse to read but still names the setting
+ * the operator has to find. Falling back to the finding's *message* — what this module
+ * does for a finding with no field key at all — was refused here: it turns a short list
+ * of names into a list of sentences exactly when the banner is already hardest to read.
+ *
+ * **For reading about, not for finding by.** `findingsByNodeField` deliberately does NOT
+ * use this. Its keys are how the configuration dialog attaches a message to an input, so
+ * a translated one would stop matching the field it belongs to.
+ */
+export declare function fieldDisplayLabel(node: WorkflowNode, fieldKey: string): string;
 /**
  * The setting a finding is about: the config key its path ends in.
  *
@@ -71,7 +94,7 @@ export declare function findingFieldKey(path: string): string | null;
  * `null` nodeId), rendered after the node groups — it has no node to hide
  * behind, and dropping it would lose an issue the user has to fix.
  */
-export declare function groupFindingsByNode(findings: readonly ValidationFinding[], nodes: readonly WorkflowNode[], labelOf?: (node: WorkflowNode) => string): FindingNodeGroup[];
+export declare function groupFindingsByNode(findings: readonly ValidationFinding[], nodes: readonly WorkflowNode[], labelOf?: (node: WorkflowNode) => string, fieldLabelOf?: (node: WorkflowNode, fieldKey: string) => string): FindingNodeGroup[];
 /**
  * Node id → config key → the message to show AT that setting
  * (specs/node-configuration.md AC-8).

package/dist/runtime/utils/validationFindings.js

@@ -5,6 +5,11 @@ export function nodeDisplayLabel(node) {
   const manifest = findManifest(node.nodeSlug, node.nodeVersion);
   return resolveLocalized(node.name) || resolveLocalized(manifest?.name) || node.nodeSlug;
 }
+export function fieldDisplayLabel(node, fieldKey) {
+  const manifest = findManifest(node.nodeSlug, node.nodeVersion);
+  const field = manifest?.config?.find((f) => f.key === fieldKey);
+  return resolveLocalized(field?.label) || fieldKey;
+}
 export function findingFieldKey(path) {
   const m = /^blob\.nodes\.\d+\.config\.([^.[]+)/.exec(path);
   return m ? m[1] : null;
@@ -13,10 +18,11 @@ function findingNode(path, nodes) {
   const m = /^blob\.nodes\.(\d+)\b/.exec(path);
   return m ? nodes[Number(m[1])] : void 0;
 }
-export function groupFindingsByNode(findings, nodes, labelOf = nodeDisplayLabel) {
+export function groupFindingsByNode(findings, nodes, labelOf = nodeDisplayLabel, fieldLabelOf = fieldDisplayLabel) {
   const nodeGroups = [];
   const orphans = [];
   const byNodeId = /* @__PURE__ */ new Map();
+  const seenKeys = /* @__PURE__ */ new Map();
   for (const finding of findings) {
     const node = findingNode(finding.path, nodes);
     if (!node) {
@@ -29,8 +35,17 @@ export function groupFindingsByNode(findings, nodes, labelOf = nodeDisplayLabel)
       byNodeId.set(node.id, group);
       nodeGroups.push(group);
     }
-    const field = findingFieldKey(finding.path) ?? finding.message;
-    if (!group.fields.includes(field)) group.fields.push(field);
+    const key = findingFieldKey(finding.path);
+    if (key === null) {
+      if (!group.fields.includes(finding.message)) group.fields.push(finding.message);
+    } else {
+      const seen = seenKeys.get(node.id) ?? /* @__PURE__ */ new Set();
+      seenKeys.set(node.id, seen);
+      if (!seen.has(key)) {
+        seen.add(key);
+        group.fields.push(fieldLabelOf(node, key));
+      }
+    }
     group.messages.push(finding.message);
   }
   return [...nodeGroups, ...orphans];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {