nvent 0.4.4 → 0.4.5

package/dist/runtime/events/wiring/registry.d.ts

@@ -0,0 +1,19 @@
+export interface Wiring {
+    start(): void;
+    stop(): void;
+}
+export interface WiringRegistryOptions {
+    /**
+     * Stream wiring options
+     */
+    streamWiring?: {
+        enabled?: boolean;
+    };
+    /**
+     * State wiring options
+     */
+    stateWiring?: {
+        strategy?: 'never' | 'on-complete' | 'immediate' | 'ttl';
+    };
+}
+export declare function createWiringRegistry(opts?: WiringRegistryOptions): Wiring;

package/dist/runtime/events/wiring/registry.js

@@ -0,0 +1,33 @@
+import { createFlowWiring } from "./flowWiring.js";
+import { createStreamWiring } from "./streamWiring.js";
+import { createStateWiring } from "./stateWiring.js";
+export function createWiringRegistry(opts) {
+  const wirings = [
+    // 1. Flow orchestration (persistence, completion tracking, step triggering)
+    createFlowWiring(),
+    // 2. Stream wiring (publish persisted events to UI clients)
+    createStreamWiring(opts?.streamWiring || {
+      enabled: true
+    }),
+    // 3. State wiring (automatic state cleanup)
+    createStateWiring(opts?.stateWiring)
+    // Future wirings: triggers, webhooks, etc.
+  ];
+  let started = false;
+  return {
+    start() {
+      if (started) return;
+      started = true;
+      for (const w of wirings) w.start();
+    },
+    stop() {
+      for (const w of wirings) {
+        try {
+          w.stop();
+        } catch {
+        }
+      }
+      started = false;
+    }
+  };
+}

package/dist/runtime/events/wiring/stateWiring.d.ts

@@ -0,0 +1,37 @@
+/**
+ * State Wiring - Automatic cleanup of flow state
+ *
+ * Subscribes to the local event bus (single source of truth) and handles
+ * automatic cleanup of flow state based on configuration strategy.
+ *
+ * Cleanup strategies:
+ * - 'never': State persists indefinitely (default)
+ * - 'on-complete': Cleanup when flow completes (recommended)
+ * - 'immediate': Cleanup after each step (not recommended)
+ * - 'ttl': State expires automatically via TTL (handled by storage provider)
+ *
+ * Benefits:
+ * - Single source of truth (event bus)
+ * - Configurable cleanup strategies
+ * - Clear separation of concerns
+ */
+export interface StateWiringOptions {
+    /**
+     * Cleanup strategy
+     * - 'never': State persists indefinitely
+     * - 'on-complete': Cleanup when flow completes (recommended)
+     * - 'immediate': Cleanup after each step
+     * - 'ttl': State expires automatically via TTL
+     * Default: 'never'
+     */
+    strategy?: 'never' | 'on-complete' | 'immediate' | 'ttl';
+}
+/**
+ * Create state wiring
+ *
+ * Subscribes to event bus and handles state cleanup based on configuration
+ */
+export declare function createStateWiring(opts?: StateWiringOptions): {
+    start: () => void;
+    stop: () => void;
+};

package/dist/runtime/events/wiring/stateWiring.js

@@ -0,0 +1,92 @@
+import { getEventBus } from "../eventBus.js";
+import { useNventLogger, useStateAdapter, useRuntimeConfig } from "#imports";
+export function createStateWiring(opts) {
+  let strategy = opts?.strategy;
+  if (!strategy) {
+    try {
+      const rc = useRuntimeConfig();
+      strategy = rc?.nvent?.store?.state?.cleanup?.strategy || "never";
+    } catch {
+      strategy = "never";
+    }
+  }
+  const bus = getEventBus();
+  const unsubs = [];
+  let wired = false;
+  function start() {
+    if (wired) return;
+    wired = true;
+    if (strategy === "never" || strategy === "ttl") {
+      return;
+    }
+    const logger = useNventLogger("state-wiring");
+    const stateAdapter = useStateAdapter();
+    logger.info("Starting state wiring", { strategy });
+    if (strategy === "on-complete") {
+      const cleanupFlowState = async (event, reason) => {
+        const flowId = event.runId;
+        if (!flowId) return;
+        try {
+          const pattern = `flow:${flowId}:*`;
+          const deletedCount = await stateAdapter.clear(pattern);
+          if (deletedCount > 0) {
+            logger.info(`Cleaned up state after ${reason}`, {
+              flowId,
+              deletedCount
+            });
+          }
+        } catch (error) {
+          logger.error(`Error cleaning up state after ${reason}`, {
+            flowId,
+            error: error?.message
+          });
+        }
+      };
+      const handleFlowCompleted = (event) => cleanupFlowState(event, "flow completion");
+      const handleFlowFailed = (event) => cleanupFlowState(event, "flow failure");
+      const handleFlowCanceled = (event) => cleanupFlowState(event, "flow cancellation");
+      const handleFlowStalled = (event) => cleanupFlowState(event, "flow stall");
+      unsubs.push(bus.onType("flow.completed", handleFlowCompleted));
+      unsubs.push(bus.onType("flow.failed", handleFlowFailed));
+      unsubs.push(bus.onType("flow.cancel", handleFlowCanceled));
+      unsubs.push(bus.onType("flow.stalled", handleFlowStalled));
+      logger.debug("State cleanup enabled: on-complete (includes stalled and canceled)");
+    } else if (strategy === "immediate") {
+      const handleStepCompleted = async (event) => {
+        const flowId = event.runId;
+        if (!flowId) return;
+        try {
+          const pattern = `flow:${flowId}:*`;
+          const deletedCount = await stateAdapter.clear(pattern);
+          if (deletedCount > 0) {
+            logger.info("Cleaned up state after step completion", {
+              flowId,
+              stepName: event.stepName,
+              deletedCount
+            });
+          }
+        } catch (error) {
+          logger.error("Error cleaning up state after step", {
+            flowId,
+            error: error?.message
+          });
+        }
+      };
+      unsubs.push(bus.onType("step.completed", handleStepCompleted));
+      logger.debug("State cleanup enabled: immediate");
+    }
+    logger.info("State wiring started");
+  }
+  function stop() {
+    const logger = useNventLogger("state-wiring");
+    for (const unsub of unsubs.splice(0)) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    wired = false;
+    logger.debug("State wiring stopped");
+  }
+  return { start, stop };
+}

package/dist/runtime/events/wiring/streamWiring.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Stream Wiring - Publish flow events to UI clients via StreamAdapter
+ *
+ * Subscribes to the local event bus (single source of truth) and publishes
+ * persisted events to the StreamAdapter for WebSocket/SSE clients.
+ *
+ * Simple and focused:
+ * - Listens to event bus for persisted events (with id/ts)
+ * - Publishes to client channel: client:flow:{runId}
+ * - UI gets real-time updates
+ *
+ * Benefits:
+ * - Single source of truth (event bus)
+ * - Easy to debug (no republishing)
+ * - Clear separation of concerns
+ */
+export interface StreamWiringOptions {
+    /**
+     * Enable client messages (WebSocket/SSE)
+     * Default: true
+     */
+    enabled?: boolean;
+}
+/**
+ * Create stream wiring
+ *
+ * Subscribes to event bus and publishes persisted events to UI clients
+ */
+export declare function createStreamWiring(opts?: StreamWiringOptions): {
+    start: () => void;
+    stop: () => void;
+};

package/dist/runtime/events/wiring/streamWiring.js

@@ -0,0 +1,79 @@
+import { getEventBus } from "../eventBus.js";
+import { useNventLogger, useStreamAdapter, useStreamTopics } from "#imports";
+export function createStreamWiring(opts = {}) {
+  const {
+    enabled = true
+  } = opts;
+  const bus = getEventBus();
+  const unsubs = [];
+  let wired = false;
+  function start() {
+    if (wired) return;
+    wired = true;
+    if (!enabled) return;
+    const logger = useNventLogger("stream-wiring");
+    const stream = useStreamAdapter();
+    const { getClientFlowTopic } = useStreamTopics();
+    logger.info("Starting stream wiring for UI clients");
+    const handleClientMessage = async (e) => {
+      if (!e.id || !e.ts) return;
+      const runId = e.runId;
+      if (!runId) return;
+      try {
+        const topic = getClientFlowTopic(runId);
+        await stream.publish(topic, {
+          type: "flow.event",
+          data: {
+            event: {
+              id: e.id,
+              ts: e.ts,
+              type: e.type,
+              runId: e.runId,
+              flowName: e.flowName,
+              // Include step-specific fields for UI
+              stepName: e.stepName,
+              stepId: e.stepId,
+              attempt: e.attempt,
+              data: e.data
+            }
+          },
+          timestamp: Date.now()
+        });
+        logger.debug("Published to UI clients", { type: e.type, runId });
+      } catch (err) {
+        logger.error("Failed to publish to UI clients", {
+          error: err?.message
+        });
+      }
+    };
+    const clientEventTypes = [
+      "flow.start",
+      "flow.completed",
+      "flow.failed",
+      "flow.cancel",
+      "step.started",
+      "step.completed",
+      "step.failed",
+      "step.retry",
+      "log",
+      "emit",
+      "state"
+    ];
+    for (const type of clientEventTypes) {
+      unsubs.push(bus.onType(type, handleClientMessage));
+    }
+    logger.info("Stream wiring started - listening for persisted events");
+  }
+  function stop() {
+    const logger = useNventLogger("stream-wiring");
+    for (const unsub of unsubs.splice(0)) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    wired = false;
+    logger.debug("Stream wiring stopped");
+  }
+  return { start, stop };
+}

package/dist/runtime/server/api/_flows/[name]/clear-history.delete.js

@@ -1,20 +1,31 @@
-import { defineEventHandler, createError, useEventStore } from "#imports";
+import { defineEventHandler, createError, useStoreAdapter, useStreamTopics } from "#imports";
 export default defineEventHandler(async (event) => {
   const flowName = event.context.params?.name;
   if (!flowName) {
     throw createError({ statusCode: 400, statusMessage: "Flow name required" });
   }
+  let store;
+  let SubjectPatterns;
+  try {
+    store = useStoreAdapter();
+    const topics = useStreamTopics();
+    SubjectPatterns = topics.SubjectPatterns;
+  } catch {
+    throw createError({
+      statusCode: 503,
+      statusMessage: "Server initializing",
+      data: "Adapters not ready yet, please retry"
+    });
+  }
   try {
-    const store = useEventStore();
-    const names = store.names();
     let deletedStreams = 0;
     let deletedIndex = false;
-    const indexKey = names.flowIndex(flowName);
+    const indexKey = SubjectPatterns.flowRunIndex(flowName);
     if (store.indexRead) {
       const runs = await store.indexRead(indexKey, { limit: 1e4 });
       if (store.deleteStream) {
         for (const run of runs) {
-          const streamName = names.flow(run.id);
+          const streamName = SubjectPatterns.flowRun(run.id);
           await store.deleteStream(streamName);
           if (store.deleteIndex) {
             const metaKey = `${indexKey}:meta:${run.id}`;

package/dist/runtime/server/api/_flows/[name]/runs/[runId]/cancel.post.js

@@ -0,0 +1,21 @@
+import { defineEventHandler, getRouterParam, createError, useFlowEngine } from "#imports";
+export default defineEventHandler(async (event) => {
+  const flowName = getRouterParam(event, "name");
+  const runId = getRouterParam(event, "runId");
+  if (!flowName || !runId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Flow name and run ID are required"
+    });
+  }
+  const flowEngine = useFlowEngine();
+  try {
+    const result = await flowEngine.cancelFlow(flowName, runId);
+    return result;
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Failed to cancel flow: ${error.message}`
+    });
+  }
+});

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

@@ -1,7 +1,17 @@
 /**
- * GET /api/_flows/:name/runs?limit=50&offset=0
+ * GET /api/_flows/:flowName/runs
  *
- * List runs for a specific flow with pagination support
+ * Returns a list of flow runs with their metadata from the sorted set index.
+ * Supports pagination via offset/limit query params.
+ *
+ * Query params:
+ * - limit: number (default: 50)
+ * - offset: number (default: 0)
+ *
+ * Returns:
+ * {
+ *   runs: Array<{ id, score, metadata }>
+ * }
  */
 declare const _default: any;
 export default _default;

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

@@ -1,4 +1,4 @@
-import { defineEventHandler, getRouterParam, getQuery, useEventStore, useNventLogger } from "#imports";
+import { defineEventHandler, getRouterParam, getQuery, useStoreAdapter, useNventLogger, useStreamTopics } from "#imports";
 export default defineEventHandler(async (event) => {
   const logger = useNventLogger("api-flows-runs");
   const flowName = getRouterParam(event, "name");
@@ -11,10 +11,21 @@ export default defineEventHandler(async (event) => {
   if (!flowName) {
     return { error: "Missing flow name" };
   }
-  const store = useEventStore();
-  const names = store.names();
+  let store;
+  let SubjectPatterns;
   try {
-    const runIndexKey = names.flowIndex(flowName);
+    store = useStoreAdapter();
+    const topics = useStreamTopics();
+    SubjectPatterns = topics.SubjectPatterns;
+  } catch (err) {
+    logger.error("[flows/runs] Adapters not initialized yet:", { error: err });
+    return {
+      error: "Server initializing",
+      message: "Please retry in a moment"
+    };
+  }
+  try {
+    const runIndexKey = SubjectPatterns.flowRunIndex(flowName);
     let totalCount = 0;
     try {
       const allEntries = await store.indexRead(runIndexKey, { limit: 1e4 });

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

@@ -1,4 +1,4 @@
-import { defineEventHandler, readBody, getRouterParam, createError, useQueue, $useQueueRegistry } from "#imports";
+import { defineEventHandler, readBody, getRouterParam, createError, useQueueAdapter, $useQueueRegistry } from "#imports";
 export default defineEventHandler(async (event) => {
   const flowName = getRouterParam(event, "name");
   if (!flowName) {
@@ -24,7 +24,16 @@ export default defineEventHandler(async (event) => {
     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 queue = useQueue();
+  let queue;
+  try {
+    queue = useQueueAdapter();
+  } catch {
+    throw createError({
+      statusCode: 503,
+      statusMessage: "Server initializing",
+      data: "Queue adapter not ready yet, please retry"
+    });
+  }
   const scheduleOpts = {};
   if (cron) scheduleOpts.cron = cron;
   if (delay) scheduleOpts.delay = delay;

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

@@ -1,5 +1,4 @@
-import { defineEventHandler, getRouterParam, createError, useRuntimeConfig, $useQueueRegistry } from "#imports";
-import { Queue } from "bullmq";
+import { defineEventHandler, getRouterParam, createError, useQueueAdapter, $useQueueRegistry } from "#imports";
 export default defineEventHandler(async (event) => {
   const flowName = getRouterParam(event, "name");
   const scheduleId = getRouterParam(event, "id");
@@ -11,29 +10,35 @@ export default defineEventHandler(async (event) => {
   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;
+  let adapter;
   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;
-      }
-    }
+    adapter = useQueueAdapter();
   } catch {
+    throw createError({
+      statusCode: 503,
+      statusMessage: "Server initializing",
+      data: "Queue adapter not ready yet, please retry"
+    });
+  }
+  if (!adapter.removeScheduledJob) {
+    throw createError({
+      statusCode: 501,
+      statusMessage: "Queue adapter does not support scheduled jobs removal"
+    });
   }
-  const queue = new Queue(queueName, { connection, prefix });
   try {
-    await queue.removeRepeatableByKey(scheduleId);
-    await queue.close();
+    const removed = await adapter.removeScheduledJob(scheduleId);
+    if (!removed) {
+      throw createError({ statusCode: 404, statusMessage: "Schedule not found" });
+    }
     return {
       success: true,
       message: "Schedule deleted successfully"
     };
   } catch (error) {
-    await queue.close();
+    if (error.statusCode === 404) {
+      throw error;
+    }
     throw createError({
       statusCode: 500,
       statusMessage: `Failed to delete schedule: ${error.message}`

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

@@ -1,5 +1,4 @@
-import { defineEventHandler, getRouterParam, createError, useRuntimeConfig, $useQueueRegistry } from "#imports";
-import { Queue } from "bullmq";
+import { defineEventHandler, getRouterParam, createError, useQueueAdapter, $useQueueRegistry } from "#imports";
 export default defineEventHandler(async (event) => {
   const flowName = getRouterParam(event, "name");
   if (!flowName) {
@@ -10,36 +9,39 @@ export default defineEventHandler(async (event) => {
   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;
+  let adapter;
   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;
-      }
-    }
+    adapter = useQueueAdapter();
   } catch {
+    throw createError({
+      statusCode: 503,
+      statusMessage: "Server initializing",
+      data: "Queue adapter not ready yet, please retry"
+    });
+  }
+  if (!adapter.getScheduledJobs) {
+    throw createError({
+      statusCode: 501,
+      statusMessage: "Queue adapter does not support scheduled jobs"
+    });
   }
-  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,
+    const scheduledJobs = await adapter.getScheduledJobs(queueName);
+    const schedules = scheduledJobs.filter((job) => job.jobName === flow.entry.step).map((job) => ({
+      id: job.id,
       flowName,
       queue: queueName,
       step: flow.entry.step,
       schedule: {
-        cron: job.pattern
+        cron: job.cron || job.pattern
       },
-      nextRun: job.next ? new Date(job.next).toISOString() : void 0
+      nextRun: job.nextRun ? job.nextRun.toISOString() : void 0,
+      repeatCount: job.repeatCount,
+      limit: job.limit
     }));
-    await queue.close();
     return schedules;
   } catch (error) {
-    await queue.close();
     throw createError({
       statusCode: 500,
       statusMessage: `Failed to list schedules: ${error.message}`