nvent 0.4.5 → 0.5.0

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

@@ -1,6 +1,6 @@
 export interface Wiring {
-    start(): void;
-    stop(): void;
+    start(): void | Promise<void>;
+    stop(): void | Promise<void>;
 }
 export interface WiringRegistryOptions {
     /**

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

@@ -1,6 +1,7 @@
 import { createFlowWiring } from "./flowWiring.js";
 import { createStreamWiring } from "./streamWiring.js";
 import { createStateWiring } from "./stateWiring.js";
+import { createTriggerWiring } from "./triggerWiring.js";
 export function createWiringRegistry(opts) {
   const wirings = [
     // 1. Flow orchestration (persistence, completion tracking, step triggering)
@@ -10,20 +11,21 @@ export function createWiringRegistry(opts) {
       enabled: true
     }),
     // 3. State wiring (automatic state cleanup)
-    createStateWiring(opts?.stateWiring)
-    // Future wirings: triggers, webhooks, etc.
+    createStateWiring(opts?.stateWiring),
+    // 4. Trigger wiring (v0.5: trigger.fired, await.registered, await.resolved)
+    createTriggerWiring()
   ];
   let started = false;
   return {
-    start() {
+    async start() {
       if (started) return;
       started = true;
-      for (const w of wirings) w.start();
+      for (const w of wirings) await w.start();
     },
-    stop() {
+    async stop() {
       for (const w of wirings) {
         try {
-          w.stop();
+          await w.stop();
         } catch {
         }
       }

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

@@ -1,18 +1,22 @@
 /**
- * Stream Wiring - Publish flow events to UI clients via StreamAdapter
+ * Stream Wiring - Bridge event bus to StreamAdapter for real-time UI updates
  *
- * Subscribes to the local event bus (single source of truth) and publishes
- * persisted events to the StreamAdapter for WebSocket/SSE clients.
+ * Architecture:
+ * 1. Event Bus - Single source of truth for all events (in-memory)
+ * 2. StreamWiring - Bridges persisted events to stream topics (this file)
+ * 3. StreamAdapter - Pub/sub for real-time distribution (Redis/Memory)
+ * 4. WebSocket handlers - Subscribe to topics and send to 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
+ * Flow:
+ * Event Bus → StreamWiring → StreamAdapter → WebSocket → UI
  *
- * Benefits:
- * - Single source of truth (event bus)
- * - Easy to debug (no republishing)
- * - Clear separation of concerns
+ * Stream Topics (defined in useStreamTopics):
+ * - stream:flow:events:{runId} - Flow events for specific run
+ * - stream:flow:stats - Flow statistics updates
+ * - stream:trigger:events:{triggerName} - Trigger events
+ * - stream:trigger:stats - Trigger statistics updates
+ *
+ * Only publishes persisted events (with id/ts) to avoid duplicates
  */
 export interface StreamWiringOptions {
     /**

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

@@ -13,14 +13,14 @@ export function createStreamWiring(opts = {}) {
     if (!enabled) return;
     const logger = useNventLogger("stream-wiring");
     const stream = useStreamAdapter();
-    const { getClientFlowTopic } = useStreamTopics();
+    const { StreamTopics } = useStreamTopics();
     logger.info("Starting stream wiring for UI clients");
-    const handleClientMessage = async (e) => {
+    const handleFlowEvent = async (e) => {
       if (!e.id || !e.ts) return;
       const runId = e.runId;
       if (!runId) return;
       try {
-        const topic = getClientFlowTopic(runId);
+        const topic = StreamTopics.flowEvents(runId);
         await stream.publish(topic, {
           type: "flow.event",
           data: {
@@ -39,14 +39,46 @@ export function createStreamWiring(opts = {}) {
           },
           timestamp: Date.now()
         });
-        logger.debug("Published to UI clients", { type: e.type, runId });
+        logger.debug("Published flow event to stream", { type: e.type, runId });
       } catch (err) {
-        logger.error("Failed to publish to UI clients", {
+        logger.error("Failed to publish flow event to stream", {
           error: err?.message
         });
       }
     };
-    const clientEventTypes = [
+    const handleTriggerEvent = async (e) => {
+      if (!e.id || !e.ts) return;
+      const triggerName = e.triggerName;
+      if (!triggerName) return;
+      try {
+        const topic = StreamTopics.triggerEvents(triggerName);
+        await stream.publish(topic, {
+          type: "trigger.event",
+          data: {
+            event: {
+              id: e.id,
+              ts: e.ts,
+              type: e.type,
+              triggerName,
+              data: e.data
+            }
+          },
+          timestamp: Date.now()
+        });
+        logger.debug("Published trigger event to stream", {
+          triggerName,
+          type: e.type,
+          id: e.id
+        });
+      } catch (err) {
+        logger.error("Failed to publish trigger event to stream", {
+          triggerName,
+          type: e.type,
+          error: err?.message
+        });
+      }
+    };
+    const flowEventTypes = [
       "flow.start",
       "flow.completed",
       "flow.failed",
@@ -55,14 +87,59 @@ export function createStreamWiring(opts = {}) {
       "step.completed",
       "step.failed",
       "step.retry",
+      "await.registered",
+      "await.resolved",
+      "await.timeout",
       "log",
-      "emit",
-      "state"
+      "emit"
     ];
-    for (const type of clientEventTypes) {
-      unsubs.push(bus.onType(type, handleClientMessage));
+    const triggerEventTypes = [
+      "trigger.registered",
+      "trigger.updated",
+      "trigger.deleted",
+      "trigger.fired",
+      "subscription.added",
+      "subscription.removed"
+    ];
+    const handleFlowStatsUpdate = async (e) => {
+      try {
+        const topic = StreamTopics.flowStats();
+        await stream.publish(topic, {
+          id: e.flowName,
+          metadata: e.metadata
+        });
+        logger.debug("Published flow stats to stream", { flowName: e.flowName });
+      } catch (err) {
+        logger.error("Failed to publish flow stats to stream", {
+          flowName: e.flowName,
+          error: err?.message
+        });
+      }
+    };
+    const handleTriggerStatsUpdate = async (e) => {
+      try {
+        const topic = StreamTopics.triggerStats();
+        await stream.publish(topic, {
+          id: e.triggerName,
+          metadata: e.metadata
+        });
+        logger.debug("Published trigger stats to stream", { triggerName: e.triggerName });
+      } catch (err) {
+        logger.error("Failed to publish trigger stats to stream", {
+          triggerName: e.triggerName,
+          error: err?.message
+        });
+      }
+    };
+    for (const type of flowEventTypes) {
+      unsubs.push(bus.onType(type, handleFlowEvent));
+    }
+    for (const type of triggerEventTypes) {
+      unsubs.push(bus.onType(type, handleTriggerEvent));
     }
-    logger.info("Stream wiring started - listening for persisted events");
+    unsubs.push(bus.onType("flow.stats.updated", handleFlowStatsUpdate));
+    unsubs.push(bus.onType("trigger.stats.updated", handleTriggerStatsUpdate));
+    logger.info("Stream wiring started - listening for persisted flow and trigger events");
   }
   function stop() {
     const logger = useNventLogger("stream-wiring");

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

@@ -0,0 +1,21 @@
+import type { TriggerFiredEvent } from '../types.js';
+/**
+ * Create trigger event wiring
+ * Listens to trigger.fired events and starts subscribed flows
+ * Handles await.registered and await.resolved events
+ */
+export declare function createTriggerWiring(): {
+    start: () => Promise<void>;
+    stop: () => void;
+};
+/**
+ * Handle trigger.fired event
+ * Starts all subscribed flows (auto mode) or queues them (manual mode)
+ * Returns list of flows that were started for stream metadata
+ */
+export declare function handleTriggerFired(event: TriggerFiredEvent): Promise<string[]>;
+/**
+ * Start a flow from a trigger event
+ * Enqueues the entry step and publishes flow.start event
+ */
+export declare function startFlowFromTrigger(flowName: string, triggerName: string, triggerData: any): Promise<void>;

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/{server → nitro}/plugins/00.adapters.js

@@ -1,4 +1,4 @@
-import { defineNitroPlugin, useRuntimeConfig, useNventLogger, setAdapters } from "#imports";
+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";
@@ -34,7 +34,8 @@ export default defineNitroPlugin(async (nitroApp) => {
       streamAdapter: config.stream.adapter,
       storeAdapter: config.store.adapter
     });
-    await nitroApp.hooks.callHook("nvent:adapters:ready");
+    await initializeScheduler(adapters.store);
+    logger.info("Scheduler initialized");
     const wiring = createWiringRegistry({
       streamWiring: {
         enabled: true
@@ -45,15 +46,18 @@ export default defineNitroPlugin(async (nitroApp) => {
         // Can be overridden here if needed
       }
     });
-    wiring.start();
+    await wiring.start();
     logger.info("Flow wiring started");
+    await nitroApp.hooks.callHook("nvent:adapters:ready");
     return {
       hooks: {
         close: async () => {
           logger.info("Shutting down");
           try {
-            wiring.stop();
+            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) {