@revenexx/studio-integrations 1.4.0 → 2.0.0

package/dist/runtime/utils/apiError.js

@@ -18,20 +18,20 @@ export function apiValidationIssues(err) {
   }
   return issues;
 }
-export function apiFieldErrors(err) {
-  if (!(err instanceof IntegrationsApiError) || err.status !== 422) return {};
+export function apiRefusal(err, drawn) {
+  const refusal = { atFields: {}, unshown: [] };
+  if (!(err instanceof IntegrationsApiError) || err.status !== 422) return refusal;
   const errors = err.body?.errors;
-  if (!errors || typeof errors !== "object") return {};
-  const out = {};
-  for (const [key, val] of Object.entries(errors)) {
-    if (key === "blob" || key.startsWith("blob.")) continue;
-    const first = Array.isArray(val) ? val[0] : val;
-    if (first !== void 0 && first !== null) out[key] = String(first);
-  }
-  for (const key of Object.keys(out)) {
-    if (Object.keys(out).some((other) => other.startsWith(`${key}.`))) delete out[key];
+  if (!errors || typeof errors !== "object") return refusal;
+  const keys = Object.keys(errors).filter((key) => key !== "blob" && !key.startsWith("blob."));
+  for (const key of keys) {
+    if (keys.some((other) => other.startsWith(`${key}.`))) continue;
+    const messages = (Array.isArray(errors[key]) ? errors[key] : [errors[key]]).filter((message) => message !== void 0 && message !== null).map(String);
+    if (!messages.length) continue;
+    if (drawn.includes(key)) refusal.atFields[key] = messages[0];
+    else refusal.unshown.push(...messages.map((message) => ({ key, message })));
   }
-  return out;
+  return refusal;
 }
 export function errorReason(err, fallback) {
   const raw = err?.message?.trim();

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

@@ -65,6 +65,23 @@
  * Two members exist here only because the code reads them off values the cockpit
  * may hand back as `null`: `getCredential` and `createCredential` both resolve to
  * `MailCredential | null`, and the callers have to say what they do about it.
+ *
+ * **What "narrowed to the members it reads" costs when it is wrong, measured on
+ * `sftp` (PO-387).** This declaration was five members behind what
+ * `SftpAccountImportDialog.vue` actually reads — `loading`, `activeTenantSlug`,
+ * an optional rather than required argument to `load`, and `server` and
+ * `home_directory` on an account. The cockpit has had all five throughout
+ * (`app/composables/useConsoleSftp.ts`, `app/types/consoleSftp.ts`), so nothing
+ * was ever broken for an operator; what was broken is that the playground's
+ * double is built from *this* file, so a host honouring the written contract
+ * threw `TypeError: Cannot read properties of undefined (reading 'value')` while
+ * drawing that dialog. **Vue's error handler turns such a throw into a
+ * `console.error` and unmounts the tree, so no `pageerror` fires** — the suite's
+ * usual way of catching this class (`e2e/credential-managed-source.spec.ts`,
+ * `pageErrors`) cannot see it, and the only evidence is a blank page. The dialog
+ * now takes its type from here (`Pick<CockpitSources['sftp'], …>`) rather than
+ * declaring its own, so the two cannot disagree again; nothing yet compares
+ * either against the cockpit, which is [PO-310](https://linear.app/revenexx/issue/PO-310).
  */
 export interface CockpitSources {
     tenants: {
@@ -102,7 +119,53 @@ export interface CockpitSources {
         accounts: {
             value: CockpitSftpAccount[];
         };
-        load: (tenant: string | null) => Promise<unknown>;
+        /**
+         * True while the cockpit's **account fetch** is in flight — which is narrower
+         * than "this source is busy", and a caller that needs the wider question has
+         * to keep its own answer beside this one.
+         *
+         * `useConsoleSftp.load()` resolves the tenant above the flag
+         * (`if (!tenantSlug) await loadTenants()` sits before `loading.value = true`),
+         * and leaves by two paths that never set it at all: no tenant resolved, and a
+         * load already in flight for another surface. `SftpAccountImportDialog.vue`
+         * learned this the expensive way — it drew its "there are none, go and create
+         * one" empty state throughout the tenants fetch on every first open.
+         */
+        loading: {
+            value: boolean;
+        };
+        /**
+         * Why the last account fetch failed, or `null`.
+         *
+         * The cockpit catches its own fetch errors — `load` never rejects — so this
+         * is the **only** way a caller learns the list is missing rather than empty.
+         * Without it a failed load and a tenant that owns no account are the same
+         * screen, and that screen tells the operator to go and create one.
+         *
+         * **Optional, and the only member here that is.** The standalone dev studio's
+         * stand-ins provide the other four and not this one
+         * (`integrations/studio-ui/app/composables/consoleStubs.ts`), so a required
+         * member would be this file's own defect a second time — PO-387 is exactly a
+         * dialog that dereferenced what a host did not have. Its absence costs only
+         * the message: a caller reading it with `?.` falls back to the empty state,
+         * which is what such a host showed before. A host that means to keep
+         * `specs/node-configuration.md` AC-34 has to provide it.
+         *
+         * It is also **not a verdict on the load that just returned.** It is a
+         * `useState` singleton shared by every surface in the host, and both early
+         * returns described under `loading` leave it at whatever it already held —
+         * so it can be stale and can be somebody else's. `SftpAccountImportDialog.vue`
+         * shows how much has to be true around it before it is worth repeating.
+         */
+        error?: {
+            value: string | null;
+        };
+        /** The tenant the accounts belong to — the org's only one, or `null`. */
+        activeTenantSlug: {
+            value: string | null;
+        };
+        /** The argument is **optional**: omitted, the cockpit falls back to `activeTenantSlug`. */
+        load: (tenant?: string | null) => Promise<unknown>;
         /** `null` while the account is still provisioning (the Console answers 404). */
         revealPassword: (tenant: string, id: number) => Promise<{
             username: string;
@@ -131,6 +194,10 @@ export interface CockpitSftpAccount {
     id: number;
     /** The gateway login. `null` until the account finished provisioning. */
     login_username: string | null;
+    /** The gateway host to connect to. */
+    server: string | null;
+    /** Where on the gateway the account lands; shown instead of `server` when set. */
+    home_directory: string | null;
     status: string;
     is_active: boolean;
     error_message: string | null;

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

@@ -28,6 +28,21 @@ export interface CredentialStateInfo {
 }
 type TestableCredential = Pick<Credential, 'status' | 'last_test_ok' | 'last_test_at' | 'last_test_message'>;
 /** Every state a credential can be in, in the order a reader is offered them. */
+/**
+ * Which of the two words a three-legged credential's provider step is offered under,
+ * or `null` where its state gives no reason to offer one at all.
+ *
+ * The distinction is whether anything has ever proved this credential connected. Only
+ * a credential nothing has — never tested, and for an `oauth2-authcode` type that is
+ * what a provider window which failed to open leaves behind — is offered the step as
+ * *connecting*. One whose test failed, or whose authorisation expired, was working at
+ * some point, so it is offered *reconnecting*: the word says which of the two happened
+ * (PO-478).
+ *
+ * It answers for a state rather than a credential because both surfaces that offer the
+ * step derive that state first, and the word may not disagree between them.
+ */
+export declare function providerStepWord(state: CredentialConnState): 'connect' | 'reconnect' | null;
 export declare const CREDENTIAL_STATES: readonly ["connected", "failed", "needs_reauth", "untested"];
 /**
  * What a state is called for the reader, keyed rather than derived from a

package/dist/runtime/utils/credentialState.js

@@ -1,4 +1,8 @@
 import { useIntegrationsT } from "../composables/useIntegrationsT.js";
+export function providerStepWord(state) {
+  if (state === "connected") return null;
+  return state === "untested" ? "connect" : "reconnect";
+}
 export const CREDENTIAL_STATES = ["connected", "failed", "needs_reauth", "untested"];
 const MESSAGE_KEY = {
   connected: "integration.credentials.state.connected",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "1.4.0",
+  "version": "2.0.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,13 @@
   },
   "dependencies": {
     "@nuxt/kit": "^4.0.0",
-    "@revenexx/studio-shared": "^0.3.0",
+    "@revenexx/studio-shared": "^0.3.2",
     "@solar-icons/nuxt": "^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",

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));
-}