@revenexx/studio-integrations 0.1.0

package/dist/runtime/types/integrations.d.ts

@@ -0,0 +1,427 @@
+/**
+ * Type contracts for the Integration Studio surface.
+ *
+ * These mirror the integrations Laravel service (see `playground/integrations`)
+ * and its Scribe-published API. The wire format is the JSON `blob` of a
+ * workflow whose shape is defined by the `v0-draft` schema. We type a
+ * subset that the mockup needs — the editor only reads/writes the blob,
+ * never invents fields outside it.
+ */
+export type LocalizedString = string | Record<string, string>;
+export type WorkflowVariableType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+export interface WorkflowVariable {
+    type: WorkflowVariableType;
+    default?: unknown;
+    description?: LocalizedString;
+    required?: boolean;
+}
+export type TriggerType = 'manual' | 'schedule' | 'webhook' | 'event';
+export interface WorkflowTrigger {
+    id: string;
+    type: TriggerType;
+    name?: LocalizedString;
+    /** Whether the trigger is active (API field). */
+    active?: boolean;
+    config: {
+        cron?: string;
+        timezone?: string;
+        path?: string;
+        method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+        secretRef?: string;
+        event_type?: string;
+    };
+}
+export type RetryStrategy = 'linear' | 'exponential';
+export interface WorkflowNodeRetry {
+    maxAttempts: number;
+    backoffSeconds?: number;
+    strategy?: RetryStrategy;
+}
+export interface WorkflowNodePosition {
+    x: number;
+    y: number;
+}
+export interface WorkflowNode {
+    id: string;
+    /** kebab-case slug pointing at a Node manifest in the registry. */
+    nodeSlug: string;
+    /** semver pin for the chosen manifest version. */
+    nodeVersion: string;
+    name?: LocalizedString;
+    /** Free-form key→value config, validated against the node manifest. */
+    config: Record<string, unknown>;
+    position?: WorkflowNodePosition;
+    retry?: WorkflowNodeRetry;
+}
+export interface WorkflowEdge {
+    id: string;
+    from: {
+        nodeId: string;
+        output: string;
+    };
+    to: {
+        nodeId: string;
+        input?: string;
+    };
+}
+export interface WorkflowBlob {
+    nodeManifestVersion: string;
+    name: LocalizedString;
+    description?: LocalizedString;
+    variables?: Record<string, WorkflowVariable>;
+    triggers: WorkflowTrigger[];
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    /** Canvas positions for triggers, keyed by trigger handle (BlobDef). */
+    triggerPositions?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+}
+export type WorkflowExecutionMode = 'async_only' | 'sync_only' | 'caller_decides';
+export interface Workflow {
+    id: number;
+    name: string;
+    description: string | null;
+    blob_definition_version: 'v0-draft';
+    blob: WorkflowBlob;
+    active: boolean;
+    revision: number;
+    execution_mode?: WorkflowExecutionMode;
+    created_at: string;
+    updated_at: string;
+}
+export type NodeCategory = 'trigger' | 'action' | 'transform' | 'control' | 'io';
+export type NodeDataType = 'any' | 'object' | 'array' | 'string' | 'number' | 'boolean';
+export type OutputKind = 'default' | 'branch' | 'error';
+export interface NodeManifestInput {
+    dataType: NodeDataType;
+    required?: boolean;
+    description?: LocalizedString;
+}
+export interface NodeManifestOutput {
+    name?: string;
+    label?: LocalizedString;
+    kind: OutputKind;
+    dataType: NodeDataType;
+    description?: LocalizedString;
+    sourceFromConfig?: string;
+    fallback?: {
+        name: string;
+        label?: LocalizedString;
+    };
+}
+export type ConfigFieldType = 'string' | 'number' | 'boolean' | 'select' | 'multiselect' | 'object' | 'array' | 'expression' | 'secret-ref' | 'credentials-ref';
+export interface ConfigFieldOption {
+    value: string | number | boolean;
+    label: LocalizedString;
+}
+export interface ConfigField {
+    key: string;
+    label: LocalizedString;
+    description?: LocalizedString;
+    type: ConfigFieldType;
+    required?: boolean;
+    default?: unknown;
+    placeholder?: LocalizedString;
+    expressionAllowed?: boolean;
+    options?: ConfigFieldOption[];
+    /** sub-fields when type === 'object' (one level deep) */
+    properties?: ConfigField[];
+    /** item type when type === 'array' */
+    items?: ConfigField;
+    /** credential type slug the field binds to when type === 'credentials-ref' (e.g. 'revenexx:business-central'). */
+    credentialType?: string;
+    validation?: {
+        pattern?: string;
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+    };
+}
+export interface NodeManifest {
+    slug: string;
+    version: string;
+    category: NodeCategory;
+    name: LocalizedString;
+    description?: LocalizedString;
+    /** lucide-vue-next icon name OR mdi:icon-id. */
+    icon?: string;
+    input: NodeManifestInput;
+    outputs: NodeManifestOutput[];
+    config?: ConfigField[];
+}
+export interface SecretRecord {
+    key: string;
+    created_at: string;
+    updated_at: string;
+}
+/** How a credential type resolves to runtime access data. */
+export type AuthKind = 'static' | 'api-key' | 'basic' | 'oauth2-client-credentials' | 'oauth2-authcode';
+/** A single configurable field of a credential type (from its descriptor). */
+export interface CredentialTypeField {
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'select' | 'secret';
+    label: LocalizedString;
+    required?: boolean;
+    options?: Array<{
+        label: string;
+        value: string | number | boolean;
+    }>;
+    validation?: {
+        pattern?: string;
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+    };
+}
+/** A globally-registered credential type — drives the dynamic credential form. */
+export interface CredentialType {
+    slug: string;
+    version: string;
+    name: LocalizedString;
+    description?: LocalizedString;
+    icon?: string;
+    auth_kind: AuthKind;
+    fields: CredentialTypeField[];
+}
+export type CredentialStatus = 'active' | 'needs_reauth';
+/** A tenant's credential instance (secret fields never returned). */
+export interface Credential {
+    id: string;
+    credential_type_slug: string;
+    name: string;
+    status: CredentialStatus;
+    /** non-secret field values only (whitelisted types). */
+    public_config?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export type ConnectionStatus = 'connected' | 'misconfigured' | 'unverified' | 'failing';
+export interface ConnectionTemplate {
+    /** kebab-case slug (e.g. 'shopify'). */
+    vendor: string;
+    name: string;
+    description: string;
+    icon: string;
+    category: 'erp' | 'pim' | 'crm' | 'shop' | 'mail' | 'analytics' | 'other';
+    /** secrets the connection needs; UI nudges the user to set them. */
+    requiredSecrets: Array<{
+        key: string;
+        label: string;
+        sensitive?: boolean;
+    }>;
+}
+export interface Connection {
+    id: string;
+    vendor: string;
+    name: string;
+    status: ConnectionStatus;
+    lastVerifiedAt: string | null;
+    /** keys this connection composes from the secrets store. */
+    secretRefs: string[];
+    config: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WebhookEntry {
+    /** opaque id — combines workflow id and trigger id. */
+    id: string;
+    workflowId: number;
+    workflowName: string;
+    triggerId: string;
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    secretRef?: string;
+    active: boolean;
+    lastFiredAt: string | null;
+    callCount24h: number;
+}
+export interface ScheduleEntry {
+    id: string;
+    workflowId: number;
+    workflowName: string;
+    triggerId: string;
+    cron: string;
+    timezone: string;
+    active: boolean;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+}
+export type TemplateCategory = 'sync' | 'notification' | 'enrichment' | 'fulfilment' | 'reporting' | 'finance';
+export interface WorkflowTemplate {
+    /** kebab-case stable id. */
+    slug: string;
+    name: string;
+    description: string;
+    category: TemplateCategory;
+    industries: Array<'mechanical-engineering' | 'chemicals' | 'wholesale' | 'manufacturing' | 'retail' | 'any'>;
+    /** Vendor slugs this template wires together (used to compute prerequisites). */
+    vendors: string[];
+    /** Required secret keys; UI shows which are missing. */
+    requiredSecrets: string[];
+    /** Difficulty hint for the editor. */
+    level: 'beginner' | 'intermediate' | 'advanced';
+    /** Steps in the template — surfaced as a preview without rendering the canvas. */
+    outline: string[];
+    /** Number of node instances in the canonical blob. */
+    nodeCount: number;
+    /** Number of installs across the platform (used for "popular" ranking). */
+    installs: number;
+    /** Author identity. */
+    publisher: {
+        name: string;
+        kind: 'revenexx' | 'partner' | 'community';
+    };
+    /** Updated date for "last refreshed" labels. */
+    updatedAt: string;
+    /** The blob the editor receives when the user clicks "Use template". */
+    blob: WorkflowBlob;
+    /** Set when the entry came from the live registry (`GET /v1/templates`). */
+    fromApi?: boolean;
+}
+/** A credential type a template's workflow references (GET /templates/{slug}/requirements). */
+export interface TemplateCredentialRequirement {
+    slug: string;
+    registered: boolean;
+    existingInstances: number;
+    usedBy: {
+        nodeId: string;
+        configKey: string;
+    }[];
+    version?: string;
+    name?: string;
+    authKind?: string;
+    fields?: unknown[];
+}
+/**
+ * A secret key a template references, cross-referenced against the tenant.
+ * `key` is null when the template author left it for the installing user to
+ * choose; `exists` is whether the tenant already stores that key.
+ */
+export interface TemplateSecretRequirement {
+    key: string | null;
+    exists: boolean;
+    usedBy?: Array<{
+        nodeId?: string;
+        configKey?: string;
+        source?: string;
+        handle?: string | null;
+    }>;
+}
+/** Install prerequisites for a template, scoped to the current tenant. */
+export interface TemplateRequirements {
+    credentialTypes: TemplateCredentialRequirement[];
+    secrets: TemplateSecretRequirement[];
+}
+export type RunStatus = 'running' | 'succeeded' | 'failed' | 'cancelled' | 'queued';
+export interface WorkflowRunNodeStep {
+    nodeId: string;
+    status: 'succeeded' | 'failed' | 'skipped' | 'pending';
+    startedAt: string;
+    finishedAt: string | null;
+    attempt: number;
+    durationMs: number | null;
+}
+export interface WorkflowRun {
+    id: string;
+    workflowId: number;
+    workflowName: string;
+    status: RunStatus;
+    triggerId: string;
+    triggerType: TriggerType;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    steps: WorkflowRunNodeStep[];
+    errorMessage?: string;
+}
+/** A webhook delivery outcome, shared by events and attempts. */
+export type DeliveryStatus = 'success' | 'failed' | 'pending';
+/**
+ * An event that arrived in Outpost for this tenant (GET /events). Outpost
+ * fans it out to every destination subscribed to its topic.
+ */
+export interface OutpostEvent {
+    id: string;
+    /** Topic the event was published on, e.g. "order.created". */
+    topic: string;
+    /** ISO timestamp the event was received. */
+    time: string;
+    /** Whether delivery may be retried (eligible_for_retry). */
+    eligibleForRetry: boolean;
+    /** Freeform event payload. */
+    data: Record<string, unknown>;
+    /** Header-style metadata forwarded to webhooks. */
+    metadata: Record<string, string>;
+    /**
+     * Rolled-up delivery state. Outpost's event object does not carry one;
+     * set only when the UI derives it (e.g. from deliveries).
+     */
+    status?: DeliveryStatus;
+    /** How many destinations this event matched (matched_destination_ids). */
+    destinationCount: number;
+}
+/** Per-destination delivery of one event (GET /events/{id}, attempts). */
+export interface OutpostEventDelivery {
+    destinationId: string;
+    destinationName: string;
+    status: DeliveryStatus;
+    attempts: number;
+    lastAttemptAt: string | null;
+    responseStatus: number | null;
+}
+/** Outpost destination type (GET /destination-types). v1: webhooks. */
+export type OutboundDestinationType = 'webhook';
+/**
+ * A webhook destination the tenant registered (GET/POST
+ * /tenants/{id}/destinations). "Event X on a subscribed topic → this webhook."
+ */
+export interface OutboundDestination {
+    id: string;
+    type: OutboundDestinationType;
+    /** Human label. */
+    name: string;
+    /** Topics this destination subscribes to; "*" means all. */
+    topics: string[];
+    /** Provider config — for webhooks, the target URL (+ optional secret ref). */
+    config: {
+        url: string;
+        secretRef?: string | null;
+    };
+    /** disabled_at === null means enabled. */
+    disabledAt: string | null;
+    createdAt: string;
+    /**
+     * Rolling delivery health — not on the Outpost destination object; present
+     * only when derived from metrics/attempts. UI shows "—" when absent.
+     */
+    successRate24h?: number;
+    lastDeliveryAt?: string | null;
+}
+/**
+ * A single delivery attempt to a destination
+ * (GET /tenants/{id}/destinations/{id}/attempts). This is the
+ * "Event X → Webhook Y" log row.
+ */
+export interface OutboundDeliveryAttempt {
+    id: string;
+    destinationId: string;
+    eventId: string;
+    /** Topic of the delivered event; present when Outpost inlines the event. */
+    topic?: string;
+    status: DeliveryStatus;
+    /** HTTP status (Outpost `code`) returned by the destination, if it responded. */
+    responseStatus: number | null;
+    /** Outpost `attempt_number`. */
+    attempt: number;
+    time: string;
+    /** Not provided by Outpost's attempt object today. */
+    durationMs?: number | null;
+}
+/** A topic available to subscribe to (GET /topics). */
+export interface OutboundTopic {
+    name: string;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Resolve a multilingual value from the Integrations API. The API returns
+ * names and descriptions either as a plain string or as an already-parsed
+ * object `{de:"…", en:"…"}` (the HTTP client does JSON decoding automatically).
+ * JSON-encoded strings like `'{"de":"…","en":"…"}'` are also handled.
+ *
+ * Priority: 1) current browser locale language, 2) "en", 3) first key found.
+ */
+export declare function resolveLocalized(value: unknown): string;

package/dist/runtime/utils/localize.js

@@ -0,0 +1,21 @@
+export function resolveLocalized(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const map = value;
+    const keys = Object.keys(map);
+    if (!keys.length) return "";
+    const lang = typeof navigator !== "undefined" ? navigator.language?.split("-")[0]?.toLowerCase() ?? "en" : "en";
+    const picked = map[lang] ?? map["en"] ?? map[keys[0]];
+    return typeof picked === "string" ? picked : "";
+  }
+  if (typeof value !== "string") return String(value);
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{")) return trimmed;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return trimmed;
+    return resolveLocalized(parsed);
+  } catch {
+    return trimmed;
+  }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * One source of truth for status → colour across the cockpit.
+ *
+ * Studios used to each carry their own `statusClass` map with slightly
+ * different palettes. Map a domain status string to a semantic tone, and
+ * a tone to the Badge/pill classes, so "succeeded", "active", "paid" and
+ * "published" all read as the same green everywhere.
+ */
+export type StatusTone = 'success' | 'running' | 'warning' | 'error' | 'info' | 'neutral';
+/** Resolve a status string to its semantic tone (neutral when unknown). */
+export declare function statusTone(status: string | null | undefined): StatusTone;
+/** Badge/pill classes for a status string (use with `variant="outline"`). */
+export declare function statusClass(status: string | null | undefined): string;
+/** Tone classes directly (when you already have a tone). */
+export declare function toneClass(tone: StatusTone): string;

package/dist/runtime/utils/statusStyle.js

@@ -0,0 +1,78 @@
+const TONE_CLASS = {
+  success: "bg-emerald-500/15 text-emerald-700 border-emerald-500/20",
+  running: "bg-sky-500/15 text-sky-700 border-sky-500/20",
+  warning: "bg-amber-500/15 text-amber-700 border-amber-500/20",
+  error: "bg-rose-500/15 text-rose-700 border-rose-500/20",
+  info: "bg-violet-500/15 text-violet-700 border-violet-500/20",
+  neutral: "bg-slate-500/15 text-slate-700 border-slate-500/20"
+};
+const STATUS_TONE = {
+  // success
+  succeeded: "success",
+  success: "success",
+  active: "success",
+  enabled: "success",
+  published: "success",
+  completed: "success",
+  complete: "success",
+  paid: "success",
+  connected: "success",
+  delivered: "success",
+  healthy: "success",
+  live: "success",
+  ok: "success",
+  done: "success",
+  approved: "success",
+  sent: "success",
+  // running / in progress
+  running: "running",
+  processing: "running",
+  provisioning: "running",
+  pending: "running",
+  syncing: "running",
+  sending: "running",
+  in_progress: "running",
+  started: "running",
+  // warning / awaiting
+  queued: "warning",
+  draft: "warning",
+  paused: "warning",
+  warning: "warning",
+  past_due: "warning",
+  retrying: "warning",
+  scheduled: "warning",
+  waiting: "warning",
+  partial: "warning",
+  // error
+  failed: "error",
+  failure: "error",
+  error: "error",
+  rejected: "error",
+  bounced: "error",
+  disconnected: "error",
+  expired: "error",
+  overdue: "error",
+  dead: "error",
+  unpaid: "error",
+  // neutral
+  cancelled: "neutral",
+  canceled: "neutral",
+  inactive: "neutral",
+  disabled: "neutral",
+  unknown: "neutral",
+  archived: "neutral",
+  uninstalled: "neutral",
+  none: "neutral",
+  skipped: "neutral"
+};
+export function statusTone(status) {
+  if (!status) return "neutral";
+  const key = String(status).toLowerCase().replace(/[\s-]+/g, "_");
+  return STATUS_TONE[key] ?? "neutral";
+}
+export function statusClass(status) {
+  return TONE_CLASS[statusTone(status)];
+}
+export function toneClass(tone) {
+  return TONE_CLASS[tone];
+}

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'
+
+export * from '../dist/runtime/types/integrations.js'

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@revenexx/studio-integrations",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
+  "main": "./dist/module.mjs",
+  "types": "./dist/types.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@dagrejs/dagre": "^3.0.0",
+    "@revenexx/studio": "*",
+    "@vue-flow/background": "^1.3.2",
+    "@vue-flow/controls": "^1.1.3",
+    "@vue-flow/core": "^1.48.2",
+    "@vue-flow/minimap": "^1.5.4",
+    "lucide-vue-next": "^1.0.0",
+    "nuxt": "^4.0.0",
+    "vue": "^3.5.0",
+    "@revenexx/studio-shared": "0.1.0"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/kit": "^4.0.0",
+    "nuxt": "^4.2.2",
+    "vue": "^3.5.26",
+    "vue-tsc": "^2.2.0"
+  },
+  "scripts": {
+    "build": "nuxt-module-build build"
+  }
+}