nvent 0.4.3 → 0.4.5

package/dist/module.d.mts

@@ -1,193 +1,12 @@
 import * as _nuxt_schema from '@nuxt/schema';
-
-/**
- * Redis connection configuration
- */
-interface RedisConfig {
-    host?: string;
-    port?: number;
-    username?: string;
-    password?: string;
-    db?: number;
-    url?: string;
-}
-/**
- * PostgreSQL connection configuration
- */
-interface PostgresConfig {
-    connectionString?: string;
-    host?: string;
-    port?: number;
-    database?: string;
-    user?: string;
-    password?: string;
-}
-/**
- * Queue provider configuration
- */
-interface QueueConfig {
-    /**
-     * Queue backend adapter: 'redis' (BullMQ) or 'postgres' (PGBoss)
-     */
-    adapter?: 'redis' | 'postgres';
-    /**
-     * Redis connection config (when using BullMQ)
-     */
-    redis?: RedisConfig;
-    /**
-     * Postgres connection config (when using PGBoss)
-     */
-    postgres?: PostgresConfig;
-    /**
-     * Default configuration for queues and workers.
-     * Combines both queue and worker options for convenience.
-     */
-    defaultConfig?: {
-        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?: {
-            concurrency?: number;
-            lockDurationMs?: number;
-            maxStalledCount?: number;
-            drainDelayMs?: number;
-            autorun?: boolean;
-            pollingIntervalMs?: number;
-        };
-    };
-}
-/**
- * State provider configuration
- */
-interface StateConfig {
-    adapter?: 'redis' | 'postgres';
-    namespace?: string;
-    autoScope?: 'always' | 'flow' | 'never';
-    cleanup?: {
-        strategy?: 'never' | 'immediate' | 'ttl' | 'on-complete';
-        ttlMs?: number;
-    };
-    redis?: RedisConfig;
-    postgres?: PostgresConfig;
-}
-/**
- * Event store configuration
- */
-interface EventStoreConfig {
-    adapter?: 'redis' | 'postgres' | 'memory' | 'file';
-    streams?: any;
-    options?: {
-        file?: {
-            dir?: string;
-            ext?: string;
-            pollMs?: number;
-        };
-    };
-    redis?: RedisConfig;
-    postgres?: PostgresConfig;
-    /**
-     * Retention settings for event lifecycle tracking
-     */
-    retention?: {
-        /**
-         * How long to keep event stream data (in seconds)
-         * @default 604800 (7 days)
-         */
-        eventTTL?: number;
-        /**
-         * How long to keep flow metadata after completion/failure (in seconds)
-         * @default 2592000 (30 days)
-         */
-        metadataTTL?: number;
-    };
-}
-/**
- * Store shortcut - sets all backends to the same storage
- */
-interface StoreShortcut {
-    /**
-     * Storage backend adapter to use for everything
-     */
-    adapter: 'redis' | 'postgres';
-    /**
-     * Redis config (used when adapter is 'redis')
-     */
-    redis?: RedisConfig;
-    /**
-     * Postgres config (used when adapter is 'postgres')
-     */
-    postgres?: PostgresConfig;
-}
-/**
- * Module options for nuxt-queue
- */
-interface ModuleOptions {
-    /**
-     * Directory to scan for queue workers
-     */
-    dir?: string;
-    /**
-     * Enable dev UI
-     */
-    ui?: boolean;
-    /**
-     * Debug configuration
-     */
-    debug?: Record<string, any>;
-    /**
-     * Shortcut to configure all backends at once.
-     * Setting this will configure queue, state, and eventStore to use the same backend.
-     * Individual configs can still override this.
-     */
-    store?: StoreShortcut;
-    /**
-     * Queue provider configuration (BullMQ/PGBoss)
-     */
-    queue?: QueueConfig;
-    /**
-     * State provider configuration
-     */
-    state?: StateConfig;
-    /**
-     * Event store configuration
-     */
-    eventStore?: EventStoreConfig;
-}
-/**
- * Runtime config shape for queue module
- */
-interface QueueModuleConfig {
-    debug?: Record<string, any>;
-    workers: any[];
-    registry?: any;
-    queue: Required<QueueConfig>;
-    state: Required<StateConfig>;
-    eventStore: Required<EventStoreConfig>;
-    rootDir?: string;
-}
+import { ModuleConfig, ModuleOptions } from '../dist/runtime/config/types.js';
+export { ModuleOptions } from '../dist/runtime/config/types.js';
 
 declare module '@nuxt/schema' {
     interface RuntimeConfig {
-        queue: QueueModuleConfig;
+        nvent: ModuleConfig;
     }
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { _default as default };
-export type { ModuleOptions };

package/dist/module.json

@@ -1,7 +1,7 @@
 {
-  "name": "queue",
-  "version": "0.1",
-  "configKey": "queue",
+  "name": "nvent",
+  "version": "0.4.1",
+  "configKey": "nvent",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { dirname, join, extname, relative } from 'node:path';
-import { useLogger, defineNuxtModule, createResolver, addServerScanDir, addImportsDir, addPlugin, addComponentsDir, addComponent, addTemplate, addServerImports, updateTemplates } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addServerScanDir, addTemplate, addTypeTemplate, addServerImports, updateTemplates } from '@nuxt/kit';
 import defu from 'defu';
 import { existsSync, realpathSync } from 'node:fs';
 import { globby } from 'globby';
@@ -10,6 +10,7 @@ import { spawn } from 'node:child_process';
 import chokidar from 'chokidar';
 import { join as join$1 } from 'pathe';
 import { debounce } from 'perfect-debounce';
+import { normalizeModuleOptions, getRedisStorageConfig, toRuntimeConfig } from '../dist/runtime/config/index.js';
 
 async function loadJsConfig(absPath) {
   const cacheBust = `?t=${Date.now()}`;
@@ -127,7 +128,7 @@ function astToValue(node) {
 
 async function loadPyConfig(absPath, logger) {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
-  const helper = join(moduleDir, "..", "..", "runtime", "python", "get_config.py");
+  const helper = join(moduleDir, "..", "..", "runtime", "worker", "python", "get_config.py");
   let pyConfig;
   if (existsSync(helper)) {
     pyConfig = await new Promise((resolve) => {
@@ -685,144 +686,12 @@ export default useAnalyzedFlows;
 `;
 }
 
-function normalizeModuleOptions(options) {
-  const defaults = {
-    dir: "queues",
-    ui: true,
-    debug: {},
-    queue: {
-      adapter: "redis",
-      redis: {
-        host: "127.0.0.1",
-        port: 6379
-      },
-      defaultConfig: {
-        // Queue options
-        prefix: "nq",
-        defaultJobOptions: {},
-        // Worker options
-        worker: {
-          concurrency: 2,
-          autorun: true
-        }
-      }
-    },
-    state: {
-      adapter: "redis",
-      namespace: "nq",
-      autoScope: "always",
-      cleanup: {
-        strategy: "never"
-      },
-      redis: {
-        host: "127.0.0.1",
-        port: 6379
-      }
-    },
-    eventStore: {
-      adapter: "memory",
-      options: {
-        file: {
-          dir: ".data/nq-events",
-          ext: ".ndjson",
-          pollMs: 1e3
-        }
-      },
-      retention: {
-        eventTTL: 604800,
-        // 7 days
-        metadataTTL: 2592e3
-        // 30 days
-      }
-    }
-  };
-  if (options.store) {
-    const storeConfig = expandStoreShortcut(options.store);
-    return defu(options, storeConfig, defaults);
-  }
-  return defu(options, defaults);
-}
-function expandStoreShortcut(store) {
-  if (!store) return {};
-  const storeAdapter = store.adapter;
-  if (storeAdapter === "redis") {
-    const redisConfig = store.redis || {
-      host: "127.0.0.1",
-      port: 6379
-    };
-    return {
-      queue: {
-        adapter: "redis",
-        redis: redisConfig,
-        defaultConfig: {}
-      },
-      state: {
-        adapter: "redis",
-        namespace: "nq",
-        autoScope: "always",
-        cleanup: { strategy: "never" },
-        redis: redisConfig
-      },
-      eventStore: {
-        adapter: "redis",
-        redis: redisConfig
-      }
-    };
-  }
-  if (storeAdapter === "postgres") {
-    const postgresConfig = store.postgres || {
-      connectionString: process.env.DATABASE_URL || "postgresql://localhost:5432/nuxt_queue"
-    };
-    return {
-      queue: {
-        adapter: "postgres",
-        postgres: postgresConfig,
-        defaultConfig: {}
-      },
-      state: {
-        adapter: "postgres",
-        postgres: postgresConfig
-      },
-      eventStore: {
-        adapter: "postgres",
-        postgres: postgresConfig
-      }
-    };
-  }
-  return {};
-}
-function toRuntimeConfig(normalizedOptions) {
-  return {
-    debug: normalizedOptions.debug,
-    workers: [],
-    queue: normalizedOptions.queue,
-    state: normalizedOptions.state,
-    eventStore: normalizedOptions.eventStore
-  };
-}
-function getRedisStorageConfig(normalizedOptions) {
-  const redisConfig = normalizedOptions.queue.redis || normalizedOptions.state.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
-  };
-}
-
 const meta = {
-  name: "queue",
-  version: "0.1",
-  configKey: "queue"
+  name: "nvent",
+  version: "0.4.1",
+  configKey: "nvent"
 };
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta,
   defaults: {},
   moduleDependencies: {
@@ -832,30 +701,10 @@ const module = defineNuxtModule({
   },
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    const config = normalizeModuleOptions(options);
+    const userConfig = nuxt.options[meta.configKey] || {};
+    const mergedOptions = { ...userConfig, ...options };
+    const config = normalizeModuleOptions(mergedOptions);
     addServerScanDir(resolve("./runtime/server"));
-    addImportsDir(resolve("./runtime/shared/utils"));
-    addImportsDir(resolve("./runtime/app/composables"));
-    if (config.ui) {
-      nuxt.options.css = nuxt.options.css || [];
-      nuxt.options.css.push(resolve("./runtime/app/assets/vueflow.css"));
-      addPlugin({
-        src: resolve("./runtime/app/plugins/vueflow.client"),
-        mode: "client"
-      });
-      addComponentsDir({
-        path: resolve("./runtime/app/components"),
-        prefix: "Queue"
-      });
-      addComponent({
-        name: "QueueApp",
-        filePath: resolve("./runtime/app/pages/index.vue"),
-        global: true
-      });
-    }
-    nuxt.options.vite.optimizeDeps = defu(nuxt.options.vite.optimizeDeps, {
-      include: ["vanilla-jsoneditor"]
-    });
     nuxt.hook("nitro:config", (nitro) => {
       const redisConfig = getRedisStorageConfig(config);
       nitro.storage = defu(nitro.storage || {}, {
@@ -870,28 +719,25 @@ const module = defineNuxtModule({
       });
     });
     const runtimeConfig = nuxt.options.runtimeConfig;
-    runtimeConfig.queue = defu(runtimeConfig.queue || {}, toRuntimeConfig(config));
-    if (!runtimeConfig.queue) runtimeConfig.queue = {};
-    runtimeConfig.queue.rootDir = nuxt.options.rootDir;
+    runtimeConfig.nvent = defu(runtimeConfig.nvent || {}, toRuntimeConfig(config));
+    if (!runtimeConfig.nvent) runtimeConfig.nvent = {};
+    runtimeConfig.nvent.rootDir = nuxt.options.rootDir;
     const layerInfos = nuxt.options._layers.map((l) => ({
       rootDir: l.config.rootDir,
       serverDir: l.config?.serverDir || join(l.config.rootDir, "server")
     }));
-    const { worker: _worker, ...queueOptions } = config.queue.defaultConfig || {};
+    const { worker, ...queueOptions } = config.queue;
     const defaultConfigs = {
       queue: queueOptions,
-      worker: config.queue.defaultConfig?.worker
+      worker
     };
-    const compiledRegistry = await compileRegistryFromServerWorkers(layerInfos, config.dir || "queues", defaultConfigs);
+    const compiledRegistry = await compileRegistryFromServerWorkers(layerInfos, config.dir || "functions", defaultConfigs);
     const compiledWithMeta = defu(compiledRegistry, {
       version: 1,
       compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
       provider: { name: config.queue.adapter === "postgres" ? "pgboss" : "bullmq" },
       logger: { name: "console", level: "info" },
-      state: config.state,
-      eventStore: config.eventStore,
       runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
-      workers: [],
       flows: {},
       eventIndex: {}
     });
@@ -919,6 +765,70 @@ const module = defineNuxtModule({
       write: true,
       getContents: () => generateAnalyzedFlowsTemplate(lastCompiledRegistry)
     });
+    addTypeTemplate({
+      filename: "types/nvent-adapters.d.ts",
+      getContents: () => `
+// Auto-generated adapter type definitions
+// External adapter packages can import these types
+
+// Queue Adapter
+export type {
+  QueueAdapter,
+  JobInput,
+  Job,
+  JobsQuery,
+  JobOptions,
+  JobState,
+  ScheduleOptions,
+  JobCounts,
+  QueueEvent,
+  WorkerHandler,
+  WorkerContext,
+  WorkerOptions,
+} from ${JSON.stringify(resolve("./runtime/adapters/interfaces/queue"))}
+
+// Stream Adapter
+export type {
+  StreamAdapter,
+  StreamEvent,
+  SubscribeOptions,
+  SubscriptionHandle,
+} from ${JSON.stringify(resolve("./runtime/adapters/interfaces/stream"))}
+
+// Store Adapter
+export type {
+  StoreAdapter,
+  EventRecord,
+  EventReadOptions,
+  EventSubscription,
+  ListOptions,
+} from ${JSON.stringify(resolve("./runtime/adapters/interfaces/store"))}
+
+// Event Types
+export type {
+  EventType,
+  BaseEvent,
+  StepEvent,
+  FlowStartEvent,
+  FlowCompletedEvent,
+  FlowFailedEvent,
+  FlowCancelEvent,
+  FlowStalledEvent,
+  StepStartedEvent,
+  StepCompletedEvent,
+  StepFailedEvent,
+  StepRetryEvent,
+  LogEvent,
+  EmitEvent,
+  StateEvent,
+  FlowEvent,
+} from ${JSON.stringify(resolve("./runtime/events/types"))}
+
+// Adapter Registry
+export type { AdapterRegistry } from ${JSON.stringify(resolve("./runtime/adapters/registry"))}
+      `.trim()
+    });
+    nuxt.options.alias["#nvent/adapters"] = resolve(nuxt.options.buildDir, "types/nvent-adapters");
     addServerImports([
       // Generated templates
       {
@@ -936,57 +846,83 @@ const module = defineNuxtModule({
         as: "$useAnalyzedFlows",
         from: resolve(nuxt.options.buildDir, "analyzed-flows")
       },
-      // Core utilities for user code (moved to server-utils to avoid bundling issues)
+      // Core utilities for user code
       {
-        name: "defineQueueConfig",
-        from: resolve("./runtime/server-utils/utils/defineQueueConfig")
+        name: "defineFunctionConfig",
+        from: resolve("./runtime/utils/defineFunctionConfig")
       },
       {
-        name: "defineQueueWorker",
-        from: resolve("./runtime/server-utils/utils/defineQueueWorker")
+        name: "defineFunction",
+        from: resolve("./runtime/utils/defineFunction")
       },
       // Composables users may need in server code
       {
-        name: "useQueue",
-        from: resolve("./runtime/server-utils/utils/useQueue")
+        name: "useFlowEngine",
+        from: resolve("./runtime/utils/useFlowEngine")
       },
       {
-        name: "useFlowEngine",
-        from: resolve("./runtime/server-utils/utils/useFlowEngine")
+        name: "useEventManager",
+        from: resolve("./runtime/utils/useEventManager")
       },
       {
-        name: "useEventStore",
-        from: resolve("./runtime/server-utils/utils/useEventStore")
+        name: "usePeerManager",
+        from: resolve("./runtime/utils/wsPeerManager")
       },
       {
-        name: "useLogs",
-        from: resolve("./runtime/server-utils/utils/useLogs")
+        name: "useNventLogger",
+        from: resolve("./runtime/utils/useNventLogger")
       },
       {
-        name: "useEventManager",
-        from: resolve("./runtime/server-utils/utils/useEventManager")
+        name: "useQueueAdapter",
+        from: resolve("./runtime/utils/adapters")
       },
       {
-        name: "usePeerManager",
-        from: resolve("./runtime/server-utils/utils/wsPeerManager")
+        name: "useStoreAdapter",
+        from: resolve("./runtime/utils/adapters")
       },
       {
-        name: "useNventLogger",
-        from: resolve("./runtime/server-utils/utils/useNventLogger")
+        name: "useStreamAdapter",
+        from: resolve("./runtime/utils/adapters")
+      },
+      {
+        name: "useStateAdapter",
+        from: resolve("./runtime/utils/adapters")
+      },
+      {
+        name: "getAdapters",
+        from: resolve("./runtime/utils/adapters")
+      },
+      {
+        name: "setAdapters",
+        from: resolve("./runtime/utils/adapters")
+      },
+      {
+        name: "useStreamTopics",
+        from: resolve("./runtime/utils/useStreamTopics")
+      },
+      // Adapter registration utilities for external modules
+      {
+        name: "registerQueueAdapter",
+        from: resolve("./runtime/utils/registerAdapter")
+      },
+      {
+        name: "registerStreamAdapter",
+        from: resolve("./runtime/utils/registerAdapter")
+      },
+      {
+        name: "registerStoreAdapter",
+        from: resolve("./runtime/utils/registerAdapter")
       }
     ]);
     const refreshRegistry = async (reason, changedPath) => {
-      const queuesRel = config.dir || "queues";
-      const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, queuesRel, defaultConfigs);
+      const functionsDir = config.dir || "functions";
+      const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, functionsDir, defaultConfigs);
       lastCompiledRegistry = JSON.parse(JSON.stringify(defu(updatedRegistry, {
         version: 1,
         compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
         provider: { name: config.queue.adapter === "postgres" ? "pgboss" : "bullmq" },
         logger: { name: "console", level: "info" },
-        state: config.state,
-        eventStore: config.eventStore,
         runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
-        workers: [],
         flows: {},
         eventIndex: {}
       })));
@@ -1005,15 +941,15 @@ const module = defineNuxtModule({
       console.log(`[nuxt-queue] templates updated`);
     };
     if (nuxt.options.dev) {
-      const queuesRel = config.dir || "queues";
+      const functionsDir = config.dir || "functions";
       watchQueueFiles({
         nuxt,
         layerInfos,
-        queuesDir: queuesRel,
+        queuesDir: functionsDir,
         onRefresh: refreshRegistry
       });
     }
   }
 });
 
-export { module as default };
+export { module$1 as default };

package/dist/runtime/adapters/builtin/file-queue.d.ts

@@ -0,0 +1,53 @@
+/**
+ * File Queue Adapter
+ *
+ * File-based queue implementation for development/small deployments
+ * - Uses fastq for job processing (same as memory adapter)
+ * - Persists jobs to file system
+ * - Survives restarts
+ * - Single instance only (no distributed lock)
+ *
+ * Storage format:
+ * - {dataDir}/queues/{queueName}/jobs/{jobId}.json - Individual job files
+ * - Jobs are loaded on init and kept in memory with fastq
+ */
+import type { QueueAdapter, JobInput, Job, JobsQuery, ScheduleOptions, JobCounts, QueueEvent, WorkerHandler, WorkerOptions } from '../interfaces/queue.js';
+export interface FileQueueAdapterOptions {
+    dataDir: string;
+    maxQueueSize?: number;
+}
+export declare class FileQueueAdapter implements QueueAdapter {
+    private jobs;
+    private eventListeners;
+    private workers;
+    private scheduledJobs;
+    private options;
+    private initialized;
+    constructor(options: FileQueueAdapterOptions);
+    init(): Promise<void>;
+    private loadJobsFromDisk;
+    private persistJob;
+    private deleteJobFile;
+    enqueue(queueName: string, job: JobInput): Promise<string>;
+    schedule(queueName: string, job: JobInput, opts?: ScheduleOptions): Promise<string>;
+    getJob(_queueName: string, id: string): Promise<Job | null>;
+    getJobs(queueName: string, query?: JobsQuery): Promise<Job[]>;
+    on(queueName: string, event: QueueEvent, callback: (payload: any) => void): () => void;
+    isPaused(queueName: string): Promise<boolean>;
+    getJobCounts(queueName: string): Promise<JobCounts>;
+    getScheduledJobs(queueName: string): Promise<Array<any>>;
+    removeScheduledJob(scheduleId: string): Promise<boolean>;
+    pause(queueName: string): Promise<void>;
+    resume(queueName: string): Promise<void>;
+    close(): Promise<void>;
+    registerWorker(queueName: string, jobName: string, handler: WorkerHandler, opts?: WorkerOptions): void;
+    /**
+     * Start processing waiting jobs for a queue
+     * Should be called after all handlers are registered
+     */
+    startProcessingQueue(queueName: string): void;
+    private updateJobState;
+    private emitEvent;
+    private generateId;
+    private scheduleCronJob;
+}