nvent 0.5.15 → 1.0.0-alpha.2

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

@@ -1,54 +0,0 @@
-import { useRuntimeConfig } from "#imports";
-import { consola } from "consola";
-const LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-const loggerCache = /* @__PURE__ */ new Map();
-export function useNventLogger(scope) {
-  const rc = useRuntimeConfig();
-  const debugConfig = rc?.nvent?.debug;
-  const configLevel = debugConfig?.level || process.env.NQ_DEBUG_LEVEL || "info";
-  const globalLevelNum = configLevel === "silent" ? Infinity : LOG_LEVELS[configLevel] ?? LOG_LEVELS.info;
-  const scopeKey = scope.replace(/[^a-z0-9]/gi, "_").toLowerCase();
-  const envKey = `NQ_DEBUG_${scopeKey.toUpperCase()}`;
-  const isScopeDebugEnabled = debugConfig?.[scopeKey] === true || process.env[envKey] === "1";
-  let scopedConsola = loggerCache.get(scope);
-  if (!scopedConsola) {
-    scopedConsola = consola.withTag(scope);
-    loggerCache.set(scope, scopedConsola);
-  }
-  const logger = scopedConsola;
-  function isEnabled(level) {
-    const levelNum = LOG_LEVELS[level];
-    if (isScopeDebugEnabled && level === "debug") {
-      return true;
-    }
-    return levelNum >= globalLevelNum;
-  }
-  function log(level, message, context) {
-    if (!isEnabled(level)) return;
-    if (context && Object.keys(context).length > 0) {
-      logger[level](message, context);
-    } else {
-      logger[level](message);
-    }
-  }
-  return {
-    debug: (message, context) => log("debug", message, context),
-    info: (message, context) => log("info", message, context),
-    warn: (message, context) => log("warn", message, context),
-    error: (message, context) => log("error", message, context),
-    log,
-    isEnabled,
-    consola: logger
-  };
-}
-export function isDebugEnabled() {
-  const rc = useRuntimeConfig();
-  const debugConfig = rc?.nvent?.debug;
-  const level = debugConfig?.level || process.env.NQ_DEBUG_LEVEL;
-  return level === "debug" || Object.keys(debugConfig || {}).some((key) => key !== "level");
-}

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

@@ -1,6 +0,0 @@
-import type { RunContext } from '../worker/node/runner.js';
-/**
- * Create a minimal RunContext for use in lifecycle hooks and event handlers
- * This is a lightweight version without the full worker context
- */
-export declare function useRunContext(partial?: Partial<RunContext>): RunContext;

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

@@ -1,102 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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>;
-};