nvent 0.4.4 → 0.5.0

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

@@ -0,0 +1,102 @@
+import { useEventManager, useFlow, useRuntimeConfig, useStateAdapter } from "#imports";
+const defaultState = {
+  async get() {
+    return null;
+  },
+  async set() {
+  },
+  async delete() {
+  }
+};
+function scopeKey(baseKey, flowId) {
+  if (!flowId) return baseKey;
+  return `flow:${flowId}:${baseKey}`;
+}
+export function useRunContext(partial) {
+  const state = partial?.state || (() => {
+    try {
+      const stateAdapter = useStateAdapter();
+      const rc = useRuntimeConfig();
+      const cleanupCfg = rc?.nvent?.state?.cleanup || { strategy: "never" };
+      return {
+        async get(key) {
+          return stateAdapter.get(scopeKey(key, partial?.flowId));
+        },
+        async set(key, value, opts) {
+          const ttl = opts?.ttl ?? (cleanupCfg?.strategy === "ttl" ? cleanupCfg?.ttlMs : void 0);
+          return stateAdapter.set(scopeKey(key, partial?.flowId), value, ttl ? { ttl } : void 0);
+        },
+        async delete(key) {
+          return stateAdapter.delete(scopeKey(key, partial?.flowId));
+        }
+      };
+    } catch {
+      return defaultState;
+    }
+  })();
+  const logger = partial?.logger || (() => {
+    const eventManager = useEventManager();
+    return {
+      log: (level, msg, meta) => {
+        const runId = partial?.flowId || "unknown";
+        const flowName = meta?.flowName || partial?.flowName || "unknown";
+        void eventManager.publishBus({
+          type: "log",
+          runId,
+          flowName,
+          stepName: meta?.stepName || partial?.stepName,
+          stepId: meta?.stepId,
+          attempt: meta?.attempt,
+          data: { level, message: msg, ...meta }
+        });
+      }
+    };
+  })();
+  const baseFlowEngine = useFlow();
+  const flow = {
+    ...baseFlowEngine,
+    emit: async (trigger, payload = {}) => {
+      const enrichedPayload = {
+        ...payload,
+        flowId: payload.flowId || partial?.flowId,
+        flowName: payload.flowName || partial?.flowName,
+        stepName: payload.stepName || partial?.stepName
+      };
+      return baseFlowEngine.emit(trigger, enrichedPayload);
+    },
+    cancel: async () => {
+      if (!partial?.flowName || !partial?.flowId) {
+        throw new Error("Cannot cancel flow: flowName or flowId not available in context");
+      }
+      return baseFlowEngine.cancelFlow(partial.flowName, partial.flowId);
+    },
+    isRunning: async (flowName, runId) => {
+      const targetFlowName = flowName || partial?.flowName;
+      if (!targetFlowName) {
+        throw new Error("flowName is required to check if flow is running");
+      }
+      return baseFlowEngine.isRunning(targetFlowName, runId);
+    },
+    getRunningFlows: async (flowName) => {
+      const targetFlowName = flowName || partial?.flowName;
+      if (!targetFlowName) {
+        throw new Error("flowName is required to get running flows");
+      }
+      return baseFlowEngine.getRunningFlows(targetFlowName);
+    }
+  };
+  return {
+    jobId: partial?.jobId,
+    queue: partial?.queue,
+    flowId: partial?.flowId,
+    flowName: partial?.flowName,
+    stepName: partial?.stepName,
+    stepId: partial?.stepId,
+    attempt: partial?.attempt,
+    logger,
+    state,
+    flow,
+    trigger: partial?.trigger,
+    awaitConfig: partial?.awaitConfig
+  };
+}

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

@@ -0,0 +1,83 @@
+export declare function useStreamTopics(): {
+    StoreSubjects: {
+        /**
+         * Flow run event stream
+         * Pattern: {prefix}:flow:run:{runId}
+         * Type: Redis Stream (XADD/XRANGE)
+         * Contains: All events for a specific flow run
+         */
+        readonly flowRun: (runId: string) => string;
+        /**
+         * Flow runs index (sorted set)
+         * Pattern: {prefix}:flow:runs:{flowName}
+         * Type: Sorted Set + Hash metadata
+         * Contains: List of run IDs for a flow, sorted by timestamp
+         */
+        readonly flowRunIndex: (flowName: string) => string;
+        /**
+         * Flows index (sorted set)
+         * Pattern: {prefix}:flows
+         * Type: Sorted Set + Hash metadata
+         * Contains: Flow metadata and statistics
+         */
+        readonly flowIndex: () => string;
+        /**
+         * Trigger event stream
+         * Pattern: {prefix}:trigger:event:{triggerName}
+         * Type: Redis Stream (XADD/XRANGE)
+         * Contains: All events for a specific trigger
+         */
+        readonly triggerStream: (triggerName: string) => string;
+        /**
+         * Triggers index (sorted set)
+         * Pattern: {prefix}:triggers
+         * Type: Sorted Set + Hash metadata
+         * Contains: Trigger metadata, subscriptions, and statistics
+         */
+        readonly triggerIndex: () => string;
+        /**
+         * Scheduler job index
+         * Pattern: {prefix}:scheduler:jobs
+         * Type: Sorted Set + Hash metadata
+         * Contains: Scheduled job metadata
+         */
+        readonly schedulerJobs: () => string;
+        /**
+         * Scheduler lock index
+         * Pattern: {prefix}:scheduler:locks
+         * Type: Sorted Set + Hash metadata
+         * Contains: Distributed scheduler lock metadata
+         */
+        readonly schedulerLocks: () => string;
+    };
+    StreamTopics: {
+        /**
+         * Flow events for a specific run
+         * Pattern: {prefix}:stream:flow:events:{runId}
+         * Published: When flow events occur (StreamWiring)
+         * Subscribed: By WebSocket clients watching a specific flow run
+         */
+        readonly flowEvents: (runId: string) => string;
+        /**
+         * Flow statistics updates
+         * Pattern: {prefix}:stream:flow:stats
+         * Published: When flow stats change (StreamWiring)
+         * Subscribed: By WebSocket clients watching flow overview
+         */
+        readonly flowStats: () => string;
+        /**
+         * Trigger events for a specific trigger
+         * Pattern: {prefix}:stream:trigger:events:{triggerName}
+         * Published: When trigger events occur (StreamWiring)
+         * Subscribed: By WebSocket clients watching a specific trigger
+         */
+        readonly triggerEvents: (triggerName: string) => string;
+        /**
+         * Trigger statistics updates
+         * Pattern: {prefix}:stream:trigger:stats
+         * Published: When trigger stats change (StreamWiring)
+         * Subscribed: By WebSocket clients watching trigger overview
+         */
+        readonly triggerStats: () => string;
+    };
+};

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

@@ -0,0 +1,94 @@
+import { useRuntimeConfig } from "#imports";
+function getStoreSubjects(prefix) {
+  return {
+    /**
+     * Flow run event stream
+     * Pattern: {prefix}:flow:run:{runId}
+     * Type: Redis Stream (XADD/XRANGE)
+     * Contains: All events for a specific flow run
+     */
+    flowRun: (runId) => `${prefix}:flow:run:${runId}`,
+    /**
+     * Flow runs index (sorted set)
+     * Pattern: {prefix}:flow:runs:{flowName}
+     * Type: Sorted Set + Hash metadata
+     * Contains: List of run IDs for a flow, sorted by timestamp
+     */
+    flowRunIndex: (flowName) => `${prefix}:flow:runs:${flowName}`,
+    /**
+     * Flows index (sorted set)
+     * Pattern: {prefix}:flows
+     * Type: Sorted Set + Hash metadata
+     * Contains: Flow metadata and statistics
+     */
+    flowIndex: () => `${prefix}:flows`,
+    /**
+     * Trigger event stream
+     * Pattern: {prefix}:trigger:event:{triggerName}
+     * Type: Redis Stream (XADD/XRANGE)
+     * Contains: All events for a specific trigger
+     */
+    triggerStream: (triggerName) => `${prefix}:trigger:event:${triggerName}`,
+    /**
+     * Triggers index (sorted set)
+     * Pattern: {prefix}:triggers
+     * Type: Sorted Set + Hash metadata
+     * Contains: Trigger metadata, subscriptions, and statistics
+     */
+    triggerIndex: () => `${prefix}:triggers`,
+    /**
+     * Scheduler job index
+     * Pattern: {prefix}:scheduler:jobs
+     * Type: Sorted Set + Hash metadata
+     * Contains: Scheduled job metadata
+     */
+    schedulerJobs: () => `${prefix}:scheduler:jobs`,
+    /**
+     * Scheduler lock index
+     * Pattern: {prefix}:scheduler:locks
+     * Type: Sorted Set + Hash metadata
+     * Contains: Distributed scheduler lock metadata
+     */
+    schedulerLocks: () => `${prefix}:scheduler:locks`
+  };
+}
+function getStreamTopics(prefix) {
+  return {
+    /**
+     * Flow events for a specific run
+     * Pattern: {prefix}:stream:flow:events:{runId}
+     * Published: When flow events occur (StreamWiring)
+     * Subscribed: By WebSocket clients watching a specific flow run
+     */
+    flowEvents: (runId) => `${prefix}:stream:flow:events:${runId}`,
+    /**
+     * Flow statistics updates
+     * Pattern: {prefix}:stream:flow:stats
+     * Published: When flow stats change (StreamWiring)
+     * Subscribed: By WebSocket clients watching flow overview
+     */
+    flowStats: () => `${prefix}:stream:flow:stats`,
+    /**
+     * Trigger events for a specific trigger
+     * Pattern: {prefix}:stream:trigger:events:{triggerName}
+     * Published: When trigger events occur (StreamWiring)
+     * Subscribed: By WebSocket clients watching a specific trigger
+     */
+    triggerEvents: (triggerName) => `${prefix}:stream:trigger:events:${triggerName}`,
+    /**
+     * Trigger statistics updates
+     * Pattern: {prefix}:stream:trigger:stats
+     * Published: When trigger stats change (StreamWiring)
+     * Subscribed: By WebSocket clients watching trigger overview
+     */
+    triggerStats: () => `${prefix}:stream:trigger:stats`
+  };
+}
+export function useStreamTopics() {
+  const config = useRuntimeConfig();
+  const prefix = config.nvent.store?.prefix || "nvent";
+  return {
+    StoreSubjects: getStoreSubjects(prefix),
+    StreamTopics: getStreamTopics(prefix)
+  };
+}

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

@@ -0,0 +1,150 @@
+import type { TriggerEntry, TriggerSubscription } from '../../../registry/types.js';
+/**
+ * Public export for resolving payload references
+ * Allows external code to resolve references if needed
+ */
+export declare function resolvePayload(data: any): Promise<any>;
+export interface RegisterTriggerOptions {
+    name: string;
+    type: 'event' | 'webhook' | 'schedule' | 'manual';
+    scope: 'flow' | 'run';
+    status?: 'active' | 'inactive' | 'retired';
+    displayName?: string;
+    description?: string;
+    source?: string;
+    expectedSubscribers?: string[];
+    webhook?: {
+        path: string;
+        method?: string;
+        auth?: any;
+    };
+    schedule?: {
+        cron: string;
+        timezone?: string;
+        enabled?: boolean;
+    };
+    schema?: any;
+    transform?: (data: any) => any;
+    config?: {
+        persistData?: boolean;
+        payloadThreshold?: number;
+        retentionDays?: number;
+        rateLimit?: {
+            max: number;
+            window: number;
+        };
+    };
+}
+export interface SubscribeTriggerOptions {
+    trigger: string;
+    flow: string;
+    mode?: 'auto' | 'manual';
+    filter?: (data: any) => boolean;
+    transform?: (data: any) => any;
+}
+/**
+ * Core trigger composable
+ * Provides runtime API for trigger registration and emission
+ */
+export declare function useTrigger(): {
+    /**
+     * Register a trigger (programmatic)
+     * Publishes event to bus - triggerWiring handles persistence and orchestration
+     */
+    registerTrigger(opts: RegisterTriggerOptions): Promise<void>;
+    /**
+     * Subscribe flow to trigger (programmatic)
+     * Publishes event to bus - triggerWiring handles persistence and orchestration
+     */
+    subscribeTrigger(opts: SubscribeTriggerOptions): Promise<void>;
+    /**
+     * Unsubscribe flow from trigger
+     * Publishes event to bus - triggerWiring handles persistence and orchestration
+     */
+    unsubscribeTrigger(trigger: string, flow: string): Promise<void>;
+    /**
+     * Emit trigger (fire event)
+     * Publishes event to bus - triggerWiring handles persistence, stats, and orchestration
+     *
+     * Large payloads are automatically stored in KV store and replaced with references
+     * to keep stream events small and memory-efficient.
+     */
+    emitTrigger(name: string, data: any, opts?: {
+        payloadThreshold?: number;
+    }): Promise<void>;
+    /**
+     * Query methods
+     */
+    /**
+     * Check if a trigger exists in the registry
+     */
+    hasTrigger(name: string): boolean;
+    /**
+     * Get trigger entry by name
+     */
+    getTrigger(name: string): TriggerEntry | undefined;
+    /**
+     * Get all registered triggers
+     * @param options - Sorting and pagination options
+     * @param options.sortBy - Field to sort by
+     * @param options.order - Sort order (asc or desc)
+     * @param options.limit - Maximum number of results
+     * @param options.offset - Number of results to skip
+     */
+    getAllTriggers(options?: {
+        sortBy?: "registeredAt" | "lastActivityAt" | "name";
+        order?: "asc" | "desc";
+        limit?: number;
+        offset?: number;
+    }): TriggerEntry[];
+    /**
+     * Get all flows subscribed to a specific trigger
+     */
+    getSubscribedFlows(trigger: string): string[];
+    /**
+     * Get all triggers that a flow is subscribed to
+     */
+    getFlowTriggers(flow: string): string[];
+    /**
+     * Get subscription details for a specific trigger-flow pair
+     */
+    getSubscription(trigger: string, flow: string): TriggerSubscription | undefined;
+    getAllSubscriptions(): TriggerSubscription[];
+    /**
+     * Initialize runtime from store (called on startup)
+     * Uses index + stream architecture (v0.5.1)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get runtime state (for debugging)
+     */
+    getRuntime(): {
+        triggerCount: number;
+        subscriptionCount: number;
+        flowCount: number;
+        initialized: boolean;
+    };
+    /**
+     * Delete a trigger completely (removes all data)
+     * Publishes event to bus - triggerWiring handles persistence and orchestration
+     */
+    deleteTrigger(name: string): Promise<void>;
+    /**
+     * Update trigger status (active/inactive/retired)
+     * For future status management UI
+     */
+    updateTriggerStatus(name: string, status: "active" | "inactive" | "retired"): Promise<void>;
+    /**
+     * Get trigger statistics
+     * v0.5.1: New analytics method
+     */
+    getTriggerStats(name: string): Promise<any>;
+    /**
+     * Get trigger history from stream
+     * v0.5.1: New analytics method
+     */
+    getTriggerHistory(name: string, opts?: {
+        limit?: number;
+        types?: string[];
+    }): Promise<any>;
+};