nvent 0.4.0

package/dist/runtime/server/api/_flows/[name]/schedules/[id].delete.js

@@ -0,0 +1,42 @@
+import { defineEventHandler, getRouterParam, createError, useRuntimeConfig, $useQueueRegistry } from "#imports";
+import { Queue } from "bullmq";
+export default defineEventHandler(async (event) => {
+  const flowName = getRouterParam(event, "name");
+  const scheduleId = getRouterParam(event, "id");
+  if (!flowName || !scheduleId) {
+    throw createError({ statusCode: 400, statusMessage: "Flow name and schedule ID are required" });
+  }
+  const registry = $useQueueRegistry();
+  const flow = registry?.flows?.[flowName];
+  if (!flow || !flow.entry) {
+    throw createError({ statusCode: 404, statusMessage: `Flow '${flowName}' not found` });
+  }
+  const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
+  const rc = useRuntimeConfig();
+  const connection = rc.queue?.redis;
+  let prefix;
+  try {
+    if (registry && Array.isArray(registry.workers)) {
+      const worker = registry.workers.find((w) => w?.queue?.name === queueName);
+      if (worker?.queue?.prefix) {
+        prefix = worker.queue.prefix;
+      }
+    }
+  } catch {
+  }
+  const queue = new Queue(queueName, { connection, prefix });
+  try {
+    await queue.removeRepeatableByKey(scheduleId);
+    await queue.close();
+    return {
+      success: true,
+      message: "Schedule deleted successfully"
+    };
+  } catch (error) {
+    await queue.close();
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to delete schedule: ${error.message}`
+    });
+  }
+});

package/dist/runtime/server/api/_flows/[name]/schedules.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_flows/[name]/schedules.get.js

@@ -0,0 +1,48 @@
+import { defineEventHandler, getRouterParam, createError, useRuntimeConfig, $useQueueRegistry } from "#imports";
+import { Queue } from "bullmq";
+export default defineEventHandler(async (event) => {
+  const flowName = getRouterParam(event, "name");
+  if (!flowName) {
+    throw createError({ statusCode: 400, statusMessage: "Flow name is required" });
+  }
+  const registry = $useQueueRegistry();
+  const flow = registry?.flows?.[flowName];
+  if (!flow || !flow.entry) {
+    throw createError({ statusCode: 404, statusMessage: `Flow '${flowName}' not found` });
+  }
+  const rc = useRuntimeConfig();
+  const connection = rc.queue?.redis;
+  const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
+  let prefix;
+  try {
+    if (registry && Array.isArray(registry.workers)) {
+      const worker = registry.workers.find((w) => w?.queue?.name === queueName);
+      if (worker?.queue?.prefix) {
+        prefix = worker.queue.prefix;
+      }
+    }
+  } catch {
+  }
+  const queue = new Queue(queueName, { connection, prefix });
+  try {
+    const repeatableJobs = await queue.getRepeatableJobs();
+    const schedules = repeatableJobs.filter((job) => job.name === flow.entry.step).map((job) => ({
+      id: job.key,
+      flowName,
+      queue: queueName,
+      step: flow.entry.step,
+      schedule: {
+        cron: job.pattern
+      },
+      nextRun: job.next ? new Date(job.next).toISOString() : void 0
+    }));
+    await queue.close();
+    return schedules;
+  } catch (error) {
+    await queue.close();
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to list schedules: ${error.message}`
+    });
+  }
+});

package/dist/runtime/server/api/_flows/[name]/start.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_flows/[name]/start.post.js

@@ -0,0 +1,9 @@
+import { defineEventHandler, getRouterParam, createError, readBody, useFlowEngine } from "#imports";
+export default defineEventHandler(async (event) => {
+  const flowName = getRouterParam(event, "name");
+  if (!flowName) throw createError({ statusCode: 400, statusMessage: "Flow name is required" });
+  const { startFlow } = useFlowEngine();
+  const body = await readBody(event);
+  const result = await startFlow(flowName, body || {});
+  return result;
+});

package/dist/runtime/server/api/_flows/index.get.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns pre-analyzed flows from the build-time registry.
+ * Flows are analyzed during the build process for optimal performance.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_flows/index.get.js

@@ -0,0 +1,5 @@
+import { defineEventHandler, $useAnalyzedFlows } from "#imports";
+export default defineEventHandler(() => {
+  const flows = $useAnalyzedFlows();
+  return flows || [];
+});

package/dist/runtime/server/api/_flows/ws.d.ts

@@ -0,0 +1,60 @@
+/**
+ * WebSocket endpoint for flow run events
+ * Supports subscribing to specific flow runs and receiving real-time updates
+ *
+ * Message format (client -> server):
+ * {
+ *   "type": "subscribe",
+ *   "flowName": "example",
+ *   "runId": "abc123"
+ * }
+ *
+ * {
+ *   "type": "unsubscribe",
+ *   "flowName": "example",
+ *   "runId": "abc123"
+ * }
+ *
+ * {
+ *   "type": "ping"
+ * }
+ *
+ * Message format (server -> client):
+ * {
+ *   "type": "event",
+ *   "flowName": "example",
+ *   "runId": "abc123",
+ *   "event": { v: 1, eventType: "...", record: {...} }
+ * }
+ *
+ * {
+ *   "type": "history",
+ *   "flowName": "example",
+ *   "runId": "abc123",
+ *   "events": [ ...historicalEvents ]
+ * }
+ *
+ * {
+ *   "type": "subscribed",
+ *   "flowName": "example",
+ *   "runId": "abc123"
+ * }
+ *
+ * {
+ *   "type": "unsubscribed",
+ *   "flowName": "example",
+ *   "runId": "abc123"
+ * }
+ *
+ * {
+ *   "type": "pong",
+ *   "timestamp": 1234567890
+ * }
+ *
+ * {
+ *   "type": "error",
+ *   "message": "error description"
+ * }
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_flows/ws.js

@@ -0,0 +1,183 @@
+import {
+  defineWebSocketHandler,
+  useEventStore,
+  registerWsPeer,
+  unregisterWsPeer,
+  useServerLogger
+} from "#imports";
+const logger = useServerLogger("api-flows-ws");
+const peerContexts = /* @__PURE__ */ new WeakMap();
+function safeSend(peer, data) {
+  try {
+    peer.send(JSON.stringify(data));
+    return true;
+  } catch {
+    return false;
+  }
+}
+export default defineWebSocketHandler({
+  open(peer) {
+    logger.info("[ws] client connected:", { peerId: peer.id });
+    registerWsPeer(peer);
+    peerContexts.set(peer, {
+      subscriptions: /* @__PURE__ */ new Map()
+    });
+    safeSend(peer, {
+      type: "connected",
+      timestamp: Date.now()
+    });
+  },
+  async message(peer, message) {
+    const context = peerContexts.get(peer);
+    if (!context) {
+      logger.error("[ws] no context for peer:", { peerId: peer.id });
+      return;
+    }
+    let data;
+    try {
+      data = JSON.parse(message.text());
+    } catch {
+      safeSend(peer, {
+        type: "error",
+        message: "Invalid JSON"
+      });
+      return;
+    }
+    const { type, flowName, runId } = data;
+    if (type === "subscribe") {
+      if (!flowName || !runId) {
+        safeSend(peer, {
+          type: "error",
+          message: "Missing flowName or runId"
+        });
+        return;
+      }
+      const store = useEventStore();
+      const names = store.names();
+      const flowStream = names.flow(runId);
+      const subscriptionKey = `${flowName}:${runId}`;
+      const existingUnsub = context.subscriptions.get(subscriptionKey);
+      if (existingUnsub) {
+        try {
+          existingUnsub();
+        } catch (err) {
+          logger.error("[ws] error unsubscribing:", { error: err });
+        }
+      }
+      const unsub = store.subscribe(flowStream, async (event) => {
+        safeSend(peer, {
+          type: "event",
+          flowName,
+          runId,
+          event: {
+            v: 1,
+            eventType: event.type,
+            record: event
+          }
+        });
+      });
+      context.subscriptions.set(subscriptionKey, unsub);
+      try {
+        const historicalEvents = await store.read(flowStream, {
+          limit: 100,
+          direction: "forward"
+        });
+        safeSend(peer, {
+          type: "history",
+          flowName,
+          runId,
+          events: historicalEvents.map((e) => ({
+            v: 1,
+            eventType: e.kind || e.type,
+            record: e
+          }))
+        });
+      } catch (err) {
+        logger.error("[ws] error sending history:", { error: err });
+        safeSend(peer, {
+          type: "error",
+          message: "Failed to load history"
+        });
+      }
+      safeSend(peer, {
+        type: "subscribed",
+        flowName,
+        runId
+      });
+    } else if (type === "unsubscribe") {
+      if (!flowName || !runId) {
+        safeSend(peer, {
+          type: "error",
+          message: "Missing flowName or runId"
+        });
+        return;
+      }
+      const subscriptionKey = `${flowName}:${runId}`;
+      const unsub = context.subscriptions.get(subscriptionKey);
+      if (unsub) {
+        try {
+          unsub();
+          context.subscriptions.delete(subscriptionKey);
+          safeSend(peer, {
+            type: "unsubscribed",
+            flowName,
+            runId
+          });
+        } catch (err) {
+          logger.error("[ws] error unsubscribing:", { error: err });
+          safeSend(peer, {
+            type: "error",
+            message: "Failed to unsubscribe"
+          });
+        }
+      }
+    } else if (type === "ping") {
+      safeSend(peer, {
+        type: "pong",
+        timestamp: Date.now()
+      });
+    } else {
+      safeSend(peer, {
+        type: "error",
+        message: `Unknown message type: ${type}`
+      });
+    }
+  },
+  close(peer, event) {
+    const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
+    if (!isNormalClosure) {
+      logger.info("[ws] client disconnected:", { peerId: peer.id, code: event?.code, reason: event?.reason });
+    }
+    unregisterWsPeer(peer);
+    const context = peerContexts.get(peer);
+    if (context) {
+      for (const unsub of context.subscriptions.values()) {
+        try {
+          unsub();
+        } catch (err) {
+          if (!isNormalClosure) {
+            logger.error("[ws] error unsubscribing on close:", { error: err });
+          }
+        }
+      }
+      context.subscriptions.clear();
+      peerContexts.delete(peer);
+    }
+  },
+  error(peer, error) {
+    logger.error("[ws] error for peer:", { peerId: peer.id, error });
+    unregisterWsPeer(peer);
+    const context = peerContexts.get(peer);
+    if (context) {
+      for (const unsub of context.subscriptions.values()) {
+        try {
+          unsub();
+        } catch (err) {
+          logger.error("[ws] error unsubscribing on error:", { error: err });
+        }
+      }
+      context.subscriptions.clear();
+      peerContexts.delete(peer);
+    }
+  }
+});

package/dist/runtime/server/api/_queues/[name]/job/[id].get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_queues/[name]/job/[id].get.js

@@ -0,0 +1,9 @@
+import { defineEventHandler, getRouterParam, useQueue } from "#imports";
+export default defineEventHandler(async (event) => {
+  const name = getRouterParam(event, "name") || "";
+  const id = getRouterParam(event, "id") || "";
+  const { getJob } = useQueue();
+  const job = await getJob(name, id);
+  if (!job) return null;
+  return { ...job, queue: name };
+});

package/dist/runtime/server/api/_queues/[name]/job/index.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_queues/[name]/job/index.get.js

@@ -0,0 +1,18 @@
+import { defineEventHandler, getRouterParam, getQuery, useQueue, createError } from "#imports";
+export default defineEventHandler(async (event) => {
+  const name = getRouterParam(event, "name");
+  if (!name) {
+    throw createError({ statusCode: 400, statusMessage: "Missing queue name" });
+  }
+  const query = getQuery(event);
+  const state = query.state;
+  const { getJobs } = useQueue();
+  const jobs = await getJobs(name, {
+    state: state ? [state] : void 0,
+    limit: 1e3
+    // Fetch all jobs, pagination happens client-side
+  });
+  return {
+    jobs
+  };
+});

package/dist/runtime/server/api/_queues/index.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/_queues/index.get.js

@@ -0,0 +1,63 @@
+import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueue, useServerLogger } from "#imports";
+const logger = useServerLogger("api-queues-index");
+export default defineEventHandler(async () => {
+  const rc = useRuntimeConfig();
+  const cfgQueues = rc?.queue?.queues || {};
+  const registry = $useQueueRegistry();
+  const queue = useQueue();
+  const names = /* @__PURE__ */ new Set();
+  for (const q in cfgQueues) names.add(q);
+  if (registry?.workers?.length) {
+    for (const w of registry.workers) names.add(w.queue.name);
+  }
+  const queuesWithCounts = await Promise.all(
+    Array.from(names).map(async (name) => {
+      try {
+        const counts = await queue.getJobCounts(name);
+        const isPaused = await queue.isPaused(name);
+        const worker = registry?.workers?.find((w) => w.queue.name === name);
+        const queueConfig = worker?.queue || {};
+        const workerConfig = worker?.worker || {};
+        return {
+          name,
+          counts,
+          isPaused,
+          config: {
+            queue: {
+              prefix: queueConfig.prefix,
+              defaultJobOptions: queueConfig.defaultJobOptions,
+              limiter: queueConfig.limiter
+            },
+            worker: {
+              concurrency: workerConfig.concurrency,
+              lockDurationMs: workerConfig.lockDurationMs,
+              maxStalledCount: workerConfig.maxStalledCount,
+              drainDelayMs: workerConfig.drainDelayMs,
+              autorun: workerConfig.autorun,
+              pollingIntervalMs: workerConfig.pollingIntervalMs
+            }
+          }
+        };
+      } catch (err) {
+        logger.error(`Failed to get counts for queue ${name}:`, { error: err });
+        return {
+          name,
+          counts: {
+            active: 0,
+            completed: 0,
+            failed: 0,
+            delayed: 0,
+            waiting: 0,
+            paused: 0
+          },
+          isPaused: false,
+          config: {
+            queue: {},
+            worker: {}
+          }
+        };
+      }
+    })
+  );
+  return queuesWithCounts;
+});

package/dist/runtime/server/api/_queues/ws.d.ts

@@ -0,0 +1,48 @@
+/**
+ * WebSocket endpoint for queue events
+ * Supports subscribing to specific queues and receiving real-time job updates
+ *
+ * Message format (client -> server):
+ * {
+ *   "type": "subscribe",
+ *   "queueName": "test"
+ * }
+ *
+ * {
+ *   "type": "unsubscribe",
+ *   "queueName": "test"
+ * }
+ *
+ * {
+ *   "type": "ping"
+ * }
+ *
+ * Message format (server -> client):
+ * {
+ *   "type": "event",
+ *   "queueName": "test",
+ *   "event": { eventType: "waiting|active|completed|failed", jobId: "...", ... }
+ * }
+ *
+ * {
+ *   "type": "subscribed",
+ *   "queueName": "test"
+ * }
+ *
+ * {
+ *   "type": "unsubscribed",
+ *   "queueName": "test"
+ * }
+ *
+ * {
+ *   "type": "pong",
+ *   "timestamp": 1234567890
+ * }
+ *
+ * {
+ *   "type": "error",
+ *   "message": "error description"
+ * }
+ */
+declare const _default: any;
+export default _default;