@revenexx/studio-integrations 0.6.0 → 1.0.0

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

@@ -0,0 +1,149 @@
+import type { ComputedRef, Ref } from 'vue';
+/**
+ * The Studio's single Talkback subscriber.
+ *
+ * The integrations service publishes its run, workflow and bundle-build lifecycle
+ * onto the platform event bus (`App\Enums\OutboxTopic` → `event_outbox` → the relay
+ * → NATS → the Talkback bridge → Centrifugo), so a browser can learn that a run
+ * finished — or that a build is done — instead of asking every three seconds. This
+ * is the browser end of that chain, and everything it hands out is a **refetch
+ * signal**: the envelope carries no run payload — the bus has a 1 MB cap — so "the
+ * data arrived over the socket" was never on offer, and every surface still reloads
+ * through its own loader.
+ *
+ * ONE SUBSCRIBER FOR THE WHOLE APPLICATION, and this is the part that is not a
+ * style preference. `talkback-js` deduplicates on `envelope.id` **across the whole
+ * client**, before it dispatches to a channel's listeners (`src/core/talkback.ts`,
+ * `seen.admit`). The bridge publishes every event twice — once to the action
+ * channel, once to the resource channel, which is contractual (ADR-0094) — so if
+ * the runs grid took the action channel and an open detail panel took the resource
+ * channel, only whichever arrived first would fire and the other would silently
+ * never refetch. Two components cannot each own a subscription to the same event.
+ * So the channels are owned here, once, and the surfaces watch the signals below.
+ *
+ * ONLY ACTION CHANNELS, for the same reason: subscribing to just one of the two
+ * channels an event lands on makes each event exactly one delivery, with nothing
+ * to lose the race against. A resource channel would buy a narrower filter that
+ * `lastRunEvent.topicId` already provides.
+ *
+ * ONE ACTION IS ONE CHANNEL. The action is the fourth topic segment and Centrifugo
+ * has no wildcards, so watching the five run actions costs five subscriptions, and
+ * the eleven topics the service emits cost eleven for the whole application. The
+ * three-segment form (`revenexx.integrations.run`) is the resource KIND channel,
+ * which the bridge never publishes to.
+ *
+ * SAFE WHEN REALTIME IS OFF, which is the production state in the cockpit until
+ * the edge is shown to pass a WebSocket upgrade (PE-382 T0.2). With no
+ * `talkbackHost` configured nothing is subscribed, `delivering` stays false, and
+ * every caller keeps the polling it had — as it does for a tenant that is
+ * configured but whose channels never carry anything.
+ */
+/** Mirrors `App\Enums\OutboxTopic` in `revenexx/integrations`. */
+export declare const RUN_TOPIC = "revenexx.integrations.run";
+export declare const WORKFLOW_TOPIC = "revenexx.integrations.workflow";
+/**
+ * The bundle build. Its own entity rather than `workflow.build_started`, because
+ * the service's envelope allows no underscore in a topic segment and Console's
+ * manifest schema allows no hyphen — `build.started` is the only form that passes
+ * both. `topic_id` is still the WORKFLOW's id: a build has no row of its own.
+ */
+export declare const BUILD_TOPIC = "revenexx.integrations.build";
+/** `run.cancelled` also carries a `terminated` status — the two collapse into one topic. */
+export declare const RUN_ACTIONS: readonly ["created", "started", "finished", "failed", "cancelled"];
+/**
+ * There is no `run.deleted`. Runs cascade with their workflow inside Postgres
+ * without firing model events, which is why `workflow.deleted` carries
+ * `cascades_runs: true` instead.
+ */
+export declare const WORKFLOW_ACTIONS: readonly ["created", "updated", "deleted"];
+/**
+ * `started` is emitted per queue ATTEMPT, and the job has three: a failing build
+ * sends started/failed up to three times, with `data.attempt` (1-based) as the
+ * only way to tell a final failure from one that is about to be retried.
+ */
+export declare const BUILD_ACTIONS: readonly ["started", "succeeded", "failed"];
+/** What a surface needs off an envelope. A structural subset of talkback-js's `Envelope`. */
+export interface RealtimeEvent {
+    /** `evt_<ulid>`, the client's deduplication key. Carried for logging. */
+    id: string;
+    /** The fourth topic segment: `finished`, `deleted`, … */
+    action: string;
+    /** The run's or workflow's primary key, as a string. Never a number — see OutboxEnvelope. */
+    topicId: string | null;
+    /** The event's `data` map, e.g. `cascades_runs` on `workflow.deleted`. */
+    data: Record<string, unknown>;
+}
+export interface IntegrationsRealtime {
+    /**
+     * Whether this connection has actually reported something, and therefore
+     * whether a poll may take the long budget (`pollBudget.ts`).
+     *
+     * IT COUNTS DELIVERIES, NOT CONFIGURATION, and that is the whole reason it is
+     * not called `live`. Being subscribed is no evidence of anything: a channel
+     * resolves from the LOCAL subscription, and a tenant whose Console event
+     * catalogue does not mark these topics `channel: true` holds eleven channels
+     * that will never carry a byte (PE-375). Spending that state as a delivery
+     * signal would thin every run surface's refresh by ten with nothing arriving to
+     * make up for it — ten times worse than before any of this existed, silently.
+     * So the budget is only thinned once something has really been delivered.
+     *
+     * What it still cannot say is whether delivery is *continuing*: a socket that
+     * dies quietly after one event keeps reading true, because the per-channel
+     * confirmation that would settle it is not passed through the packages between
+     * Centrifugo and here (`docs/realtime.md`). That is why the poll backs off to a
+     * slow safety interval rather than stopping.
+     */
+    delivering: ComputedRef<boolean>;
+    /** Bumped on every run event. Watch it to refetch a run list. */
+    runTick: Readonly<Ref<number>>;
+    /** Bumped on every workflow event. */
+    workflowTick: Readonly<Ref<number>>;
+    /**
+     * Bumped on every bundle-build event.
+     *
+     * Kept apart from `workflowTick` rather than folded into it: a build is the one
+     * workflow change that happens WITHOUT anybody editing the workflow, and it can
+     * fire six times for a single save (three attempts × started/failed). The runs
+     * grid watches `workflowTick` to catch a cascade-delete and has no business
+     * reloading for build progress.
+     */
+    buildTick: Readonly<Ref<number>>;
+    /** The last run event, for a surface that only cares about one run's id. */
+    lastRunEvent: Readonly<Ref<RealtimeEvent | null>>;
+    lastWorkflowEvent: Readonly<Ref<RealtimeEvent | null>>;
+    /** The last build event. `topicId` is the workflow it belongs to. */
+    lastBuildEvent: Readonly<Ref<RealtimeEvent | null>>;
+    /** The subscribed channel names, for diagnostics. */
+    channels: ComputedRef<string[]>;
+}
+/** The shape a handler receives. Talkback's `Envelope` is assignable to it. */
+export interface EnvelopeLike {
+    id?: unknown;
+    topic?: unknown;
+    topic_id?: unknown;
+    data?: unknown;
+}
+/**
+ * Narrows a publication to the fields a surface acts on.
+ *
+ * Everything is read defensively rather than cast. The envelope crosses four
+ * services to get here (`OutboxEmitter` → the relay → NATS → the bridge), and a
+ * surface that threw on an unexpected shape would take the page down over an event
+ * it could simply have ignored.
+ *
+ * `topic_id` is stringified on purpose: it is a string on the wire — an 18-digit id
+ * loses precision as a float64 above 2^53 — and `OutboxEnvelope` is careful about
+ * that, so nothing here should be the place that turns it back into a number.
+ */
+export declare function toRealtimeEvent(envelope: EnvelopeLike): RealtimeEvent;
+/**
+ * The workflow a run or build event belongs to, or null.
+ *
+ * `WorkflowRunEventObserver`'s payload carries `workflow_id` beside `run_id`, which
+ * is what lets a workflow-scoped surface ignore every other workflow's runs — in a
+ * busy tenant that is the difference between one refetch and a refetch per run in
+ * the account. Null means "cannot tell", and a caller should refetch rather than
+ * assume the event was not for it.
+ */
+export declare function workflowIdOf(event: RealtimeEvent | null): string | null;
+export declare function useIntegrationsRealtime(): IntegrationsRealtime;

package/dist/runtime/composables/useIntegrationsRealtime.js

@@ -0,0 +1,80 @@
+import { computed, effectScope, ref, shallowRef } from "vue";
+export const RUN_TOPIC = "revenexx.integrations.run";
+export const WORKFLOW_TOPIC = "revenexx.integrations.workflow";
+export const BUILD_TOPIC = "revenexx.integrations.build";
+export const RUN_ACTIONS = ["created", "started", "finished", "failed", "cancelled"];
+export const WORKFLOW_ACTIONS = ["created", "updated", "deleted"];
+export const BUILD_ACTIONS = ["started", "succeeded", "failed"];
+export function toRealtimeEvent(envelope) {
+  const topic = typeof envelope.topic === "string" ? envelope.topic : "";
+  const topicId = envelope.topic_id;
+  const data = envelope.data;
+  return {
+    id: typeof envelope.id === "string" ? envelope.id : "",
+    action: topic.split(".")[3] ?? "",
+    topicId: topicId === null || topicId === void 0 ? null : String(topicId),
+    data: data !== null && typeof data === "object" ? data : {}
+  };
+}
+export function workflowIdOf(event) {
+  const id = event?.data.workflow_id;
+  return typeof id === "string" && id ? id : null;
+}
+const runTick = ref(0);
+const workflowTick = ref(0);
+const buildTick = ref(0);
+const lastRunEvent = shallowRef(null);
+const lastWorkflowEvent = shallowRef(null);
+const lastBuildEvent = shallowRef(null);
+const deliveries = computed(() => runTick.value + workflowTick.value + buildTick.value);
+let scope = null;
+let openChannels = null;
+function onRun(envelope) {
+  lastRunEvent.value = toRealtimeEvent(envelope);
+  runTick.value++;
+}
+function onWorkflow(envelope) {
+  lastWorkflowEvent.value = toRealtimeEvent(envelope);
+  workflowTick.value++;
+}
+function onBuild(envelope) {
+  lastBuildEvent.value = toRealtimeEvent(envelope);
+  buildTick.value++;
+}
+function onRunGap() {
+  lastRunEvent.value = null;
+  runTick.value++;
+}
+function onWorkflowGap() {
+  lastWorkflowEvent.value = null;
+  workflowTick.value++;
+}
+function onBuildGap() {
+  lastBuildEvent.value = null;
+  buildTick.value++;
+}
+export function useIntegrationsRealtime() {
+  const { talkback, enabled } = usePlatformTalkback();
+  if (enabled && import.meta.client && !scope) {
+    scope = effectScope(true);
+    scope.run(() => {
+      const subs = [
+        ...RUN_ACTIONS.map((action) => useTalkbackTopic(`${RUN_TOPIC}.${action}`, { handler: onRun, onResync: onRunGap })),
+        ...WORKFLOW_ACTIONS.map((action) => useTalkbackTopic(`${WORKFLOW_TOPIC}.${action}`, { handler: onWorkflow, onResync: onWorkflowGap })),
+        ...BUILD_ACTIONS.map((action) => useTalkbackTopic(`${BUILD_TOPIC}.${action}`, { handler: onBuild, onResync: onBuildGap }))
+      ];
+      openChannels = computed(() => subs.map((s) => s.channel.value).filter((c) => !!c));
+    });
+  }
+  const channels = computed(() => openChannels?.value ?? []);
+  return {
+    delivering: computed(() => deliveries.value > 0 && enabled && !!talkback.value && channels.value.length > 0),
+    runTick,
+    workflowTick,
+    buildTick,
+    lastRunEvent,
+    lastWorkflowEvent,
+    lastBuildEvent,
+    channels
+  };
+}

package/dist/runtime/composables/useIntegrationsRevisions.js

@@ -1,8 +1,10 @@
 import { ref } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 export function useIntegrationsRevisions() {
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   const loading = ref(false);
   const error = ref(null);
   function captureError(e, fallback) {
@@ -16,7 +18,7 @@ export function useIntegrationsRevisions() {
       const res = await api.get(`/workflows/${workflowId}/revisions?page=${page}&per_page=${perPage}`);
       return { revisions: res.data ?? [], meta: res.meta };
     } catch (e) {
-      error.value = captureError(e, "Could not load the revision history.");
+      error.value = captureError(e, t("integration.revisions.error.loadFailed"));
       throw e;
     } finally {
       loading.value = false;
@@ -25,12 +27,12 @@ export function useIntegrationsRevisions() {
   async function get(workflowId, revision) {
     const res = await api.get(`/workflows/${workflowId}/revisions/${revision}`);
     const apiBlob = res.blob ?? {};
-    const triggers = (res.triggers ?? []).map((t) => ({
-      id: t.handle ?? String(t.id ?? ""),
-      type: t.type,
-      name: typeof t.name === "string" ? t.name : t.name ?? void 0,
-      active: t.active,
-      config: t.config ?? {}
+    const triggers = (res.triggers ?? []).map((t2) => ({
+      id: t2.handle ?? String(t2.id ?? ""),
+      type: t2.type,
+      name: typeof t2.name === "string" ? t2.name : t2.name ?? void 0,
+      active: t2.active,
+      config: t2.config ?? {}
     }));
     return {
       ...res,

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

@@ -24,7 +24,7 @@ export declare function useIntegrationsRuns(): {
     }) => WorkflowRun[];
     get: (id: string) => WorkflowRun | null;
     fetchRun: (workflowId: number | string, runId: number | string, workflowName: string) => Promise<WorkflowRun>;
-    trigger: (workflowId: number | string, payload?: Record<string, unknown>, mode?: "sync" | "async") => Promise<unknown>;
+    trigger: (workflowId: number | string, payload?: Record<string, unknown>, mode?: "async" | "sync") => Promise<unknown>;
     cancelRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
     terminateRun: (workflowId: number | string, runId: number | string, reason?: string) => Promise<unknown>;
     retryRun: (workflowId: number | string, runId: number | string) => Promise<unknown>;

package/dist/runtime/composables/useIntegrationsRuns.js

@@ -1,5 +1,6 @@
 import { computed } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
 function mapStatus(status) {
@@ -33,6 +34,7 @@ export function useIntegrationsRuns() {
   const gate = useLoadGate("integrations.runs", { loading, loaded });
   const SYNC_LIMIT = 5;
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
   function mapRun(r, workflowName) {
     const startedMs = r.started_at ? new Date(r.started_at).getTime() : null;
@@ -99,7 +101,7 @@ export function useIntegrationsRuns() {
       }
       loaded.value = workflowsLoaded.value && perWorkflow.every((p) => p.status === "fulfilled");
     } catch (e) {
-      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load runs.";
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.runs.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/useIntegrationsSecrets.js

@@ -1,5 +1,6 @@
 import { computed } from "vue";
 import { useIntegrationsApi } from "./integrationsApi.js";
+import { useIntegrationsT } from "./useIntegrationsT.js";
 import { IntegrationsApiError } from "../utils/apiError.js";
 import { useLoadGate } from "./useLoadGate.js";
 const KEY_PATTERN = /^[A-Z0-9_]+$/;
@@ -10,6 +11,7 @@ export function useIntegrationsSecrets() {
   const loaded = useState("integrations.secrets.loaded", () => false);
   const gate = useLoadGate("integrations.secrets", { loading, loaded });
   const api = useIntegrationsApi();
+  const t = useIntegrationsT();
   function isValidKey(key) {
     return KEY_PATTERN.test(key);
   }
@@ -35,7 +37,7 @@ export function useIntegrationsSecrets() {
       secrets.value = normalize(await api.get("/secrets"));
       loaded.value = true;
     } catch (e) {
-      error.value = captureError(e, "Could not load secrets.");
+      error.value = captureError(e, t("integration.secrets.error.loadFailed"));
     } finally {
       gate.release();
     }
@@ -47,7 +49,7 @@ export function useIntegrationsSecrets() {
   }
   async function upsert(key, value) {
     if (!isValidKey(key)) {
-      throw new Error("Key must match ^[A-Z0-9_]+$");
+      throw new Error(t("integration.secrets.error.invalidKey"));
     }
     const created = !secrets.value.some((s) => s.key === key);
     await api.post("/secrets", { key, value });

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

@@ -0,0 +1,35 @@
+import type { ComputedRef } from 'vue';
+import type { Translate } from '../i18n/translate.js';
+/**
+ * `useIntegrationsT()` — the studio's own interface strings.
+ *
+ *   const t = useIntegrationsT()
+ *   t('integration.dashboard.runs.title')
+ *   t('integration.dashboard.attention.missedRuns', missed.length)
+ *   t('integration.credentials.toast.deleted', { name: credential.name })
+ *
+ * Returns `t` directly rather than `{ t }`, matching `useT()` in
+ * `@revenexx/studio-shared`. It is **not** that function: `useT()` asks the
+ * host's catalogue, which has no `integration.*` keys in it, so this module
+ * reads its own (`runtime/i18n/messages/*.json`) instead. The names differ on
+ * purpose — studio-shared registers a global auto-import called `useT`, and two
+ * modules claiming one name is a silent, one-wins collision.
+ *
+ * Not a composable in the reactive-state sense: no component instance is
+ * needed, so it may be called from a plain helper or outside `setup()`.
+ *
+ * **Reactivity is on the caller.** `t()` reads the language at call time, so
+ * anything evaluated once — a `const TABS = [...]` at module or setup scope —
+ * keeps whatever language was current when the file loaded. Put it in a
+ * `computed()`. That is the one way to ship this looking finished and have it
+ * not switch.
+ */
+export declare function useIntegrationsT(): Translate;
+/**
+ * The language the studio's chrome is rendering in, as a `ComputedRef`.
+ *
+ * For the rare case that needs the tag itself — an `Intl` format, a `lang`
+ * attribute — rather than a translated string. To *set* it, that is
+ * `useIntegrationsLocale()`, which is the host's seam.
+ */
+export declare function useIntegrationsUiLocale(): ComputedRef<string>;

package/dist/runtime/composables/useIntegrationsT.js

@@ -0,0 +1,9 @@
+import { computed } from "vue";
+import { studioLocale } from "../utils/localize.js";
+import { translate } from "../i18n/translate.js";
+export function useIntegrationsT() {
+  return translate;
+}
+export function useIntegrationsUiLocale() {
+  return computed(() => studioLocale());
+}

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

@@ -1,11 +1,11 @@
 import type { TemplateRequirements, WorkflowTemplate } from '../types/integrations.js';
 export declare function useIntegrationsTemplates(): {
-    templates: any;
+    templates: import("vue").ComputedRef<WorkflowTemplate[]>;
     loaded: any;
     loading: any;
     error: any;
-    total: import("vue").ComputedRef<any>;
-    startingPoints: import("vue").ComputedRef<any>;
+    total: import("vue").ComputedRef<number>;
+    startingPoints: import("vue").ComputedRef<WorkflowTemplate[]>;
     load: (force?: boolean) => Promise<WorkflowTemplate[]>;
     list: () => WorkflowTemplate[];
     get: (slug: string) => WorkflowTemplate | null;

package/dist/runtime/composables/useIntegrationsTemplates.js

@@ -84,7 +84,14 @@ function applyDetail(base, api) {
   };
 }
 export function useIntegrationsTemplates() {
-  const templates = useState("integrations.templates", () => []);
+  const t = useIntegrationsT();
+  const rawList = useState("integrations.templates.raw", () => []);
+  const rawDetails = useState("integrations.templates.rawDetails", () => ({}));
+  const templates = computed(() => rawList.value.map((item) => {
+    const base = mapListItem(item);
+    const detail = rawDetails.value[item.slug];
+    return detail ? applyDetail(base, detail) : base;
+  }));
   const loaded = useState("integrations.templates.loaded", () => false);
   const loading = useState("integrations.templates.loading", () => false);
   const error = useState("integrations.templates.error", () => null);
@@ -101,11 +108,13 @@ export function useIntegrationsTemplates() {
     error.value = null;
     try {
       const list2 = unwrap(await api.get("/templates")) ?? [];
-      templates.value = list2.map(mapListItem);
+      rawList.value = list2;
+      rawDetails.value = {};
       loaded.value = true;
     } catch (e) {
-      error.value = captureError(e, "Could not load templates.");
-      templates.value = [];
+      error.value = captureError(e, t("integration.templates.state.error.fallback"));
+      rawList.value = [];
+      rawDetails.value = {};
       loaded.value = true;
     } finally {
       gate.release();
@@ -116,16 +125,15 @@ export function useIntegrationsTemplates() {
     return templates.value;
   }
   function get(slug) {
-    return templates.value.find((t) => t.slug === slug) ?? null;
+    return templates.value.find((t2) => t2.slug === slug) ?? null;
   }
   async function fetchDetail(slug) {
     const base = get(slug);
     if (!base?.fromApi) return base;
     try {
       const detail = unwrap(await api.get(`/templates/${slug}`));
-      const merged = applyDetail(base, detail);
-      templates.value = templates.value.map((t) => t.slug === slug ? merged : t);
-      return merged;
+      rawDetails.value = { ...rawDetails.value, [slug]: detail };
+      return get(slug);
     } catch {
       return base;
     }

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

@@ -1,13 +1,28 @@
 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);
   const error = useState("integrations.triggers.error", () => null);
   const loaded = useState("integrations.triggers.loaded", () => false);
   const api = useIntegrationsApi();
-  const { workflows, load: loadWorkflows, loaded: workflowsLoaded } = useIntegrationsWorkflows();
+  const t = useIntegrationsT();
+  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;
@@ -20,14 +35,12 @@ 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((t) => ({ ...t, 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 ?? "Could not load triggers.";
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? t("integration.triggers.error.loadFailed");
     } finally {
       gate.release();
     }

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[]>;