@nvent-addon/app 0.4.5 → 0.5.1

package/dist/runtime/app/composables/useTrigger.d.ts

@@ -0,0 +1,137 @@
+import { type Ref } from '#imports';
+import type { FetchError } from 'ofetch';
+export interface TriggerStats {
+    totalFires: number;
+    totalFlowsStarted: number;
+    activeSubscribers: number;
+    lastFiredAt?: string;
+}
+export interface TriggerInfo {
+    name: string;
+    type: 'event' | 'webhook' | 'schedule' | 'manual';
+    scope: 'flow' | 'run';
+    displayName?: string;
+    description?: string;
+    source?: string;
+    status: 'active' | 'inactive' | 'retired';
+    registeredAt?: number;
+    lastActivityAt?: number;
+    webhook?: {
+        path: string;
+        method?: string;
+        auth?: any;
+    };
+    schedule?: {
+        cron: string;
+        timezone?: string;
+        enabled?: boolean;
+    };
+    config?: any;
+    subscribedFlows: string[];
+    subscriptionCount: number;
+    stats: TriggerStats;
+}
+export interface TriggerDetail {
+    name: string;
+    type: 'event' | 'webhook' | 'schedule' | 'manual';
+    scope: 'flow' | 'run';
+    displayName?: string;
+    description?: string;
+    source?: string;
+    status: 'active' | 'inactive' | 'retired';
+    registeredAt?: number;
+    registeredBy?: string;
+    lastActivityAt?: number;
+    webhook?: {
+        path: string;
+        method?: string;
+        auth?: any;
+    };
+    schedule?: {
+        cron: string;
+        timezone?: string;
+        enabled?: boolean;
+    };
+    config?: any;
+    version?: number;
+    subscribedFlows: string[];
+    subscriptions: Array<{
+        triggerName: string;
+        flowName: string;
+        mode: 'auto' | 'manual';
+        source: string;
+        registeredAt?: number;
+    }>;
+    subscriptionCount: number;
+    stats: TriggerStats;
+}
+export interface TriggerStatsOverview {
+    total: number;
+    active: number;
+    inactive: number;
+    retired: number;
+    byType: Record<string, number>;
+    byScope: Record<string, number>;
+    byStatus: Record<string, number>;
+    totalSubscriptions: number;
+    totalFires: number;
+    withSubscribers: number;
+}
+export interface TriggerEvent {
+    type: string;
+    timestamp: number;
+    data: any;
+    triggerName?: string;
+    [key: string]: any;
+}
+export interface TriggerEventsResponse {
+    triggerName: string;
+    events: TriggerEvent[];
+    count: number;
+    total: number;
+    hasMore: boolean;
+}
+/**
+ * Composable for fetching trigger detail
+ */
+export declare function useTrigger(name: Ref<string | null>): {
+    trigger: Ref<TriggerDetail | null | undefined>;
+    refresh: () => Promise<void>;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
+};
+/**
+ * Composable for fetching trigger events
+ */
+export declare function useTriggerEvents(name: Ref<string | null>, options?: Ref<{
+    limit?: number;
+    offset?: number;
+    types?: string[];
+}> | {
+    limit?: number;
+    offset?: number;
+    types?: string[];
+}): {
+    events: Ref<TriggerEventsResponse | null | undefined>;
+    refresh: () => Promise<void>;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
+};
+/**
+ * Composable for fetching trigger list
+ */
+export declare function useTriggers(): {
+    triggers: Ref<TriggerInfo[] | null | undefined>;
+    refresh: () => Promise<void>;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
+};
+/**
+ * Composable for fetching aggregate trigger statistics
+ */
+export declare function useTriggersStats(): {
+    stats: Ref<TriggerStatsOverview | null | undefined>;
+    refresh: () => Promise<void>;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
+};

package/dist/runtime/app/composables/useTrigger.js

@@ -0,0 +1,116 @@
+import { ref, useFetch, isRef } from "#imports";
+export function useTrigger(name) {
+  const refreshCounter = ref(0);
+  const { data: trigger, refresh: _refresh, status, error } = useFetch(
+    () => {
+      if (!name.value) return "/api/_triggers/__invalid__";
+      return `/api/_triggers/${encodeURIComponent(name.value)}?_t=${refreshCounter.value}`;
+    },
+    {
+      immediate: false,
+      watch: false,
+      server: false
+      // Client-only
+    }
+  );
+  const refresh = async () => {
+    if (!name.value) return;
+    refreshCounter.value++;
+    await _refresh();
+  };
+  if (import.meta.client && name.value) {
+    refresh();
+  }
+  return {
+    trigger,
+    refresh,
+    status,
+    error
+  };
+}
+export function useTriggerEvents(name, options) {
+  const refreshCounter = ref(0);
+  const opts = isRef(options) ? options : ref(options || {});
+  const buildUrl = () => {
+    if (!name.value) return "/api/_triggers/null/events";
+    const params = new URLSearchParams();
+    params.append("_t", refreshCounter.value.toString());
+    if (opts.value.limit) params.append("limit", opts.value.limit.toString());
+    if (opts.value.offset) params.append("offset", opts.value.offset.toString());
+    if (opts.value.types) params.append("types", opts.value.types.join(","));
+    return `/api/_triggers/${encodeURIComponent(name.value)}/events?${params.toString()}`;
+  };
+  const { data: events, refresh: _refresh, status, error } = useFetch(
+    buildUrl,
+    {
+      immediate: false,
+      watch: false,
+      server: false
+      // Client-only
+    }
+  );
+  const refresh = async () => {
+    if (!name.value) return;
+    refreshCounter.value++;
+    await _refresh();
+  };
+  if (import.meta.client && name.value) {
+    refresh();
+  }
+  return {
+    events,
+    refresh,
+    status,
+    error
+  };
+}
+export function useTriggers() {
+  const refreshCounter = ref(0);
+  const { data: triggers, refresh: _refresh, status, error } = useFetch(
+    () => `/api/_triggers?_t=${refreshCounter.value}`,
+    {
+      immediate: false,
+      watch: false,
+      server: false
+      // Client-only
+    }
+  );
+  const refresh = async () => {
+    refreshCounter.value++;
+    await _refresh();
+  };
+  if (import.meta.client) {
+    refresh();
+  }
+  return {
+    triggers,
+    refresh,
+    status,
+    error
+  };
+}
+export function useTriggersStats() {
+  const refreshCounter = ref(0);
+  const { data: stats, refresh: _refresh, status, error } = useFetch(
+    () => `/api/_triggers/stats?_t=${refreshCounter.value}`,
+    {
+      immediate: false,
+      watch: false,
+      server: false
+      // Client-only
+    }
+  );
+  const refresh = async () => {
+    refreshCounter.value++;
+    await _refresh();
+  };
+  if (import.meta.client) {
+    refresh();
+  }
+  return {
+    stats,
+    refresh,
+    status,
+    error
+  };
+}

package/dist/runtime/app/composables/useTriggerWebSocket.d.ts

@@ -0,0 +1,35 @@
+export interface UseTriggerWebSocketOptions {
+    autoReconnect?: boolean;
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    onOpen?: () => void;
+    onError?: (err?: any) => void;
+    onClose?: (event?: CloseEvent) => void;
+}
+export interface TriggerSubscription {
+    triggerName: string;
+    onEvent: (event: any) => void;
+    onHistory?: (events: any[]) => void;
+}
+export interface TriggerStatsSubscription {
+    onInitial?: (data: any) => void;
+    onUpdate?: (data: any) => void;
+}
+/**
+ * WebSocket composable for trigger events and trigger stats
+ * Architecture: Client (this) → WebSocket → Server Handler → StreamAdapter.subscribe(StreamTopics.triggerEvents)
+ * Supports subscribing to specific triggers and global trigger statistics
+ * Uses a singleton connection shared across all instances
+ */
+export declare function useTriggerWebSocket(): {
+    subscribe: (subscription: TriggerSubscription, opts?: UseTriggerWebSocketOptions) => void;
+    unsubscribe: () => void;
+    subscribeStats: (subscription: TriggerStatsSubscription, opts?: UseTriggerWebSocketOptions) => void;
+    unsubscribeStats: () => void;
+    stop: () => void;
+    forceClose: () => void;
+    connected: import("vue").Ref<boolean, boolean>;
+    reconnecting: import("vue").Ref<boolean, boolean>;
+};
+export default useTriggerWebSocket;

package/dist/runtime/app/composables/useTriggerWebSocket.js

@@ -0,0 +1,333 @@
+import { ref, onBeforeUnmount } from "#imports";
+let sharedWs = null;
+let sharedConnected = false;
+let sharedReconnecting = false;
+let retry = 0;
+let reconnectTimer = null;
+let currentOptions;
+let currentSubscription = null;
+let currentStatsSubscription = null;
+let pendingStatsSubscription = false;
+let isStatsSubscribed = false;
+let statsCache = [];
+let pingInterval = null;
+let isServerRestarting = false;
+let refCount = 0;
+export function useTriggerWebSocket() {
+  const ws = ref(sharedWs);
+  const connected = ref(sharedConnected);
+  const reconnecting = ref(sharedReconnecting);
+  refCount++;
+  const computeDelay = (opts) => {
+    const base = Math.max(100, opts?.baseDelayMs ?? 1e3);
+    const max = Math.max(base, opts?.maxDelayMs ?? 1e4);
+    const exp = Math.min(max, base * Math.pow(2, retry));
+    const jitter = Math.floor(Math.random() * Math.min(1e3, exp / 4));
+    return exp + jitter;
+  };
+  const clearTimers = () => {
+    if (reconnectTimer) {
+      try {
+        clearTimeout(reconnectTimer);
+      } catch {
+      }
+      reconnectTimer = null;
+    }
+    if (pingInterval) {
+      try {
+        clearInterval(pingInterval);
+      } catch {
+      }
+      pingInterval = null;
+    }
+  };
+  const updateRefs = () => {
+    ws.value = sharedWs;
+    connected.value = sharedConnected;
+    reconnecting.value = sharedReconnecting;
+  };
+  const send = (data) => {
+    if (sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+      try {
+        sharedWs.send(JSON.stringify(data));
+        return true;
+      } catch (err) {
+        console.error("[useTriggerWebSocket] Error sending message:", err);
+        return false;
+      }
+    }
+    return false;
+  };
+  const startPingInterval = () => {
+    clearTimers();
+    pingInterval = setInterval(() => {
+      if (sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+        send({ type: "ping" });
+      }
+    }, 3e4);
+  };
+  const stop = () => {
+    refCount = Math.max(0, refCount - 1);
+  };
+  const forceClose = () => {
+    clearTimers();
+    isServerRestarting = false;
+    try {
+      if (sharedWs) {
+        sharedWs.close(1e3, "Client closing");
+      }
+    } catch (err) {
+      console.warn("[useTriggerWebSocket] Error closing WebSocket:", err);
+    }
+    sharedWs = null;
+    sharedConnected = false;
+    sharedReconnecting = false;
+    updateRefs();
+    retry = 0;
+    refCount = 0;
+    currentSubscription = null;
+    currentStatsSubscription = null;
+    isStatsSubscribed = false;
+    pendingStatsSubscription = false;
+    statsCache = [];
+  };
+  const attemptReconnect = () => {
+    if (!currentOptions?.autoReconnect) {
+      stop();
+      return;
+    }
+    const max = Math.max(0, currentOptions?.maxRetries ?? 10);
+    if (retry >= max) {
+      console.error("[useTriggerWebSocket] Max retries reached");
+      stop();
+      return;
+    }
+    retry++;
+    sharedReconnecting = true;
+    updateRefs();
+    const baseDelay = isServerRestarting ? 2e3 : computeDelay(currentOptions);
+    const delay = baseDelay;
+    clearTimers();
+    reconnectTimer = setTimeout(() => {
+      if (currentSubscription || currentStatsSubscription) {
+        connect(currentOptions);
+      }
+    }, delay);
+  };
+  const setupWebSocket = (socket, opts) => {
+    socket.onopen = () => {
+      console.log("[useTriggerWebSocket] Connected");
+      sharedConnected = true;
+      sharedReconnecting = false;
+      updateRefs();
+      retry = 0;
+      startPingInterval();
+      if (currentSubscription) {
+        send({
+          type: "subscribe",
+          triggerName: currentSubscription.triggerName
+        });
+      }
+      if (currentStatsSubscription || pendingStatsSubscription) {
+        send({
+          type: "subscribe.stats"
+        });
+        pendingStatsSubscription = false;
+      }
+      opts?.onOpen?.();
+    };
+    socket.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        switch (data.type) {
+          case "connected":
+            break;
+          case "subscribed":
+            break;
+          case "unsubscribed":
+            break;
+          case "stats.subscribed":
+            isStatsSubscribed = true;
+            break;
+          case "stats.unsubscribed":
+            isStatsSubscribed = false;
+            break;
+          case "trigger.stats.initial": {
+            const existingIndex = statsCache.findIndex((s) => s.id === data.data.id);
+            if (existingIndex >= 0) {
+              statsCache[existingIndex] = data.data;
+            } else {
+              statsCache.push(data.data);
+            }
+            if (currentStatsSubscription?.onInitial) {
+              currentStatsSubscription.onInitial(data.data);
+            } else {
+              console.warn("[useTriggerWebSocket] No onInitial handler for stats:", data.data);
+            }
+            break;
+          }
+          case "trigger.stats.update": {
+            const cacheIndex = statsCache.findIndex((s) => s.id === data.data.id);
+            if (cacheIndex >= 0) {
+              statsCache[cacheIndex] = data.data;
+            } else {
+              statsCache.push(data.data);
+            }
+            if (currentStatsSubscription?.onUpdate) {
+              currentStatsSubscription.onUpdate(data.data);
+            } else {
+              console.warn("[useTriggerWebSocket] No onUpdate handler for stats:", data.data);
+            }
+            break;
+          }
+          case "history":
+            if (currentSubscription) {
+              if (currentSubscription.onHistory) {
+                currentSubscription.onHistory(data.events);
+              } else {
+                for (const eventData of data.events) {
+                  currentSubscription.onEvent(eventData);
+                }
+              }
+            }
+            break;
+          case "event":
+            if (currentSubscription) {
+              currentSubscription.onEvent(data.event);
+            }
+            break;
+          case "pong":
+            break;
+          case "server-restart":
+            isServerRestarting = true;
+            break;
+          case "error":
+            console.error("[useTriggerWebSocket] Server error:", data.message);
+            opts?.onError?.(new Error(data.message));
+            break;
+          default:
+            console.warn("[useTriggerWebSocket] Unknown message type:", data.type);
+        }
+      } catch (err) {
+        console.error("[useTriggerWebSocket] Error parsing message:", err);
+      }
+    };
+    socket.onerror = (err) => {
+      console.error("[useTriggerWebSocket] WebSocket error:", err);
+      opts?.onError?.(err);
+    };
+    socket.onclose = (event) => {
+      console.log("[useTriggerWebSocket] Connection closed:", event.code, event.reason);
+      sharedConnected = false;
+      updateRefs();
+      clearTimers();
+      opts?.onClose?.(event);
+      const shouldReconnect = event.code !== 1e3 && opts?.autoReconnect;
+      if (shouldReconnect) {
+        attemptReconnect();
+      } else {
+        isServerRestarting = false;
+      }
+    };
+  };
+  const connect = (opts) => {
+    if (import.meta.server || typeof WebSocket === "undefined") {
+      console.warn("[useTriggerWebSocket] WebSocket not available (SSR context)");
+      return;
+    }
+    if (sharedWs && (sharedWs.readyState === WebSocket.OPEN || sharedWs.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    if (sharedWs) {
+      try {
+        sharedWs.close();
+      } catch {
+      }
+    }
+    currentOptions = opts;
+    try {
+      const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+      const wsUrl = `${protocol}//${window.location.host}/api/_triggers/ws`;
+      const socket = new WebSocket(wsUrl);
+      sharedWs = socket;
+      updateRefs();
+      setupWebSocket(socket, opts);
+    } catch (err) {
+      console.error("[useTriggerWebSocket] Error creating WebSocket:", err);
+      opts?.onError?.(err);
+      attemptReconnect();
+    }
+  };
+  const subscribe = (subscription, opts) => {
+    if (currentSubscription && sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+      send({
+        type: "unsubscribe",
+        triggerName: currentSubscription.triggerName
+      });
+    }
+    currentSubscription = subscription;
+    if (sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+      send({
+        type: "subscribe",
+        triggerName: subscription.triggerName
+      });
+      return;
+    }
+    connect(opts);
+  };
+  const unsubscribe = () => {
+    if (currentSubscription && sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+      send({
+        type: "unsubscribe",
+        triggerName: currentSubscription.triggerName
+      });
+    }
+    currentSubscription = null;
+  };
+  const subscribeStats = (subscription, opts) => {
+    currentStatsSubscription = subscription;
+    if (sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+      if (isStatsSubscribed) {
+        if (subscription.onInitial && statsCache.length > 0) {
+          for (const cachedStat of statsCache) {
+            subscription.onInitial(cachedStat);
+          }
+        }
+        return;
+      }
+      send({
+        type: "subscribe.stats"
+      });
+      return;
+    }
+    if (sharedWs && sharedWs.readyState === WebSocket.CONNECTING) {
+      pendingStatsSubscription = true;
+      return;
+    }
+    pendingStatsSubscription = true;
+    connect(opts);
+  };
+  const unsubscribeStats = () => {
+    if (currentStatsSubscription && sharedWs && sharedWs.readyState === WebSocket.OPEN) {
+      send({
+        type: "unsubscribe.stats"
+      });
+    }
+    currentStatsSubscription = null;
+    isStatsSubscribed = false;
+  };
+  onBeforeUnmount(() => {
+    stop();
+  });
+  return {
+    subscribe,
+    unsubscribe,
+    subscribeStats,
+    unsubscribeStats,
+    stop,
+    forceClose,
+    connected,
+    reconnecting
+  };
+}
+export default useTriggerWebSocket;

package/dist/runtime/app/pages/dashboard.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;