nvent 0.5.15 → 1.0.0-alpha.2

package/dist/runtime/adapters/registry.js

@@ -1,161 +0,0 @@
-export class AdapterRegistry {
-  queueAdapters = /* @__PURE__ */ new Map();
-  streamAdapters = /* @__PURE__ */ new Map();
-  storeAdapters = /* @__PURE__ */ new Map();
-  // ============================================================
-  // Registration
-  // ============================================================
-  /**
-   * Register a queue adapter
-   * @param name - Adapter name (e.g., 'redis', 'memory', 'postgres')
-   * @param adapter - QueueAdapter implementation
-   */
-  registerQueue(name, adapter) {
-    if (this.queueAdapters.has(name)) {
-      console.warn(`[nvent] Queue adapter "${name}" is already registered, overwriting`);
-    }
-    this.queueAdapters.set(name, adapter);
-  }
-  /**
-   * Register a stream adapter
-   * @param name - Adapter name (e.g., 'redis', 'memory', 'rabbitmq')
-   * @param adapter - StreamAdapter implementation
-   */
-  registerStream(name, adapter) {
-    if (this.streamAdapters.has(name)) {
-      console.warn(`[nvent] Stream adapter "${name}" is already registered, overwriting`);
-    }
-    this.streamAdapters.set(name, adapter);
-  }
-  /**
-   * Register a store adapter
-   * @param name - Adapter name (e.g., 'redis', 'memory', 'postgres')
-   * @param adapter - StoreAdapter implementation
-   */
-  registerStore(name, adapter) {
-    if (this.storeAdapters.has(name)) {
-      console.warn(`[nvent] Store adapter "${name}" is already registered, overwriting`);
-    }
-    this.storeAdapters.set(name, adapter);
-  }
-  // ============================================================
-  // Retrieval
-  // ============================================================
-  /**
-   * Get a queue adapter by name
-   * @throws Error if adapter not found
-   */
-  getQueue(name) {
-    const adapter = this.queueAdapters.get(name);
-    if (!adapter) {
-      throw new Error(
-        `[nvent] Queue adapter "${name}" not found. Available: ${Array.from(this.queueAdapters.keys()).join(", ")}`
-      );
-    }
-    return adapter;
-  }
-  /**
-   * Get a stream adapter by name
-   * @throws Error if adapter not found
-   */
-  getStream(name) {
-    const adapter = this.streamAdapters.get(name);
-    if (!adapter) {
-      throw new Error(
-        `[nvent] Stream adapter "${name}" not found. Available: ${Array.from(this.streamAdapters.keys()).join(", ")}`
-      );
-    }
-    return adapter;
-  }
-  /**
-   * Get a store adapter by name
-   * @throws Error if adapter not found
-   */
-  getStore(name) {
-    const adapter = this.storeAdapters.get(name);
-    if (!adapter) {
-      throw new Error(
-        `[nvent] Store adapter "${name}" not found. Available: ${Array.from(this.storeAdapters.keys()).join(", ")}`
-      );
-    }
-    return adapter;
-  }
-  // ============================================================
-  // Utilities
-  // ============================================================
-  /**
-   * Check if a queue adapter is registered
-   */
-  hasQueue(name) {
-    return this.queueAdapters.has(name);
-  }
-  /**
-   * Check if a stream adapter is registered
-   */
-  hasStream(name) {
-    return this.streamAdapters.has(name);
-  }
-  /**
-   * Check if a store adapter is registered
-   */
-  hasStore(name) {
-    return this.storeAdapters.has(name);
-  }
-  /**
-   * List all registered queue adapters
-   */
-  listQueueAdapters() {
-    return Array.from(this.queueAdapters.keys());
-  }
-  /**
-   * List all registered stream adapters
-   */
-  listStreamAdapters() {
-    return Array.from(this.streamAdapters.keys());
-  }
-  /**
-   * List all registered store adapters
-   */
-  listStoreAdapters() {
-    return Array.from(this.storeAdapters.keys());
-  }
-  /**
-   * Initialize all registered adapters
-   */
-  async initAll() {
-    const promises = [];
-    Array.from(this.queueAdapters.values()).forEach((adapter) => {
-      promises.push(adapter.init());
-    });
-    Array.from(this.streamAdapters.values()).forEach((adapter) => {
-      promises.push(adapter.init());
-    });
-    await Promise.all(promises);
-  }
-  /**
-   * Close/cleanup all registered adapters
-   */
-  async closeAll() {
-    const promises = [];
-    Array.from(this.queueAdapters.values()).forEach((adapter) => {
-      promises.push(adapter.close());
-    });
-    Array.from(this.streamAdapters.values()).forEach((adapter) => {
-      promises.push(adapter.shutdown());
-    });
-    Array.from(this.storeAdapters.values()).forEach((adapter) => {
-      promises.push(adapter.close());
-    });
-    await Promise.all(promises);
-  }
-}
-let registry = null;
-export function useAdapterRegistry() {
-  if (!registry) {
-    registry = new AdapterRegistry();
-  }
-  return registry;
-}
-export function resetAdapterRegistry() {
-  registry = null;
-}

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

@@ -1,23 +0,0 @@
-import type { ModuleOptions, ModuleConfig } from './types.js';
-/**
- * Merge and normalize module options with defaults.
- * Applies connection fallback: adapter-specific connections override connections.redis/postgres.
- * Only includes connection defaults for adapters that are actually used.
- */
-export declare function normalizeModuleOptions(options: ModuleOptions): Required<ModuleOptions>;
-/**
- * Convert normalized module options to runtime config format.
- */
-export declare function toRuntimeConfig(normalizedOptions: Required<ModuleOptions>): ModuleConfig;
-/**
- * Get Redis connection config for nitro storage.
- * Uses shared connections.redis as primary source.
- */
-export declare function getRedisStorageConfig(normalizedOptions: Required<ModuleOptions>): {
-    host: string | undefined;
-    port: number | undefined;
-    username: string | undefined;
-    password: string | undefined;
-    db: number | undefined;
-};
-export type { ModuleOptions, ModuleConfig } from './types.js';

package/dist/runtime/config/index.js

@@ -1,200 +0,0 @@
-import defu from "defu";
-export function normalizeModuleOptions(options) {
-  const defaults = {
-    dir: "functions",
-    ui: true,
-    debug: {},
-    connections: {},
-    queue: {
-      adapter: "file",
-      prefix: "nvent",
-      schema: "nvent_queue",
-      defaultJobOptions: {},
-      worker: {
-        concurrency: 2,
-        autorun: true,
-        pollingIntervalMs: 1e3
-      }
-    },
-    stream: {
-      adapter: "memory",
-      prefix: "nvent"
-    },
-    store: {
-      adapter: "file",
-      prefix: "nvent",
-      schema: "nvent_store",
-      state: {
-        autoScope: "always",
-        cleanup: {
-          strategy: "never",
-          ttlMs: 36e5
-          // 1 hour
-        }
-      },
-      eventTTL: 604800,
-      // 7 days
-      metadataTTL: 2592e3
-      // 30 days
-    },
-    flow: {
-      stallDetection: {
-        enabled: true,
-        stallTimeout: 30 * 60 * 1e3,
-        // 30 minutes
-        checkInterval: 15 * 60 * 1e3,
-        // 15 minutes
-        enablePeriodicCheck: true
-      },
-      awaitDefaults: {
-        webhookTimeout: 24 * 60 * 60 * 1e3,
-        // 24 hours
-        eventTimeout: 24 * 60 * 60 * 1e3,
-        // 24 hours
-        timeTimeout: void 0,
-        // No default timeout for time awaits
-        scheduleTimeout: void 0,
-        // No default timeout for schedule awaits
-        timeoutAction: "fail"
-      },
-      stepTimeout: 5 * 60 * 1e3
-      // 5 minutes default step execution timeout
-    },
-    webhooks: {
-      // baseUrl will be determined at runtime from Nitro context
-      // Users can override via NUXT_PUBLIC_SITE_URL or explicit config
-      baseUrl: process.env.NUXT_PUBLIC_SITE_URL || void 0
-    }
-  };
-  const normalized = defu(options, defaults);
-  if (normalized.connections?.redis) {
-    console.log("[nvent-config] Redis connection after normalization:", {
-      host: normalized.connections.redis.host,
-      port: normalized.connections.redis.port
-    });
-  }
-  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: process.env.REDIS_HOST || "127.0.0.1",
-      port: Number.parseInt(process.env.REDIS_PORT || "6379", 10),
-      password: process.env.REDIS_PASSWORD,
-      username: process.env.REDIS_USERNAME,
-      db: process.env.REDIS_DB ? Number.parseInt(process.env.REDIS_DB, 10) : 0
-    };
-  }
-  if (neededConnections.has("postgres") && !normalized.connections.postgres) {
-    normalized.connections.postgres = {
-      connectionString: process.env.DATABASE_URL || "postgresql://localhost:5432/nvent"
-    };
-  }
-  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,
-    flow: normalizedOptions.flow,
-    webhooks: normalizedOptions.webhooks
-  };
-}
-export function getRedisStorageConfig(normalizedOptions) {
-  const redisConfig = normalizedOptions.connections.redis;
-  if (!redisConfig) {
-    return {
-      host: process.env.REDIS_HOST || "127.0.0.1",
-      port: Number.parseInt(process.env.REDIS_PORT || "6379", 10),
-      username: process.env.REDIS_USERNAME,
-      password: process.env.REDIS_PASSWORD,
-      db: process.env.REDIS_DB ? Number.parseInt(process.env.REDIS_DB, 10) : 0
-    };
-  }
-  return {
-    host: redisConfig.host,
-    port: redisConfig.port,
-    username: redisConfig.username,
-    password: redisConfig.password,
-    db: redisConfig.db
-  };
-}