nvent 0.5.4 → 0.5.5

package/dist/runtime/worker/system/awaitHandlers.js

@@ -0,0 +1,230 @@
+import { useAwait, useHookRegistry, useNventLogger, $useFunctionRegistry, useEventManager } from "#imports";
+const logger = useNventLogger("system-await-handlers");
+export async function awaitRegisterHandler(job) {
+  const { flowId, flowName, stepName, position, awaitConfig, input } = job.data;
+  logger.info("Handling await registration", {
+    flowId,
+    flowName,
+    stepName,
+    position,
+    awaitType: awaitConfig?.type
+  });
+  try {
+    const { register } = useAwait();
+    const awaitResult = await register(
+      flowId,
+      stepName,
+      flowName,
+      awaitConfig,
+      position
+    );
+    logger.info("Registered await pattern", {
+      flowId,
+      flowName,
+      stepName,
+      position
+    });
+    const hookRegistry = useHookRegistry();
+    const hooks = hookRegistry.load(flowName, stepName);
+    if (hooks?.onAwaitRegister) {
+      try {
+        let hookData = {};
+        if (awaitConfig.type === "webhook" && awaitResult.webhookUrl) {
+          hookData = { webhookUrl: awaitResult.webhookUrl };
+        } else if (awaitConfig.type === "event" && awaitResult.eventName) {
+          hookData = { eventName: awaitResult.eventName };
+        } else if (awaitConfig.type === "schedule" && awaitConfig.cron) {
+          hookData = {
+            cronExpression: awaitConfig.cron,
+            nextOccurrence: awaitResult.nextOccurrence || /* @__PURE__ */ new Date()
+          };
+        } else if (awaitConfig.type === "time" && awaitConfig.delay) {
+          hookData = { delayMs: awaitConfig.delay };
+        }
+        const eventManager = useEventManager();
+        const hookCtx = {
+          flowId,
+          flowName,
+          stepName,
+          awaitType: awaitConfig.type,
+          awaitConfig,
+          position,
+          logger: {
+            log: (level, msg, meta) => {
+              void eventManager.publishBus({
+                type: "log",
+                runId: flowId,
+                flowName,
+                stepName,
+                data: { level, message: msg, ...meta }
+              });
+            }
+          }
+        };
+        await hooks.onAwaitRegister(
+          hookData,
+          input || {},
+          hookCtx
+        );
+        logger.info("onAwaitRegister hook completed", {
+          flowId,
+          flowName,
+          stepName
+        });
+      } catch (err) {
+        logger.error("onAwaitRegister hook failed", {
+          flowId,
+          flowName,
+          stepName,
+          error: err.message
+        });
+      }
+    }
+    return { success: true, awaitResult };
+  } catch (err) {
+    logger.error("Failed to register await", {
+      flowId,
+      flowName,
+      stepName,
+      error: err.message,
+      stack: err.stack
+    });
+    throw err;
+  }
+}
+export async function awaitResolveHandler(job) {
+  const { flowId, flowName, stepName, position, triggerData, input } = job.data;
+  logger.info("Handling await resolution", {
+    flowId,
+    flowName,
+    stepName,
+    position
+  });
+  try {
+    const hookRegistry = useHookRegistry();
+    const hooks = hookRegistry.load(flowName, stepName);
+    if (hooks?.onAwaitResolve) {
+      try {
+        const registry = $useFunctionRegistry();
+        const flowRegistry = (registry?.flows || {})[flowName];
+        const stepMeta = flowRegistry?.steps?.[stepName];
+        const awaitConfig = position === "before" ? stepMeta?.awaitBefore : stepMeta?.awaitAfter;
+        const eventManager = useEventManager();
+        const hookCtx = {
+          flowId,
+          flowName,
+          stepName,
+          awaitType: awaitConfig?.type || "unknown",
+          resolvedData: triggerData,
+          position,
+          logger: {
+            log: (level, msg, meta) => {
+              void eventManager.publishBus({
+                type: "log",
+                runId: flowId,
+                flowName,
+                stepName,
+                data: { level, message: msg, ...meta }
+              });
+            }
+          }
+        };
+        await hooks.onAwaitResolve(
+          triggerData || {},
+          input || {},
+          hookCtx
+        );
+        logger.info("onAwaitResolve hook completed", {
+          flowId,
+          flowName,
+          stepName
+        });
+      } catch (err) {
+        logger.error("onAwaitResolve hook failed", {
+          flowId,
+          flowName,
+          stepName,
+          error: err.message
+        });
+      }
+    }
+    return { success: true };
+  } catch (err) {
+    logger.error("Failed to handle await resolution", {
+      flowId,
+      flowName,
+      stepName,
+      error: err.message,
+      stack: err.stack
+    });
+    throw err;
+  }
+}
+export async function awaitTimeoutHandler(job) {
+  const { flowId, flowName, stepName, position, timeoutAction, input } = job.data;
+  logger.info("Handling await timeout", {
+    flowId,
+    flowName,
+    stepName,
+    position,
+    timeoutAction
+  });
+  try {
+    const hookRegistry = useHookRegistry();
+    const hooks = hookRegistry.load(flowName, stepName);
+    if (hooks?.onAwaitTimeout) {
+      try {
+        const registry = $useFunctionRegistry();
+        const flowRegistry = (registry?.flows || {})[flowName];
+        const stepMeta = flowRegistry?.steps?.[stepName];
+        const awaitConfig = position === "before" ? stepMeta?.awaitBefore : stepMeta?.awaitAfter;
+        const eventManager = useEventManager();
+        const hookCtx = {
+          flowId,
+          flowName,
+          stepName,
+          awaitType: awaitConfig?.type || "unknown",
+          timeoutAction: timeoutAction || "fail",
+          position,
+          logger: {
+            log: (level, msg, meta) => {
+              void eventManager.publishBus({
+                type: "log",
+                runId: flowId,
+                flowName,
+                stepName,
+                data: { level, message: msg, ...meta }
+              });
+            }
+          }
+        };
+        await hooks.onAwaitTimeout(
+          input || {},
+          hookCtx
+        );
+        logger.info("onAwaitTimeout hook completed", {
+          flowId,
+          flowName,
+          stepName
+        });
+      } catch (err) {
+        logger.error("onAwaitTimeout hook failed", {
+          flowId,
+          flowName,
+          stepName,
+          error: err.message
+        });
+      }
+    }
+    return { success: true };
+  } catch (err) {
+    logger.error("Failed to handle await timeout", {
+      flowId,
+      flowName,
+      stepName,
+      error: err.message,
+      stack: err.stack
+    });
+    throw err;
+  }
+}

package/dist/runtime/worker/system/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * System handlers for await lifecycle events
+ * These handlers are registered on each queue that has workers with lifecycle hooks
+ */
+/**
+ * System handler names
+ * These handlers run in the same queue as the step that has hooks
+ */
+export declare const SYSTEM_HANDLERS: {
+    readonly AWAIT_REGISTER: "__nvent_await_register";
+    readonly AWAIT_RESOLVE: "__nvent_await_resolve";
+    readonly AWAIT_TIMEOUT: "__nvent_await_timeout";
+};
+/**
+ * Register system handlers on a specific queue
+ * Allows await lifecycle hooks to run in the same queue as the step
+ */
+export declare function registerSystemHandlersOnQueue(queueName: string, concurrency?: number): void;
+/**
+ * Initialize system workers
+ * Registers internal handlers with the queue adapter
+ * @deprecated System handlers are now registered on each step's queue
+ */
+export declare function initializeSystemWorkers(): Promise<void>;

package/dist/runtime/worker/system/index.js

@@ -0,0 +1,39 @@
+import { useQueueAdapter, useRuntimeConfig, useNventLogger } from "#imports";
+import { awaitRegisterHandler, awaitResolveHandler, awaitTimeoutHandler } from "./awaitHandlers.js";
+const logger = useNventLogger("system-workers");
+export const SYSTEM_HANDLERS = {
+  AWAIT_REGISTER: "__nvent_await_register",
+  AWAIT_RESOLVE: "__nvent_await_resolve",
+  AWAIT_TIMEOUT: "__nvent_await_timeout"
+};
+export function registerSystemHandlersOnQueue(queueName, concurrency) {
+  try {
+    const queue = useQueueAdapter();
+    const config = useRuntimeConfig();
+    const handlerConcurrency = concurrency || config?.nvent?.queue?.systemConcurrency || 5;
+    logger.debug("Registering system handlers on queue", {
+      queue: queueName,
+      concurrency: handlerConcurrency,
+      handlers: Object.values(SYSTEM_HANDLERS)
+    });
+    queue.registerWorker(queueName, SYSTEM_HANDLERS.AWAIT_REGISTER, awaitRegisterHandler, {
+      concurrency: handlerConcurrency
+    });
+    queue.registerWorker(queueName, SYSTEM_HANDLERS.AWAIT_RESOLVE, awaitResolveHandler, {
+      concurrency: handlerConcurrency
+    });
+    queue.registerWorker(queueName, SYSTEM_HANDLERS.AWAIT_TIMEOUT, awaitTimeoutHandler, {
+      concurrency: handlerConcurrency
+    });
+  } catch (err) {
+    logger.error("Failed to register system handlers on queue", {
+      queue: queueName,
+      error: err.message,
+      stack: err.stack
+    });
+    throw err;
+  }
+}
+export async function initializeSystemWorkers() {
+  logger.info("System workers module loaded (handlers registered per-queue)");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "Event-driven workflows for Nuxt",
   "repository": "DevJoghurt/nvent",
   "license": "MIT",