nvent 0.5.4 → 0.5.6

package/dist/runtime/nitro/plugins/02.workers.js

@@ -1,5 +1,6 @@
 import { defineNitroPlugin, $useWorkerHandlers, $useFunctionRegistry, useQueueAdapter, useHookRegistry } from "#imports";
 import { createJobProcessor } from "../../worker/node/runner.js";
+import { registerSystemHandlersOnQueue } from "../../worker/system/index.js";
 export default defineNitroPlugin(async (nitroApp) => {
   nitroApp.hooks.hook("close", async () => {
     const queueAdapter = useQueueAdapter();
@@ -11,6 +12,7 @@ export default defineNitroPlugin(async (nitroApp) => {
       const handlers = $useWorkerHandlers();
       const registry = $useFunctionRegistry() || { workers: [] };
       const registeredQueues = /* @__PURE__ */ new Set();
+      const queuesWithHooks = /* @__PURE__ */ new Set();
       for (const entry of handlers) {
         const { queue, id, handler, module } = entry;
         const w = registry.workers.find((rw) => rw?.id === id || rw?.queue?.name === queue && rw?.absPath === entry.absPath);
@@ -20,7 +22,7 @@ export default defineNitroPlugin(async (nitroApp) => {
         } else {
           jobName = id.includes("/") ? id.split("/").pop() : id;
         }
-        if (module && w?.flow) {
+        if (module) {
           const hooks = {};
           if (typeof module.onAwaitRegister === "function") {
             hooks.onAwaitRegister = module.onAwaitRegister;
@@ -28,7 +30,10 @@ export default defineNitroPlugin(async (nitroApp) => {
           if (typeof module.onAwaitResolve === "function") {
             hooks.onAwaitResolve = module.onAwaitResolve;
           }
-          if (Object.keys(hooks).length > 0) {
+          if (typeof module.onAwaitTimeout === "function") {
+            hooks.onAwaitTimeout = module.onAwaitTimeout;
+          }
+          if (Object.keys(hooks).length > 0 && w?.flow) {
             const hookRegistry = useHookRegistry();
             const flowNames = w.flow.names ? Array.isArray(w.flow.names) ? w.flow.names : [w.flow.names] : w.flow.name ? Array.isArray(w.flow.name) ? w.flow.name : [w.flow.name] : [];
             for (const flowName of flowNames) {
@@ -36,6 +41,20 @@ export default defineNitroPlugin(async (nitroApp) => {
                 hookRegistry.register(flowName, jobName, hooks);
               }
             }
+            queuesWithHooks.add(queue);
+          }
+          if (w?.flow?.awaitBefore || w?.flow?.awaitAfter) {
+            queuesWithHooks.add(queue);
+          }
+          if (w?.flow?.role === "entry") {
+            const flowNames = w.flow.names ? Array.isArray(w.flow.names) ? w.flow.names : [w.flow.names] : w.flow.name ? Array.isArray(w.flow.name) ? w.flow.name : [w.flow.name] : [];
+            for (const flowName of flowNames) {
+              const flowRegistry = (registry?.flows || {})[flowName];
+              if (flowRegistry?.entry?.awaitBefore || flowRegistry?.entry?.awaitAfter) {
+                queuesWithHooks.add(queue);
+                break;
+              }
+            }
           }
         }
         if (typeof handler === "function") {
@@ -52,6 +71,16 @@ export default defineNitroPlugin(async (nitroApp) => {
           registeredQueues.add(queue);
         }
       }
+      for (const queueName of queuesWithHooks) {
+        try {
+          const queueWorker = registry.workers.find((w) => w?.queue?.name === queueName);
+          const concurrency = queueWorker?.worker?.concurrency;
+          registerSystemHandlersOnQueue(queueName, concurrency);
+          registeredQueues.add(queueName);
+        } catch (err) {
+          console.error(`[nvent] Failed to register system handlers on queue ${queueName}:`, err);
+        }
+      }
       if (queueAdapter.startProcessingQueue) {
         for (const queueName of Array.from(registeredQueues)) {
           queueAdapter.startProcessingQueue(queueName);

package/dist/runtime/nitro/routes/webhook.await.js

@@ -30,8 +30,8 @@ export default defineEventHandler(async (event) => {
     });
   }
   const status = flowEntry.metadata?.status;
-  if (status && status !== "running") {
-    logger.warn(`Flow is not running`, { flowName, runId, stepName, status });
+  if (status && status !== "running" && status !== "awaiting") {
+    logger.warn(`Flow is not running or awaiting`, { flowName, runId, stepName, status });
     setResponseStatus(event, 410);
     throw createError({
       statusCode: 410,
@@ -39,9 +39,32 @@ export default defineEventHandler(async (event) => {
       message: `This webhook is no longer valid because the flow is ${status}.`
     });
   }
-  const awaitState = flowEntry.metadata?.awaitingSteps?.[stepName];
-  if (!awaitState || awaitState.status !== "awaiting") {
-    logger.warn(`Step is not awaiting`, { flowName, runId, stepName, awaitState });
+  const awaitingSteps = flowEntry.metadata?.awaitingSteps || {};
+  const awaitKeyBefore = `${stepName}:before`;
+  const awaitKeyAfter = `${stepName}:after`;
+  let awaitState = null;
+  let position = "before";
+  const awaitStateBefore = awaitingSteps[awaitKeyBefore];
+  if (awaitStateBefore && awaitStateBefore.status === "awaiting") {
+    awaitState = awaitStateBefore;
+    position = "before";
+  }
+  if (!awaitState) {
+    const awaitStateAfter = awaitingSteps[awaitKeyAfter];
+    if (awaitStateAfter && awaitStateAfter.status === "awaiting") {
+      awaitState = awaitStateAfter;
+      position = "after";
+    }
+  }
+  if (!awaitState) {
+    const legacyAwaitState = awaitingSteps[stepName];
+    if (legacyAwaitState && legacyAwaitState.status === "awaiting") {
+      awaitState = legacyAwaitState;
+      position = "after";
+    }
+  }
+  if (!awaitState) {
+    logger.warn(`Step is not awaiting`, { flowName, runId, stepName, awaitingSteps });
     setResponseStatus(event, 410);
     throw createError({
       statusCode: 410,
@@ -66,7 +89,6 @@ export default defineEventHandler(async (event) => {
       message: `This webhook expects ${expectedMethod} requests.`
     });
   }
-  const position = awaitState.position || "after";
   let webhookData;
   if (event.method === "GET") {
     webhookData = getRouterParams(event, { decode: true });

package/dist/runtime/nitro/routes/webhook.trigger.d.ts

@@ -16,6 +16,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     triggerName?: undefined;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
     success?: undefined;
@@ -27,6 +28,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     message: string;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
     success?: undefined;
@@ -38,6 +40,19 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     expectedType: string;
     actualType: any;
     message?: undefined;
+    status?: undefined;
+    expectedMethod?: undefined;
+    actualMethod?: undefined;
+    success?: undefined;
+    subscribedFlows?: undefined;
+    timestamp?: undefined;
+} | {
+    error: string;
+    triggerName: string;
+    status: any;
+    message: string;
+    expectedType?: undefined;
+    actualType?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
     success?: undefined;
@@ -51,6 +66,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     triggerName?: undefined;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     success?: undefined;
     subscribedFlows?: undefined;
     timestamp?: undefined;
@@ -63,6 +79,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     error?: undefined;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
 }>>;

package/dist/runtime/nitro/routes/webhook.trigger.js

@@ -30,6 +30,15 @@ export default defineEventHandler(async (event) => {
       actualType: triggerEntry.type
     };
   }
+  if (triggerEntry.status !== "active") {
+    logger.info(`Trigger '${triggerName}' is ${triggerEntry.status}, rejecting webhook`);
+    return {
+      error: "Trigger not active",
+      triggerName,
+      status: triggerEntry.status,
+      message: `Trigger '${triggerName}' is ${triggerEntry.status}. Update status to 'active' to enable.`
+    };
+  }
   const expectedMethod = triggerEntry.webhook?.method || "POST";
   if (event.method !== expectedMethod) {
     logger.warn(`Method mismatch: expected ${expectedMethod}, got ${event.method}`);

package/dist/runtime/nitro/utils/awaitPatterns/event.js

@@ -18,6 +18,9 @@ export async function registerEventAwait(runId, stepName, flowName, config, posi
     await resolveEventAwait(runId, stepName, flowName, position, event.data);
     unsubscribe();
   });
+  const { useAwaitDefaults } = await import("../useAwait.js");
+  const { eventTimeout: defaultTimeout, timeoutAction: defaultTimeoutAction } = useAwaitDefaults();
+  const timeoutMs = config.timeout && config.timeout > 0 ? config.timeout : defaultTimeout;
   eventBus.publish({
     type: "await.registered",
     flowName,
@@ -27,66 +30,69 @@ export async function registerEventAwait(runId, stepName, flowName, config, posi
     position,
     config,
     data: {
+      position,
+      // Store position in data for database persistence
       eventName: config.event,
       filterKey: config.filterKey,
-      timeout: config.timeout,
-      registeredAt: Date.now()
+      timeout: timeoutMs,
+      // Store resolved timeout (with default)
+      registeredAt: Date.now(),
+      timeoutAction: config.timeoutAction || defaultTimeoutAction
     }
   });
-  if (config.timeout && config.timeout > 0) {
-    const scheduler = useScheduler();
-    const timeoutAt = Date.now() + config.timeout;
-    const jobId = `await-event-timeout-${runId}-${stepName}-${position}`;
-    await scheduler.schedule({
-      id: jobId,
-      name: `Event Await Timeout: ${flowName} - ${stepName}`,
-      type: "one-time",
-      executeAt: timeoutAt,
-      handler: async () => {
-        logger.warn("Event await timeout", {
-          runId,
-          stepName,
-          flowName,
-          eventName: config.event,
-          timeout: config.timeout,
-          timeoutAction: config.timeoutAction || "fail"
-        });
-        eventBus.publish({
-          type: "await.timeout",
-          flowName,
-          runId,
-          stepName,
-          position,
-          awaitType: "event",
-          timeoutAction: config.timeoutAction || "fail",
-          data: {
-            eventName: config.event,
-            timeout: config.timeout,
-            registeredAt: Date.now() - (config.timeout || 0),
-            timedOutAt: Date.now()
-          }
-        });
-        unsubscribe();
-      },
-      metadata: {
-        component: "await-pattern",
-        awaitType: "event",
+  const scheduler = useScheduler();
+  const timeoutAt = Date.now() + timeoutMs;
+  const jobId = `await-event-timeout-${runId}-${stepName}-${position}`;
+  await scheduler.schedule({
+    id: jobId,
+    name: `Event Await Timeout: ${flowName} - ${stepName}`,
+    type: "one-time",
+    executeAt: timeoutAt,
+    handler: async () => {
+      logger.warn("Event await timeout", {
         runId,
         stepName,
         flowName,
+        eventName: config.event,
+        timeout: timeoutMs,
+        timeoutAction: config.timeoutAction || "fail"
+      });
+      eventBus.publish({
+        type: "await.timeout",
+        flowName,
+        runId,
+        stepName,
         position,
-        timeout: config.timeout,
-        eventName: config.event
-      }
-    });
-    logger.debug(`Event timeout scheduled`, {
+        awaitType: "event",
+        timeoutAction: config.timeoutAction || "fail",
+        data: {
+          eventName: config.event,
+          timeout: timeoutMs,
+          registeredAt: Date.now() - timeoutMs,
+          timedOutAt: Date.now()
+        }
+      });
+      unsubscribe();
+    },
+    metadata: {
+      component: "await-pattern",
+      awaitType: "event",
       runId,
       stepName,
-      eventName: config.event,
-      timeout: config.timeout,
-      timeoutAction: config.timeoutAction
-    });
-  }
+      flowName,
+      position,
+      timeout: timeoutMs,
+      eventName: config.event
+    }
+  });
+  logger.debug(`Event timeout scheduled`, {
+    runId,
+    stepName,
+    eventName: config.event,
+    timeout: timeoutMs,
+    timeoutAction: config.timeoutAction,
+    isDefault: !config.timeout || config.timeout <= 0
+  });
   logger.debug(`Event await registered: ${config.event}`, { runId, stepName });
   return {
     eventName: config.event,
@@ -113,6 +119,8 @@ export async function resolveEventAwait(runId, stepName, flowName, position, eve
     position,
     triggerData: eventData,
     data: {
+      position,
+      // Store position in data for database persistence
       resolvedAt: Date.now()
     }
   });

package/dist/runtime/nitro/utils/awaitPatterns/schedule.js

@@ -43,6 +43,8 @@ export async function registerScheduleAwait(runId, stepName, flowName, config, p
     position,
     config,
     data: {
+      position,
+      // Store position in data for database persistence
       cron: config.cron,
       nextOccurrence,
       timeUntilNext,
@@ -63,14 +65,17 @@ export async function resolveScheduleAwait(runId, stepName, flowName, position,
   const logger = useNventLogger("await-schedule");
   const eventBus = getEventBus();
   logger.info(`Resolving schedule await`, { runId, stepName });
+  const scheduledAt = scheduleData?.scheduledAt || Date.now();
   eventBus.publish({
     type: "await.resolved",
     flowName,
     runId,
     stepName,
     position,
-    triggerData: scheduleData,
+    triggerData: { scheduledAt },
     data: {
+      position,
+      // Store position in data for database persistence
       resolvedAt: Date.now()
     }
   });

package/dist/runtime/nitro/utils/awaitPatterns/time.d.ts

@@ -12,4 +12,4 @@ export declare function registerTimeAwait(runId: string, stepName: string, flowN
 /**
  * Resolve time await when delay completes
  */
-export declare function resolveTimeAwait(runId: string, stepName: string, flowName: string, position: 'before' | 'after', timeData: any): Promise<void>;
+export declare function resolveTimeAwait(runId: string, stepName: string, flowName: string, position: 'before' | 'after', _timeData: any): Promise<void>;

package/dist/runtime/nitro/utils/awaitPatterns/time.js

@@ -37,6 +37,8 @@ export async function registerTimeAwait(runId, stepName, flowName, config, posit
     position,
     config,
     data: {
+      position,
+      // Store position in data for database persistence
       delay: config.delay,
       resolveAt,
       registeredAt: Date.now()
@@ -48,7 +50,7 @@ export async function registerTimeAwait(runId, stepName, flowName, config, posit
     resolveAt
   };
 }
-export async function resolveTimeAwait(runId, stepName, flowName, position, timeData) {
+export async function resolveTimeAwait(runId, stepName, flowName, position, _timeData) {
   const logger = useNventLogger("await-time");
   const eventBus = getEventBus();
   logger.info(`Resolving time await`, { runId, stepName });
@@ -58,8 +60,10 @@ export async function resolveTimeAwait(runId, stepName, flowName, position, time
     runId,
     stepName,
     position,
-    triggerData: timeData,
+    triggerData: {},
     data: {
+      position,
+      // Store position in data for database persistence
       resolvedAt: Date.now()
     }
   });

package/dist/runtime/nitro/utils/awaitPatterns/webhook.js

@@ -22,6 +22,9 @@ export async function registerWebhookAwait(runId, stepName, flowName, config, po
   const webhookPath = `/api/_webhook/await${path}`;
   const fullWebhookUrl = `${baseUrl.replace(/\/$/, "")}${webhookPath}`;
   logger.info(`Registering webhook await: ${fullWebhookUrl}`, { runId, stepName });
+  const { useAwaitDefaults } = await import("../useAwait.js");
+  const { webhookTimeout: defaultTimeout, timeoutAction: defaultTimeoutAction } = useAwaitDefaults();
+  const timeoutMs = config.timeout && config.timeout > 0 ? config.timeout : defaultTimeout;
   eventBus.publish({
     type: "await.registered",
     flowName,
@@ -31,62 +34,65 @@ export async function registerWebhookAwait(runId, stepName, flowName, config, po
     position,
     config,
     data: {
+      position,
+      // Store position in data for database persistence
       path,
       method: config.method || "POST",
-      timeout: config.timeout,
+      timeout: timeoutMs,
+      // Store resolved timeout (with default)
       registeredAt: Date.now(),
-      webhookUrl: fullWebhookUrl
+      webhookUrl: fullWebhookUrl,
+      timeoutAction: config.timeoutAction || defaultTimeoutAction
     }
   });
-  if (config.timeout && config.timeout > 0) {
-    const scheduler = useScheduler();
-    const timeoutAt = Date.now() + config.timeout;
-    const jobId = `await-webhook-timeout-${runId}-${stepName}-${position}`;
-    await scheduler.schedule({
-      id: jobId,
-      name: `Webhook Timeout: ${flowName} - ${stepName}`,
-      type: "one-time",
-      executeAt: timeoutAt,
-      handler: async () => {
-        logger.warn("Webhook await timeout", {
-          runId,
-          stepName,
-          flowName,
-          timeout: config.timeout,
-          timeoutAction: config.timeoutAction || "fail"
-        });
-        eventBus.publish({
-          type: "await.timeout",
-          flowName,
-          runId,
-          stepName,
-          position,
-          awaitType: "webhook",
-          timeoutAction: config.timeoutAction || "fail",
-          data: {
-            timeout: config.timeout,
-            registeredAt: Date.now() - (config.timeout || 0),
-            timedOutAt: Date.now()
-          }
-        });
-      },
-      metadata: {
-        component: "await-pattern",
-        awaitType: "webhook",
+  const scheduler = useScheduler();
+  const timeoutAt = Date.now() + timeoutMs;
+  const jobId = `await-webhook-timeout-${runId}-${stepName}-${position}`;
+  await scheduler.schedule({
+    id: jobId,
+    name: `Webhook Timeout: ${flowName} - ${stepName}`,
+    type: "one-time",
+    executeAt: timeoutAt,
+    handler: async () => {
+      logger.warn("Webhook await timeout", {
         runId,
         stepName,
         flowName,
+        timeout: timeoutMs,
+        timeoutAction: config.timeoutAction || "fail"
+      });
+      eventBus.publish({
+        type: "await.timeout",
+        flowName,
+        runId,
+        stepName,
         position,
-        timeout: config.timeout
-      }
-    });
-    logger.debug(`Webhook timeout scheduled`, {
+        awaitType: "webhook",
+        timeoutAction: config.timeoutAction || "fail",
+        data: {
+          timeout: timeoutMs,
+          registeredAt: Date.now() - timeoutMs,
+          timedOutAt: Date.now()
+        }
+      });
+    },
+    metadata: {
+      component: "await-pattern",
+      awaitType: "webhook",
       runId,
       stepName,
-      timeout: config.timeout,
-      timeoutAction: config.timeoutAction
-    });
-  }
+      flowName,
+      position,
+      timeout: timeoutMs
+    }
+  });
+  logger.debug(`Webhook timeout scheduled`, {
+    runId,
+    stepName,
+    timeout: timeoutMs,
+    timeoutAction: config.timeoutAction,
+    isDefault: !config.timeout || config.timeout <= 0
+  });
   logger.debug(`Webhook await registered: ${fullWebhookUrl}`, { runId, stepName });
   return {
     webhookUrl: fullWebhookUrl,
@@ -113,6 +119,8 @@ export async function resolveWebhookAwait(runId, stepName, flowName, position, w
     position,
     triggerData: webhookData,
     data: {
+      position,
+      // Store position in data for database persistence
       resolvedAt: Date.now()
     }
   });

package/dist/runtime/nitro/utils/defineFunction.d.ts

@@ -1,10 +1,3 @@
-import { useFlow, useQueueAdapter } from '#imports';
-import type { RunContext, NodeHandler } from '../worker/node/runner.js';
-export type ExtendedRunContext = RunContext & {
-    provider: ReturnType<typeof useQueueAdapter>;
-    flow: ReturnType<typeof useFlow>;
-    registry: any;
-};
-export type DefineFunction = (handler: (input: any, ctx: ExtendedRunContext) => Promise<any>) => NodeHandler;
-export declare const defineFunction: DefineFunction;
+import type { RunContext, NodeHandler } from '../../worker/node/runner.js';
+export declare const defineFunction: <TInput = any, TOutput = any>(handler: (input: TInput, ctx: RunContext) => Promise<TOutput>) => NodeHandler;
 export default defineFunction;

package/dist/runtime/nitro/utils/defineFunction.js

@@ -1,17 +1,4 @@
-import { $useFunctionRegistry, useFlow, useQueueAdapter } from "#imports";
 export const defineFunction = (handler) => {
-  const wrapped = async (input, ctx) => {
-    const provider = useQueueAdapter();
-    const flow = ctx.flow || useFlow();
-    const registry = $useFunctionRegistry();
-    const extended = {
-      ...ctx,
-      provider,
-      flow,
-      registry
-    };
-    return handler(input, extended);
-  };
-  return wrapped;
+  return handler;
 };
 export default defineFunction;