nvent 0.4.4 → 0.5.0

package/dist/runtime/adapters/registry.js

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

@@ -0,0 +1,29 @@
+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;
+    port: number;
+    username?: undefined;
+    password?: undefined;
+    db?: undefined;
+} | {
+    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

@@ -0,0 +1,175 @@
+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
+      }
+    },
+    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);
+  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/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: "127.0.0.1",
+      port: 6379
+    };
+  }
+  return {
+    host: redisConfig.host,
+    port: redisConfig.port,
+    username: redisConfig.username,
+    password: redisConfig.password,
+    db: redisConfig.db
+  };
+}