@nvent-addon/app 0.4.5

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

@@ -0,0 +1,20 @@
+import { ref, useFetch } from "#imports";
+export function useQueueJobs(queueName, state = ref(null)) {
+  return useFetch(
+    () => {
+      const params = new URLSearchParams();
+      if (state.value) {
+        params.append("state", state.value);
+      }
+      const queryString = params.toString();
+      return `/api/_queues/${encodeURIComponent(queueName.value)}/job${queryString ? `?${queryString}` : ""}`;
+    },
+    {
+      key: () => `queue-jobs-${queueName.value}-${state.value || "all"}`,
+      watch: [queueName, state],
+      immediate: true,
+      server: false
+      // Client-only
+    }
+  );
+}

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

@@ -0,0 +1,24 @@
+import { type Ref } from '#imports';
+/**
+ * Composable for real-time queue updates
+ */
+export declare function useQueueUpdates(queueName: Ref<string>): {
+    isConnected: Ref<boolean, boolean>;
+    isReconnecting: Ref<boolean, boolean>;
+    counts: import("vue").ComputedRef<{
+        active: number;
+        completed: number;
+        failed: number;
+        delayed: number;
+        waiting: number;
+        paused: number;
+    } | null>;
+    lastEvent: import("vue").ComputedRef<{
+        [x: string]: any;
+        eventType: "waiting" | "active" | "completed" | "failed" | "progress";
+        jobId?: string | undefined;
+    } | null>;
+    countsUpdatedAt: import("vue").ComputedRef<number | null>;
+    shouldRefreshJobs: import("vue").ComputedRef<boolean>;
+    resetRefreshFlag: () => void;
+};

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

@@ -0,0 +1,54 @@
+import { ref, computed, watch, onUnmounted } from "#imports";
+import { useQueuesWebSocket } from "./useQueuesWebSocket.js";
+export function useQueueUpdates(queueName) {
+  const queueWs = useQueuesWebSocket();
+  const state = ref({
+    counts: null,
+    lastEvent: null,
+    countsUpdatedAt: null,
+    shouldRefreshJobs: false
+  });
+  let subscriptionId = null;
+  const subscribe = (name) => {
+    if (!import.meta.client || !name) return;
+    subscriptionId = queueWs.subscribe(
+      name,
+      (counts) => {
+        state.value.counts = counts;
+        state.value.countsUpdatedAt = Date.now();
+      },
+      (event) => {
+        state.value.lastEvent = event;
+        if (["waiting", "active", "completed", "failed"].includes(event?.eventType)) {
+          state.value.shouldRefreshJobs = true;
+        }
+      }
+    );
+  };
+  if (import.meta.client && queueName.value) {
+    subscribe(queueName.value);
+  }
+  watch(queueName, (newName, oldName) => {
+    if (oldName && subscriptionId) {
+      queueWs.unsubscribe(oldName, subscriptionId);
+    }
+    if (newName) subscribe(newName);
+  });
+  onUnmounted(() => {
+    if (queueName.value && subscriptionId) {
+      queueWs.unsubscribe(queueName.value, subscriptionId);
+    }
+  });
+  const resetRefreshFlag = () => {
+    state.value.shouldRefreshJobs = false;
+  };
+  return {
+    isConnected: queueWs.connected,
+    isReconnecting: queueWs.reconnecting,
+    counts: computed(() => state.value.counts),
+    lastEvent: computed(() => state.value.lastEvent),
+    countsUpdatedAt: computed(() => state.value.countsUpdatedAt),
+    shouldRefreshJobs: computed(() => state.value.shouldRefreshJobs),
+    resetRefreshFlag
+  };
+}

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

@@ -0,0 +1,45 @@
+import { type Ref } from '#imports';
+import type { FetchError } from 'ofetch';
+export interface QueueCounts {
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    waiting: number;
+    paused: number;
+}
+export interface QueueConfig {
+    queue: {
+        prefix?: string;
+        defaultJobOptions?: Record<string, any>;
+        limiter?: {
+            max?: number;
+            duration?: number;
+            groupKey?: string;
+        };
+    };
+    worker: {
+        concurrency?: number;
+        lockDurationMs?: number;
+        maxStalledCount?: number;
+        drainDelayMs?: number;
+        autorun?: boolean;
+        pollingIntervalMs?: number;
+    };
+}
+export interface QueueInfo {
+    name: string;
+    counts: QueueCounts;
+    isPaused: boolean;
+    config?: QueueConfig;
+}
+/**
+ * Composable for fetching queue list with job counts
+ * Client-only to avoid hydration mismatches
+ */
+export declare function useQueues(): {
+    queues: Ref<QueueInfo[] | null | undefined>;
+    refresh: () => Promise<void>;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
+};

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

@@ -0,0 +1,26 @@
+import { ref, useFetch } from "#imports";
+export function useQueues() {
+  const refreshCounter = ref(0);
+  const { data: queues, refresh: _refresh, status, error } = useFetch(
+    () => `/api/_queues?_t=${refreshCounter.value}`,
+    {
+      immediate: false,
+      watch: false,
+      server: false
+      // Client-only
+    }
+  );
+  const refresh = async () => {
+    refreshCounter.value++;
+    await _refresh();
+  };
+  if (import.meta.client) {
+    refresh();
+  }
+  return {
+    queues,
+    refresh,
+    status,
+    error
+  };
+}

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

@@ -0,0 +1,16 @@
+import { type Ref } from '#imports';
+import type { QueueInfo, QueueCounts } from './useQueues.js';
+/**
+ * Composable for live queue updates across all queues
+ */
+export declare function useQueuesLive(queues: Ref<QueueInfo[] | null | undefined>): {
+    queues: import("vue").ComputedRef<{
+        counts: QueueCounts;
+        name: string;
+        isPaused: boolean;
+        config?: import("#imports").QueueConfig;
+    }[] | null>;
+    isConnected: Ref<boolean, boolean>;
+    isReconnecting: Ref<boolean, boolean>;
+    liveCounts: Ref<Record<string, QueueCounts>, Record<string, QueueCounts>>;
+};

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

@@ -0,0 +1,62 @@
+import { ref, computed, watch, onUnmounted } from "#imports";
+import { useQueuesWebSocket } from "./useQueuesWebSocket.js";
+export function useQueuesLive(queues) {
+  const queueWs = useQueuesWebSocket();
+  const liveCounts = ref({});
+  const subscriptionIds = /* @__PURE__ */ new Map();
+  const subscribeToQueues = (queueNames) => {
+    for (const queueName of queueNames) {
+      if (!subscriptionIds.has(queueName)) {
+        const id = queueWs.subscribe(
+          queueName,
+          (counts) => {
+            liveCounts.value[queueName] = counts;
+          }
+        );
+        subscriptionIds.set(queueName, id);
+      }
+    }
+  };
+  const unsubscribeFromQueues = (queueNames) => {
+    for (const queueName of queueNames) {
+      const id = subscriptionIds.get(queueName);
+      if (id) {
+        queueWs.unsubscribe(queueName, id);
+        subscriptionIds.delete(queueName);
+      }
+    }
+  };
+  if (import.meta.client && queues.value) {
+    subscribeToQueues(queues.value.map((q) => q.name));
+  }
+  watch(
+    () => queues.value,
+    (newQueues, oldQueues) => {
+      if (!newQueues) return;
+      const oldNames = new Set(oldQueues?.map((q) => q.name) || []);
+      const newNames = newQueues.map((q) => q.name);
+      const toSubscribe = newNames.filter((name) => !oldNames.has(name));
+      const toUnsubscribe = Array.from(oldNames).filter((name) => !newNames.includes(name));
+      if (toUnsubscribe.length > 0) unsubscribeFromQueues(toUnsubscribe);
+      if (toSubscribe.length > 0) subscribeToQueues(toSubscribe);
+    }
+  );
+  onUnmounted(() => {
+    if (queues.value) {
+      unsubscribeFromQueues(queues.value.map((q) => q.name));
+    }
+  });
+  const queuesWithLiveCounts = computed(() => {
+    if (!queues.value) return null;
+    return queues.value.map((queue) => ({
+      ...queue,
+      counts: liveCounts.value[queue.name] || queue.counts
+    }));
+  });
+  return {
+    queues: queuesWithLiveCounts,
+    isConnected: queueWs.connected,
+    isReconnecting: queueWs.reconnecting,
+    liveCounts
+  };
+}

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

@@ -0,0 +1,17 @@
+import type { QueueCounts } from './useQueues.js';
+export interface QueueEvent {
+    eventType: 'waiting' | 'active' | 'completed' | 'failed' | 'progress';
+    jobId?: string;
+    [key: string]: any;
+}
+/**
+ * Shared WebSocket for queue updates
+ * All instances share the same connection
+ */
+export declare function useQueuesWebSocket(): {
+    subscribe: (queueName: string, onCounts?: (counts: QueueCounts) => void, onEvent?: (event: QueueEvent) => void) => string;
+    unsubscribe: (queueName: string, id?: string) => void;
+    stop: () => void;
+    connected: import("vue").Ref<boolean, boolean>;
+    reconnecting: import("vue").Ref<boolean, boolean>;
+};

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

@@ -0,0 +1,159 @@
+import { ref } from "#imports";
+let ws = null;
+const connected = ref(false);
+const reconnecting = ref(false);
+let retry = 0;
+let reconnectTimer = null;
+const subscriptions = /* @__PURE__ */ new Map();
+const clearTimers = () => {
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+};
+const send = (data) => {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(data));
+  }
+};
+const stop = () => {
+  clearTimers();
+  if (ws) {
+    try {
+      ws.close(1e3, "Client closing");
+    } catch (err) {
+      console.warn("[useQueuesWebSocket] Error closing:", err);
+    }
+    ws = null;
+  }
+  connected.value = false;
+  reconnecting.value = false;
+  retry = 0;
+  subscriptions.clear();
+};
+const attemptReconnect = () => {
+  if (retry >= 10) {
+    console.error("[useQueuesWebSocket] Max retries reached");
+    stop();
+    return;
+  }
+  retry++;
+  reconnecting.value = true;
+  const delay = Math.min(1e3 * Math.pow(2, retry), 1e4);
+  clearTimers();
+  reconnectTimer = setTimeout(() => {
+    connect();
+  }, delay);
+};
+const connect = () => {
+  if (import.meta.server || typeof WebSocket === "undefined") return;
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    for (const queueName of subscriptions.keys()) {
+      send({ type: "subscribe", queueName });
+    }
+    return;
+  }
+  if (ws && ws.readyState === WebSocket.CONNECTING) {
+    console.log("[useQueuesWebSocket] Connection in progress, waiting...");
+    return;
+  }
+  if (ws) {
+    try {
+      ws.close();
+    } catch {
+    }
+    ws = null;
+  }
+  try {
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const wsUrl = `${protocol}//${window.location.host}/api/_queues/ws`;
+    const socket = new WebSocket(wsUrl);
+    ws = socket;
+    socket.onopen = () => {
+      console.log("[useQueuesWebSocket] Connected");
+      connected.value = true;
+      reconnecting.value = false;
+      retry = 0;
+      for (const queueName of subscriptions.keys()) {
+        send({ type: "subscribe", queueName });
+      }
+    };
+    socket.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "counts" && data.queueName) {
+          const subs = subscriptions.get(data.queueName);
+          if (subs) {
+            for (const sub of subs) {
+              sub.onCounts?.(data.counts);
+            }
+          }
+        } else if (data.type === "event" && data.queueName) {
+          const subs = subscriptions.get(data.queueName);
+          if (subs) {
+            for (const sub of subs) {
+              sub.onEvent?.(data.event);
+            }
+          }
+        }
+      } catch (err) {
+        console.error("[useQueuesWebSocket] Parse error:", err);
+      }
+    };
+    socket.onerror = (err) => {
+      console.error("[useQueuesWebSocket] Error:", err);
+    };
+    socket.onclose = (event) => {
+      console.log("[useQueuesWebSocket] Closed:", event.code);
+      connected.value = false;
+      ws = null;
+      if (event.code !== 1e3 && subscriptions.size > 0) {
+        attemptReconnect();
+      }
+    };
+  } catch (err) {
+    console.error("[useQueuesWebSocket] Connection error:", err);
+    attemptReconnect();
+  }
+};
+const subscribe = (queueName, onCounts, onEvent) => {
+  const id = `${queueName}_${Date.now()}_${Math.random()}`;
+  const existing = subscriptions.get(queueName) || [];
+  existing.push({ id, onCounts, onEvent });
+  subscriptions.set(queueName, existing);
+  const shouldSubscribe = existing.length === 1;
+  if (shouldSubscribe) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      send({ type: "subscribe", queueName });
+    } else if (ws && ws.readyState === WebSocket.CONNECTING) {
+    } else {
+      connect();
+    }
+  }
+  return id;
+};
+const unsubscribe = (queueName, id) => {
+  const existing = subscriptions.get(queueName);
+  if (!existing) return;
+  if (id) {
+    const filtered = existing.filter((sub) => sub.id !== id);
+    if (filtered.length > 0) {
+      subscriptions.set(queueName, filtered);
+    } else {
+      subscriptions.delete(queueName);
+      send({ type: "unsubscribe", queueName });
+    }
+  } else {
+    subscriptions.delete(queueName);
+    send({ type: "unsubscribe", queueName });
+  }
+};
+export function useQueuesWebSocket() {
+  return {
+    subscribe,
+    unsubscribe,
+    stop,
+    connected,
+    reconnecting
+  };
+}

package/dist/runtime/app/pages/flows/index.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;