nvent 0.4.5 → 0.5.1

package/dist/runtime/scheduler/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Scheduler Types
+ *
+ * Unified scheduling system for all time-based operations in nvent:
+ * - Stall detection
+ * - Await timeouts
+ * - Trigger schedules
+ * - Cleanup jobs
+ */
+export interface ScheduledJob {
+    /**
+     * Unique job identifier
+     */
+    id: string;
+    /**
+     * Human-readable job name
+     */
+    name: string;
+    /**
+     * Job type
+     */
+    type: 'cron' | 'interval' | 'one-time';
+    /**
+     * Cron expression (for type: 'cron')
+     * @example '0 2 * * *' - Daily at 2 AM
+     * @example '* /5 * * * *' - Every 5 minutes
+     */
+    cron?: string;
+    /**
+     * Interval in milliseconds (for type: 'interval')
+     */
+    interval?: number;
+    /**
+     * Execution timestamp (for type: 'one-time')
+     */
+    executeAt?: number;
+    /**
+     * Job handler function
+     */
+    handler: () => Promise<void>;
+    /**
+     * Timezone for cron jobs
+     * @default 'UTC'
+     */
+    timezone?: string;
+    /**
+     * Whether the job is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Additional metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Last execution timestamp
+     */
+    lastRun?: number;
+    /**
+     * Next scheduled execution timestamp
+     */
+    nextRun?: number;
+    /**
+     * Total execution count
+     */
+    runCount?: number;
+    /**
+     * Failure count
+     */
+    failCount?: number;
+}
+export interface SchedulerAdapter {
+    /**
+     * Schedule a job with distributed locking support
+     */
+    schedule(job: ScheduledJob): Promise<string>;
+    /**
+     * Unschedule a job
+     */
+    unschedule(jobId: string): Promise<boolean>;
+    /**
+     * Start the scheduler (begins processing scheduled jobs)
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the scheduler and release all locks
+     */
+    stop(): Promise<void>;
+    /**
+     * Get all scheduled jobs (in-memory, for this instance)
+     */
+    getScheduledJobs(): Promise<ScheduledJob[]>;
+    /**
+     * Get all persisted jobs from store (across all instances)
+     * Useful for debugging and monitoring in horizontal setups
+     */
+    getAllPersistedJobs(): Promise<ScheduledJob[]>;
+    /**
+     * Check if scheduler is healthy
+     */
+    isHealthy(): Promise<boolean>;
+}
+export interface SchedulerLock {
+    jobId: string;
+    instanceId: string;
+    acquiredAt: number;
+    expiresAt: number;
+}
+export interface SchedulerStats {
+    jobId: string;
+    lastRun: number;
+    nextRun?: number;
+    runCount: number;
+    failCount: number;
+    lastError?: string;
+}

package/dist/runtime/worker/node/runner.d.ts

@@ -1,4 +1,4 @@
-import { useFlowEngine } from '#imports';
+import { useFlow } from '#imports';
 /**
  * Generic job interface that works with any queue adapter
  * Adapters should provide jobs in this format
@@ -32,7 +32,17 @@ export interface RunContext {
     attempt?: number;
     logger: RunLogger;
     state: RunState;
-    flow: ReturnType<typeof useFlowEngine>;
+    flow: ReturnType<typeof useFlow>;
+    /**
+     * Resolved data from await pattern (awaitBefore only)
+     * Available when step resumes after await resolution
+     */
+    trigger?: any;
+    /**
+     * Current step's await configuration
+     * Useful for conditional logic based on await settings
+     */
+    awaitConfig?: any;
 }
 export declare function buildContext(partial?: Partial<RunContext>): RunContext;
 export type NodeHandler = (input: any, ctx: RunContext) => Promise<any>;

package/dist/runtime/worker/node/runner.js

@@ -1,6 +1,17 @@
 import { randomUUID } from "node:crypto";
-import { useStateAdapter } from "../../utils/adapters.js";
-import { useRuntimeConfig, useFlowEngine, useEventManager, useNventLogger } from "#imports";
+import {
+  useRuntimeConfig,
+  useFlow,
+  useEventManager,
+  useNventLogger,
+  $useFunctionRegistry,
+  useAwait,
+  useHookRegistry,
+  useStreamTopics,
+  useStateAdapter,
+  useStoreAdapter,
+  useRunContext
+} from "#imports";
 const logger = useNventLogger("node-runner");
 const defaultState = {
   async get() {
@@ -55,14 +66,15 @@ export function buildContext(partial) {
       }
     };
   })();
-  const baseFlowEngine = useFlowEngine();
+  const baseFlowEngine = useFlow();
   const flow = {
     ...baseFlowEngine,
     emit: async (trigger, payload = {}) => {
       const enrichedPayload = {
         ...payload,
         flowId: payload.flowId || partial?.flowId,
-        flowName: payload.flowName || partial?.flowName
+        flowName: payload.flowName || partial?.flowName,
+        stepName: payload.stepName || partial?.stepName
       };
       return baseFlowEngine.emit(trigger, enrichedPayload);
     },
@@ -97,26 +109,13 @@ export function buildContext(partial) {
     attempt: partial?.attempt,
     logger: logger2,
     state,
-    flow
+    flow,
+    trigger: partial?.trigger,
+    awaitConfig: partial?.awaitConfig
   };
 }
 export function createJobProcessor(handler, queueName) {
   return async function processor(job) {
-    if (job.data?.__scheduledFlowStart) {
-      const { __flowName, __flowInput } = job.data;
-      try {
-        const { startFlow } = useFlowEngine();
-        const result2 = await startFlow(__flowName, __flowInput || {});
-        return {
-          scheduled: true,
-          flowId: result2.flowId,
-          flowName: __flowName
-        };
-      } catch (err) {
-        logger.error("[scheduled-flow] Failed to start flow:", err);
-        throw err;
-      }
-    }
     const eventMgr = useEventManager();
     const rc = useRuntimeConfig();
     const autoScope = rc?.nvent?.store?.state?.autoScope || "always";
@@ -127,6 +126,59 @@ export function createJobProcessor(handler, queueName) {
     const isFinalAttempt = attempt >= maxAttempts;
     const stepRunId = `${String(flowId || job.id)}__${job.name}__attempt-${attempt}`;
     const flowName = job.data?.flowName || "unknown";
+    const registry = $useFunctionRegistry();
+    const flowRegistry = (registry?.flows || {})[flowName];
+    let stepMeta = flowRegistry?.steps?.[job.name];
+    if (!stepMeta && flowRegistry?.entry?.step === job.name) {
+      stepMeta = flowRegistry?.entry;
+    }
+    const awaitBefore = stepMeta?.awaitBefore;
+    const awaitAfter = stepMeta?.awaitAfter;
+    const isAwaitResume = job.data?.awaitResolved === true;
+    const awaitData = job.data?.awaitData;
+    if (awaitBefore && !isAwaitResume) {
+      const awaitLogger = useNventLogger("await-before");
+      awaitLogger.info("Step has awaitBefore, registering await pattern", {
+        flowName,
+        runId: flowId,
+        stepName: job.name,
+        awaitType: awaitBefore.type
+      });
+      try {
+        const { register } = useAwait();
+        const awaitResult = await register(
+          flowId || "unknown",
+          job.name,
+          flowName,
+          awaitBefore,
+          "before"
+          // Position: awaitBefore means wait before execution
+        );
+        const hookRegistry = useHookRegistry();
+        const hooks = hookRegistry.load(flowName, job.name);
+        if (hooks?.onAwaitRegister) {
+          try {
+            await hooks.onAwaitRegister(
+              awaitResult.webhookUrl || awaitResult.eventName || "",
+              job.data,
+              useRunContext({ flowId, flowName, stepName: job.name })
+            );
+          } catch (err) {
+            awaitLogger.error("onAwaitRegister hook failed", { error: err.message });
+          }
+        }
+        return {
+          awaiting: true,
+          awaitType: awaitBefore.type,
+          awaitConfig: awaitBefore
+        };
+      } catch (err) {
+        awaitLogger.error("Failed to register await pattern", {
+          error: err.message,
+          stack: err.stack
+        });
+      }
+    }
     const ctx = buildContext({
       jobId: job.id,
       queue: queueName,
@@ -134,7 +186,9 @@ export function createJobProcessor(handler, queueName) {
       flowName,
       stepName: job.name,
       stepId: stepRunId,
-      attempt
+      attempt,
+      trigger: isAwaitResume ? awaitData : void 0,
+      awaitConfig: awaitBefore || awaitAfter || void 0
     });
     const attemptLogger = {
       log: (level, msg, meta) => {
@@ -168,21 +222,6 @@ export function createJobProcessor(handler, queueName) {
         stack: err?.stack
       });
       const willRetry = !isFinalAttempt;
-      try {
-        await eventMgr.publishBus({
-          type: "step.failed",
-          runId: flowId || "unknown",
-          flowName,
-          stepName: job.name,
-          stepId: stepRunId,
-          attempt,
-          data: {
-            error: String(err?.message || err),
-            stack: err?.stack
-          }
-        });
-      } catch {
-      }
       if (willRetry) {
         try {
           await eventMgr.publishBus({
@@ -197,7 +236,25 @@ export function createJobProcessor(handler, queueName) {
               queue: queueName,
               attempt,
               maxAttempts,
-              nextAttempt: attempt + 1
+              nextAttempt: attempt + 1,
+              error: String(err?.message || err),
+              stack: err?.stack
+            }
+          });
+        } catch {
+        }
+      } else {
+        try {
+          await eventMgr.publishBus({
+            type: "step.failed",
+            runId: flowId || "unknown",
+            flowName,
+            stepName: job.name,
+            stepId: stepRunId,
+            attempt,
+            data: {
+              error: String(err?.message || err),
+              stack: err?.stack
             }
           });
         } catch {
@@ -218,6 +275,53 @@ export function createJobProcessor(handler, queueName) {
       });
     } catch {
     }
+    if (awaitAfter && !isAwaitResume) {
+      const awaitLogger = useNventLogger("await-after");
+      awaitLogger.info("Step has awaitAfter, registering await pattern", {
+        flowName,
+        runId: flowId,
+        stepName: job.name,
+        awaitType: awaitAfter.type
+      });
+      try {
+        const store = useStoreAdapter();
+        const { StoreSubjects } = useStreamTopics();
+        const streamName = StoreSubjects.flowRun(flowId || "unknown");
+        let _emitEvents = [];
+        if (store.stream.read) {
+          const recentEvents = await store.stream.read(streamName, { limit: 100 });
+          _emitEvents = recentEvents.filter(
+            (evt) => evt.type === "emit" && evt.stepName === job.name && evt.stepId === stepRunId
+          );
+        }
+        const { register } = useAwait();
+        const awaitResult = await register(
+          flowId || "unknown",
+          job.name,
+          flowName,
+          awaitAfter,
+          "after"
+        );
+        const hookRegistry = useHookRegistry();
+        const hooks = hookRegistry.load(flowName, job.name);
+        if (hooks?.onAwaitRegister) {
+          try {
+            await hooks.onAwaitRegister(
+              awaitResult.webhookUrl || awaitResult.eventName || "",
+              { ...job.data, result },
+              ctx
+            );
+          } catch (err) {
+            awaitLogger.error("onAwaitRegister hook failed", { error: err.message });
+          }
+        }
+      } catch (err) {
+        awaitLogger.error("Failed to register awaitAfter pattern", {
+          error: err.message,
+          stack: err.stack
+        });
+      }
+    }
     return result;
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.4.5",
+  "version": "0.5.1",
   "description": "Event-driven workflows for Nuxt",
   "repository": "DevJoghurt/nvent",
   "license": "MIT",
@@ -19,12 +19,12 @@
   "scripts": {
     "build": "nuxt-module-build build",
     "dev": "nuxt-module-build build --stub",
-    "prepack": "pnpm build",
-    "test": "vitest"
+    "prepack": "pnpm build"
   },
   "dependencies": {
     "@nuxt/kit": "4.2.1",
-    "chokidar": "^4.0.3",
+    "chokidar": "^5.0.0",
+    "cron": "^4.3.5",
     "cron-parser": "^5.4.0",
     "defu": "^6.1.4",
     "fastq": "^1.19.1",
@@ -33,13 +33,13 @@
     "nuxt": "4.2.1",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.0.0",
-    "zod": "^4.1.12"
+    "zod": "^4.1.13"
   },
   "devDependencies": {
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "4.2.1",
     "@types/node": "^24.10.1",
     "typescript": "latest",
-    "vitest": "^4.0.10"
+    "vitest": "^4.0.15"
   }
 }

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

@@ -1,10 +0,0 @@
-/**
- * DELETE /api/_flows/:flowName/clear-history
- *
- * Clears all event history for a specific flow.
- * This deletes:
- * - All flow run streams (nq:flow:run-*)
- * - The flow runs index (nq:flows:<flowName>)
- */
-declare const _default: any;
-export default _default;

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

@@ -1,55 +0,0 @@
-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 {
-    let deletedStreams = 0;
-    let deletedIndex = false;
-    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 = SubjectPatterns.flowRun(run.id);
-          await store.deleteStream(streamName);
-          if (store.deleteIndex) {
-            const metaKey = `${indexKey}:meta:${run.id}`;
-            await store.deleteIndex(metaKey);
-          }
-          deletedStreams++;
-        }
-      }
-    }
-    if (store.deleteIndex) {
-      await store.deleteIndex(indexKey);
-      deletedIndex = true;
-    }
-    return {
-      success: true,
-      flowName,
-      deletedStreams,
-      deletedIndex
-    };
-  } catch (error) {
-    throw createError({
-      statusCode: 500,
-      statusMessage: "Failed to clear flow history",
-      data: error instanceof Error ? error.message : String(error)
-    });
-  }
-});

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

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

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

@@ -1,21 +0,0 @@
-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,17 +0,0 @@
-/**
- * GET /api/_flows/:flowName/runs
- *
- * 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,64 +0,0 @@
-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");
-  const query = getQuery(event);
-  const limit = Math.min(Number.parseInt(query.limit) || 50, 100);
-  const offset = Math.max(Number.parseInt(query.offset) || 0, 0);
-  const status = query.status;
-  event.node.res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
-  event.node.res.setHeader("Pragma", "no-cache");
-  if (!flowName) {
-    return { error: "Missing flow name" };
-  }
-  let store;
-  let SubjectPatterns;
-  try {
-    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 });
-      totalCount = allEntries.length;
-    } catch {
-      totalCount = 0;
-    }
-    const entries = await store.indexRead(runIndexKey, { offset, limit });
-    const filteredEntries = status ? entries.filter((e) => e.metadata?.status === status) : entries;
-    const items = filteredEntries.map((entry) => ({
-      id: entry.id,
-      flowName,
-      status: entry.metadata?.status || "unknown",
-      createdAt: new Date(entry.score).toISOString(),
-      startedAt: entry.metadata?.startedAt ? new Date(entry.metadata.startedAt).toISOString() : void 0,
-      completedAt: entry.metadata?.completedAt ? new Date(entry.metadata.completedAt).toISOString() : void 0,
-      stepCount: entry.metadata?.stepCount || 0,
-      completedSteps: entry.metadata?.completedSteps || 0
-    }));
-    return {
-      flowName,
-      count: items.length,
-      total: totalCount,
-      offset,
-      limit,
-      hasMore: offset + items.length < totalCount,
-      items
-    };
-  } catch (err) {
-    logger.error("[flows/runs] error:", { error: err });
-    return {
-      error: "Failed to list runs",
-      message: err instanceof Error ? err.message : String(err)
-    };
-  }
-});

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

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

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

@@ -1,66 +0,0 @@
-import { defineEventHandler, readBody, getRouterParam, createError, useQueueAdapter, $useQueueRegistry } from "#imports";
-export default defineEventHandler(async (event) => {
-  const flowName = getRouterParam(event, "name");
-  if (!flowName) {
-    throw createError({ statusCode: 400, statusMessage: "Flow name is required" });
-  }
-  const body = await readBody(event);
-  const { input, cron, delay, jobId, metadata } = body;
-  if (cron && delay) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Cannot specify both cron and delay"
-    });
-  }
-  if (!cron && !delay) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Must specify either cron or delay"
-    });
-  }
-  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;
-  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;
-  const jobData = {
-    __scheduledFlowStart: true,
-    __flowName: flowName,
-    __flowInput: input || {},
-    __schedule: {
-      metadata,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  };
-  const id = await queue.schedule(
-    queueName,
-    {
-      name: flow.entry.step,
-      data: jobData,
-      opts: jobId ? { jobId } : void 0
-    },
-    scheduleOpts
-  );
-  return {
-    id,
-    flowName,
-    queue: queueName,
-    step: flow.entry.step,
-    schedule: scheduleOpts,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-});

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

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