nvent 0.4.4 → 0.5.0

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

@@ -0,0 +1,412 @@
+import { getEventBus } from "../eventBus.js";
+import { useTrigger, useNventLogger, useStoreAdapter, useQueueAdapter, $useAnalyzedFlows, $useFunctionRegistry, useStreamTopics } from "#imports";
+import { getTriggerRuntime } from "../utils/triggerRuntime.js";
+import { scheduleTrigger, unscheduleTrigger } from "../utils/scheduleTrigger.js";
+export function createTriggerWiring() {
+  const unsubs = [];
+  let wired = false;
+  async function start() {
+    if (wired) return;
+    wired = true;
+    const logger = useNventLogger("trigger-wiring");
+    const eventBus = getEventBus();
+    const trigger = useTrigger();
+    const store = useStoreAdapter();
+    const { StoreSubjects } = useStreamTopics();
+    const runtime = getTriggerRuntime(store, logger);
+    await trigger.initialize();
+    logger.info("Setting up trigger event wiring");
+    const handlePersistence = async (e) => {
+      try {
+        if (e.id && e.ts) {
+          return;
+        }
+        const triggerName = e.triggerName || e.data?.triggerName;
+        if (!triggerName) {
+          return;
+        }
+        const streamName = StoreSubjects.triggerStream(triggerName);
+        if (!e.type) {
+          logger.error("Event missing type field", { event: e });
+          return;
+        }
+        const eventData = {
+          type: e.type,
+          triggerName,
+          data: e.data
+        };
+        const persistedEvent = await store.stream.append(streamName, eventData);
+        await eventBus.publish(persistedEvent);
+        logger.debug("Stored trigger event", {
+          type: e.type,
+          triggerName,
+          id: persistedEvent.id
+        });
+      } catch (err) {
+        logger.error("ERROR persisting trigger event", {
+          type: e.type,
+          triggerName: e.triggerName,
+          error: err?.message
+        });
+      }
+    };
+    const handleOrchestration = async (e) => {
+      try {
+        if (e.id && e.ts) {
+          return;
+        }
+        const triggerName = e.triggerName || e.data?.triggerName;
+        if (!triggerName) {
+          logger.debug("Orchestration skipped - no triggerName", { type: e.type });
+          return;
+        }
+        logger.debug("Processing trigger orchestration", { type: e.type, triggerName });
+        const indexKey = StoreSubjects.triggerIndex();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const nowTimestamp = Date.now();
+        if (e.type === "trigger.registered") {
+          const data = e.data;
+          if (store.index.add) {
+            await store.index.add(indexKey, triggerName, nowTimestamp, {
+              "name": data.name,
+              "type": data.type,
+              "scope": data.scope,
+              "status": "active",
+              "displayName": data.displayName,
+              "description": data.description,
+              "source": data.source || "programmatic",
+              "registeredAt": now,
+              "registeredBy": "runtime",
+              "lastActivityAt": now,
+              "stats.totalFires": 0,
+              "stats.totalFlowsStarted": 0,
+              "stats.activeSubscribers": 0,
+              "webhook": data.webhook,
+              "schedule": data.schedule,
+              "config": data.config,
+              "version": 1
+            });
+          }
+          const entry = {
+            name: data.name,
+            type: data.type,
+            scope: data.scope,
+            status: "active",
+            displayName: data.displayName,
+            description: data.description,
+            source: data.source || "programmatic",
+            registeredAt: now,
+            registeredBy: "runtime",
+            lastActivityAt: now,
+            subscriptions: {},
+            stats: { totalFires: 0, totalFlowsStarted: 0, activeSubscribers: 0 },
+            webhook: data.webhook,
+            schedule: data.schedule,
+            config: data.config,
+            version: 1
+          };
+          runtime.addTrigger(triggerName, entry);
+          logger.info("Registered trigger in index", { triggerName });
+          if (data.type === "schedule" && data.schedule) {
+            await scheduleTrigger(triggerName, data.schedule, data.status || "active");
+          }
+        }
+        if (e.type === "trigger.updated") {
+          const data = e.data;
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(indexKey, triggerName, {
+              type: data.type,
+              scope: data.scope,
+              status: data.status,
+              displayName: data.displayName,
+              description: data.description,
+              webhook: data.webhook,
+              schedule: data.schedule,
+              config: data.config,
+              lastActivityAt: now
+            });
+          }
+          const existing = runtime.getTrigger(triggerName);
+          if (existing) {
+            const updated = {
+              ...existing,
+              status: data.status !== void 0 ? data.status : existing.status,
+              displayName: data.displayName !== void 0 ? data.displayName : existing.displayName,
+              description: data.description !== void 0 ? data.description : existing.description,
+              webhook: data.webhook !== void 0 ? data.webhook : existing.webhook,
+              schedule: data.schedule !== void 0 ? data.schedule : existing.schedule,
+              config: data.config !== void 0 ? data.config : existing.config,
+              lastActivityAt: now
+            };
+            runtime.addTrigger(triggerName, updated);
+            if (updated.type === "schedule" && updated.schedule) {
+              await scheduleTrigger(triggerName, updated.schedule, updated.status);
+            }
+          }
+          logger.info("Updated trigger in index and runtime", { triggerName, status: data.status });
+        }
+        if (e.type === "subscription.added") {
+          const data = e.data;
+          const { flow, mode } = data;
+          const existingSub = runtime.getSubscription(triggerName, flow);
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(indexKey, triggerName, {
+              subscriptions: {
+                [flow]: {
+                  mode,
+                  subscribedAt: existingSub ? existingSub.registeredAt || now : now
+                }
+              },
+              lastActivityAt: now
+            });
+            if (!existingSub && store.index.increment) {
+              await store.index.increment(indexKey, triggerName, "stats.activeSubscribers", 1);
+            }
+          }
+          const subscription = {
+            triggerName,
+            flowName: flow,
+            mode,
+            source: "programmatic",
+            registeredAt: existingSub?.registeredAt || now
+          };
+          runtime.addSubscription(triggerName, flow, subscription);
+          logger.info(`Subscription ${existingSub ? "updated" : "added"}`, { triggerName, flow, mode });
+        }
+        if (e.type === "subscription.removed") {
+          const data = e.data;
+          const { flow } = data;
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(indexKey, triggerName, {
+              subscriptions: {
+                [flow]: null
+                // null removes the field
+              },
+              lastActivityAt: now
+            });
+            if (store.index.increment) {
+              await store.index.increment(indexKey, triggerName, "stats.activeSubscribers", -1);
+            }
+          }
+          runtime.removeSubscription(triggerName, flow);
+          logger.info("Subscription removed", { triggerName, flow });
+        }
+        if (e.type === "trigger.fired") {
+          const flowsStarted = await handleTriggerFired(e);
+          if (flowsStarted.length > 0 && store.index.increment) {
+            await store.index.increment(indexKey, triggerName, "stats.totalFlowsStarted", flowsStarted.length);
+          }
+          logger.debug("Trigger fired and processed", { triggerName, flowsStarted: flowsStarted.length });
+        }
+        if (e.type === "trigger.deleted") {
+          const triggerEntry = runtime.getTrigger(triggerName);
+          const wasScheduleTrigger = triggerEntry?.type === "schedule";
+          if (store.index.delete) {
+            await store.index.delete(indexKey, triggerName);
+          }
+          const triggerStreamKey = StoreSubjects.triggerStream(triggerName);
+          if (store.stream.delete) {
+            await store.stream.delete(triggerStreamKey);
+          }
+          runtime.removeTrigger(triggerName);
+          if (wasScheduleTrigger) {
+            await unscheduleTrigger(triggerName);
+          }
+          logger.info("Trigger deleted completely", { triggerName });
+        }
+      } catch (err) {
+        logger.error("ERROR in trigger orchestration", {
+          type: e.type,
+          triggerName: e.triggerName,
+          error: err?.message,
+          stack: err?.stack
+        });
+      }
+    };
+    const handleTriggerStats = async (e) => {
+      try {
+        if (!e.id || !e.ts) {
+          return;
+        }
+        const triggerName = e.triggerName || e.data?.triggerName;
+        if (!triggerName) return;
+        const indexKey = StoreSubjects.triggerIndex();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        if (e.type === "trigger.fired") {
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(indexKey, triggerName, {
+              stats: {
+                lastFiredAt: now
+              },
+              lastActivityAt: now
+            });
+          }
+          if (store.index.increment) {
+            await store.index.increment(indexKey, triggerName, "stats.totalFires", 1);
+          }
+          logger.debug("Updated trigger stats for fire", { triggerName });
+        }
+        try {
+          if (store.index.get) {
+            const indexEntry = await store.index.get(indexKey, triggerName);
+            if (indexEntry) {
+              await eventBus.publish({
+                type: "trigger.stats.updated",
+                triggerName,
+                id: indexEntry.id,
+                metadata: indexEntry.metadata,
+                ts: Date.now()
+              });
+              logger.debug("Published trigger stats update event to bus", { triggerName });
+            }
+          }
+        } catch (err) {
+          logger.warn("Failed to publish trigger stats update event", {
+            triggerName,
+            error: err?.message
+          });
+        }
+      } catch (err) {
+        logger.warn("Failed to update trigger stats", {
+          type: e.type,
+          triggerName: e.triggerName,
+          error: err?.message
+        });
+      }
+    };
+    const eventTypes = [
+      "trigger.registered",
+      "trigger.updated",
+      "trigger.deleted",
+      "trigger.fired",
+      "subscription.added",
+      "subscription.removed"
+    ];
+    const triggerStatsEventTypes = ["trigger.fired"];
+    for (const type of eventTypes) {
+      unsubs.push(eventBus.onType(type, handlePersistence));
+    }
+    for (const type of eventTypes) {
+      unsubs.push(eventBus.onType(type, handleOrchestration));
+    }
+    for (const type of triggerStatsEventTypes) {
+      unsubs.push(eventBus.onType(type, handleTriggerStats));
+    }
+    logger.info("Trigger event wiring setup complete (persistence + orchestration + stats)");
+  }
+  function stop() {
+    const logger = useNventLogger("trigger-wiring");
+    for (const u of unsubs.splice(0)) {
+      try {
+        u();
+      } catch {
+      }
+    }
+    wired = false;
+    logger.debug("Trigger wiring stopped");
+  }
+  return { start, stop };
+}
+export async function handleTriggerFired(event) {
+  const logger = useNventLogger("trigger-wiring");
+  const trigger = useTrigger();
+  const { triggerName, data } = event;
+  logger.debug("Trigger fired", { trigger: triggerName });
+  const subscriptions = trigger.getAllSubscriptions().filter((sub) => sub.triggerName === triggerName);
+  if (subscriptions.length === 0) {
+    logger.warn(`No flows subscribed to trigger: ${triggerName}`);
+    return [];
+  }
+  const flowsStarted = [];
+  const store = useStoreAdapter();
+  const loggerForRuntime = useNventLogger("trigger-runtime");
+  const runtime = getTriggerRuntime(store, loggerForRuntime);
+  const resolvedData = await runtime.resolvePayload(data);
+  for (const subscription of subscriptions) {
+    try {
+      if (subscription.mode === "manual") {
+        logger.info(
+          `Trigger '${triggerName}' fired for flow '${subscription.flowName}' (manual mode - awaiting manual start)`
+        );
+        continue;
+      }
+      await startFlowFromTrigger(subscription.flowName, triggerName, resolvedData);
+      flowsStarted.push(subscription.flowName);
+    } catch (error) {
+      logger.error("Error starting flow from trigger", {
+        flow: subscription.flowName,
+        trigger: triggerName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return flowsStarted;
+}
+export async function startFlowFromTrigger(flowName, triggerName, triggerData) {
+  const logger = useNventLogger("trigger-wiring");
+  const eventBus = getEventBus();
+  const queue = useQueueAdapter();
+  const registry = $useFunctionRegistry();
+  const analyzedFlows = $useAnalyzedFlows();
+  const store = useStoreAdapter();
+  const triggerRuntime = getTriggerRuntime(store, logger);
+  const flowDef = analyzedFlows.find((f) => f.id === flowName);
+  if (!flowDef || !flowDef.entry) {
+    logger.error(`Flow '${flowName}' not found or has no entry point`);
+    return;
+  }
+  const flowRegistry = (registry?.flows || {})[flowName];
+  if (!flowRegistry?.entry) {
+    logger.error(`Flow '${flowName}' has no entry in registry`);
+    return;
+  }
+  const triggerDef = triggerRuntime.getTrigger(triggerName);
+  const triggerType = triggerDef?.type || "manual";
+  const runId = `${flowName}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  logger.info(`Starting flow '${flowName}' from trigger '${triggerName}'`, { runId });
+  const queueName = flowRegistry.entry.queue;
+  const stepName = flowRegistry.entry.step;
+  const payload = {
+    flowId: runId,
+    flowName,
+    trigger: {
+      name: triggerName,
+      type: triggerType,
+      data: triggerData
+    },
+    ...triggerData
+  };
+  const entryWorker = registry?.workers?.find(
+    (w) => w?.flow?.step === stepName && w?.queue?.name === queueName
+  );
+  const defaultOpts = entryWorker?.queue?.defaultJobOptions || {};
+  const jobId = `${runId}__${stepName}`;
+  const opts = { ...defaultOpts, jobId };
+  try {
+    await queue.enqueue(queueName, {
+      name: stepName,
+      data: payload,
+      opts
+    });
+    logger.info(`Enqueued entry step '${stepName}' to queue '${queueName}'`, { runId });
+    await eventBus.publish({
+      type: "flow.start",
+      flowName,
+      runId,
+      data: {
+        input: triggerData,
+        trigger: {
+          name: triggerName,
+          type: triggerType,
+          data: triggerData
+        }
+      }
+    });
+  } catch (error) {
+    logger.error("Failed to start flow from trigger", {
+      flowName,
+      trigger: triggerName,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}

package/dist/runtime/nitro/plugins/00.adapters.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapter Initialization Plugin (v0.4.1)
+ *
+ * Initializes the three-adapter architecture with new config format:
+ * - QueueAdapter: Job queue operations (from config.queue)
+ * - StreamAdapter: Cross-instance pub/sub messaging (from config.stream)
+ * - StoreAdapter: Storage - events, documents, KV, indices (from config.store)
+ *
+ * Uses normalized config with connection fallback from connections.*
+ *
+ * External adapters can register themselves via the nvent:registerAdapter Nitro hook
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/nitro/plugins/00.adapters.js

@@ -0,0 +1,73 @@
+import { defineNitroPlugin, useRuntimeConfig, useNventLogger, setAdapters, initializeScheduler, shutdownScheduler } from "#imports";
+import { createAdapters, shutdownAdapters } from "../../adapters/factory.js";
+import { useAdapterRegistry } from "../../adapters/registry.js";
+import { createWiringRegistry } from "../../events/wiring/registry.js";
+export default defineNitroPlugin(async (nitroApp) => {
+  const logger = useNventLogger("adapters-plugin");
+  const runtimeConfig = useRuntimeConfig();
+  const config = runtimeConfig.nvent;
+  if (!config) {
+    logger.error("No nvent config found in runtime config");
+    throw new Error("Missing nvent configuration");
+  }
+  logger.info("Initializing adapters", {
+    queue: config.queue?.adapter || "file",
+    stream: config.stream?.adapter || "memory",
+    store: config.store?.adapter || "file"
+  });
+  try {
+    await nitroApp.hooks.callHook("nvent:register-adapters");
+    const registry = useAdapterRegistry();
+    logger.info("Checking registered adapters", {
+      queueAdapters: registry.listQueueAdapters(),
+      streamAdapters: registry.listStreamAdapters(),
+      storeAdapters: registry.listStoreAdapters()
+    });
+    const adapters = await createAdapters({
+      queue: config.queue,
+      stream: config.stream,
+      store: config.store
+    });
+    setAdapters(adapters);
+    logger.info("Adapters initialized successfully", {
+      queueAdapter: config.queue.adapter,
+      streamAdapter: config.stream.adapter,
+      storeAdapter: config.store.adapter
+    });
+    await initializeScheduler(adapters.store);
+    logger.info("Scheduler initialized");
+    const wiring = createWiringRegistry({
+      streamWiring: {
+        enabled: true
+        // Enable for WebSocket support
+      },
+      stateWiring: {
+        // Strategy is read from config by default (queue.store.state.cleanup.strategy)
+        // Can be overridden here if needed
+      }
+    });
+    await wiring.start();
+    logger.info("Flow wiring started");
+    await nitroApp.hooks.callHook("nvent:adapters:ready");
+    return {
+      hooks: {
+        close: async () => {
+          logger.info("Shutting down");
+          try {
+            await wiring.stop();
+            logger.info("Flow wiring stopped");
+            await shutdownScheduler();
+            logger.info("Scheduler shut down");
+            await shutdownAdapters(adapters);
+            logger.info("Adapters shut down successfully");
+          } catch (error) {
+            logger.error("Error during shutdown", { error });
+          }
+        }
+      }
+    };
+  } catch (error) {
+    logger.error("Failed to initialize adapters", { error });
+    throw error;
+  }
+});

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

@@ -0,0 +1,63 @@
+import { defineNitroPlugin, $useWorkerHandlers, $useFunctionRegistry, useQueueAdapter, useHookRegistry } from "#imports";
+import { createJobProcessor } from "../../worker/node/runner.js";
+export default defineNitroPlugin(async (nitroApp) => {
+  nitroApp.hooks.hook("close", async () => {
+    const queueAdapter = useQueueAdapter();
+    await queueAdapter.close();
+  });
+  nitroApp.hooks.hook("nvent:adapters:ready", async () => {
+    const queueAdapter = useQueueAdapter();
+    try {
+      const handlers = $useWorkerHandlers();
+      const registry = $useFunctionRegistry() || { workers: [] };
+      const registeredQueues = /* @__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);
+        let jobName;
+        if (w?.flow?.step) {
+          jobName = Array.isArray(w.flow.step) ? w.flow.step[0] : w.flow.step;
+        } else {
+          jobName = id.includes("/") ? id.split("/").pop() : id;
+        }
+        if (module && w?.flow) {
+          const hooks = {};
+          if (typeof module.onAwaitRegister === "function") {
+            hooks.onAwaitRegister = module.onAwaitRegister;
+          }
+          if (typeof module.onAwaitResolve === "function") {
+            hooks.onAwaitResolve = module.onAwaitResolve;
+          }
+          if (Object.keys(hooks).length > 0) {
+            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) {
+              if (flowName) {
+                hookRegistry.register(flowName, jobName, hooks);
+              }
+            }
+          }
+        }
+        if (typeof handler === "function") {
+          const workerCfg = w && w.worker || {};
+          const queueCfg = w && w.queue || {};
+          const opts = {};
+          if (typeof workerCfg.concurrency === "number") opts.concurrency = workerCfg.concurrency;
+          if (typeof workerCfg.autorun === "boolean") opts.autorun = workerCfg.autorun;
+          if (queueCfg.defaultJobOptions) opts.defaultJobOptions = queueCfg.defaultJobOptions;
+          if (queueCfg.prefix) opts.prefix = queueCfg.prefix;
+          if (queueCfg.limiter) opts.limiter = queueCfg.limiter;
+          const processor = createJobProcessor(handler, queue);
+          queueAdapter.registerWorker(queue, jobName, processor, opts);
+          registeredQueues.add(queue);
+        }
+      }
+      if (queueAdapter.startProcessingQueue) {
+        for (const queueName of Array.from(registeredQueues)) {
+          queueAdapter.startProcessingQueue(queueName);
+        }
+      }
+    } catch {
+    }
+  });
+});

package/dist/runtime/nitro/plugins/03.triggers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Trigger Registration Plugin
+ *
+ * Loads pre-analyzed triggers and subscriptions from build-time registry
+ * and registers them via event bus (trigger.registered events).
+ * The trigger wiring will handle the actual registration logic.
+ *
+ * This plugin is ONLY for registering dev/build-time discovered triggers.
+ * Trigger wiring and event handling is done in the wiring registry.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/nitro/plugins/03.triggers.js

@@ -0,0 +1,55 @@
+import { defineNitroPlugin, $useTriggerRegistry, useNventLogger, useTrigger } from "#imports";
+import { getEventBus } from "../../events/eventBus.js";
+export default defineNitroPlugin(async (nitroApp) => {
+  nitroApp.hooks.hook("nvent:adapters:ready", async () => {
+    const logger = useNventLogger("trigger-registration");
+    const eventBus = getEventBus();
+    const trigger = useTrigger();
+    try {
+      logger.info("Registering build-time triggers...");
+      const triggerRegistry = $useTriggerRegistry();
+      const subscriptions = triggerRegistry?.subscriptions || [];
+      const triggers = triggerRegistry?.triggers || [];
+      logger.info(`Found ${triggers.length} triggers and ${subscriptions.length} subscriptions from build`);
+      let newTriggers = 0;
+      for (const triggerData of triggers) {
+        if (!trigger.hasTrigger(triggerData.name)) {
+          await eventBus.publish({
+            type: "trigger.registered",
+            triggerName: triggerData.name,
+            data: triggerData
+          });
+          newTriggers++;
+        } else {
+          logger.debug(`Trigger '${triggerData.name}' already registered, skipping`);
+        }
+      }
+      let newSubscriptions = 0;
+      for (const sub of subscriptions) {
+        const existing = trigger.getSubscription(sub.triggerName, sub.flowName);
+        if (!existing) {
+          await eventBus.publish({
+            type: "subscription.added",
+            triggerName: sub.triggerName,
+            data: {
+              trigger: sub.triggerName,
+              flow: sub.flowName,
+              mode: sub.mode,
+              source: "build-time"
+            }
+          });
+          newSubscriptions++;
+        } else {
+          logger.debug(`Subscription '${sub.flowName}' -> '${sub.triggerName}' already exists, skipping`);
+        }
+      }
+      logger.info(
+        `Build-time trigger registration complete (${newTriggers} new triggers, ${newSubscriptions} new subscriptions)`
+      );
+    } catch (error) {
+      logger.error("Failed to register build-time triggers", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+});

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

@@ -0,0 +1,23 @@
+/**
+ * Dynamic webhook handler for await patterns
+ * Handles webhook calls and resolves awaiting steps
+ *
+ * Routes:
+ * - POST /api/_webhook/await/{flowName}/{runId}/{stepName}
+ * - GET /api/_webhook/await/{flowName}/{runId}/{stepName}
+ *
+ * Architecture:
+ * 1. Parse URL params to get flowName, runId, stepName
+ * 2. Look up flow in store index to verify it exists and is awaiting
+ * 3. Verify flow status and await configuration
+ * 4. Use useAwait().webhook.resolve() which publishes await.resolved event
+ * 5. Trigger wiring handles the actual flow resumption
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    success: boolean;
+    runId: string;
+    stepName: string;
+    flowName: string;
+    message: string;
+}>>;
+export default _default;