nvent 0.5.15 → 1.0.0-alpha.2

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

@@ -1,169 +0,0 @@
-import {
-  registerAwaitPattern,
-  resolveAwaitPattern,
-  registerWebhookAwait,
-  resolveWebhookAwait,
-  registerEventAwait,
-  resolveEventAwait,
-  registerScheduleAwait,
-  resolveScheduleAwait,
-  registerTimeAwait,
-  resolveTimeAwait
-} from "./awaitPatterns/index.js";
-import { useStoreAdapter, useStreamTopics, useNventLogger, useRuntimeConfig } from "#imports";
-export function useAwaitDefaults() {
-  try {
-    const config = useRuntimeConfig();
-    const awaitDefaults = config?.nvent?.flow?.awaitDefaults;
-    return {
-      webhookTimeout: awaitDefaults?.webhookTimeout ?? 24 * 60 * 60 * 1e3,
-      // 24 hours
-      eventTimeout: awaitDefaults?.eventTimeout ?? 24 * 60 * 60 * 1e3,
-      // 24 hours
-      timeTimeout: awaitDefaults?.timeTimeout,
-      // undefined by default
-      scheduleTimeout: awaitDefaults?.scheduleTimeout,
-      // undefined by default
-      timeoutAction: awaitDefaults?.timeoutAction ?? "fail"
-    };
-  } catch {
-    return {
-      webhookTimeout: 24 * 60 * 60 * 1e3,
-      // 24 hours
-      eventTimeout: 24 * 60 * 60 * 1e3,
-      // 24 hours
-      timeTimeout: void 0,
-      scheduleTimeout: void 0,
-      timeoutAction: "fail"
-    };
-  }
-}
-export function useAwait() {
-  const logger = useNventLogger("await");
-  const store = useStoreAdapter();
-  const { StoreSubjects } = useStreamTopics();
-  return {
-    /**
-     * Register an await pattern based on config type
-     * Automatically routes to appropriate implementation
-     */
-    register: registerAwaitPattern,
-    /**
-     * Resolve an await pattern by type
-     */
-    resolve: resolveAwaitPattern,
-    /**
-     * Direct access to specific await pattern implementations
-     */
-    webhook: {
-      register: registerWebhookAwait,
-      resolve: resolveWebhookAwait
-    },
-    event: {
-      register: registerEventAwait,
-      resolve: resolveEventAwait
-    },
-    schedule: {
-      register: registerScheduleAwait,
-      resolve: resolveScheduleAwait
-    },
-    time: {
-      register: registerTimeAwait,
-      resolve: resolveTimeAwait
-    },
-    /**
-     * Query methods for await state
-     */
-    /**
-     * Get await state for a specific flow run and step
-     */
-    async getAwaitState(flowName, runId, stepName) {
-      const indexKey = StoreSubjects.flowRunIndex(flowName);
-      if (!store.index.get) {
-        logger.warn("Store does not support indexGet");
-        return null;
-      }
-      const entry = await store.index.get(indexKey, runId);
-      if (!entry?.metadata) {
-        return null;
-      }
-      const awaitingSteps = entry.metadata.awaitingSteps || {};
-      if (stepName) {
-        const awaitKeyBefore = `${stepName}:before`;
-        const awaitKeyAfter = `${stepName}:after`;
-        const awaitState = awaitingSteps[awaitKeyBefore] || awaitingSteps[awaitKeyAfter] || awaitingSteps[stepName];
-        return awaitState || null;
-      }
-      return awaitingSteps;
-    },
-    /**
-     * Check if a step is currently awaiting
-     */
-    async isAwaiting(flowName, runId, stepName) {
-      const awaitState = await this.getAwaitState(flowName, runId, stepName);
-      return awaitState?.status === "awaiting";
-    },
-    /**
-     * Get all active awaits across all flows
-     */
-    async getAllActiveAwaits(flowName) {
-      const activeAwaits = [];
-      if (!store.index.read) {
-        logger.warn("Store does not support index read");
-        return activeAwaits;
-      }
-      if (flowName) {
-        const indexKey = StoreSubjects.flowRunIndex(flowName);
-        const entries = await store.index.read(indexKey, { limit: 1e3 });
-        for (const entry of entries) {
-          const awaitingSteps = entry.metadata?.awaitingSteps || {};
-          for (const [stepName, awaitState] of Object.entries(awaitingSteps)) {
-            if (awaitState.status === "awaiting") {
-              activeAwaits.push({
-                flowName,
-                runId: entry.id,
-                stepName,
-                awaitType: awaitState.awaitType,
-                position: awaitState.position,
-                registeredAt: awaitState.registeredAt
-              });
-            }
-          }
-        }
-      } else {
-        logger.warn("Scanning all flows not yet implemented - provide flowName parameter");
-      }
-      return activeAwaits;
-    },
-    /**
-     * Get await history for a specific flow run from stream
-     */
-    async getAwaitHistory(runId, opts) {
-      const streamName = StoreSubjects.flowRun(runId);
-      const events = await store.stream.read(streamName, {
-        limit: opts?.limit || 100,
-        types: ["await.registered", "await.resolved", "await.timeout"],
-        order: "desc"
-      });
-      if (opts?.stepName) {
-        return events.filter((e) => e.stepName === opts.stepName);
-      }
-      return events;
-    },
-    /**
-     * Cancel/timeout an active await
-     */
-    async timeoutAwait(flowName, runId, stepName, reason = "Manual timeout") {
-      const indexKey = StoreSubjects.flowRunIndex(flowName);
-      if (store.index.updateWithRetry) {
-        await store.index.updateWithRetry(indexKey, runId, {
-          [`awaitingSteps.${stepName}.status`]: "timeout",
-          [`awaitingSteps.${stepName}.timeoutReason`]: reason,
-          [`awaitingSteps.${stepName}.timeoutAt`]: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        logger.info("Await timed out", { flowName, runId, stepName, reason });
-      }
-      logger.warn("await.timeout event publishing not yet implemented in useAwait");
-    }
-  };
-}

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

@@ -1,15 +0,0 @@
-import { getEventBus } from '../../events/eventBus.js';
-import type { EventRecord } from '../../adapters/interfaces/store.js';
-export interface EventManager {
-    /**
-     * Publish an event directly to the in-proc bus.
-     */
-    publishBus(evt: Partial<EventRecord>): Promise<void>;
-    onType: (type: string, handler: (e: EventRecord) => void) => () => void;
-    subscribeRunId: ReturnType<typeof getEventBus>['subscribeRunId'];
-}
-declare global {
-    var __nq_event_manager: EventManager | undefined;
-}
-export declare function useEventManager(): EventManager;
-export declare function setEventManager(mgr: EventManager): void;

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

@@ -1,26 +0,0 @@
-import { getEventBus } from "../../events/eventBus.js";
-import { useNventLogger } from "#imports";
-export function useEventManager() {
-  if (globalThis.__nq_event_manager) return globalThis.__nq_event_manager;
-  const logger = useNventLogger("event-manager");
-  const bus = getEventBus();
-  const publishBus = async (evt) => {
-    const rec = {
-      ...evt,
-      runId: evt.runId || ""
-    };
-    bus.publish(rec);
-    logger.debug("Published event to bus", { type: rec.type, runId: rec.runId });
-  };
-  const subscribeRunId = (runId, handler) => {
-    return bus.subscribeRunId(runId, handler);
-  };
-  const onType = (type, handler) => {
-    return bus.onType(type, handler);
-  };
-  globalThis.__nq_event_manager = { publishBus, onType, subscribeRunId };
-  return globalThis.__nq_event_manager;
-}
-export function setEventManager(mgr) {
-  globalThis.__nq_event_manager = mgr;
-}

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

@@ -1,66 +0,0 @@
-export interface FlowStats {
-    name: string;
-    displayName?: string;
-    registeredAt: string;
-    lastRunAt?: string;
-    lastCompletedAt?: string;
-    stats: {
-        total: number;
-        success: number;
-        failure: number;
-        cancel: number;
-        running: number;
-        awaiting: number;
-    };
-    version?: number;
-}
-export interface StartFlowResult {
-    id: string;
-    queue: string;
-    step: string;
-    flowId: string;
-}
-export interface CancelFlowResult {
-    success: boolean;
-    runId: string;
-    flowName: string;
-}
-export interface RestartFlowResult {
-    success: boolean;
-    oldRunId: string;
-    newRunId: string;
-    flowName: string;
-}
-export interface RunningFlow {
-    id: string;
-    flowName: string;
-    status: string;
-    startedAt: string | undefined;
-    stepCount: number;
-    completedSteps: number;
-}
-export interface FlowComposable {
-    startFlow: (flowName: string, payload?: any) => Promise<StartFlowResult>;
-    emit: (trigger: string, payload?: any) => Promise<any[]>;
-    cancelFlow: (flowName: string, runId: string) => Promise<CancelFlowResult>;
-    restartFlow: (flowName: string, runId: string) => Promise<RestartFlowResult>;
-    isRunning: (flowName: string, runId?: string, options?: {
-        excludeRunIds?: string[];
-    }) => Promise<boolean>;
-    getRunningFlows: (flowName: string, options?: {
-        excludeRunIds?: string[];
-    }) => Promise<RunningFlow[]>;
-    getFlowStats: (flowName: string) => Promise<FlowStats | null>;
-    getAllFlowStats: (options?: {
-        sortBy?: 'registeredAt' | 'lastRunAt' | 'name';
-        order?: 'asc' | 'desc';
-        limit?: number;
-        offset?: number;
-    }) => Promise<FlowStats[]>;
-    hasFlowStats: (flowName: string) => Promise<boolean>;
-}
-/**
- * Flow composable for managing flows and accessing flow statistics
- * Provides methods for starting, canceling, and querying flows
- */
-export declare function useFlow(): FlowComposable;

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

@@ -1,310 +0,0 @@
-import { $useFunctionRegistry, useQueueAdapter, useEventManager, useStoreAdapter, useNventLogger, useStreamTopics } from "#imports";
-import { randomUUID } from "node:crypto";
-export function useFlow() {
-  const registry = $useFunctionRegistry();
-  const queueAdapter = useQueueAdapter();
-  const eventsManager = useEventManager();
-  const store = useStoreAdapter();
-  const logger = useNventLogger("use-flow");
-  const { StoreSubjects } = useStreamTopics();
-  return {
-    /**
-     * Start a flow with the given payload
-     */
-    async startFlow(flowName, payload = {}) {
-      const flow = registry?.flows?.[flowName];
-      if (!flow || !flow.entry) throw new Error("Flow not found");
-      const queueName = typeof flow.entry.queue === "string" ? flow.entry.queue : flow.entry.queue?.name || flow.entry.queue;
-      const entryWorker = registry?.workers?.find(
-        (w) => w?.flow?.step === flow.entry.step && w?.queue?.name === queueName
-      );
-      const opts = entryWorker?.queue?.defaultJobOptions || {};
-      const flowId = randomUUID();
-      const id = await queueAdapter.enqueue(queueName, {
-        name: flow.entry.step,
-        data: { ...payload, flowId, flowName },
-        opts
-      });
-      try {
-        await eventsManager.publishBus({
-          type: "flow.start",
-          runId: flowId,
-          flowName,
-          data: {
-            input: payload
-          }
-        });
-      } catch {
-      }
-      return { id, queue: queueName, step: flow.entry.step, flowId };
-    },
-    /**
-     * Emit a trigger event for flow coordination
-     */
-    async emit(trigger, payload = {}) {
-      const flowId = payload?.flowId;
-      const flowName = payload?.flowName || "unknown";
-      const stepName = payload?.stepName;
-      if (!flowId) {
-        logger.warn("emit called without flowId, trigger may not work", { trigger });
-      }
-      const { flowId: _, flowName: __, stepName: ___, ...actualPayload } = payload;
-      try {
-        await eventsManager.publishBus({
-          type: "emit",
-          runId: flowId || "unknown",
-          flowName,
-          stepName,
-          data: {
-            name: trigger,
-            payload: actualPayload
-          }
-        });
-      } catch (err) {
-        logger.error("Failed to emit trigger event", { trigger, error: err });
-      }
-      return [];
-    },
-    /**
-     * Cancel a running flow
-     */
-    async cancelFlow(flowName, runId) {
-      try {
-        let previousStatus;
-        try {
-          const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-          const entry = await store.index.get(runIndexKey, runId);
-          previousStatus = entry?.metadata?.status;
-        } catch {
-        }
-        await eventsManager.publishBus({
-          type: "flow.cancel",
-          runId,
-          flowName,
-          data: {
-            canceledAt: (/* @__PURE__ */ new Date()).toISOString(),
-            previousStatus
-            // Include for correct stats counter decrement
-          }
-        });
-        logger.info("Flow canceled", { flowName, runId, previousStatus });
-        return { success: true, runId, flowName };
-      } catch (err) {
-        logger.error("Failed to cancel flow", { flowName, runId, error: err });
-        throw err;
-      }
-    },
-    /**
-     * Restart a flow by canceling the current run and starting a new one with the same input
-     * @param flowName - The name of the flow
-     * @param runId - The run ID to restart
-     */
-    async restartFlow(flowName, runId) {
-      try {
-        const streamName = StoreSubjects.flowRun(runId);
-        const events = await store.stream.read(streamName);
-        const startEvent = events.find((e) => e.type === "flow.start" || e.type === "flow.started");
-        const originalInput = startEvent?.data?.input || {};
-        logger.debug("Found original input for restart", { flowName, runId, hasInput: !!startEvent });
-        const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-        const entry = await store.index.get(runIndexKey, runId);
-        const currentStatus = entry?.metadata?.status;
-        if (currentStatus === "running" || currentStatus === "awaiting") {
-          await eventsManager.publishBus({
-            type: "flow.cancel",
-            runId,
-            flowName,
-            data: {
-              canceledAt: (/* @__PURE__ */ new Date()).toISOString(),
-              previousStatus: currentStatus,
-              reason: "Restarted"
-            }
-          });
-          logger.info("Canceled flow for restart", { flowName, runId, previousStatus: currentStatus });
-        }
-        const newResult = await this.startFlow(flowName, originalInput);
-        logger.info("Flow restarted", {
-          flowName,
-          oldRunId: runId,
-          newRunId: newResult.flowId
-        });
-        return {
-          success: true,
-          oldRunId: runId,
-          newRunId: newResult.flowId,
-          flowName
-        };
-      } catch (err) {
-        logger.error("Failed to restart flow", { flowName, runId, error: err });
-        throw err;
-      }
-    },
-    /**
-     * Check if a flow is currently running (includes 'running' and 'awaiting' status)
-     * @param flowName - The name of the flow to check
-     * @param runId - Optional specific run ID to check (if provided, only checks that run)
-     * @param options - Optional configuration
-     * @param options.excludeRunIds - Exclude these run IDs from the check (useful when called from within a flow)
-     */
-    async isRunning(flowName, runId, options) {
-      try {
-        if (!store.index.read) {
-          return false;
-        }
-        const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-        const activeStatuses = ["running", "awaiting"];
-        if (runId) {
-          const run = await store.index.get(runIndexKey, runId);
-          return activeStatuses.includes(run?.metadata?.status);
-        }
-        const entries = await store.index.read(runIndexKey, {
-          limit: 1e3,
-          filter: { status: activeStatuses }
-        });
-        const excludeSet = new Set(options?.excludeRunIds || []);
-        const matchingRuns = entries.filter((e) => !excludeSet.has(e.id));
-        return matchingRuns.length > 0;
-      } catch (err) {
-        logger.error("Error checking flow status:", err);
-        return false;
-      }
-    },
-    /**
-     * Get all currently running flows (includes 'running' and 'awaiting' status)
-     * @param flowName - The name of the flow to check
-     * @param options - Optional configuration
-     * @param options.excludeRunIds - Exclude these run IDs from the results (useful when called from within a flow)
-     */
-    async getRunningFlows(flowName, options) {
-      try {
-        if (!store.index.read) {
-          return [];
-        }
-        const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-        const activeStatuses = ["running", "awaiting"];
-        const entries = await store.index.read(runIndexKey, {
-          limit: 1e3,
-          filter: { status: activeStatuses }
-        });
-        const excludeSet = new Set(options?.excludeRunIds || []);
-        const filteredEntries = entries.filter((e) => !excludeSet.has(e.id));
-        return filteredEntries.map((e) => ({
-          id: e.id,
-          flowName,
-          status: e.metadata?.status,
-          startedAt: e.metadata?.startedAt,
-          stepCount: e.metadata?.stepCount || 0,
-          completedSteps: e.metadata?.completedSteps || 0
-        }));
-      } catch (err) {
-        logger.error("Error getting running flows:", err);
-        return [];
-      }
-    },
-    /**
-     * Get flow statistics by name
-     */
-    async getFlowStats(flowName) {
-      try {
-        const indexKey = StoreSubjects.flowIndex();
-        if (!store.index.get) {
-          logger.warn("Store adapter does not support indexGet");
-          return null;
-        }
-        const entry = await store.index.get(indexKey, flowName);
-        if (!entry) {
-          return null;
-        }
-        const metadata = entry.metadata;
-        return {
-          name: metadata.name || flowName,
-          displayName: metadata.displayName,
-          registeredAt: metadata.registeredAt,
-          lastRunAt: metadata.lastRunAt,
-          lastCompletedAt: metadata.lastCompletedAt,
-          stats: {
-            total: metadata.stats?.total || 0,
-            success: metadata.stats?.success || 0,
-            failure: metadata.stats?.failure || 0,
-            cancel: metadata.stats?.cancel || 0,
-            running: metadata.stats?.running || 0,
-            awaiting: metadata.stats?.awaiting || 0
-          },
-          version: metadata.version
-        };
-      } catch (err) {
-        logger.error("Error getting flow stats", {
-          flowName,
-          error: err?.message
-        });
-        return null;
-      }
-    },
-    /**
-     * Get all flows with their statistics
-     */
-    async getAllFlowStats(options) {
-      try {
-        const indexKey = StoreSubjects.flowIndex();
-        if (!store.index.read) {
-          logger.warn("Store adapter does not support indexRead");
-          return [];
-        }
-        const entries = await store.index.read(indexKey, {
-          limit: options?.limit || 1e3,
-          offset: options?.offset || 0
-        });
-        const flows = entries.map((entry) => {
-          const metadata = entry.metadata;
-          return {
-            name: metadata.name || entry.id,
-            displayName: metadata.displayName,
-            registeredAt: metadata.registeredAt,
-            lastRunAt: metadata.lastRunAt,
-            lastCompletedAt: metadata.lastCompletedAt,
-            stats: {
-              total: metadata.stats?.total || 0,
-              success: metadata.stats?.success || 0,
-              failure: metadata.stats?.failure || 0,
-              cancel: metadata.stats?.cancel || 0,
-              running: metadata.stats?.running || 0,
-              awaiting: metadata.stats?.awaiting || 0
-            },
-            version: metadata.version
-          };
-        });
-        if (options?.sortBy) {
-          flows.sort((a, b) => {
-            let aVal;
-            let bVal;
-            if (options.sortBy === "name") {
-              aVal = a.name;
-              bVal = b.name;
-            } else if (options.sortBy === "registeredAt") {
-              aVal = new Date(a.registeredAt).getTime();
-              bVal = new Date(b.registeredAt).getTime();
-            } else if (options.sortBy === "lastRunAt") {
-              aVal = a.lastRunAt ? new Date(a.lastRunAt).getTime() : 0;
-              bVal = b.lastRunAt ? new Date(b.lastRunAt).getTime() : 0;
-            }
-            const order = options.order === "desc" ? -1 : 1;
-            return (aVal > bVal ? 1 : aVal < bVal ? -1 : 0) * order;
-          });
-        }
-        return flows;
-      } catch (err) {
-        logger.error("Error getting all flow stats", {
-          error: err?.message
-        });
-        return [];
-      }
-    },
-    /**
-     * Check if a flow has statistics in the index
-     */
-    async hasFlowStats(flowName) {
-      const stats = await this.getFlowStats(flowName);
-      return stats !== null;
-    }
-  };
-}

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

@@ -1,40 +0,0 @@
-/**
- * Lifecycle hooks registry for await patterns
- * v0.5 - Await Integration
- */
-export interface LifecycleHooks {
-    /**
-     * Called when await pattern is registered
-     * @param hookData - Type-safe data based on await type (webhookUrl, eventName, etc.)
-     * @param stepData - Current step data
-     * @param ctx - Worker context with awaitType and awaitConfig
-     */
-    onAwaitRegister?: (hookData: any, stepData: any, ctx: any) => Promise<void>;
-    /**
-     * Called when await pattern is resolved
-     * @param resolvedData - Data from the trigger that resolved the await
-     * @param stepData - Current step data
-     * @param ctx - Worker context with awaitType
-     */
-    onAwaitResolve?: (resolvedData: any, stepData: any, ctx: any) => Promise<void>;
-    /**
-     * Called when await pattern times out
-     * @param stepData - Current step data
-     * @param ctx - Worker context with awaitType and timeoutAction
-     */
-    onAwaitTimeout?: (stepData: any, ctx: any) => Promise<void>;
-}
-export declare function useHookRegistry(): {
-    /**
-     * Register lifecycle hooks for a specific flow step
-     */
-    register(flowName: string, stepName: string, hooks: LifecycleHooks): void;
-    /**
-     * Load lifecycle hooks for a specific flow step
-     */
-    load(flowName: string, stepName: string): LifecycleHooks | null;
-    /**
-     * Clear all registered hooks (useful for testing)
-     */
-    clear(): void;
-};

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

@@ -1,25 +0,0 @@
-const hookRegistry = /* @__PURE__ */ new Map();
-export function useHookRegistry() {
-  return {
-    /**
-     * Register lifecycle hooks for a specific flow step
-     */
-    register(flowName, stepName, hooks) {
-      const key = `${flowName}:${stepName}`;
-      hookRegistry.set(key, hooks);
-    },
-    /**
-     * Load lifecycle hooks for a specific flow step
-     */
-    load(flowName, stepName) {
-      const key = `${flowName}:${stepName}`;
-      return hookRegistry.get(key) || null;
-    },
-    /**
-     * Clear all registered hooks (useful for testing)
-     */
-    clear() {
-      hookRegistry.clear();
-    }
-  };
-}

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

@@ -1,42 +0,0 @@
-import { type ConsolaInstance } from 'consola';
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface NventLogger {
-    debug: (message: string, context?: any) => void;
-    info: (message: string, context?: any) => void;
-    warn: (message: string, context?: any) => void;
-    error: (message: string, context?: any) => void;
-    log: (level: LogLevel, message: string, context?: any) => void;
-    isEnabled: (level: LogLevel) => boolean;
-    consola: ConsolaInstance;
-}
-/**
- * Creates a contextual server logger with configurable log levels
- * Uses consola for beautiful, styled console output with colors and icons
- *
- * Configuration via runtime config or environment variables:
- * - queue.debug.level: 'debug' | 'info' | 'warn' | 'error' | 'silent'
- * - queue.debug.<scope>: boolean (enables debug logging for specific scope)
- * - NQ_DEBUG_LEVEL: environment variable override
- * - NQ_DEBUG_<SCOPE>: environment variable for scope (e.g., NQ_DEBUG_FLOW_WIRING=1)
- *
- * @param scope - Logger scope/namespace (e.g., 'flow-wiring', 'event-manager')
- * @returns NventLogger instance with scoped logging methods
- *
- * @example
- * ```ts
- * const logger = useNventLogger('flow-wiring')
- * logger.debug('Step triggered', { stepName: 'process', runId: '123' })
- * logger.info('Flow completed', { flowName: 'example' })
- * logger.warn('Retry attempt', { attempt: 3 })
- * logger.error('Processing failed', { error: err.message })
- *
- * // Access consola instance for advanced features
- * logger.consola.success('All steps completed!')
- * logger.consola.box('🚀 Flow Started')
- * ```
- */
-export declare function useNventLogger(scope: string): NventLogger;
-/**
- * Type guard to check if debug logging is enabled for any scope
- */
-export declare function isDebugEnabled(): boolean;