nvent 0.5.15 → 1.0.0-alpha.2

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

@@ -1,378 +0,0 @@
-export type FlowRole = 'entry' | 'step';
-/**
- * Trigger definition for inline trigger registration
- * Can be defined in function config alongside subscription
- */
-export interface TriggerDefinition {
-    /**
-     * Unique trigger name (e.g., 'manual.approve-order')
-     */
-    name: string;
-    /**
-     * Trigger type
-     */
-    type: 'event' | 'webhook' | 'schedule' | 'manual';
-    /**
-     * Trigger scope: 'flow' for entry triggers, 'await' for await patterns
-     */
-    scope?: 'flow' | 'await';
-    /**
-     * Human-readable display name
-     */
-    displayName?: string;
-    /**
-     * Description of what this trigger does
-     */
-    description?: string;
-    /**
-     * Expected flows that should subscribe to this trigger (for validation)
-     */
-    expectedSubscribers?: string[];
-    /**
-     * Webhook-specific configuration
-     */
-    webhook?: {
-        /**
-         * URL path for webhook (e.g., '/api/webhooks/stripe')
-         */
-        path: string;
-        /**
-         * HTTP method
-         */
-        method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
-        /**
-         * Authentication configuration
-         */
-        auth?: any;
-    };
-    /**
-     * Schedule-specific configuration
-     */
-    schedule?: {
-        /**
-         * Cron expression (e.g., '0 9 * * *' for 9 AM daily)
-         */
-        cron: string;
-        /**
-         * Timezone for cron expression
-         */
-        timezone?: string;
-        /**
-         * Whether schedule is enabled
-         */
-        enabled?: boolean;
-    };
-    /**
-     * Additional configuration options
-     */
-    config?: Record<string, any>;
-}
-export interface FlowConfig {
-    /**
-     * One or more flow names this step belongs to.
-     * A single worker step can participate in multiple flows.
-     */
-    name: string | string[];
-    /**
-     * Role of this step in the flow.
-     */
-    role: FlowRole;
-    /**
-     * Logical step name (used as job name and event kind on start).
-     */
-    step: string;
-    /**
-     * Event kinds this step emits (e.g., `${step}.completed`).
-     */
-    emits?: string[];
-    /**
-     * Event kinds this step subscribes to; can be a single string or an array.
-     * The compiler normalizes this to `string[]` under `subscribes`.
-     */
-    subscribes?: string | string[];
-    /**
-     * Entry trigger configuration (v0.5)
-     * Define and/or subscribe to triggers to start flow runs
-     */
-    triggers?: {
-        /**
-         * Define a new trigger inline (optional)
-         * If provided, this trigger will be registered at build time
-         */
-        define?: TriggerDefinition;
-        /**
-         * Array of trigger names to subscribe to
-         * Can include the defined trigger or external triggers
-         */
-        subscribe: string[];
-        /**
-         * Trigger mode: 'auto' (immediate) or 'manual' (requires approval)
-         */
-        mode?: 'auto' | 'manual';
-    };
-    /**
-     * Step execution timeout in milliseconds (v0.5.1)
-     * Overrides global flow.stepTimeout and queue.defaultJobOptions.timeout for this specific step
-     *
-     * @example 600000 // 10 minutes
-     * @example 3600000 // 1 hour
-     */
-    stepTimeout?: number;
-    /**
-     * Await pattern: Wait BEFORE step execution (v0.5)
-     * Step won't execute until trigger fires
-     */
-    awaitBefore?: AwaitConfig;
-    /**
-     * Await pattern: Wait AFTER step execution (v0.5)
-     * Next steps won't trigger until trigger fires
-     */
-    awaitAfter?: AwaitConfig;
-}
-/**
- * Await configuration (run-scoped triggers)
- *
- * Pauses flow execution until a specific condition is met. Can be used with:
- * - `awaitBefore`: Wait before step execution starts
- * - `awaitAfter`: Wait after step completes before triggering next steps
- *
- * Declared in config, no functions allowed (AST-parsed at build time)
- */
-export interface AwaitConfig {
-    /**
-     * Type of trigger to wait for
-     * - `webhook`: Wait for HTTP request to specific endpoint
-     * - `event`: Wait for custom event with optional data matching
-     * - `schedule`: Wait until specific cron schedule time
-     * - `time`: Wait for fixed time delay
-     */
-    type: 'webhook' | 'event' | 'schedule' | 'time';
-    /**
-     * URL path for webhook trigger (supports template variables)
-     *
-     * Only used when `type: 'webhook'`
-     *
-     * Template variables available:
-     * - `{runId}`: Current flow run ID
-     * - `{stepId}`: Current step execution ID
-     *
-     * @example '/webhooks/approve/{runId}'
-     * @example '/api/confirm/{stepId}'
-     */
-    path?: string;
-    /**
-     * HTTP method for webhook endpoint
-     *
-     * Only used when `type: 'webhook'`
-     *
-     * @default 'POST'
-     */
-    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
-    /**
-     * Event name to wait for
-     *
-     * Only used when `type: 'event'`
-     *
-     * @example 'payment.completed'
-     * @example 'order.shipped'
-     */
-    event?: string;
-    /**
-     * Key to match between event data and step output
-     *
-     * Only used when `type: 'event'`
-     *
-     * Matches incoming event data against step output data.
-     * Supports nested paths using dot notation.
-     *
-     * @example 'orderId' - matches event.orderId === stepOutput.orderId
-     * @example 'order.id' - matches event.order.id === stepOutput.order.id
-     */
-    filterKey?: string;
-    /**
-     * Cron expression defining when to trigger (one-time schedule)
-     *
-     * Only used when `type: 'schedule'`
-     *
-     * Note: This is a one-time trigger, not recurring. The next occurrence
-     * of the cron expression after step completion will trigger continuation.
-     *
-     * @example '0 9 * * *' - 9 AM daily (triggers at next 9 AM occurrence)
-     * @example '0 0 * * MON' - Midnight every Monday
-     */
-    cron?: string;
-    /**
-     * Timezone for cron expression evaluation
-     *
-     * Only used when `type: 'schedule'`
-     *
-     * @example 'America/New_York'
-     * @example 'Europe/Berlin'
-     * @default 'UTC'
-     */
-    timezone?: string;
-    /**
-     * Fixed delay in milliseconds before continuation
-     *
-     * Only used when `type: 'time'`
-     *
-     * @example 60000 - 1 minute
-     * @example 3600000 - 1 hour
-     */
-    delay?: number;
-    /**
-     * Maximum wait time in milliseconds before timeout
-     *
-     * Applies to all trigger types. If the trigger doesn't fire within
-     * this duration, the timeout action will be taken.
-     *
-     * @example 86400000 - 24 hours
-     * @example 604800000 - 7 days
-     */
-    timeout?: number;
-    /**
-     * Action to take when timeout is reached
-     *
-     * - `fail`: Mark step/flow as failed
-     * - `continue`: Continue flow execution anyway
-     * - `retry`: Retry waiting (reset timeout)
-     *
-     * @default 'fail'
-     */
-    timeoutAction?: 'fail' | 'continue' | 'retry';
-}
-export interface QueueJobDefaults {
-    /**
-     * Number of retry attempts for failed jobs.
-     * BullMQ: attempts, PGBoss: retryLimit
-     */
-    attempts?: number;
-    /**
-     * Backoff strategy for retries.
-     * BullMQ: backoff, PGBoss: retryBackoff + exponentialBackoff
-     */
-    backoff?: number | {
-        type: 'fixed' | 'exponential';
-        delay: number;
-    };
-    /**
-     * Delay in milliseconds before the job is processed.
-     * BullMQ: delay, PGBoss: startAfter
-     */
-    delay?: number;
-    /**
-     * Job priority (higher number = higher priority).
-     * BullMQ: priority, PGBoss: priority
-     */
-    priority?: number;
-    /**
-     * Job timeout in milliseconds.
-     * BullMQ: timeout, PGBoss: expireInSeconds (converted)
-     */
-    timeout?: number;
-    /**
-     * Process jobs in LIFO (Last In First Out) order.
-     * BullMQ: lifo, PGBoss: not supported
-     */
-    lifo?: boolean;
-    /**
-     * Remove job from queue when completed.
-     * BullMQ: removeOnComplete, PGBoss: deleteAfterSeconds
-     */
-    removeOnComplete?: boolean | number;
-    /**
-     * Remove job from queue when failed.
-     * BullMQ: removeOnFail, PGBoss: deleteAfterSeconds
-     */
-    removeOnFail?: boolean | number;
-    /**
-     * Repeatable job configuration.
-     * BullMQ: repeat, PGBoss: schedule pattern
-     */
-    repeat?: {
-        cron?: string;
-        every?: number;
-        limit?: number;
-        tz?: string;
-    };
-}
-export interface QueueConfig {
-    /**
-     * Queue name. If not provided, the filename will be used.
-     */
-    name?: string;
-    /**
-     * Default options for jobs enqueued to this queue.
-     */
-    defaultJobOptions?: QueueJobDefaults;
-    /**
-     * Prefix for queue keys in Redis/storage.
-     * BullMQ: prefix, PGBoss: schema
-     */
-    prefix?: string;
-    /**
-     * Rate limiting configuration.
-     * BullMQ: limiter, PGBoss: teamSize + teamConcurrency (partial)
-     */
-    limiter?: {
-        /**
-         * Maximum number of jobs to process in the duration window.
-         */
-        max?: number;
-        /**
-         * Duration of the rate limit window in milliseconds.
-         */
-        duration?: number;
-        /**
-         * Group key for rate limiting (optional).
-         * BullMQ only: allows per-group rate limiting
-         */
-        groupKey?: string;
-    };
-}
-export interface WorkerConfig {
-    /**
-     * Number of jobs to process concurrently.
-     * BullMQ: concurrency, PGBoss: teamSize
-     */
-    concurrency?: number;
-    /**
-     * Lock duration in milliseconds.
-     * BullMQ: lockDuration, PGBoss: newJobCheckInterval (similar concept)
-     */
-    lockDurationMs?: number;
-    /**
-     * Maximum number of times a job can be stalled before being failed.
-     * BullMQ: maxStalledCount, PGBoss: not directly supported
-     */
-    maxStalledCount?: number;
-    /**
-     * Delay in milliseconds before processing jobs after queue is drained.
-     * BullMQ: drainDelay, PGBoss: not directly supported
-     */
-    drainDelayMs?: number;
-    /**
-     * Automatically run worker on startup.
-     * BullMQ: autorun, PGBoss: workers start automatically
-     */
-    autorun?: boolean;
-    /**
-     * Polling interval in milliseconds for checking new jobs.
-     * PGBoss: newJobCheckInterval, BullMQ: uses blocking wait
-     */
-    pollingIntervalMs?: number;
-}
-export interface QueueWorkerConfig {
-    queue?: QueueConfig;
-    flow?: FlowConfig;
-    worker?: WorkerConfig;
-}
-export type DefineFunctionConfig = <T extends QueueWorkerConfig>(cfg: T) => T;
-export declare const defineFunctionConfig: DefineFunctionConfig;
-/**
- * Helper for defining trigger configurations inline
- * This is just a type helper, actual value is the same as defineFunctionConfig
- */
-export type DefineTriggerConfig = <T extends TriggerDefinition>(cfg: T) => T;
-export declare const defineTriggerConfig: DefineTriggerConfig;
-export default defineFunctionConfig;

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

@@ -1,3 +0,0 @@
-export const defineFunctionConfig = (cfg) => cfg;
-export const defineTriggerConfig = (cfg) => cfg;
-export default defineFunctionConfig;

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

@@ -1,95 +0,0 @@
-/**
- * Type-safe hook definitions for await patterns
- * v0.5 - Await Integration
- */
-import type { RunContext } from '../../worker/node/runner.js';
-export type AwaitType = 'webhook' | 'event' | 'schedule' | 'time';
-/**
- * Hook data types specific to each await type
- */
-export interface WebhookHookData {
-    webhookUrl: string;
-}
-export interface EventHookData {
-    eventName: string;
-}
-export interface ScheduleHookData {
-    cronExpression: string;
-    nextOccurrence: Date;
-}
-export interface TimeHookData {
-    delayMs: number;
-}
-/**
- * Conditional type to get the correct hook data based on await type
- */
-export type HookDataForAwaitType<T extends AwaitType> = T extends 'webhook' ? WebhookHookData : T extends 'event' ? EventHookData : T extends 'schedule' ? ScheduleHookData : T extends 'time' ? TimeHookData : never;
-export interface AwaitRegisterContext<T extends AwaitType = AwaitType> extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
-    awaitType: T;
-    awaitConfig: any;
-    position: 'before' | 'after';
-}
-export interface AwaitResolveContext<T extends AwaitType = AwaitType> extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
-    awaitType: T;
-    resolvedData: any;
-    position: 'before' | 'after';
-}
-export interface AwaitTimeoutContext<T extends AwaitType = AwaitType> extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
-    awaitType: T;
-    timeoutAction: 'fail' | 'continue' | 'retry';
-    position: 'before' | 'after';
-}
-/**
- * Define onAwaitRegister hook with proper types
- * Called when an await pattern is registered (before handler execution or after completion)
- *
- * @example
- * // Webhook example
- * export const onAwaitRegister = defineAwaitRegisterHook(async (hookData, stepData, ctx) => {
- *   // hookData.webhookUrl is typed correctly for webhook awaits
- *   await sendEmail({
- *     to: stepData.reviewerEmail,
- *     subject: 'Approval Required',
- *     approveUrl: hookData.webhookUrl
- *   })
- * })
- *
- * // Event example
- * export const onAwaitRegister = defineAwaitRegisterHook(async (hookData, stepData, ctx) => {
- *   // hookData.eventName is available for event awaits
- *   console.log(`Waiting for event: ${hookData.eventName}`)
- * })
- */
-export declare function defineAwaitRegisterHook<T extends AwaitType = AwaitType>(hook: (hookData: HookDataForAwaitType<T>, stepData: any, ctx: AwaitRegisterContext<T>) => Promise<void>): (hookData: HookDataForAwaitType<T>, stepData: any, ctx: AwaitRegisterContext<T>) => Promise<void>;
-/**
- * Define onAwaitResolve hook with proper types
- * Called when an await pattern is resolved (external trigger fired)
- *
- * @example
- * export const onAwaitResolve = defineAwaitResolveHook(async (resolvedData, stepData, ctx) => {
- *   ctx.logger.log('info', 'Approval received', { approved: resolvedData.approved })
- *
- *   // Update external system
- *   await updateTicketStatus(stepData.ticketId, resolvedData.approved ? 'approved' : 'rejected')
- * })
- */
-export declare function defineAwaitResolveHook<T extends AwaitType = AwaitType>(hook: (resolvedData: any, stepData: any, ctx: AwaitResolveContext<T>) => Promise<void>): (resolvedData: any, stepData: any, ctx: AwaitResolveContext<T>) => Promise<void>;
-/**
- * Define onAwaitTimeout hook with proper types
- * Called when an await pattern times out (timeout exceeded without resolution)
- *
- * @example
- * export const onAwaitTimeout = defineAwaitTimeoutHook(async (stepData, ctx) => {
- *   ctx.logger.log('warn', 'Approval request timed out', {
- *     action: ctx.timeoutAction
- *   })
- *
- *   // Send timeout notification
- *   await sendEmail({
- *     to: stepData.reviewerEmail,
- *     subject: 'Approval Request Expired',
- *     message: 'The approval request was not completed in time'
- *   })
- * })
- */
-export declare function defineAwaitTimeoutHook<T extends AwaitType = AwaitType>(hook: (stepData: any, ctx: AwaitTimeoutContext<T>) => Promise<void>): (stepData: any, ctx: AwaitTimeoutContext<T>) => Promise<void>;

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

@@ -1,9 +0,0 @@
-export function defineAwaitRegisterHook(hook) {
-  return hook;
-}
-export function defineAwaitResolveHook(hook) {
-  return hook;
-}
-export function defineAwaitTimeoutHook(hook) {
-  return hook;
-}

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

@@ -1,59 +0,0 @@
-/**
- * Adapter Registration Utilities
- *
- * Used by external adapter modules to register their adapters with nvent
- */
-import type { QueueAdapter } from '../../adapters/interfaces/queue.js';
-import type { StreamAdapter } from '../../adapters/interfaces/stream.js';
-import type { StoreAdapter } from '../../adapters/interfaces/store.js';
-/**
- * Register a queue adapter
- *
- * Called by external adapter modules (e.g., @nvent/adapter-queue-redis)
- * to register their adapter implementation.
- *
- * @param name - Adapter name (e.g., 'redis', 'postgres', 'rabbitmq')
- * @param adapter - QueueAdapter implementation
- *
- * @example
- * import { registerQueueAdapter } from '#imports'
- * import { RedisQueueAdapter } from './adapter'
- *
- * const adapter = new RedisQueueAdapter({ connection })
- * registerQueueAdapter('redis', adapter)
- */
-export declare function registerQueueAdapter(name: string, adapter: QueueAdapter): void;
-/**
- * Register a stream adapter
- *
- * Called by external adapter modules (e.g., @nvent/adapter-stream-redis)
- * to register their adapter implementation.
- *
- * @param name - Adapter name (e.g., 'redis', 'rabbitmq', 'kafka')
- * @param adapter - StreamAdapter implementation
- *
- * @example
- * import { registerStreamAdapter } from '#imports'
- * import { RedisStreamAdapter } from './adapter'
- *
- * const adapter = new RedisStreamAdapter({ connection })
- * registerStreamAdapter('redis', adapter)
- */
-export declare function registerStreamAdapter(name: string, adapter: StreamAdapter): void;
-/**
- * Register a store adapter
- *
- * Called by external adapter modules (e.g., @nvent/adapter-store-redis)
- * to register their adapter implementation.
- *
- * @param name - Adapter name (e.g., 'redis', 'postgres')
- * @param adapter - StoreAdapter implementation
- *
- * @example
- * import { registerStoreAdapter } from '#imports'
- * import { RedisStoreAdapter } from './adapter'
- *
- * const adapter = new RedisStoreAdapter({ connection })
- * registerStoreAdapter('redis', adapter)
- */
-export declare function registerStoreAdapter(name: string, adapter: StoreAdapter): void;

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

@@ -1,13 +0,0 @@
-import { useAdapterRegistry } from "../../adapters/registry.js";
-export function registerQueueAdapter(name, adapter) {
-  const registry = useAdapterRegistry();
-  registry.registerQueue(name, adapter);
-}
-export function registerStreamAdapter(name, adapter) {
-  const registry = useAdapterRegistry();
-  registry.registerStream(name, adapter);
-}
-export function registerStoreAdapter(name, adapter) {
-  const registry = useAdapterRegistry();
-  registry.registerStore(name, adapter);
-}

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

@@ -1,83 +0,0 @@
-import type { AwaitConfig } from '../../../registry/types.js';
-import { registerAwaitPattern, resolveAwaitPattern, registerWebhookAwait, resolveWebhookAwait, registerEventAwait, resolveEventAwait, registerScheduleAwait, resolveScheduleAwait, registerTimeAwait, resolveTimeAwait } from './awaitPatterns/index.js';
-/**
- * Get default timeout values for await patterns from runtime config
- * These are configurable via module options and used throughout the system
- * Exported for use by await pattern implementations
- */
-export declare function useAwaitDefaults(): {
-    webhookTimeout: any;
-    eventTimeout: any;
-    timeTimeout: any;
-    scheduleTimeout: any;
-    timeoutAction: any;
-};
-/**
- * Await pattern composable
- * Provides unified API for managing await patterns in flows
- * Separate from useTrigger which handles entry triggers (manual, webhook, schedule, event)
- */
-export declare function useAwait(): {
-    /**
-     * Register an await pattern based on config type
-     * Automatically routes to appropriate implementation
-     */
-    register: typeof registerAwaitPattern;
-    /**
-     * Resolve an await pattern by type
-     */
-    resolve: typeof resolveAwaitPattern;
-    /**
-     * Direct access to specific await pattern implementations
-     */
-    webhook: {
-        register: typeof registerWebhookAwait;
-        resolve: typeof resolveWebhookAwait;
-    };
-    event: {
-        register: typeof registerEventAwait;
-        resolve: typeof resolveEventAwait;
-    };
-    schedule: {
-        register: typeof registerScheduleAwait;
-        resolve: typeof resolveScheduleAwait;
-    };
-    time: {
-        register: typeof registerTimeAwait;
-        resolve: typeof resolveTimeAwait;
-    };
-    /**
-     * Query methods for await state
-     */
-    /**
-     * Get await state for a specific flow run and step
-     */
-    getAwaitState(flowName: string, runId: string, stepName?: string): Promise<any>;
-    /**
-     * Check if a step is currently awaiting
-     */
-    isAwaiting(flowName: string, runId: string, stepName: string): Promise<boolean>;
-    /**
-     * Get all active awaits across all flows
-     */
-    getAllActiveAwaits(flowName?: string): Promise<{
-        flowName: string;
-        runId: string;
-        stepName: string;
-        awaitType: string;
-        position: "before" | "after";
-        registeredAt: string;
-    }[]>;
-    /**
-     * Get await history for a specific flow run from stream
-     */
-    getAwaitHistory(runId: string, opts?: {
-        limit?: number;
-        stepName?: string;
-    }): Promise<any>;
-    /**
-     * Cancel/timeout an active await
-     */
-    timeoutAwait(flowName: string, runId: string, stepName: string, reason?: string): Promise<void>;
-};
-export type { AwaitConfig };