@revenexx/studio-integrations 0.1.0

package/dist/runtime/composables/useIntegrationsTriggers.js

@@ -0,0 +1,39 @@
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+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 } = useIntegrationsWorkflows();
+  function unwrapList(res) {
+    if (Array.isArray(res)) return res;
+    return res?.data ?? [];
+  }
+  async function list(workflowId) {
+    return unwrapList(await api.get(`/workflows/${workflowId}/triggers`));
+  }
+  async function loadAll(force = false) {
+    if (loading.value) return all.value;
+    if (loaded.value && !force) return all.value;
+    loading.value = true;
+    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 = true;
+    } catch (e) {
+      error.value = e instanceof IntegrationsApiError ? e.message : e?.message ?? "Could not load triggers.";
+    } finally {
+      loading.value = false;
+    }
+    return all.value;
+  }
+  const create = (workflowId, data) => api.post(`/workflows/${workflowId}/triggers`, data);
+  const update = (workflowId, triggerId, data) => api.put(`/workflows/${workflowId}/triggers/${triggerId}`, data);
+  const remove = (workflowId, triggerId) => api.del(`/workflows/${workflowId}/triggers/${triggerId}`);
+  return { all, loading, error, loaded, list, loadAll, create, update, remove };
+}

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

@@ -0,0 +1,28 @@
+import type { Workflow, WorkflowBlob, WorkflowExecutionMode } from '../types/integrations.js';
+export declare function useIntegrationsWorkflows(): {
+    workflows: any;
+    loading: any;
+    error: any;
+    loaded: any;
+    total: import("vue").ComputedRef<any>;
+    activeCount: import("vue").ComputedRef<any>;
+    load: (force?: boolean) => Promise<Workflow[]>;
+    list: () => Promise<Workflow[]>;
+    get: (id: number) => Promise<Workflow | null>;
+    create: (input: {
+        name: string;
+        description?: string | null;
+        blob: WorkflowBlob;
+        active?: boolean;
+        executionMode?: WorkflowExecutionMode;
+    }) => Promise<Workflow>;
+    update: (id: number, patch: {
+        name: string;
+        description?: string | null;
+        blob: WorkflowBlob;
+        active: boolean;
+        executionMode?: WorkflowExecutionMode;
+    }) => Promise<Workflow>;
+    remove: (id: number) => Promise<void>;
+    toggleActive: (id: number) => Promise<Workflow | null>;
+};

package/dist/runtime/composables/useIntegrationsWorkflows.js

@@ -0,0 +1,152 @@
+import { computed } from "vue";
+import { IntegrationsApiError, useIntegrationsApi } from "./integrationsApi.js";
+const BLOB_VERSION = "v0-draft";
+function toCockpit(api) {
+  const apiBlob = api.blob ?? {};
+  const triggers = (api.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 blob = {
+    nodeManifestVersion: apiBlob.nodeManifestVersion ?? BLOB_VERSION,
+    name: apiBlob.name ?? api.name,
+    nodes: apiBlob.nodes ?? [],
+    edges: apiBlob.edges ?? [],
+    triggerPositions: apiBlob.triggerPositions ?? {},
+    triggers
+  };
+  return {
+    id: Number(api.id),
+    name: api.name,
+    description: api.description ?? null,
+    blob_definition_version: BLOB_VERSION,
+    blob,
+    active: api.active ?? false,
+    revision: api.revision ?? 0,
+    execution_mode: api.execution_mode,
+    created_at: api.created_at ?? "",
+    updated_at: api.updated_at ?? ""
+  };
+}
+function toPayload(meta) {
+  const b = meta.blob;
+  return {
+    name: meta.name,
+    description: meta.description ?? null,
+    blob_definition_version: BLOB_VERSION,
+    blob: {
+      nodeManifestVersion: b.nodeManifestVersion ?? BLOB_VERSION,
+      name: typeof b.name === "string" ? b.name : meta.name,
+      nodes: b.nodes ?? [],
+      edges: b.edges ?? [],
+      triggerPositions: b.triggerPositions ?? {}
+    },
+    active: meta.active,
+    execution_mode: meta.executionMode ?? "async_only",
+    triggers: (b.triggers ?? []).map((t) => ({
+      handle: t.id,
+      type: t.type,
+      name: (typeof t.name === "string" ? t.name : null) ?? null,
+      config: t.type === "webhook" ? { method: "POST", ...t.config ?? {} } : t.config ?? null,
+      active: t.active ?? true
+    }))
+  };
+}
+export function useIntegrationsWorkflows() {
+  const workflows = useState("integrations.workflows", () => []);
+  const loading = useState("integrations.workflows.loading", () => false);
+  const error = useState("integrations.workflows.error", () => null);
+  const loaded = useState("integrations.workflows.loaded", () => false);
+  const api = useIntegrationsApi();
+  function unwrap(res) {
+    return res?.data ?? res;
+  }
+  function captureError(e, fallback) {
+    if (e instanceof IntegrationsApiError) return e.message;
+    return e?.message ?? fallback;
+  }
+  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);
+  }
+  async function load(force = false) {
+    if (loading.value) return workflows.value;
+    if (loaded.value && !force) return workflows.value;
+    loading.value = true;
+    error.value = null;
+    try {
+      const list2 = unwrap(await api.get("/workflows")) ?? [];
+      workflows.value = list2.map(toCockpit);
+      loaded.value = true;
+    } catch (e) {
+      error.value = captureError(e, "Could not load workflows.");
+    } finally {
+      loading.value = false;
+    }
+    return workflows.value;
+  }
+  async function list() {
+    if (!loaded.value) await load();
+    return workflows.value;
+  }
+  async function get(id) {
+    try {
+      const wf = toCockpit(unwrap(await api.get(`/workflows/${id}`)));
+      upsertCache(wf);
+      return wf;
+    } catch {
+      return workflows.value.find((w) => w.id === id) ?? null;
+    }
+  }
+  async function create(input) {
+    const wf = toCockpit(unwrap(await api.post("/workflows", toPayload({
+      name: input.name,
+      description: input.description,
+      blob: input.blob,
+      active: input.active ?? true,
+      executionMode: input.executionMode
+    }))));
+    upsertCache(wf);
+    return wf;
+  }
+  async function update(id, patch) {
+    const wf = toCockpit(unwrap(await api.put(`/workflows/${id}`, toPayload({
+      name: patch.name,
+      description: patch.description,
+      blob: patch.blob,
+      active: patch.active,
+      executionMode: patch.executionMode
+    }))));
+    upsertCache(wf);
+    return wf;
+  }
+  async function remove(id) {
+    await api.del(`/workflows/${id}`);
+    workflows.value = workflows.value.filter((w) => w.id !== id);
+  }
+  async function toggleActive(id) {
+    const wf = workflows.value.find((w) => w.id === id);
+    if (!wf) return null;
+    return update(id, { name: wf.name, description: wf.description, blob: wf.blob, active: !wf.active, executionMode: wf.execution_mode });
+  }
+  const total = computed(() => workflows.value.length);
+  const activeCount = computed(() => workflows.value.filter((w) => w.active).length);
+  return {
+    workflows,
+    loading,
+    error,
+    loaded,
+    total,
+    activeCount,
+    load,
+    list,
+    get,
+    create,
+    update,
+    remove,
+    toggleActive
+  };
+}

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

@@ -0,0 +1,41 @@
+import type { NodeManifest, TriggerType } from '../types/integrations.js';
+/**
+ * Reactive node-manifest registry — populated ONLY from the live registry
+ * (`GET /nodes`, via useIntegrationsNodes). No bundled fallback: either the
+ * online registry, or nothing. Consumers read this array directly and
+ * `findManifest` resolves against it synchronously, staying reactive to the
+ * live update.
+ */
+export declare const INTEGRATION_NODE_CATALOG: NodeManifest[];
+/** Replace the catalog contents in place (preserves the reactive identity). */
+export declare function applyNodeCatalog(manifests: NodeManifest[]): void;
+/**
+ * Categories rendered in the picker. Colors map to the L.I.D.F.
+ * domain palette we use across the cockpit.
+ */
+export declare const NODE_CATEGORIES: Array<{
+    key: NodeManifest['category'];
+    label: string;
+    color: string;
+}>;
+export declare function findManifest(slug: string, version?: string): NodeManifest | null;
+export declare const TRIGGER_OUTPUT_PORT = "default";
+export interface TriggerTemplate {
+    /** Stable picker id. */
+    id: string;
+    /** Maps to WorkflowTrigger.type once dropped. */
+    type: TriggerType;
+    /** Localized display name. */
+    name: {
+        en: string;
+        de: string;
+    };
+    description: {
+        en: string;
+        de: string;
+    };
+    icon: string;
+    /** Default config the canvas seeds when the user drops the tile. */
+    defaultConfig: Record<string, unknown>;
+}
+export declare const TRIGGER_TEMPLATES: TriggerTemplate[];

package/dist/runtime/data/integrationNodeCatalog.js

@@ -0,0 +1,67 @@
+import { reactive } from "vue";
+export const INTEGRATION_NODE_CATALOG = reactive([]);
+export function applyNodeCatalog(manifests) {
+  INTEGRATION_NODE_CATALOG.splice(0, INTEGRATION_NODE_CATALOG.length, ...manifests);
+}
+export const NODE_CATEGORIES = [
+  // Slate background everywhere; a faint accent on the icon stroke keeps
+  // the categories distinguishable without the rainbow.
+  { key: "trigger", label: "Triggers", color: "bg-slate-100 text-emerald-600/80" },
+  { key: "action", label: "Actions", color: "bg-slate-100 text-sky-600/80" },
+  { key: "io", label: "I/O", color: "bg-slate-100 text-violet-600/80" },
+  { key: "transform", label: "Transforms", color: "bg-slate-100 text-amber-700/80" },
+  { key: "control", label: "Control flow", color: "bg-slate-100 text-rose-600/80" }
+];
+export function findManifest(slug, version) {
+  const matches = INTEGRATION_NODE_CATALOG.filter((m) => m.slug === slug);
+  if (!matches.length) return null;
+  if (version) return matches.find((m) => m.version === version) ?? matches[0] ?? null;
+  return matches[0] ?? null;
+}
+export const TRIGGER_OUTPUT_PORT = "default";
+export const TRIGGER_TEMPLATES = [
+  {
+    id: "trigger-manual",
+    type: "manual",
+    name: { en: "Manual", de: "Manuell" },
+    description: {
+      en: "Run on demand from the editor or API.",
+      de: "Auf Knopfdruck aus dem Editor oder via API."
+    },
+    icon: "Play",
+    defaultConfig: {}
+  },
+  {
+    id: "trigger-schedule",
+    type: "schedule",
+    name: { en: "Schedule", de: "Zeitplan" },
+    description: {
+      en: "Cron-based recurring execution.",
+      de: "Wiederkehrende Ausf\xFChrung per Cron."
+    },
+    icon: "Clock",
+    defaultConfig: { cron: "0 * * * *", timezone: "Europe/Berlin" }
+  },
+  {
+    id: "trigger-webhook",
+    type: "webhook",
+    name: { en: "Webhook", de: "Webhook" },
+    description: {
+      en: "Trigger from an inbound HTTP request.",
+      de: "Ausl\xF6sen durch eingehenden HTTP-Aufruf."
+    },
+    icon: "Webhook",
+    defaultConfig: { path: "/incoming", method: "POST" }
+  },
+  {
+    id: "trigger-event",
+    type: "event",
+    name: { en: "Event", de: "Event" },
+    description: {
+      en: "Run when a platform event fires (e.g. customer.created).",
+      de: "Ausl\xF6sen bei einem Plattform-Event (z. B. customer.created)."
+    },
+    icon: "Zap",
+    defaultConfig: { event_type: "" }
+  }
+];

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

@@ -0,0 +1,7 @@
+import type { WorkflowRun } from '../types/integrations.js';
+/**
+ * Mock execution history. In production this comes from Temporal — workflow
+ * status, started/finished, step durations, retry counts, and error messages.
+ * Listed newest-first.
+ */
+export declare const SAMPLE_RUNS: WorkflowRun[];

package/dist/runtime/data/integrationRuns.js

@@ -0,0 +1,109 @@
+export const SAMPLE_RUNS = [
+  {
+    id: "run-01HZX9F8N7",
+    workflowId: 1,
+    workflowName: "Manual REST GET",
+    status: "succeeded",
+    triggerId: "manual-1",
+    triggerType: "manual",
+    startedAt: "2026-05-11T08:14:11Z",
+    finishedAt: "2026-05-11T08:14:12Z",
+    durationMs: 894,
+    steps: [
+      { nodeId: "fetch", status: "succeeded", startedAt: "2026-05-11T08:14:11Z", finishedAt: "2026-05-11T08:14:12Z", attempt: 1, durationMs: 850 }
+    ]
+  },
+  {
+    id: "run-01HZX8K2C5",
+    workflowId: 2,
+    workflowName: "Webhook order receiver",
+    status: "succeeded",
+    triggerId: "stripe-hook",
+    triggerType: "webhook",
+    startedAt: "2026-05-11T08:08:02Z",
+    finishedAt: "2026-05-11T08:08:03Z",
+    durationMs: 1244,
+    steps: [
+      { nodeId: "validate", status: "succeeded", startedAt: "2026-05-11T08:08:02Z", finishedAt: "2026-05-11T08:08:02Z", attempt: 1, durationMs: 12 },
+      { nodeId: "forward", status: "succeeded", startedAt: "2026-05-11T08:08:02Z", finishedAt: "2026-05-11T08:08:03Z", attempt: 1, durationMs: 1191 }
+    ]
+  },
+  {
+    id: "run-01HZX7Y3D2",
+    workflowId: 2,
+    workflowName: "Webhook order receiver",
+    status: "failed",
+    triggerId: "stripe-hook",
+    triggerType: "webhook",
+    startedAt: "2026-05-11T07:42:17Z",
+    finishedAt: "2026-05-11T07:42:25Z",
+    durationMs: 7842,
+    errorMessage: "fetch failed: 502 Bad Gateway on https://fulfillment.internal/orders after 4 attempts",
+    steps: [
+      { nodeId: "validate", status: "succeeded", startedAt: "2026-05-11T07:42:17Z", finishedAt: "2026-05-11T07:42:17Z", attempt: 1, durationMs: 9 },
+      { nodeId: "forward", status: "failed", startedAt: "2026-05-11T07:42:17Z", finishedAt: "2026-05-11T07:42:24Z", attempt: 4, durationMs: 7820 },
+      { nodeId: "notify-failure", status: "succeeded", startedAt: "2026-05-11T07:42:24Z", finishedAt: "2026-05-11T07:42:25Z", attempt: 1, durationMs: 612 }
+    ]
+  },
+  {
+    id: "run-01HZX5R7A1",
+    workflowId: 3,
+    workflowName: "Daily ETL with branching",
+    status: "running",
+    triggerId: "nightly",
+    triggerType: "schedule",
+    startedAt: "2026-05-11T08:14:00Z",
+    finishedAt: null,
+    durationMs: null,
+    steps: [
+      { nodeId: "fetch", status: "succeeded", startedAt: "2026-05-11T08:14:00Z", finishedAt: "2026-05-11T08:14:02Z", attempt: 1, durationMs: 2100 },
+      { nodeId: "route", status: "pending", startedAt: "2026-05-11T08:14:02Z", finishedAt: null, attempt: 1, durationMs: null }
+    ]
+  },
+  {
+    id: "run-01HZX4Q8B3",
+    workflowId: 3,
+    workflowName: "Daily ETL with branching",
+    status: "succeeded",
+    triggerId: "nightly",
+    triggerType: "schedule",
+    startedAt: "2026-05-10T03:00:00Z",
+    finishedAt: "2026-05-10T03:00:21Z",
+    durationMs: 21344,
+    steps: [
+      { nodeId: "fetch", status: "succeeded", startedAt: "2026-05-10T03:00:00Z", finishedAt: "2026-05-10T03:00:02Z", attempt: 1, durationMs: 2050 },
+      { nodeId: "route", status: "succeeded", startedAt: "2026-05-10T03:00:02Z", finishedAt: "2026-05-10T03:00:02Z", attempt: 1, durationMs: 8 },
+      { nodeId: "ship", status: "succeeded", startedAt: "2026-05-10T03:00:02Z", finishedAt: "2026-05-10T03:00:21Z", attempt: 1, durationMs: 19200 }
+    ]
+  },
+  {
+    id: "run-01HZX3M2E6",
+    workflowId: 1,
+    workflowName: "Manual REST GET",
+    status: "failed",
+    triggerId: "manual-1",
+    triggerType: "manual",
+    startedAt: "2026-05-10T16:11:00Z",
+    finishedAt: "2026-05-10T16:11:34Z",
+    durationMs: 33812,
+    errorMessage: "timeout exceeded after 30s on https://api.example.com/health",
+    steps: [
+      { nodeId: "fetch", status: "failed", startedAt: "2026-05-10T16:11:00Z", finishedAt: "2026-05-10T16:11:34Z", attempt: 3, durationMs: 33800 }
+    ]
+  },
+  {
+    id: "run-01HZX2N9F4",
+    workflowId: 2,
+    workflowName: "Webhook order receiver",
+    status: "succeeded",
+    triggerId: "stripe-hook",
+    triggerType: "webhook",
+    startedAt: "2026-05-10T11:33:48Z",
+    finishedAt: "2026-05-10T11:33:49Z",
+    durationMs: 942,
+    steps: [
+      { nodeId: "validate", status: "succeeded", startedAt: "2026-05-10T11:33:48Z", finishedAt: "2026-05-10T11:33:48Z", attempt: 1, durationMs: 8 },
+      { nodeId: "forward", status: "succeeded", startedAt: "2026-05-10T11:33:48Z", finishedAt: "2026-05-10T11:33:49Z", attempt: 1, durationMs: 901 }
+    ]
+  }
+];

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

@@ -0,0 +1,11 @@
+import type { WorkflowTemplate } from '../types/integrations.js';
+/**
+ * Category lens config for the Templates catalogue. The templates themselves
+ * come live from the Integrations registry (`GET /templates`) — there is no
+ * mock catalogue; an empty registry is an empty catalogue.
+ */
+export declare const TEMPLATE_CATEGORIES: Array<{
+    key: WorkflowTemplate['category'];
+    label: string;
+    color: string;
+}>;

package/dist/runtime/data/integrationTemplates.js

@@ -0,0 +1,9 @@
+export const TEMPLATE_CATEGORIES = [
+  // Uniform muted pill — the label carries the meaning, no rainbow needed.
+  { key: "sync", label: "Sync", color: "bg-slate-100 text-slate-700" },
+  { key: "notification", label: "Notification", color: "bg-slate-100 text-slate-700" },
+  { key: "fulfilment", label: "Fulfilment", color: "bg-slate-100 text-slate-700" },
+  { key: "enrichment", label: "Enrichment", color: "bg-slate-100 text-slate-700" },
+  { key: "finance", label: "Finance", color: "bg-slate-100 text-slate-700" },
+  { key: "reporting", label: "Reporting", color: "bg-slate-100 text-slate-700" }
+];

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

@@ -0,0 +1,18 @@
+import type { Connection, ConnectionTemplate, Workflow } from '../types/integrations.js';
+/**
+ * Seed data for the workflow list. Built strictly with the manifests the
+ * backend currently has fixtures for (`rest-get`, `control-if`,
+ * `control-switch`) and the trigger output port the reference workflow
+ * blobs use (`default` — see
+ * `playground/integrations/tests/Fixtures/WorkflowBlobs/*.json`).
+ *
+ * If you change a manifest's `slug` / `version`, change it here too.
+ */
+export declare const SAMPLE_WORKFLOWS: Workflow[];
+export declare const SAMPLE_SECRETS: {
+    key: string;
+    created_at: string;
+    updated_at: string;
+}[];
+export declare const CONNECTION_TEMPLATES: ConnectionTemplate[];
+export declare const SAMPLE_CONNECTIONS: Connection[];