nvent 0.4.5 → 0.5.1

package/dist/runtime/events/utils/triggerRuntime.d.ts

@@ -0,0 +1,58 @@
+import type { TriggerEntry, TriggerSubscription } from '../../../registry/types.js';
+import type { StoreAdapter } from '../../adapters/interfaces/store.js';
+/**
+ * Centralized trigger runtime management
+ * Handles runtime state, payload storage/resolution, and state manipulation
+ *
+ * This class is the single source of truth for trigger runtime state,
+ * used by both useTrigger (public API) and triggerWiring (event orchestration)
+ */
+export declare class TriggerRuntime {
+    private state;
+    private store;
+    private logger;
+    constructor(store: StoreAdapter, logger: any);
+    get initialized(): boolean;
+    setInitialized(value: boolean): void;
+    hasTrigger(name: string): boolean;
+    getTrigger(name: string): TriggerEntry | undefined;
+    getAllTriggers(options?: {
+        sortBy?: 'registeredAt' | 'lastActivityAt' | 'name';
+        order?: 'asc' | 'desc';
+        limit?: number;
+        offset?: number;
+    }): TriggerEntry[];
+    getSubscribedFlows(trigger: string): string[];
+    getFlowTriggers(flow: string): string[];
+    getSubscription(trigger: string, flow: string): TriggerSubscription | undefined;
+    getAllSubscriptions(): TriggerSubscription[];
+    getRuntimeStats(): {
+        triggerCount: number;
+        subscriptionCount: number;
+        flowCount: number;
+        initialized: boolean;
+    };
+    addTrigger(name: string, entry: TriggerEntry): void;
+    removeTrigger(name: string): void;
+    addSubscription(triggerName: string, flowName: string, subscription: TriggerSubscription): void;
+    removeSubscription(triggerName: string, flowName: string): void;
+    /**
+     * Extract a minimal summary from payload for debugging
+     * Keeps only small, identifying fields
+     */
+    private extractSummary;
+    /**
+     * Store large payload in KV store and return reference
+     * Returns either the original data (if small) or a reference object
+     */
+    handleLargePayload(triggerName: string, data: any, threshold: number): Promise<any>;
+    /**
+     * Resolve payload reference if needed
+     * Returns the full payload from KV store, or falls back to summary if expired
+     */
+    resolvePayload(data: any): Promise<any>;
+}
+/**
+ * Get or create the singleton TriggerRuntime instance
+ */
+export declare function getTriggerRuntime(store: StoreAdapter, logger: any): TriggerRuntime;

package/dist/runtime/events/utils/triggerRuntime.js

@@ -0,0 +1,212 @@
+export class TriggerRuntime {
+  state;
+  store;
+  logger;
+  constructor(store, logger) {
+    this.store = store;
+    this.logger = logger;
+    this.state = {
+      triggers: /* @__PURE__ */ new Map(),
+      triggerToFlows: /* @__PURE__ */ new Map(),
+      flowToTriggers: /* @__PURE__ */ new Map(),
+      initialized: false
+    };
+  }
+  // ============================================================================
+  // State Access (Read-only)
+  // ============================================================================
+  get initialized() {
+    return this.state.initialized;
+  }
+  setInitialized(value) {
+    this.state.initialized = value;
+  }
+  hasTrigger(name) {
+    return this.state.triggers.has(name);
+  }
+  getTrigger(name) {
+    return this.state.triggers.get(name);
+  }
+  getAllTriggers(options) {
+    let triggers = Array.from(this.state.triggers.values());
+    if (options?.sortBy) {
+      triggers.sort((a, b) => {
+        const aValue = a[options.sortBy];
+        const bValue = b[options.sortBy];
+        if (aValue === void 0 && bValue === void 0) return 0;
+        if (aValue === void 0) return 1;
+        if (bValue === void 0) return -1;
+        if (typeof aValue === "string" && typeof bValue === "string") {
+          return options.order === "desc" ? bValue.localeCompare(aValue) : aValue.localeCompare(bValue);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return options.order === "desc" ? bValue - aValue : aValue - bValue;
+        }
+        return 0;
+      });
+    }
+    if (options?.offset !== void 0 || options?.limit !== void 0) {
+      const offset = options.offset || 0;
+      const limit = options.limit || triggers.length;
+      triggers = triggers.slice(offset, offset + limit);
+    }
+    return triggers;
+  }
+  getSubscribedFlows(trigger) {
+    const subs = this.state.triggerToFlows.get(trigger) || /* @__PURE__ */ new Set();
+    return Array.from(new Set(Array.from(subs).map((s) => s.flowName)));
+  }
+  getFlowTriggers(flow) {
+    return Array.from(this.state.flowToTriggers.get(flow) || /* @__PURE__ */ new Set());
+  }
+  getSubscription(trigger, flow) {
+    const subs = this.state.triggerToFlows.get(trigger);
+    if (!subs) return void 0;
+    return Array.from(subs).find((s) => s.flowName === flow);
+  }
+  getAllSubscriptions() {
+    const allSubs = [];
+    for (const subs of this.state.triggerToFlows.values()) {
+      allSubs.push(...Array.from(subs));
+    }
+    return allSubs;
+  }
+  getRuntimeStats() {
+    return {
+      triggerCount: this.state.triggers.size,
+      subscriptionCount: Array.from(this.state.triggerToFlows.values()).reduce((acc, subs) => acc + subs.size, 0),
+      flowCount: this.state.flowToTriggers.size,
+      initialized: this.state.initialized
+    };
+  }
+  // ============================================================================
+  // State Manipulation (Internal)
+  // ============================================================================
+  addTrigger(name, entry) {
+    this.state.triggers.set(name, entry);
+  }
+  removeTrigger(name) {
+    this.state.triggers.delete(name);
+    this.state.triggerToFlows.delete(name);
+    for (const [flow, triggers] of this.state.flowToTriggers.entries()) {
+      triggers.delete(name);
+      if (triggers.size === 0) {
+        this.state.flowToTriggers.delete(flow);
+      }
+    }
+  }
+  addSubscription(triggerName, flowName, subscription) {
+    if (!this.state.triggerToFlows.has(triggerName)) {
+      this.state.triggerToFlows.set(triggerName, /* @__PURE__ */ new Set());
+    }
+    const triggerSubs = this.state.triggerToFlows.get(triggerName);
+    const existingSub = Array.from(triggerSubs).find((s) => s.flowName === flowName);
+    if (existingSub) {
+      triggerSubs.delete(existingSub);
+    }
+    triggerSubs.add(subscription);
+    if (!this.state.flowToTriggers.has(flowName)) {
+      this.state.flowToTriggers.set(flowName, /* @__PURE__ */ new Set());
+    }
+    this.state.flowToTriggers.get(flowName).add(triggerName);
+  }
+  removeSubscription(triggerName, flowName) {
+    const triggerSubs = this.state.triggerToFlows.get(triggerName);
+    if (triggerSubs) {
+      const subToRemove = Array.from(triggerSubs).find((s) => s.flowName === flowName);
+      if (subToRemove) {
+        triggerSubs.delete(subToRemove);
+        if (triggerSubs.size === 0) {
+          this.state.triggerToFlows.delete(triggerName);
+        }
+      }
+    }
+    const flowTriggers = this.state.flowToTriggers.get(flowName);
+    if (flowTriggers) {
+      flowTriggers.delete(triggerName);
+      if (flowTriggers.size === 0) {
+        this.state.flowToTriggers.delete(flowName);
+      }
+    }
+  }
+  // ============================================================================
+  // Payload Management
+  // ============================================================================
+  /**
+   * Extract a minimal summary from payload for debugging
+   * Keeps only small, identifying fields
+   */
+  extractSummary(data, maxDepth = 2) {
+    if (maxDepth === 0) return "[nested]";
+    if (Array.isArray(data)) {
+      return {
+        __type: "array",
+        length: data.length,
+        sample: data.length > 0 ? this.extractSummary(data[0], maxDepth - 1) : null
+      };
+    }
+    if (data && typeof data === "object") {
+      const summary = {};
+      for (const [key, val] of Object.entries(data)) {
+        if (typeof val === "string" && val.length > 100) {
+          summary[key] = `${val.slice(0, 100)}... (${val.length} chars)`;
+        } else if (typeof val === "object" && val !== null) {
+          summary[key] = this.extractSummary(val, maxDepth - 1);
+        } else {
+          summary[key] = val;
+        }
+      }
+      return summary;
+    }
+    return data;
+  }
+  /**
+   * Store large payload in KV store and return reference
+   * Returns either the original data (if small) or a reference object
+   */
+  async handleLargePayload(triggerName, data, threshold) {
+    const serialized = JSON.stringify(data);
+    const sizeBytes = new TextEncoder().encode(serialized).length;
+    if (sizeBytes < threshold) {
+      return data;
+    }
+    const payloadId = `payload:${triggerName}:${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const ttl = 7 * 24 * 60 * 60;
+    await this.store.kv.set(payloadId, data, ttl);
+    this.logger.debug("Stored large payload in KV", {
+      triggerName,
+      payloadId,
+      originalSize: sizeBytes,
+      threshold
+    });
+    return {
+      __payloadRef: payloadId,
+      __size: sizeBytes,
+      __summary: this.extractSummary(data)
+    };
+  }
+  /**
+   * Resolve payload reference if needed
+   * Returns the full payload from KV store, or falls back to summary if expired
+   */
+  async resolvePayload(data) {
+    if (data?.__payloadRef) {
+      const payload = await this.store.kv.get(data.__payloadRef);
+      if (!payload) {
+        this.logger.warn("Payload reference expired or not found, using summary", {
+          ref: data.__payloadRef
+        });
+        return data.__summary || {};
+      }
+      return payload;
+    }
+    return data;
+  }
+}
+let instance = null;
+export function getTriggerRuntime(store, logger) {
+  if (!instance) {
+    instance = new TriggerRuntime(store, logger);
+  }
+  return instance;
+}

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

@@ -1,21 +1,27 @@
+import { useStoreAdapter } from '#imports';
 /**
  * Check if all dependencies for a step are met
  * Returns true if all subscriptions have been emitted or completed
  */
 export declare function checkPendingStepTriggers(step: any, emittedEvents: Set<string>, completedSteps: Set<string>): boolean;
+/**
+ * Check all steps in the flow and trigger any that now have all dependencies satisfied
+ * This is called after emit events and step completions
+ */
+export declare function checkAndTriggerPendingSteps(flowName: string, runId: string, store: ReturnType<typeof useStoreAdapter>): Promise<void>;
 /**
  * Analyze flow completion status from events
  * Returns status, step counts, and timestamps
  */
-export declare function analyzeFlowCompletion(flowSteps: Record<string, any>, entryStep: string | undefined, events: any[]): {
-    status: 'running' | 'completed' | 'failed' | 'canceled';
+export declare function analyzeFlowCompletion(flowSteps: Record<string, any>, entryStep: string | undefined, events: any[], entryStepDef?: any): {
+    status: 'running' | 'completed' | 'failed' | 'canceled' | 'awaiting';
     totalSteps: number;
     completedSteps: number;
     startedAt: number;
     completedAt: number;
 };
 /**
- * v0.4 Lean Flow Wiring
+ * Lean Flow Wiring
  *
  * 1. Persists flow events to streams using runId
  * 2. Maintains a sorted set index using projection names for listing runs
@@ -23,6 +29,6 @@ export declare function analyzeFlowCompletion(flowSteps: Record<string, any>, en
  * Events arrive as "ingress" (no id/ts) and are persisted to `nq:flow:{runId}` streams.
  */
 export declare function createFlowWiring(): {
-    start: () => void;
-    stop: () => void;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
 };