nvent 0.4.0

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

@@ -0,0 +1,122 @@
+import { ref, computed, onUnmounted } from "#imports";
+export function useQueueUpdates(queueName) {
+  const ws = ref(null);
+  const isConnected = ref(false);
+  const isReconnecting = ref(false);
+  const state = ref({
+    counts: null,
+    lastEvent: null,
+    countsUpdatedAt: null,
+    shouldRefreshJobs: false
+  });
+  let reconnectTimeout = null;
+  let reconnectAttempts = 0;
+  const maxReconnectAttempts = 5;
+  const connect = () => {
+    if (!import.meta.client || !queueName.value) return;
+    if (ws.value) {
+      try {
+        ws.value.close();
+      } catch {
+      }
+      ws.value = null;
+    }
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const wsUrl = `${protocol}//${window.location.host}/api/_queues/ws`;
+    try {
+      const socket = new WebSocket(wsUrl);
+      ws.value = socket;
+      socket.onopen = () => {
+        console.log("[useQueueUpdates] connected");
+        isConnected.value = true;
+        isReconnecting.value = false;
+        reconnectAttempts = 0;
+        socket.send(JSON.stringify({
+          type: "subscribe",
+          queueName: queueName.value
+        }));
+      };
+      socket.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (message.type === "event") {
+            state.value.lastEvent = message.event;
+            const eventType = message.event?.eventType;
+            if (["waiting", "active", "completed", "failed"].includes(eventType)) {
+              state.value.shouldRefreshJobs = true;
+            }
+          } else if (message.type === "counts") {
+            state.value.counts = message.counts;
+            state.value.countsUpdatedAt = Date.now();
+          } else if (message.type === "error") {
+            console.error("[useQueueUpdates] error:", message.message);
+          }
+        } catch (err) {
+          console.error("[useQueueUpdates] parse error:", err);
+        }
+      };
+      socket.onerror = (error) => {
+        console.error("[useQueueUpdates] error:", error);
+      };
+      socket.onclose = () => {
+        console.log("[useQueueUpdates] disconnected");
+        isConnected.value = false;
+        if (reconnectAttempts < maxReconnectAttempts && queueName.value) {
+          isReconnecting.value = true;
+          reconnectAttempts++;
+          const delay = Math.min(1e3 * Math.pow(2, reconnectAttempts), 1e4);
+          reconnectTimeout = setTimeout(() => {
+            console.log(`[useQueueUpdates] reconnecting (attempt ${reconnectAttempts})...`);
+            connect();
+          }, delay);
+        } else {
+          isReconnecting.value = false;
+        }
+      };
+    } catch (err) {
+      console.error("[useQueueUpdates] connection error:", err);
+      isConnected.value = false;
+    }
+  };
+  const disconnect = () => {
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+    if (ws.value) {
+      try {
+        if (ws.value.readyState === WebSocket.OPEN) {
+          ws.value.send(JSON.stringify({
+            type: "unsubscribe",
+            queueName: queueName.value
+          }));
+        }
+        ws.value.close();
+      } catch {
+      }
+      ws.value = null;
+    }
+    isConnected.value = false;
+    isReconnecting.value = false;
+  };
+  if (import.meta.client && queueName.value) {
+    connect();
+  }
+  onUnmounted(() => {
+    disconnect();
+  });
+  const resetRefreshFlag = () => {
+    state.value.shouldRefreshJobs = false;
+  };
+  return {
+    isConnected: computed(() => isConnected.value),
+    isReconnecting: computed(() => isReconnecting.value),
+    counts: computed(() => state.value.counts),
+    lastEvent: computed(() => state.value.lastEvent),
+    countsUpdatedAt: computed(() => state.value.countsUpdatedAt),
+    shouldRefreshJobs: computed(() => state.value.shouldRefreshJobs),
+    resetRefreshFlag,
+    connect,
+    disconnect
+  };
+}

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

@@ -0,0 +1,43 @@
+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: any;
+    refresh: () => Promise<void>;
+    status: any;
+    error: any;
+};

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

@@ -0,0 +1,26 @@
+import { ref } 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,19 @@
+import { type Ref } from '#imports';
+import type { QueueInfo, QueueCounts } from './useQueues.js';
+/**
+ * Composable for live queue updates across all queues
+ * Subscribes to WebSocket updates for multiple 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: import("vue").ComputedRef<boolean>;
+    isReconnecting: import("vue").ComputedRef<boolean>;
+    liveCounts: import("vue").ComputedRef<Record<string, QueueCounts>>;
+    connect: () => void;
+    disconnect: () => void;
+};

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

@@ -0,0 +1,143 @@
+import { ref, computed, watch, onUnmounted } from "#imports";
+export function useQueuesLive(queues) {
+  const ws = ref(null);
+  const isConnected = ref(false);
+  const isReconnecting = ref(false);
+  const liveCounts = ref({});
+  let reconnectTimeout = null;
+  let reconnectAttempts = 0;
+  const maxReconnectAttempts = 5;
+  const safeSend = (data) => {
+    if (!ws.value || ws.value.readyState !== WebSocket.OPEN) return false;
+    try {
+      ws.value.send(JSON.stringify(data));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const subscribeToQueues = (queueNames) => {
+    if (!ws.value || ws.value.readyState !== WebSocket.OPEN) return;
+    for (const queueName of queueNames) {
+      safeSend({
+        type: "subscribe",
+        queueName
+      });
+    }
+  };
+  const connect = () => {
+    if (!import.meta.client) return;
+    if (ws.value) {
+      try {
+        ws.value.close();
+      } catch {
+      }
+      ws.value = null;
+    }
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const wsUrl = `${protocol}//${window.location.host}/api/_queues/ws`;
+    try {
+      const socket = new WebSocket(wsUrl);
+      ws.value = socket;
+      socket.onopen = () => {
+        console.log("[useQueuesLive] connected");
+        isConnected.value = true;
+        isReconnecting.value = false;
+        reconnectAttempts = 0;
+        if (queues.value) {
+          const queueNames = queues.value.map((q) => q.name);
+          subscribeToQueues(queueNames);
+        }
+      };
+      socket.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (message.type === "counts" && message.queueName) {
+            liveCounts.value[message.queueName] = message.counts;
+          } else if (message.type === "error") {
+            console.error("[useQueuesLive] error:", message.message);
+          }
+        } catch (err) {
+          console.error("[useQueuesLive] parse error:", err);
+        }
+      };
+      socket.onerror = (error) => {
+        console.error("[useQueuesLive] error:", error);
+      };
+      socket.onclose = () => {
+        console.log("[useQueuesLive] disconnected");
+        isConnected.value = false;
+        if (reconnectAttempts < maxReconnectAttempts) {
+          isReconnecting.value = true;
+          reconnectAttempts++;
+          const delay = Math.min(1e3 * Math.pow(2, reconnectAttempts), 1e4);
+          reconnectTimeout = setTimeout(() => {
+            console.log(`[useQueuesLive] reconnecting (attempt ${reconnectAttempts})...`);
+            connect();
+          }, delay);
+        } else {
+          isReconnecting.value = false;
+        }
+      };
+    } catch (err) {
+      console.error("[useQueuesLive] connection error:", err);
+      isConnected.value = false;
+    }
+  };
+  const disconnect = () => {
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+    if (ws.value) {
+      try {
+        if (queues.value) {
+          for (const queue of queues.value) {
+            safeSend({
+              type: "unsubscribe",
+              queueName: queue.name
+            });
+          }
+        }
+        ws.value.close();
+      } catch {
+      }
+      ws.value = null;
+    }
+    isConnected.value = false;
+    isReconnecting.value = false;
+  };
+  if (import.meta.client) {
+    connect();
+  }
+  watch(
+    () => queues.value,
+    (newQueues, oldQueues) => {
+      if (!newQueues || !ws.value || ws.value.readyState !== WebSocket.OPEN) 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));
+      if (toSubscribe.length > 0) {
+        subscribeToQueues(toSubscribe);
+      }
+    }
+  );
+  onUnmounted(() => {
+    disconnect();
+  });
+  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: computed(() => isConnected.value),
+    isReconnecting: computed(() => isReconnecting.value),
+    liveCounts: computed(() => liveCounts.value),
+    connect,
+    disconnect
+  };
+}

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;