nvent 0.4.4 → 0.4.5

package/dist/runtime/config/index.js

@@ -0,0 +1,167 @@
+import defu from "defu";
+export function normalizeModuleOptions(options) {
+  const defaults = {
+    dir: "functions",
+    ui: true,
+    debug: {},
+    connections: {},
+    queue: {
+      adapter: "file",
+      prefix: "nq",
+      defaultJobOptions: {},
+      worker: {
+        concurrency: 2,
+        autorun: true,
+        pollingIntervalMs: 1e3
+      }
+    },
+    stream: {
+      adapter: "memory",
+      prefix: "nq"
+    },
+    store: {
+      adapter: "file",
+      prefix: "nq",
+      state: {
+        autoScope: "always",
+        cleanup: {
+          strategy: "never",
+          ttlMs: 36e5
+          // 1 hour
+        }
+      },
+      eventTTL: 604800,
+      // 7 days
+      metadataTTL: 2592e3
+      // 30 days
+    },
+    flows: {
+      stallDetection: {
+        enabled: true,
+        stallTimeout: 30 * 60 * 1e3,
+        // 30 minutes
+        checkInterval: 15 * 60 * 1e3,
+        // 15 minutes
+        enablePeriodicCheck: true
+      }
+    }
+  };
+  const normalized = defu(options, defaults);
+  const neededConnections = /* @__PURE__ */ new Set();
+  const queueAdapter = normalized.queue.adapter;
+  if (queueAdapter === "redis") {
+    neededConnections.add("redis");
+  } else if (queueAdapter === "postgres") {
+    neededConnections.add("postgres");
+  } else if (queueAdapter === "file") {
+    neededConnections.add("file");
+  }
+  const streamAdapter = normalized.stream.adapter;
+  if (streamAdapter === "redis") {
+    neededConnections.add("redis");
+  } else if (streamAdapter === "rabbitmq") {
+    neededConnections.add("rabbitmq");
+  } else if (streamAdapter === "kafka") {
+    neededConnections.add("kafka");
+  }
+  const storeAdapter = normalized.store.adapter;
+  if (storeAdapter === "redis") {
+    neededConnections.add("redis");
+  } else if (storeAdapter === "postgres") {
+    neededConnections.add("postgres");
+  } else if (storeAdapter === "file") {
+    neededConnections.add("file");
+  }
+  if (!normalized.connections) {
+    normalized.connections = {};
+  }
+  if (neededConnections.has("redis") && !normalized.connections.redis) {
+    normalized.connections.redis = {
+      host: "127.0.0.1",
+      port: 6379
+    };
+  }
+  if (neededConnections.has("postgres") && !normalized.connections.postgres) {
+    normalized.connections.postgres = {
+      connectionString: process.env.DATABASE_URL || "postgresql://localhost:5432/nuxt_queue"
+    };
+  }
+  if (neededConnections.has("rabbitmq") && !normalized.connections.rabbitmq) {
+    normalized.connections.rabbitmq = {
+      host: "localhost",
+      port: 5672
+    };
+  }
+  if (neededConnections.has("kafka") && !normalized.connections.kafka) {
+    normalized.connections.kafka = {
+      brokers: ["localhost:9092"]
+    };
+  }
+  if (neededConnections.has("file") && !normalized.connections.file) {
+    normalized.connections.file = {
+      dataDir: ".data"
+    };
+  }
+  applyConnectionFallback(normalized);
+  return normalized;
+}
+function applyConnectionFallback(config) {
+  if (!config.queue.redis && config.connections.redis) {
+    config.queue.redis = config.connections.redis;
+  }
+  if (!config.queue.postgres && config.connections.postgres) {
+    config.queue.postgres = config.connections.postgres;
+  }
+  if (!config.queue.file && config.connections.file) {
+    config.queue.file = {
+      dataDir: `${config.connections.file.dataDir}/queue`
+    };
+  }
+  if (!config.stream.redis && config.connections.redis) {
+    config.stream.redis = config.connections.redis;
+  }
+  if (!config.stream.rabbitmq && config.connections.rabbitmq) {
+    config.stream.rabbitmq = config.connections.rabbitmq;
+  }
+  if (!config.stream.kafka && config.connections.kafka) {
+    config.stream.kafka = config.connections.kafka;
+  }
+  if (!config.store.redis && config.connections.redis) {
+    config.store.redis = config.connections.redis;
+  }
+  if (!config.store.postgres && config.connections.postgres) {
+    config.store.postgres = config.connections.postgres;
+  }
+  if (!config.store.file && config.connections.file) {
+    config.store.file = {
+      dataDir: `${config.connections.file.dataDir}/store`
+    };
+  }
+}
+export function toRuntimeConfig(normalizedOptions) {
+  return {
+    debug: normalizedOptions.debug,
+    rootDir: void 0,
+    queue: normalizedOptions.queue,
+    stream: normalizedOptions.stream,
+    store: normalizedOptions.store,
+    connections: normalizedOptions.connections,
+    flows: normalizedOptions.flows
+  };
+}
+export function getRedisStorageConfig(normalizedOptions) {
+  const redisConfig = normalizedOptions.connections.redis;
+  if (!redisConfig) {
+    return {
+      host: "127.0.0.1",
+      port: 6379
+    };
+  }
+  return {
+    host: redisConfig.host,
+    port: redisConfig.port,
+    username: redisConfig.username,
+    password: redisConfig.password,
+    db: redisConfig.db
+  };
+}

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

@@ -0,0 +1,367 @@
+/**
+ * Redis connection configuration
+ */
+export interface RedisConfig {
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    db?: number;
+    url?: string;
+}
+/**
+ * PostgreSQL connection configuration
+ */
+export interface PostgresConfig {
+    connectionString?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    ssl?: boolean | object;
+}
+/**
+ * RabbitMQ connection configuration
+ */
+export interface RabbitMQConfig {
+    url?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    vhost?: string;
+}
+/**
+ * Kafka connection configuration
+ */
+export interface KafkaConfig {
+    brokers?: string[];
+    clientId?: string;
+    groupId?: string;
+}
+/**
+ * File storage configuration
+ */
+export interface FileConfig {
+    /**
+     * Base directory for file storage
+     * @default '.data'
+     */
+    dataDir?: string;
+}
+/**
+ * Shared connection configurations (v0.4.1)
+ * Provides fallback connections for all adapters
+ */
+export interface ConnectionsConfig {
+    /**
+     * Shared Redis connection - used by adapters that specify 'redis' but don't provide connection details
+     */
+    redis?: RedisConfig;
+    /**
+     * Shared Postgres connection - used by adapters that specify 'postgres' but don't provide connection details
+     */
+    postgres?: PostgresConfig;
+    /**
+     * Shared RabbitMQ connection - used by stream adapter when 'rabbitmq' is specified
+     */
+    rabbitmq?: RabbitMQConfig;
+    /**
+     * Shared Kafka connection - used by stream adapter when 'kafka' is specified
+     */
+    kafka?: KafkaConfig;
+    /**
+     * Shared file storage configuration - used by file adapters
+     */
+    file?: FileConfig;
+}
+/**
+ * Worker configuration
+ */
+export interface WorkerConfig {
+    /**
+     * Number of concurrent jobs to process
+     * @default 2
+     */
+    concurrency?: number;
+    /**
+     * Lock duration for jobs in milliseconds
+     */
+    lockDurationMs?: number;
+    /**
+     * Maximum number of times a job can be stalled before failing
+     */
+    maxStalledCount?: number;
+    /**
+     * Delay before draining the queue on shutdown
+     */
+    drainDelayMs?: number;
+    /**
+     * Automatically start workers
+     * @default true
+     */
+    autorun?: boolean;
+    /**
+     * Polling interval for file adapter (milliseconds)
+     * @default 1000
+     */
+    pollingIntervalMs?: number;
+}
+/**
+ * Queue adapter configuration (v0.4.1)
+ */
+export interface QueueConfig {
+    /**
+     * Queue backend adapter
+     * @default 'file'
+     */
+    adapter?: 'memory' | 'file' | 'redis' | 'postgres';
+    /**
+     * Redis connection (overrides connections.redis if specified)
+     */
+    redis?: RedisConfig;
+    /**
+     * Postgres connection (overrides connections.postgres if specified)
+     */
+    postgres?: PostgresConfig;
+    /**
+     * File storage configuration (overrides connections.file if specified)
+     */
+    file?: FileConfig;
+    /**
+     * Queue-specific options (BullMQ/PGBoss configuration)
+     */
+    prefix?: string;
+    defaultJobOptions?: {
+        attempts?: number;
+        backoff?: number | {
+            type: 'fixed' | 'exponential';
+            delay: number;
+        };
+        delay?: number;
+        priority?: number;
+        timeout?: number;
+        lifo?: boolean;
+        removeOnComplete?: boolean | number;
+        removeOnFail?: boolean | number;
+    };
+    limiter?: {
+        max?: number;
+        duration?: number;
+        groupKey?: string;
+    };
+    /**
+     * Worker configuration
+     */
+    worker?: WorkerConfig;
+}
+/**
+ * Stream adapter configuration (v0.4.1)
+ * Cross-instance pub/sub messaging
+ */
+export interface StreamConfig {
+    /**
+     * Stream adapter
+     * @default 'memory'
+     */
+    adapter?: 'memory' | 'redis' | 'rabbitmq' | 'kafka';
+    /**
+     * Redis connection (overrides connections.redis if specified)
+     */
+    redis?: RedisConfig;
+    /**
+     * Postgres connection (overrides connections.postgres if specified)
+     */
+    postgres?: PostgresConfig;
+    /**
+     * RabbitMQ connection (overrides connections.rabbitmq if specified)
+     */
+    rabbitmq?: RabbitMQConfig;
+    /**
+     * Kafka connection (overrides connections.kafka if specified)
+     */
+    kafka?: KafkaConfig;
+    /**
+     * Stream-specific options
+     */
+    prefix?: string;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+/**
+ * Flow configuration
+ */
+export interface FlowConfig {
+    /**
+     * Stall detection configuration
+     * Detects and marks flows that have been running without activity for too long
+     */
+    stallDetection?: {
+        /**
+         * Enable stall detection
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Time in milliseconds after which a running flow without activity is considered stalled
+         * @default 1800000 (30 minutes)
+         */
+        stallTimeout?: number;
+        /**
+         * Interval in milliseconds for periodic stall checks
+         * @default 900000 (15 minutes)
+         */
+        checkInterval?: number;
+        /**
+         * Enable periodic background checks
+         * Set to false to use only lazy detection (when flows are queried)
+         * @default true
+         */
+        enablePeriodicCheck?: boolean;
+    };
+}
+/**
+ * State management configuration
+ */
+export interface StateManagementConfig {
+    /**
+     * Automatic scope/flow ID assignment for state operations
+     * - 'always': Always create a new flow ID (recommended for most cases)
+     * - 'flow': Only use flow ID if provided in context
+     * - 'never': Never scope state to flow IDs
+     * @default 'always'
+     */
+    autoScope?: 'always' | 'flow' | 'never';
+    /**
+     * State cleanup strategy
+     */
+    cleanup?: {
+        /**
+         * Cleanup strategy
+         * - 'never': State persists indefinitely
+         * - 'immediate': Cleanup after each step (not recommended)
+         * - 'on-complete': Cleanup when flow completes (recommended)
+         * - 'ttl': Automatic expiration via TTL
+         * @default 'never'
+         */
+        strategy?: 'never' | 'immediate' | 'on-complete' | 'ttl';
+        /**
+         * TTL in milliseconds for 'ttl' strategy
+         * @default 3600000 (1 hour)
+         */
+        ttlMs?: number;
+    };
+}
+/**
+ * Store adapter configuration (v0.4.1)
+ * Three-tier storage: events (NDJSON), documents (JSON), KV (JSON), indices (JSON)
+ * Replaces both state and eventStore configs from v0.4.0
+ */
+export interface StoreConfig {
+    /**
+     * Store adapter
+     * @default 'file'
+     */
+    adapter?: 'memory' | 'file' | 'redis' | 'postgres';
+    /**
+     * Redis connection (overrides connections.redis if specified)
+     */
+    redis?: RedisConfig;
+    /**
+     * Postgres connection (overrides connections.postgres if specified)
+     */
+    postgres?: PostgresConfig;
+    /**
+     * File storage configuration (overrides connections.file if specified)
+     */
+    file?: FileConfig;
+    /**
+     * Key prefix/namespace for all store operations
+     * @default 'nq'
+     */
+    prefix?: string;
+    /**
+     * State management configuration (KV store behavior)
+     */
+    state?: StateManagementConfig;
+    /**
+     * Event stream TTL in seconds
+     * @default 604800 (7 days)
+     */
+    eventTTL?: number;
+    /**
+     * Metadata document TTL in seconds
+     * @default 2592000 (30 days)
+     */
+    metadataTTL?: number;
+    /**
+     * KV store TTL in seconds
+     */
+    kvTTL?: number;
+    /**
+     * Index TTL in seconds
+     */
+    indexTTL?: number;
+    /**
+     * Enable compression for stored data
+     */
+    compression?: boolean;
+}
+/**
+ * Module options for nvent (v0.4.1+)
+ */
+export interface ModuleOptions {
+    /**
+     * Directory to scan for function definitions
+     * @default 'server/functions'
+     */
+    dir?: string;
+    /**
+     * Enable dev UI
+     * @default true in development
+     */
+    ui?: boolean;
+    /**
+     * Debug configuration
+     */
+    debug?: Record<string, any>;
+    /**
+     * Queue adapter configuration (job execution)
+     */
+    queue?: QueueConfig;
+    /**
+     * Stream adapter configuration (pub/sub messaging)
+     * @since v0.4.1
+     */
+    stream?: StreamConfig;
+    /**
+     * Store adapter configuration (persistence)
+     * Three-tier storage: events, documents, KV, indices
+     * @since v0.4.1
+     */
+    store?: StoreConfig;
+    /**
+     * Flow-specific configuration
+     * @since v0.4.1
+     */
+    flows?: FlowConfig;
+    /**
+     * Shared connection configurations
+     * Used as fallback if adapters don't specify their own connections
+     * @since v0.4.1
+     */
+    connections?: ConnectionsConfig;
+}
+/**
+ * Runtime config shape for nvent module (v0.4.1+)
+ */
+export interface ModuleConfig {
+    debug?: Record<string, any>;
+    queue: Required<QueueConfig>;
+    stream: Required<StreamConfig>;
+    store: Required<StoreConfig>;
+    flows: Required<FlowConfig>;
+    connections: Required<ConnectionsConfig>;
+    rootDir?: string;
+}

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

@@ -0,0 +1,116 @@
+export interface PublishContext {
+    queue?: string;
+    jobId?: string;
+    /** Flow run ID for flow events */
+    flowId?: string;
+    /** Trigger ID for trigger events */
+    triggerId?: string;
+}
+export interface PublishPayload<T = any> {
+    type: string;
+    runId: string;
+    flowName: string;
+    stepName?: string;
+    stepId?: string;
+    attempt?: number;
+    data?: T;
+}
+export type EventType = 'flow.start' | 'flow.completed' | 'flow.failed' | 'flow.cancel' | 'step.started' | 'step.completed' | 'step.failed' | 'step.retry' | 'log' | 'emit' | 'state' | 'flow.stalled';
+export interface BaseEvent {
+    id?: string;
+    ts?: string;
+    type: EventType;
+    runId: string;
+    flowName: string;
+}
+export interface StepEvent extends BaseEvent {
+    stepName: string;
+    stepId: string;
+    attempt: number;
+}
+export interface FlowStartEvent extends BaseEvent {
+    type: 'flow.start';
+    data?: {
+        input?: any;
+    };
+}
+export interface FlowCompletedEvent extends BaseEvent {
+    type: 'flow.completed';
+    data?: {
+        result?: any;
+    };
+}
+export interface FlowFailedEvent extends BaseEvent {
+    type: 'flow.failed';
+    data?: {
+        error?: string;
+        stack?: string;
+    };
+}
+export interface FlowCancelEvent extends BaseEvent {
+    type: 'flow.cancel';
+    data?: {
+        canceledAt?: string;
+    };
+}
+export interface FlowStalledEvent extends BaseEvent {
+    type: 'flow.stalled';
+    data?: {
+        lastActivityAt?: number;
+        stallTimeout?: number;
+    };
+}
+export interface StepStartedEvent extends StepEvent {
+    type: 'step.started';
+    data?: {
+        input?: any;
+    };
+}
+export interface StepCompletedEvent extends StepEvent {
+    type: 'step.completed';
+    data?: {
+        result?: any;
+    };
+}
+export interface StepFailedEvent extends StepEvent {
+    type: 'step.failed';
+    data?: {
+        error?: string;
+        stack?: string;
+    };
+}
+export interface StepRetryEvent extends StepEvent {
+    type: 'step.retry';
+    data?: {
+        stepName: string;
+        queue: string;
+        attempt: number;
+        maxAttempts: number;
+        nextAttempt: number;
+    };
+}
+export interface LogEvent extends StepEvent {
+    type: 'log';
+    data: {
+        level: 'debug' | 'info' | 'warn' | 'error';
+        message: string;
+        [key: string]: any;
+    };
+}
+export interface EmitEvent extends StepEvent {
+    type: 'emit';
+    data: {
+        topic: string;
+        payload: any;
+    };
+}
+export interface StateEvent extends StepEvent {
+    type: 'state';
+    data: {
+        operation: 'get' | 'set' | 'delete';
+        scope?: string;
+        key: string;
+        value?: any;
+    };
+}
+export type FlowEvent = FlowStartEvent | FlowCompletedEvent | FlowFailedEvent | FlowCancelEvent | FlowStalledEvent | StepStartedEvent | StepCompletedEvent | StepFailedEvent | StepRetryEvent | LogEvent | EmitEvent | StateEvent;