nvent 0.5.15 → 1.0.0-alpha.2

package/dist/runtime/scheduler/types.d.ts

@@ -1,122 +0,0 @@
-/**
- * Scheduler Types
- *
- * Unified scheduling system for all time-based operations in nvent:
- * - Stall detection
- * - Await timeouts
- * - Trigger schedules
- * - Cleanup jobs
- */
-export interface ScheduledJob {
-    /**
-     * Unique job identifier
-     */
-    id: string;
-    /**
-     * Human-readable job name
-     */
-    name: string;
-    /**
-     * Job type
-     */
-    type: 'cron' | 'interval' | 'one-time';
-    /**
-     * Cron expression (for type: 'cron')
-     * @example '0 2 * * *' - Daily at 2 AM
-     * @example '* /5 * * * *' - Every 5 minutes
-     */
-    cron?: string;
-    /**
-     * Interval in milliseconds (for type: 'interval')
-     */
-    interval?: number;
-    /**
-     * Execution timestamp (for type: 'one-time')
-     */
-    executeAt?: number;
-    /**
-     * Job handler function
-     */
-    handler: () => Promise<void>;
-    /**
-     * Timezone for cron jobs
-     * @default 'UTC'
-     */
-    timezone?: string;
-    /**
-     * Whether the job is enabled
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * Additional metadata
-     */
-    metadata?: Record<string, any>;
-    /**
-     * Last execution timestamp
-     */
-    lastRun?: number;
-    /**
-     * Next scheduled execution timestamp
-     */
-    nextRun?: number;
-    /**
-     * Total execution count
-     */
-    runCount?: number;
-    /**
-     * Failure count
-     */
-    failCount?: number;
-}
-export interface SchedulerAdapter {
-    /**
-     * Schedule a job with distributed locking support
-     */
-    schedule(job: ScheduledJob): Promise<string>;
-    /**
-     * Unschedule a job
-     */
-    unschedule(jobId: string): Promise<boolean>;
-    /**
-     * Start the scheduler (begins processing scheduled jobs)
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the scheduler and release all locks
-     */
-    stop(): Promise<void>;
-    /**
-     * Get all scheduled jobs (in-memory, for this instance)
-     */
-    getScheduledJobs(): Promise<ScheduledJob[]>;
-    /**
-     * Get jobs matching a pattern (e.g., by runId)
-     * Queries persisted store, works across all instances
-     * More efficient than getAllPersistedJobs() when filtering
-     */
-    getJobsByPattern(pattern: string): Promise<ScheduledJob[]>;
-    /**
-     * Get all persisted jobs from store (across all instances)
-     * Useful for debugging and monitoring in horizontal setups
-     */
-    getAllPersistedJobs(): Promise<ScheduledJob[]>;
-    /**
-     * Check if scheduler is healthy
-     */
-    isHealthy(): Promise<boolean>;
-}
-export interface SchedulerLock {
-    jobId: string;
-    instanceId: string;
-    acquiredAt: number;
-    expiresAt: number;
-}
-export interface SchedulerStats {
-    jobId: string;
-    lastRun: number;
-    nextRun?: number;
-    runCount: number;
-    failCount: number;
-    lastError?: string;
-}

package/dist/runtime/worker/node/runner.d.ts

@@ -1,95 +0,0 @@
-import type { FlowStats, StartFlowResult, CancelFlowResult, RunningFlow } from '../../nitro/utils/useFlow.js';
-/**
- * Generic job interface that works with any queue adapter
- * Adapters should provide jobs in this format
- */
-export interface QueueJob {
-    id: string;
-    name: string;
-    data: any;
-    attemptsMade?: number;
-    opts?: {
-        attempts?: number;
-    };
-}
-export interface RunLogger {
-    log: (level: 'debug' | 'info' | 'warn' | 'error', msg: string, meta?: any) => void;
-}
-export interface RunState {
-    get<T = any>(key: string): Promise<T | null>;
-    set<T = any>(key: string, value: T, opts?: {
-        ttl?: number;
-    }): Promise<void>;
-    delete(key: string): Promise<void>;
-}
-/**
- * Flow context available within step handlers
- * Provides context-aware versions of flow operations with auto-injected flowId/flowName
- */
-export interface RunContextFlow {
-    /** Start a new flow with the given payload */
-    startFlow: (flowName: string, payload?: any) => Promise<StartFlowResult>;
-    /** Emit a trigger event (auto-injects flowId, flowName, stepName from context) */
-    emit: (trigger: string, payload?: any) => Promise<any[]>;
-    /** Cancel a specific flow by name and runId */
-    cancelFlow: (flowName: string, runId: string) => Promise<CancelFlowResult>;
-    /** Cancel the current flow (uses flowId from context) */
-    cancel: () => Promise<CancelFlowResult>;
-    /**
-     * Check if a flow is currently running
-     * @param flowName - Optional flow name (defaults to current flow)
-     * @param runId - Optional specific run ID to check
-     * @param options - Optional configuration (auto-excludes current flow if not specified)
-     */
-    isRunning: (flowName?: string, runId?: string, options?: {
-        excludeRunIds?: string[];
-    }) => Promise<boolean>;
-    /**
-     * Get all currently running flows
-     * @param flowName - Optional flow name (defaults to current flow)
-     * @param options - Optional configuration (auto-excludes current flow if not specified)
-     */
-    getRunningFlows: (flowName?: string, options?: {
-        excludeRunIds?: string[];
-    }) => Promise<RunningFlow[]>;
-    /** Get flow statistics by name */
-    getFlowStats: (flowName: string) => Promise<FlowStats | null>;
-    /** Get all flows with their statistics */
-    getAllFlowStats: (options?: {
-        sortBy?: 'registeredAt' | 'lastRunAt' | 'name';
-        order?: 'asc' | 'desc';
-        limit?: number;
-        offset?: number;
-    }) => Promise<FlowStats[]>;
-    /** Check if a flow has statistics in the index */
-    hasFlowStats: (flowName: string) => Promise<boolean>;
-}
-export interface RunContext {
-    jobId?: string;
-    queue?: string;
-    flowId?: string;
-    flowName?: string;
-    stepName?: string;
-    stepId?: string;
-    attempt?: number;
-    logger: RunLogger;
-    state: RunState;
-    flow: RunContextFlow;
-    /**
-     * Resolved data from await pattern (awaitBefore only)
-     * Available when step resumes after await resolution
-     */
-    trigger?: any;
-    /**
-     * Current step's await configuration
-     * Useful for conditional logic based on await settings
-     */
-    awaitConfig?: any;
-}
-export declare function buildContext(partial?: Partial<RunContext>): RunContext;
-export type NodeHandler = (input: any, ctx: RunContext) => Promise<any>;
-/**
- * Wraps a NodeHandler with full RunContext building and event emission
- * Works with any queue adapter by accepting a job-like object
- */
-export declare function createJobProcessor(handler: NodeHandler, queueName: string): (job: QueueJob) => Promise<any>;

package/dist/runtime/worker/node/runner.js

@@ -1,272 +0,0 @@
-import { randomUUID } from "node:crypto";
-import {
-  useRuntimeConfig,
-  useFlow,
-  useEventManager,
-  useNventLogger,
-  $useFunctionRegistry,
-  $useAnalyzedFlows,
-  useStateAdapter,
-  useQueueAdapter
-} from "#imports";
-import { SYSTEM_HANDLERS } from "../system/index.js";
-const logger = useNventLogger("node-runner");
-const defaultState = {
-  async get() {
-    return null;
-  },
-  async set() {
-  },
-  async delete() {
-  }
-};
-function scopeKey(baseKey, flowId) {
-  if (!flowId) return baseKey;
-  return `flow:${flowId}:${baseKey}`;
-}
-export function buildContext(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 logger2 = partial?.logger || (() => {
-    const eventManager = useEventManager();
-    return {
-      log: (level, msg, meta) => {
-        const runId = partial?.flowId || "unknown";
-        const flowName = meta?.flowName || "unknown";
-        const metaObj = meta !== null && meta !== void 0 ? typeof meta === "object" && !Array.isArray(meta) ? meta : { value: meta } : {};
-        void eventManager.publishBus({
-          type: "log",
-          runId,
-          flowName,
-          stepName: metaObj?.stepName,
-          stepId: metaObj?.stepId || metaObj?.stepRunId,
-          attempt: metaObj?.attempt,
-          data: { level, message: msg, ...metaObj }
-        });
-      }
-    };
-  })();
-  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, options) => {
-      const targetFlowName = flowName || partial?.flowName;
-      if (!targetFlowName) {
-        throw new Error("flowName is required to check if flow is running");
-      }
-      const effectiveOptions = options || (partial?.flowId ? { excludeRunIds: [partial.flowId] } : void 0);
-      return baseFlowEngine.isRunning(targetFlowName, runId, effectiveOptions);
-    },
-    getRunningFlows: async (flowName, options) => {
-      const targetFlowName = flowName || partial?.flowName;
-      if (!targetFlowName) {
-        throw new Error("flowName is required to get running flows");
-      }
-      const effectiveOptions = options || (partial?.flowId ? { excludeRunIds: [partial.flowId] } : void 0);
-      return baseFlowEngine.getRunningFlows(targetFlowName, effectiveOptions);
-    }
-  };
-  return {
-    jobId: partial?.jobId,
-    queue: partial?.queue,
-    flowId: partial?.flowId,
-    flowName: partial?.flowName,
-    stepName: partial?.stepName,
-    stepId: partial?.stepId,
-    attempt: partial?.attempt,
-    logger: logger2,
-    state,
-    flow,
-    trigger: partial?.trigger,
-    awaitConfig: partial?.awaitConfig
-  };
-}
-export function createJobProcessor(handler, queueName) {
-  return async function processor(job) {
-    const eventMgr = useEventManager();
-    const rc = useRuntimeConfig();
-    const autoScope = rc?.nvent?.store?.state?.autoScope || "always";
-    const providedFlow = job.data?.flowId;
-    const flowId = providedFlow || (autoScope === "always" ? randomUUID() : void 0);
-    const attempt = (job.attemptsMade || 0) + 1;
-    const maxAttempts = job.opts?.attempts || 1;
-    const isFinalAttempt = attempt >= maxAttempts;
-    const stepRunId = `${String(flowId || job.id)}__${job.name}__attempt-${attempt}`;
-    const flowName = job.data?.flowName || "unknown";
-    const registry = $useFunctionRegistry();
-    const flowRegistry = (registry?.flows || {})[flowName];
-    let stepMeta = flowRegistry?.steps?.[job.name];
-    if (!stepMeta && flowRegistry?.entry?.step === job.name) {
-      stepMeta = flowRegistry?.entry;
-    }
-    const awaitBefore = stepMeta?.awaitBefore;
-    const awaitAfter = stepMeta?.awaitAfter;
-    const isAwaitResume = job.data?.awaitResolved === true;
-    const awaitData = job.data?.awaitData;
-    const awaitPosition = job.data?.awaitPosition;
-    const ctx = buildContext({
-      jobId: job.id,
-      queue: queueName,
-      flowId,
-      flowName,
-      stepName: job.name,
-      stepId: stepRunId,
-      attempt,
-      trigger: isAwaitResume ? awaitData : void 0,
-      awaitConfig: awaitBefore || awaitAfter || void 0
-    });
-    const attemptLogger = {
-      log: (level, msg, meta) => {
-        const metaObj = meta !== null && meta !== void 0 ? typeof meta === "object" && !Array.isArray(meta) ? meta : { value: meta } : {};
-        const enriched = { ...metaObj, stepName: job.name, attempt, stepRunId, flowName };
-        ctx.logger.log(level, msg, enriched);
-      }
-    };
-    try {
-      await eventMgr.publishBus({
-        type: "step.started",
-        runId: flowId || "unknown",
-        flowName,
-        stepName: job.name,
-        stepId: stepRunId,
-        attempt,
-        data: {
-          jobId: job.id,
-          name: job.name,
-          queue: queueName
-        }
-      });
-    } catch {
-    }
-    let result;
-    try {
-      const workerInput = job.data?.input !== void 0 ? job.data.input : job.data;
-      result = await handler(workerInput, { ...ctx, logger: attemptLogger });
-    } catch (err) {
-      logger.error(`[worker] Job failed: ${job.name} (${job.id})`, {
-        queue: queueName,
-        flowId,
-        flowName,
-        stepName: job.name,
-        error: err?.message || String(err),
-        stack: err?.stack
-      });
-      const willRetry = !isFinalAttempt;
-      if (willRetry) {
-        try {
-          await eventMgr.publishBus({
-            type: "step.retry",
-            runId: flowId || "unknown",
-            flowName,
-            stepName: job.name,
-            stepId: stepRunId,
-            attempt,
-            data: {
-              stepName: job.name,
-              queue: queueName,
-              attempt,
-              maxAttempts,
-              nextAttempt: attempt + 1,
-              error: String(err?.message || err),
-              stack: err?.stack
-            }
-          });
-        } catch {
-        }
-      } else {
-        try {
-          await eventMgr.publishBus({
-            type: "step.failed",
-            runId: flowId || "unknown",
-            flowName,
-            stepName: job.name,
-            stepId: stepRunId,
-            attempt,
-            data: {
-              error: String(err?.message || err),
-              stack: err?.stack
-            }
-          });
-        } catch {
-        }
-      }
-      throw err;
-    }
-    try {
-      const eventMgr2 = useEventManager();
-      await eventMgr2.publishBus({
-        type: "step.completed",
-        runId: flowId || "unknown",
-        flowName,
-        stepName: job.name,
-        stepId: stepRunId,
-        attempt,
-        data: { result }
-      });
-    } catch {
-    }
-    const shouldRegisterAwaitAfter = awaitAfter && (!isAwaitResume || awaitPosition === "before");
-    if (shouldRegisterAwaitAfter) {
-      try {
-        const queue = useQueueAdapter();
-        const analyzedFlows = $useAnalyzedFlows();
-        const flowDef = analyzedFlows.find((f) => f.id === flowName);
-        const analyzedAwaitStep = flowDef?.analyzed?.steps?.[job.name];
-        const awaitStepTimeout = analyzedAwaitStep?.stepTimeout;
-        await queue.enqueue(queueName, {
-          name: SYSTEM_HANDLERS.AWAIT_REGISTER,
-          data: {
-            flowId: flowId || "unknown",
-            flowName,
-            stepName: job.name,
-            position: "after",
-            awaitConfig: awaitAfter,
-            input: { ...job.data, result }
-          },
-          opts: { jobId: `${flowId}__${job.name}__await-register-after`, timeout: awaitStepTimeout }
-        });
-      } catch (err) {
-        logger.error("Failed to register awaitAfter pattern", {
-          flowName,
-          stepName: job.name,
-          error: err.message
-        });
-      }
-    }
-    return result;
-  };
-}

package/dist/runtime/worker/python/get_config.py

@@ -1,64 +0,0 @@
-import sys
-import json
-import importlib.util
-import os
-import platform
-
-
-def send_message(payload):
-    """Send a JSON line to the parent process.
-
-    On Unix-like systems, write to the file descriptor provided via env
-    NODE_CHANNEL_FD. On Windows, write to stdout.
-    """
-    bytes_message = (json.dumps(payload) + "\n").encode("utf-8")
-
-    if platform.system() == "Windows":
-        # On Windows, write to stdout
-        sys.stdout.buffer.write(bytes_message)
-        sys.stdout.buffer.flush()
-    else:
-        # On Unix systems, use the provided file descriptor
-        fd = int(os.environ["NODE_CHANNEL_FD"])  # expected to be set by parent
-        os.write(fd, bytes_message)
-
-
-async def run_python_module(file_path: str) -> None:
-    try:
-        module_dir = os.path.dirname(os.path.abspath(file_path))
-
-        if module_dir not in sys.path:
-            sys.path.insert(0, module_dir)
-
-        spec = importlib.util.spec_from_file_location(
-            os.path.splitext(os.path.basename(file_path))[0], file_path
-        )
-        if spec is None or spec.loader is None:
-            raise ImportError(f"Could not load module from {file_path}")
-
-        module = importlib.util.module_from_spec(spec)
-        # Set a basic package name to allow relative imports from same dir
-        module.__package__ = os.path.basename(module_dir)
-        spec.loader.exec_module(module)
-
-        if not hasattr(module, "config"):
-            raise AttributeError(f"No 'config' found in module {file_path}")
-
-        cfg = getattr(module, "config")
-        # Remove keys that are not serializable or not needed
-        if isinstance(cfg, dict) and "middleware" in cfg:
-            del cfg["middleware"]
-
-        send_message(cfg)
-    except Exception as error:
-        print("Error running Python module:", str(error), file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        sys.exit(1)
-    file_path = sys.argv[1]
-    import asyncio
-
-    asyncio.run(run_python_module(file_path))

package/dist/runtime/worker/system/awaitHandlers.d.ts

@@ -1,27 +0,0 @@
-/**
- * Internal system handlers for await lifecycle events
- * These handlers run in job context to handle await registration, resolution, and timeout
- */
-import type { QueueJob } from '../node/runner.js';
-/**
- * System handler for await registration
- * Registers await pattern and calls onAwaitRegister hook
- */
-export declare function awaitRegisterHandler(job: QueueJob): Promise<{
-    success: boolean;
-    awaitResult: any;
-}>;
-/**
- * System handler for await resolution
- * Calls onAwaitResolve hook and enqueues the actual step (for awaitBefore)
- */
-export declare function awaitResolveHandler(job: QueueJob): Promise<{
-    success: boolean;
-}>;
-/**
- * System handler for await timeout
- * Calls onAwaitTimeout hook
- */
-export declare function awaitTimeoutHandler(job: QueueJob): Promise<{
-    success: boolean;
-}>;