@revenexx/studio-integrations 0.7.0 → 1.0.0

package/dist/runtime/components/Integrations/WorkflowSettingsDialog.vue

@@ -1,11 +1,11 @@
 <script setup>
-import { ref, watch } from "vue";
-import { RefreshCircle as Loader2 } from "#solar-icons";
+import { computed, ref, watch } from "vue";
 import {
   Button,
   Dialog,
   DialogContent,
   DialogDescription,
+  DialogFooter,
   DialogHeader,
   DialogTitle,
   Input,
@@ -23,24 +23,35 @@ const props = defineProps({
   open: { type: Boolean, required: true },
   workflow: { type: Object, required: true },
   modes: { type: Array, required: true },
-  modeDraft: { type: String, required: true },
-  savingMode: { type: Boolean, required: false },
-  savingMeta: { type: Boolean, required: false },
+  current: { type: Object, required: true },
   tagSuggestions: { type: Array, required: false }
 });
-const emit = defineEmits(["update:open", "change-mode", "save-meta"]);
+const emit = defineEmits(["update:open", "apply"]);
 const t = useIntegrationsT();
 const nameDraft = ref("");
 const descriptionDraft = ref("");
 const tagsDraft = ref([]);
 const iconDraft = ref(null);
+const modeDraft = ref("");
 watch(() => props.open, (v) => {
   if (!v) return;
-  nameDraft.value = props.workflow.name;
-  descriptionDraft.value = props.workflow.description ?? "";
-  tagsDraft.value = [...props.workflow.blob.tags ?? []];
-  iconDraft.value = props.workflow.blob.icon ?? null;
+  nameDraft.value = props.current.name;
+  descriptionDraft.value = props.current.description;
+  tagsDraft.value = [...props.current.tags];
+  iconDraft.value = props.current.icon;
+  modeDraft.value = props.current.executionMode;
 }, { immediate: true });
+const edited = computed(() => ({
+  name: nameDraft.value.trim(),
+  description: descriptionDraft.value.trim(),
+  tags: tagsDraft.value,
+  icon: iconDraft.value,
+  executionMode: modeDraft.value
+}));
+function applyAndClose() {
+  if (JSON.stringify(edited.value) !== JSON.stringify(props.current)) emit("apply", edited.value);
+  emit("update:open", false);
+}
 function formatDateTime(iso) {
   if (!iso) return "\u2014";
   try {
@@ -57,7 +68,10 @@ function formatDateTime(iso) {
       <DialogHeader>
         <DialogTitle>{{ t("integration.workflows.settings.dialog.title") }}</DialogTitle>
         <DialogDescription class="text-sm">
-          {{ t("integration.workflows.settings.dialog.description", { name: workflow.name }) }}
+          <!-- The name as it stands, drafted included: this dialog is where a rename is
+               typed, so naming the workflow by its stored name here contradicts the
+               field directly below. -->
+          {{ t("integration.workflows.settings.dialog.description", { name: current.name }) }}
         </DialogDescription>
       </DialogHeader>
 
@@ -66,9 +80,7 @@ function formatDateTime(iso) {
           <div class="text-mono text-muted-foreground">{{ t("integration.workflows.settings.section.execution") }}</div>
           <div class="flex items-center gap-2">
             <Select
-              :model-value="modeDraft"
-              :disabled="savingMode"
-              @update:model-value="(v) => emit('change-mode', v)"
+              v-model="modeDraft"
             >
               <!-- Named explicitly: the section caption above says "Execution",
                    which is not a name the control itself carries. -->
@@ -81,7 +93,6 @@ function formatDateTime(iso) {
                 </SelectItem>
               </SelectContent>
             </Select>
-            <Loader2 v-if="savingMode" :size="14" class="shrink-0 animate-spin text-muted-foreground" />
           </div>
           <p class="text-xs text-muted-foreground">
             {{ modes.find((m2) => m2.value === modeDraft)?.hint }}
@@ -109,17 +120,6 @@ function formatDateTime(iso) {
             <Label id="wf-set-icon-label" class="text-sm font-normal text-muted-foreground">{{ t("integration.workflows.settings.field.icon.label") }}</Label>
             <WorkflowIconPicker v-model="iconDraft" trigger-labelledby="wf-set-icon-label" />
           </div>
-          <div class="flex justify-end">
-            <Button
-              size="sm"
-              class="h-7 text-sm"
-              :disabled="savingMeta || !nameDraft.trim()"
-              @click="emit('save-meta', { name: nameDraft.trim(), description: descriptionDraft.trim(), tags: tagsDraft, icon: iconDraft })"
-            >
-              <Loader2 v-if="savingMeta" :size="12" class="animate-spin" />
-              {{ t("integration.workflows.settings.action.save") }}
-            </Button>
-          </div>
         </div>
 
         <div class="rounded-lg border border-black/[0.06] bg-white p-4 space-y-2">
@@ -138,6 +138,17 @@ function formatDateTime(iso) {
           </div>
         </div>
       </div>
+
+      <!-- Cancel / Done, the pair every dialog in the editor closes on. Done reaches
+           the workflow's unsaved state; the header's Save reaches the platform. -->
+      <DialogFooter>
+        <Button variant="outline" size="sm" class="h-8" @click="emit('update:open', false)">
+          {{ t("integration.common.action.cancel") }}
+        </Button>
+        <Button size="sm" class="h-8" :disabled="!nameDraft.trim()" @click="applyAndClose">
+          {{ t("integration.workflows.settings.action.done") }}
+        </Button>
+      </DialogFooter>
     </DialogContent>
   </Dialog>
 </template>

package/dist/runtime/components/Integrations/WorkflowSettingsDialog.vue.d.ts

@@ -4,33 +4,32 @@ export interface ExecutionModeOption {
     label: string;
     hint: string;
 }
+/** What this dialog edits — the values as they stand, saved or not. */
+export interface WorkflowSettingsValues {
+    name: string;
+    description: string;
+    tags: string[];
+    icon: WorkflowIcon | null;
+    executionMode: string;
+}
 type __VLS_Props = {
     open: boolean;
     workflow: Workflow;
     modes: ExecutionModeOption[];
-    modeDraft: string;
-    savingMode?: boolean;
-    savingMeta?: boolean;
+    /**
+     * The values to edit: the editor's unsaved ones where it has any, the saved ones
+     * otherwise. Reopening the dialog therefore shows what the operator last entered
+     * rather than what the platform still holds.
+     */
+    current: WorkflowSettingsValues;
     /** Tag suggestions (tags already used across the tenant's workflows). */
     tagSuggestions?: string[];
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (args_0: boolean) => any;
-    "change-mode": (mode: string) => any;
-    "save-meta": (meta: {
-        name: string;
-        description: string;
-        tags: string[];
-        icon: WorkflowIcon | null;
-    }) => any;
+    apply: (values: WorkflowSettingsValues) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:open"?: ((args_0: boolean) => any) | undefined;
-    "onChange-mode"?: ((mode: string) => any) | undefined;
-    "onSave-meta"?: ((meta: {
-        name: string;
-        description: string;
-        tags: string[];
-        icon: WorkflowIcon | null;
-    }) => any) | undefined;
+    onApply?: ((values: WorkflowSettingsValues) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/components/Integrations/WorkflowTriggerView.vue

@@ -2,7 +2,8 @@
 import { computed, ref } from "vue";
 import { Handle, Position, useVueFlow } from "@vue-flow/core";
 import { NodeToolbar } from "@vue-flow/node-toolbar";
-import { ClockCircle as Clock, Play, TrashBinMinimalistic as TrashBin, LinkRound as Webhook, Bolt } from "#solar-icons";
+import { TrashBinMinimalistic as TrashBin } from "#solar-icons";
+import { triggerGlyph as glyphForTrigger } from "../../data/triggerGlyphs";
 import { resolveDisplayName } from "../../utils/localize";
 import { triggerTypeLabel } from "../../data/integrationNodeCatalog";
 import { describeCron } from "../../utils/schedule";
@@ -14,9 +15,7 @@ const props = defineProps({
 defineOptions({ inheritAttrs: false });
 defineEmits(["updateNodeInternals"]);
 const t = useIntegrationsT();
-const icon = computed(() => {
-  return props.data.type === "schedule" ? Clock : props.data.type === "webhook" ? Webhook : props.data.type === "event" ? Bolt : Play;
-});
+const icon = computed(() => glyphForTrigger(props.data.type));
 const subtitle = computed(() => {
   const c = props.data.config;
   if (props.data.type === "schedule") return describeCron(c.cron) ?? c.cron ?? t("integration.canvas.trigger.subtitle.noSchedule");
@@ -77,7 +76,7 @@ function sideToPosition(s) {
          identically (icon chip size-8/15, subtitle plain text-sm, mt-0.5). -->
     <div class="flex items-center gap-2.5 px-3 py-2.5">
       <span class="flex size-8 shrink-0 items-center justify-center rounded-md bg-emerald-500 text-white shadow-sm">
-        <component :is="icon" :size="15" :stroke-width="2.5" />
+        <component :is="icon" :size="15" />
       </span>
       <div class="min-w-0 flex-1">
         <div class="text-sm font-semibold text-foreground leading-tight truncate">

package/dist/runtime/components/Integrations/WorkflowVariablesDialog.vue

@@ -6,6 +6,7 @@ import {
   Dialog,
   DialogContent,
   DialogDescription,
+  DialogFooter,
   DialogHeader,
   DialogTitle,
   Input,
@@ -18,7 +19,7 @@ import {
   SelectValue
 } from "@revenexx/studio";
 import { toast } from "vue-sonner";
-import { resolveDisplayName } from "../../utils/localize";
+import { languageKeyRead, languageKeyToWrite, resolveDisplayName } from "../../utils/localize";
 const props = defineProps({
   open: { type: Boolean, required: true },
   variables: { type: Object, required: true }
@@ -27,32 +28,50 @@ const emit = defineEmits(["update:open", "update:variables"]);
 const t = useIntegrationsT();
 const KEY_PATTERN = /^[a-z_][a-z0-9_]*$/i;
 const TYPES = ["string", "number", "boolean", "object", "array"];
+const working = ref({});
 const jsonDrafts = reactive({});
 const jsonErrors = reactive({});
+const descDrafts = reactive({});
 watch(() => props.open, (o) => {
   if (!o) return;
+  working.value = JSON.parse(JSON.stringify(props.variables));
   for (const k of Object.keys(jsonDrafts)) delete jsonDrafts[k];
   for (const k of Object.keys(jsonErrors)) delete jsonErrors[k];
-  for (const [key, v] of Object.entries(props.variables)) {
+  for (const k of Object.keys(descDrafts)) delete descDrafts[k];
+  for (const [key, v] of Object.entries(working.value)) {
+    descDrafts[key] = descriptionText(v);
     if (v.type === "object" || v.type === "array") {
       jsonDrafts[key] = v.default === void 0 ? "" : JSON.stringify(v.default, null, 2);
       jsonErrors[key] = null;
     }
   }
 });
-const entries = computed(() => Object.entries(props.variables));
+const entries = computed(() => Object.entries(working.value));
+const changed = computed(() => JSON.stringify(working.value) !== JSON.stringify(props.variables));
+const hasJsonError = computed(() => Object.values(jsonErrors).some(Boolean));
 function commit(next) {
-  emit("update:variables", next);
+  working.value = next;
+}
+function applyAndClose() {
+  for (const [key, v] of Object.entries(working.value)) {
+    if ((v.type === "object" || v.type === "array") && jsonDrafts[key] !== void 0) {
+      applyJsonDraft(key, v.type);
+    }
+  }
+  if (hasJsonError.value) return;
+  if (changed.value) emit("update:variables", working.value);
+  emit("update:open", false);
 }
 function patchVar(key, patch) {
-  const cur = props.variables[key];
+  const cur = working.value[key];
   if (!cur) return;
-  commit({ ...props.variables, [key]: { ...cur, ...patch } });
+  commit({ ...working.value, [key]: { ...cur, ...patch } });
 }
 function removeVar(key) {
-  const next = { ...props.variables };
+  const next = { ...working.value };
   delete next[key];
   delete jsonDrafts[key];
+  delete descDrafts[key];
   delete jsonErrors[key];
   commit(next);
 }
@@ -65,6 +84,8 @@ function changeType(key, type) {
     array: void 0
   };
   patchVar(key, { type, default: blank[type] });
+  delete jsonDrafts[key];
+  delete jsonErrors[key];
   if (type === "object" || type === "array") {
     jsonDrafts[key] = "";
     jsonErrors[key] = null;
@@ -94,28 +115,34 @@ function descriptionText(v) {
   return resolveDisplayName(v.description);
 }
 function writeDescription(key, text) {
-  const cur = props.variables[key];
+  const cur = working.value[key];
   if (!cur) return;
+  descDrafts[key] = text;
+  const existing = typeof cur.description === "object" && cur.description !== null ? { ...cur.description } : {};
   if (!text.trim()) {
+    delete existing[languageKeyRead(cur.description)];
+    if (Object.keys(existing).length) {
+      patchVar(key, { description: existing });
+      return;
+    }
     const { description: _drop, ...rest } = cur;
-    commit({ ...props.variables, [key]: rest });
+    commit({ ...working.value, [key]: rest });
     return;
   }
-  const existing = typeof cur.description === "object" && cur.description !== null ? cur.description : {};
-  patchVar(key, { description: { ...existing, en: text } });
+  patchVar(key, { description: { ...existing, [languageKeyToWrite(cur.description)]: text } });
 }
 const newKey = ref("");
 const newKeyError = computed(() => {
   const k = newKey.value.trim();
   if (!k) return null;
   if (!KEY_PATTERN.test(k)) return t("integration.workflows.variables.error.invalidKey");
-  if (props.variables[k]) return t("integration.workflows.variables.error.keyExists");
+  if (working.value[k]) return t("integration.workflows.variables.error.keyExists");
   return null;
 });
 function addVariable() {
   const k = newKey.value.trim();
   if (!k || newKeyError.value) return;
-  commit({ ...props.variables, [k]: { type: "string", default: "" } });
+  commit({ ...working.value, [k]: { type: "string", default: "" } });
   newKey.value = "";
 }
 async function copyUsage(key) {
@@ -247,7 +274,7 @@ async function copyUsage(key) {
             <Label :for="`var-${key}-desc`" class="text-mono text-muted-foreground">{{ t("integration.workflows.variables.field.description.label") }}</Label>
             <Input
               :id="`var-${key}-desc`"
-              :model-value="descriptionText(v)"
+              :model-value="descDrafts[key] ?? descriptionText(v)"
               class="h-8 bg-white text-sm"
               :placeholder="t('integration.workflows.variables.field.description.placeholder')"
               @update:model-value="(val) => writeDescription(key, String(val))"
@@ -274,6 +301,18 @@ async function copyUsage(key) {
           <p v-if="newKeyError" class="mt-1 text-xs text-rose-600">{{ newKeyError }}</p>
         </div>
       </div>
+
+      <!-- Cancel / Done, the same pair every dialog in the editor closes on. Done
+           reaches the workflow's unsaved state; only the header's Save reaches the
+           platform. -->
+      <DialogFooter>
+        <Button variant="outline" size="sm" class="h-8" @click="emit('update:open', false)">
+          {{ t("integration.common.action.cancel") }}
+        </Button>
+        <Button size="sm" class="h-8" :disabled="hasJsonError" @click="applyAndClose">
+          {{ t("integration.workflows.variables.action.done") }}
+        </Button>
+      </DialogFooter>
     </DialogContent>
   </Dialog>
 </template>

package/dist/runtime/composables/useIntegrationsCredentials.d.ts

@@ -13,8 +13,19 @@ import type { Credential } from '../types/integrations.js';
  *   POST   /credentials/{id}/test        → test saved instance
  *   POST   /credentials/{id}/oauth/authorize-url → { authorize_url, state }
  */
+/**
+ * `message` is what the credential type said about the test, whichever way it went —
+ * which host answered, which environment, which plan, or why it was refused. The
+ * service sends it on every path, and it may be absent.
+ *
+ * `error` is not the service's: it is what THIS composable puts there when the call
+ * never arrived — a network failure, a refusal that is not an answer. Nothing on the
+ * wire ever carries it, so a surface that reads `error` alone and falls back to a
+ * fixed sentence throws away every reason the platform did send.
+ */
 export interface CredentialTestResult {
     ok: boolean;
+    message?: string;
     error?: string;
 }
 export declare function useIntegrationsCredentials(): {

package/dist/runtime/composables/useIntegrationsCredentials.js

@@ -60,7 +60,7 @@ export function useIntegrationsCredentials() {
   async function testInline(credentialTypeSlug, config) {
     try {
       const res = await api.post("/credentials/test", { credential_type_slug: credentialTypeSlug, config });
-      return res?.ok === false ? res : { ok: true };
+      return res?.ok === false ? res : { ok: true, message: res?.message };
     } catch (e) {
       return { ok: false, error: captureError(e, t("integration.credentials.error.testFailed")) };
     }
@@ -68,7 +68,7 @@ export function useIntegrationsCredentials() {
   async function test(id) {
     try {
       const res = await api.post(`/credentials/${encodeURIComponent(id)}/test`);
-      return res?.ok === false ? res : { ok: true };
+      return res?.ok === false ? res : { ok: true, message: res?.message };
     } catch (e) {
       return { ok: false, error: captureError(e, t("integration.credentials.error.testFailed")) };
     }

package/dist/runtime/composables/useIntegrationsNodes.js

@@ -4,14 +4,17 @@ import { useIntegrationsApi } from "./integrationsApi.js";
 import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
+const RETRY_COOLDOWN_MS = 3e4;
 export function useIntegrationsNodes() {
   const loading = useState("integrations.nodes.loading", () => false);
   const error = useState("integrations.nodes.error", () => null);
   const loaded = useState("integrations.nodes.loaded", () => false);
+  const failedAt = useState("integrations.nodes.failedAt", () => 0);
   const gate = useLoadGate("integrations.nodes", { loading, loaded });
   const api = useIntegrationsApi();
   const t = useIntegrationsT();
   async function load(force = false) {
+    if (!force && failedAt.value && Date.now() - failedAt.value < RETRY_COOLDOWN_MS) return;
     if (!await gate.claim(force)) return;
     error.value = null;
     try {
@@ -23,12 +26,19 @@ export function useIntegrationsNodes() {
         version: n.manifest.version ?? n.version,
         name: n.manifest.name ?? n.name,
         // Keep the source package — the palette groups app nodes by it.
-        __package: n.package ? { name: n.package.name, label: n.package.label ?? null } : void 0
+        __package: n.package ? { name: n.package.name, label: n.package.label ?? null } : void 0,
+        // Registered and built are two different things: a version whose code
+        // was never built can be drawn but not executed, so the palette must
+        // be able to leave it out (PO-338). Missing field = assume built.
+        __hasBundle: n.has_bundle !== false
       }));
       applyNodeCatalog(manifests);
       loaded.value = true;
+      failedAt.value = 0;
     } catch (e) {
       applyNodeCatalog([]);
+      loaded.value = false;
+      failedAt.value = Date.now();
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.nodes.error.loadFailed");
     } finally {
       gate.release();

package/dist/runtime/composables/useIntegrationsSchedules.d.ts

@@ -1,7 +1,8 @@
 import type { ScheduleEntry } from '../types/integrations.js';
 /**
- * Derived view — every trigger of type `schedule` across all workflows,
- * sourced from the real triggers sub-resource (useIntegrationsTriggers).
+ * Derived view — every trigger of type `schedule` across all workflows, as
+ * `useIntegrationsTriggers` holds them: read out of the workflow list, which carries
+ * each workflow's triggers, rather than fetched per workflow (PO-236).
  * Next/last-run timestamps are mocked deterministically (no telemetry
  * endpoint yet).
  *

package/dist/runtime/composables/useIntegrationsTriggers.d.ts

@@ -1,9 +1,14 @@
 import type { TriggerType } from '../types/integrations.js';
+import type { ApiTriggerLite } from './useIntegrationsWorkflows.js';
 /**
  * Workflow triggers — a per-workflow sub-resource in the Integrations service
- * (`/workflows/{id}/triggers`), NOT part of the workflow blob. The global
- * Schedules / Webhooks views fan `loadAll()` out across the tenant's workflows
- * and filter by `type`.
+ * (`/workflows/{id}/triggers`), NOT part of the workflow blob. `list()`, `create()`,
+ * `update()` and `remove()` address that sub-resource, one workflow at a time, which
+ * is how the editor's trigger settings work.
+ *
+ * `loadAll()` does NOT: the workflow list carries each workflow's triggers in full,
+ * so the tenant-wide view is derived from that response rather than fetched per
+ * workflow (PO-236). What it still costs is the workflow list, once.
  */
 export interface ApiTrigger {
     id: number;
@@ -26,6 +31,21 @@ export interface TriggerInput {
     config?: Record<string, unknown> | null;
     active?: boolean;
 }
+/**
+ * The tenant's triggers, read off the workflow list rather than fetched per workflow
+ * (PO-236). Pure, and exported for that reason: it is the whole of what the tenant-wide
+ * view now does, and the composable around it needs a Nuxt app that the unit setup has
+ * no environment for.
+ *
+ * `byWorkflow` holds the triggers as the API sent them (`useIntegrationsWorkflows`
+ * keeps them beside the cockpit model, whose `id` is the handle). Two fields are not
+ * in there and are filled from the workflow the triggers arrived with: `workflow_id`,
+ * which every row id and route is built from, and `workflowName`, which the views show.
+ */
+export declare function tenantTriggers(workflows: {
+    id: number;
+    name: string;
+}[], byWorkflow: Record<number, ApiTriggerLite[]>): TriggerWithWorkflow[];
 export declare function useIntegrationsTriggers(): {
     all: any;
     loading: any;

package/dist/runtime/composables/useIntegrationsTriggers.js

@@ -2,6 +2,19 @@ import { useIntegrationsApi } from "./integrationsApi.js";
 import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
+export function tenantTriggers(workflows, byWorkflow) {
+  return workflows.flatMap((wf) => (byWorkflow[wf.id] ?? []).flatMap((t) => {
+    if (typeof t.id !== "number") return [];
+    return [{
+      ...t,
+      id: t.id,
+      workflow_id: wf.id,
+      workflowName: wf.name,
+      handle: t.handle ?? "",
+      active: t.active ?? true
+    }];
+  }));
+}
 export function useIntegrationsTriggers() {
   const all = useState("integrations.triggers.all", () => []);
   const loading = useState("integrations.triggers.loading", () => false);
@@ -9,7 +22,7 @@ export function useIntegrationsTriggers() {
   const loaded = useState("integrations.triggers.loaded", () => false);
   const api = useIntegrationsApi();
   const t = useIntegrationsT();
-  const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
+  const { workflows, apiTriggers, load: loadWorkflows, loaded: workflowsLoaded, error: workflowsError } = useIntegrationsWorkflows();
   const gate = useLoadGate("integrations.triggers", { loading, loaded });
   function unwrapList(res) {
     if (Array.isArray(res)) return res;
@@ -22,12 +35,10 @@ export function useIntegrationsTriggers() {
     if (!await gate.claim(force)) return all.value;
     error.value = null;
     try {
-      await loadWorkflows();
-      const settled = await Promise.allSettled(
-        workflows.value.map(async (wf) => (await list(wf.id)).map((t2) => ({ ...t2, workflowName: wf.name })))
-      );
-      all.value = settled.flatMap((p) => p.status === "fulfilled" ? p.value : []);
-      loaded.value = workflowsLoaded.value && settled.every((p) => p.status === "fulfilled");
+      await loadWorkflows(force);
+      all.value = tenantTriggers(workflows.value, apiTriggers.value);
+      error.value = workflowsError.value;
+      loaded.value = workflowsLoaded.value && !workflowsError.value;
     } catch (e) {
       error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.triggers.error.loadFailed");
     } finally {

package/dist/runtime/composables/useIntegrationsWorkflows.d.ts

@@ -1,9 +1,18 @@
-import type { Workflow, WorkflowBlob, WorkflowExecutionMode } from '../types/integrations.js';
+import type { TriggerType, Workflow, WorkflowBlob, WorkflowExecutionMode } from '../types/integrations.js';
+export interface ApiTriggerLite {
+    id?: number;
+    handle?: string;
+    type: TriggerType;
+    name?: string | Record<string, string> | null;
+    config?: Record<string, unknown> | null;
+    active?: boolean;
+}
 export declare function useIntegrationsWorkflows(): {
     workflows: any;
     loading: any;
     error: any;
     loaded: any;
+    apiTriggers: any;
     total: import("vue").ComputedRef<any>;
     activeCount: import("vue").ComputedRef<any>;
     load: (force?: boolean) => Promise<Workflow[]>;

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -82,6 +82,7 @@ export function useIntegrationsWorkflows() {
   const loading = useState("integrations.workflows.loading", () => false);
   const error = useState("integrations.workflows.error", () => null);
   const loaded = useState("integrations.workflows.loaded", () => false);
+  const apiTriggers = useState("integrations.workflows.apiTriggers", () => ({}));
   const gate = useLoadGate("integrations.workflows", { loading, loaded });
   const api = useIntegrationsApi();
   const t = useIntegrationsT();
@@ -92,6 +93,24 @@ export function useIntegrationsWorkflows() {
     if (e instanceof IntegrationsApiError) return e.message;
     return e?.message ?? fallback;
   }
+  function remember(api2, into) {
+    if (api2.triggers !== void 0) into[Number(api2.id)] = api2.triggers;
+  }
+  function ingest(api2) {
+    const next = { ...apiTriggers.value };
+    remember(api2, next);
+    apiTriggers.value = next;
+    return toCockpit(api2);
+  }
+  function ingestList(list2) {
+    const next = { ...apiTriggers.value };
+    const out = list2.map((api2) => {
+      remember(api2, next);
+      return toCockpit(api2);
+    });
+    apiTriggers.value = next;
+    return out;
+  }
   function upsertCache(wf) {
     const idx = workflows.value.findIndex((w) => w.id === wf.id);
     workflows.value = idx < 0 ? [...workflows.value, wf] : workflows.value.map((w) => w.id === wf.id ? wf : w);
@@ -101,10 +120,11 @@ export function useIntegrationsWorkflows() {
     error.value = null;
     try {
       const list2 = unwrap(await api.get("/workflows")) ?? [];
-      workflows.value = list2.map(toCockpit);
+      workflows.value = ingestList(list2);
       loaded.value = true;
     } catch (e) {
       error.value = captureError(e, t("integration.workflows.error.loadFailed"));
+      loaded.value = false;
     } finally {
       gate.release();
     }
@@ -116,7 +136,7 @@ export function useIntegrationsWorkflows() {
   }
   async function get(id) {
     try {
-      const wf = toCockpit(unwrap(await api.get(`/workflows/${id}`)));
+      const wf = ingest(unwrap(await api.get(`/workflows/${id}`)));
       upsertCache(wf);
       return wf;
     } catch {
@@ -124,7 +144,7 @@ export function useIntegrationsWorkflows() {
     }
   }
   async function create(input) {
-    const wf = toCockpit(unwrap(await api.post("/workflows", toPayload({
+    const wf = ingest(unwrap(await api.post("/workflows", toPayload({
       name: input.name,
       description: input.description,
       blob: input.blob,
@@ -175,7 +195,7 @@ export function useIntegrationsWorkflows() {
     throw lastError instanceof Error ? lastError : new Error(t("integration.workflows.error.duplicateFailed"));
   }
   async function update(id, patch) {
-    const wf = toCockpit(unwrap(await api.put(`/workflows/${id}`, toPayload({
+    const wf = ingest(unwrap(await api.put(`/workflows/${id}`, toPayload({
       name: patch.name,
       description: patch.description,
       blob: patch.blob,
@@ -201,6 +221,7 @@ export function useIntegrationsWorkflows() {
     loading,
     error,
     loaded,
+    apiTriggers,
     total,
     activeCount,
     load,

package/dist/runtime/composables/useNodeConfigResolve.js

@@ -1,4 +1,5 @@
 import { computed, onScopeDispose, ref, toValue, watch } from "vue";
+import { isVersionExecutable } from "../data/integrationNodeCatalog.js";
 import { useIntegrationsApi } from "./integrationsApi.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 export function isResolvableValue(v) {
@@ -54,7 +55,7 @@ export function useNodeConfigResolve(opts) {
   });
   const gated = computed(() => unsatisfied.value.length > 0);
   const isEnabled = computed(
-    () => (toValue(opts.enabled) ?? true) && !gated.value && !!toValue(opts.slug) && !!toValue(opts.version)
+    () => (toValue(opts.enabled) ?? true) && isVersionExecutable(toValue(opts.slug), toValue(opts.version)) && !gated.value && !!toValue(opts.slug) && !!toValue(opts.version)
   );
   const subsetKey = computed(() => {
     const cfg = toValue(opts.config);