nvent 0.4.4 → 0.5.0

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

@@ -1,9 +0,0 @@
-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

@@ -1,6 +0,0 @@
-/**
- * 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

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

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

@@ -1,60 +0,0 @@
-/**
- * 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

@@ -1,188 +0,0 @@
-import {
-  defineWebSocketHandler,
-  useEventStore,
-  usePeerManager,
-  useNventLogger
-} from "#imports";
-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) {
-    const logger = useNventLogger("api-flows-ws");
-    logger.info("[ws] client connected:", { peerId: peer.id });
-    const { registerWsPeer } = usePeerManager();
-    registerWsPeer(peer);
-    peerContexts.set(peer, {
-      subscriptions: /* @__PURE__ */ new Map()
-    });
-    safeSend(peer, {
-      type: "connected",
-      timestamp: Date.now()
-    });
-  },
-  async message(peer, message) {
-    const logger = useNventLogger("api-flows-ws");
-    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 logger = useNventLogger("api-flows-ws");
-    const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
-    if (!isNormalClosure) {
-      logger.info("[ws] client disconnected:", { peerId: peer.id, code: event?.code, reason: event?.reason });
-    }
-    const { unregisterWsPeer } = usePeerManager();
-    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) {
-    const logger = useNventLogger("api-flows-ws");
-    logger.error("[ws] error for peer:", { peerId: peer.id, error });
-    const { unregisterWsPeer } = usePeerManager();
-    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

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

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

@@ -1,9 +0,0 @@
-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

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

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

@@ -1,18 +0,0 @@
-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

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

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

@@ -1,63 +0,0 @@
-import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
-export default defineEventHandler(async () => {
-  const rc = useRuntimeConfig();
-  const logger = useNventLogger("api-queues-index");
-  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

@@ -1,48 +0,0 @@
-/**
- * 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;

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

@@ -1,205 +0,0 @@
-import {
-  defineWebSocketHandler,
-  useQueue,
-  usePeerManager,
-  useNventLogger
-} from "#imports";
-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) {
-    const logger = useNventLogger("api-queues-ws");
-    logger.info("[ws:queues] client connected:", peer.id);
-    const { registerWsPeer } = usePeerManager();
-    registerWsPeer(peer);
-    peerContexts.set(peer, {
-      subscriptions: /* @__PURE__ */ new Map()
-    });
-    safeSend(peer, {
-      type: "connected",
-      timestamp: Date.now()
-    });
-  },
-  async message(peer, message) {
-    const logger = useNventLogger("api-queues-ws");
-    const context = peerContexts.get(peer);
-    if (!context) {
-      logger.error("[ws:queues] no context for peer:", peer.id);
-      return;
-    }
-    let data;
-    try {
-      data = JSON.parse(message.text());
-    } catch {
-      safeSend(peer, {
-        type: "error",
-        message: "Invalid JSON"
-      });
-      return;
-    }
-    const { type, queueName } = data;
-    if (type === "subscribe") {
-      if (!queueName) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing queueName"
-        });
-        return;
-      }
-      const queue = useQueue();
-      const existingUnsub = context.subscriptions.get(queueName);
-      if (existingUnsub) {
-        try {
-          existingUnsub();
-        } catch (err) {
-          logger.error("[ws:queues] error unsubscribing:", err);
-        }
-      }
-      const events = [
-        "waiting",
-        "active",
-        "completed",
-        "failed",
-        "progress"
-      ];
-      const unsubs = events.map(
-        (eventType) => queue.on(queueName, eventType, async (payload) => {
-          safeSend(peer, {
-            type: "event",
-            queueName,
-            event: {
-              eventType,
-              ...payload
-            }
-          });
-          if (["waiting", "active", "completed", "failed"].includes(eventType)) {
-            try {
-              const counts = await queue.getJobCounts(queueName);
-              safeSend(peer, {
-                type: "counts",
-                queueName,
-                counts
-              });
-            } catch (err) {
-              logger.error("[ws:queues] error fetching counts after event:", err);
-            }
-          }
-        })
-      );
-      const unsub = () => {
-        for (const u of unsubs) {
-          try {
-            u();
-          } catch (err) {
-            logger.error("[ws:queues] error unsubscribing:", err);
-          }
-        }
-      };
-      context.subscriptions.set(queueName, unsub);
-      try {
-        const counts = await queue.getJobCounts(queueName);
-        safeSend(peer, {
-          type: "counts",
-          queueName,
-          counts
-        });
-      } catch (err) {
-        logger.error("[ws:queues] error fetching counts:", err);
-      }
-      safeSend(peer, {
-        type: "subscribed",
-        queueName
-      });
-    } else if (type === "unsubscribe") {
-      if (!queueName) {
-        safeSend(peer, {
-          type: "error",
-          message: "Missing queueName"
-        });
-        return;
-      }
-      const unsub = context.subscriptions.get(queueName);
-      if (unsub) {
-        try {
-          unsub();
-          context.subscriptions.delete(queueName);
-          safeSend(peer, {
-            type: "unsubscribed",
-            queueName
-          });
-        } catch (err) {
-          logger.error("[ws:queues] error unsubscribing:", 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 logger = useNventLogger("api-queues-ws");
-    const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
-    if (!isNormalClosure) {
-      logger.info("[ws:queues] client disconnected:", {
-        peerId: peer.id,
-        code: event?.code,
-        reason: event?.reason
-      });
-    }
-    const { unregisterWsPeer } = usePeerManager();
-    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:queues] error unsubscribing on close:", err);
-          }
-        }
-      }
-      context.subscriptions.clear();
-      peerContexts.delete(peer);
-    }
-  },
-  error(peer, error) {
-    const logger = useNventLogger("api-queues-ws");
-    logger.error("[ws:queues] error for peer:", {
-      peerId: peer.id,
-      error
-    });
-    const { unregisterWsPeer } = usePeerManager();
-    unregisterWsPeer(peer);
-    const context = peerContexts.get(peer);
-    if (context) {
-      for (const unsub of context.subscriptions.values()) {
-        try {
-          unsub();
-        } catch (err) {
-          logger.error("[ws:queues] error unsubscribing on error:", { error: err });
-        }
-      }
-      context.subscriptions.clear();
-      peerContexts.delete(peer);
-    }
-  }
-});

package/dist/runtime/server/plugins/00.event-store.d.ts

@@ -1,13 +0,0 @@
-/**
- * Flow Run Snapshots (stream-based)
- *
- * Writes append-only snapshot events to nq:proj:flow:<flowName>:<runId>
- * for key lifecycle kinds:
- *  - flow.start -> status=running
- *  - flow.complete -> status=completed
- *  - runner.log (with correlationId) -> logsCount++ (as a patch)
- *
- * Consumers reduce the small snapshot stream to a final object.
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/server/plugins/00.event-store.js

@@ -1,16 +0,0 @@
-import { defineNitroPlugin } from "#imports";
-import { getEventStoreFactory } from "../../server-utils/events/eventStoreFactory.js";
-export default defineNitroPlugin(() => {
-  const factory = getEventStoreFactory();
-  factory.start();
-  return {
-    hooks: {
-      close: async () => {
-        try {
-          factory.stop();
-        } catch {
-        }
-      }
-    }
-  };
-});

package/dist/runtime/server/plugins/flow-management.d.ts

@@ -1,13 +0,0 @@
-/**
- * Flow Management Plugin
- *
- * Handles NEW flow starts from external triggers:
- * - Processes external triggers to start new flows
- * - Emits flow.start events for new flow runs
- * - Maps flowIds to flowNames
- *
- * Note: Step orchestration (checking dependencies, triggering next steps)
- * is handled by flowWiring.ts which subscribes to emit/step.completed events
- */
-declare const _default: any;
-export default _default;