nvent 0.4.3 → 0.4.5

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

@@ -0,0 +1,39 @@
+/**
+ * File Stream Adapter
+ *
+ * DEPRECATED: This adapter is identical to MemoryStreamAdapter
+ *
+ * For file-based deployments (single instance):
+ * - StreamAdapter is NOT needed for cross-instance pub/sub
+ * - StoreAdapter.subscribe() handles in-process subscriptions
+ * - StoreAdapter handles ALL persistence (events, documents, KV)
+ *
+ * This adapter exists only for API compatibility.
+ * Use MemoryStreamAdapter instead - it's the same implementation.
+ */
+import type { StreamAdapter, StreamEvent, SubscribeOptions, SubscriptionHandle } from '../interfaces/stream.js';
+/**
+ * @deprecated Use MemoryStreamAdapter instead. FileStreamAdapter is identical.
+ */
+export interface FileStreamAdapterOptions {
+    dataDir?: string;
+}
+/**
+ * @deprecated Use MemoryStreamAdapter instead
+ *
+ * Pure in-memory pub/sub (same as MemoryStreamAdapter)
+ * - No persistence (StoreAdapter handles that)
+ * - Single instance only
+ * - Events lost if no subscribers
+ */
+export declare class FileStreamAdapter implements StreamAdapter {
+    private subscriptions;
+    private subscriptionCounter;
+    init(): Promise<void>;
+    publish(topic: string, event: StreamEvent): Promise<void>;
+    subscribe(topic: string, handler: (event: StreamEvent) => void | Promise<void>, _opts?: SubscribeOptions): Promise<SubscriptionHandle>;
+    unsubscribe(handle: SubscriptionHandle): Promise<void>;
+    listTopics(): Promise<string[]>;
+    getSubscriptionCount(topic: string): Promise<number>;
+    shutdown(): Promise<void>;
+}

package/dist/runtime/adapters/builtin/file-stream.js

@@ -0,0 +1,56 @@
+export class FileStreamAdapter {
+  subscriptions = /* @__PURE__ */ new Map();
+  subscriptionCounter = 0;
+  async init() {
+  }
+  async publish(topic, event) {
+    const topicSubscriptions = this.subscriptions.get(topic);
+    if (!topicSubscriptions || topicSubscriptions.size === 0) {
+      return;
+    }
+    const eventWithTs = {
+      ...event,
+      timestamp: event.timestamp || Date.now()
+    };
+    const promises = [];
+    Array.from(topicSubscriptions.values()).forEach((handler) => {
+      promises.push(handler(eventWithTs));
+    });
+    await Promise.all(promises);
+  }
+  async subscribe(topic, handler, _opts) {
+    const subscriptionId = `sub-${++this.subscriptionCounter}`;
+    if (!this.subscriptions.has(topic)) {
+      this.subscriptions.set(topic, /* @__PURE__ */ new Map());
+    }
+    const topicSubscriptions = this.subscriptions.get(topic);
+    topicSubscriptions.set(subscriptionId, handler);
+    return {
+      id: subscriptionId,
+      topic,
+      unsubscribe: async () => {
+        await this.unsubscribe({ id: subscriptionId, topic, unsubscribe: async () => {
+        } });
+      }
+    };
+  }
+  async unsubscribe(handle) {
+    const topicSubscriptions = this.subscriptions.get(handle.topic);
+    if (topicSubscriptions) {
+      topicSubscriptions.delete(handle.id);
+      if (topicSubscriptions.size === 0) {
+        this.subscriptions.delete(handle.topic);
+      }
+    }
+  }
+  async listTopics() {
+    return Array.from(this.subscriptions.keys());
+  }
+  async getSubscriptionCount(topic) {
+    const topicSubscriptions = this.subscriptions.get(topic);
+    return topicSubscriptions ? topicSubscriptions.size : 0;
+  }
+  async shutdown() {
+    this.subscriptions.clear();
+  }
+}

package/dist/runtime/adapters/builtin/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Built-in Adapters
+ *
+ * In-memory and file-based adapters for development (no external dependencies)
+ */
+export { MemoryQueueAdapter } from './memory-queue.js';
+export { MemoryStreamAdapter } from './memory-stream.js';
+export { MemoryStoreAdapter } from './memory-store.js';
+export { FileQueueAdapter } from './file-queue.js';
+export { FileStoreAdapter } from './file-store.js';

package/dist/runtime/adapters/builtin/index.js

@@ -0,0 +1,5 @@
+export { MemoryQueueAdapter } from "./memory-queue.js";
+export { MemoryStreamAdapter } from "./memory-stream.js";
+export { MemoryStoreAdapter } from "./memory-store.js";
+export { FileQueueAdapter } from "./file-queue.js";
+export { FileStoreAdapter } from "./file-store.js";

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

@@ -0,0 +1,52 @@
+/**
+ * Memory Queue Adapter
+ *
+ * In-memory queue implementation using fastq for development
+ * - Fast and simple
+ * - No external dependencies beyond fastq
+ * - Data lost on restart
+ * - Single instance only
+ *
+ * Architecture:
+ * - QueueAdapter: Manages job storage and queue events
+ * - WorkerManager: Executes jobs using fastq
+ * - Dispatcher pattern: Routes jobs to handlers by job.name
+ */
+import type { QueueAdapter, JobInput, Job, JobsQuery, ScheduleOptions, JobCounts, QueueEvent, WorkerHandler, WorkerOptions } from '../interfaces/queue.js';
+export interface MemoryQueueAdapterOptions {
+    maxQueueSize?: number;
+}
+export declare class MemoryQueueAdapter implements QueueAdapter {
+    private jobs;
+    private eventListeners;
+    private workers;
+    private options;
+    constructor(options?: MemoryQueueAdapterOptions);
+    init(): Promise<void>;
+    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>;
+    pause(queueName: string): Promise<void>;
+    resume(queueName: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Register a worker handler for a queue
+     * This is called by the worker registration system
+     */
+    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;
+    /**
+     * Update job state (called internally and by worker manager)
+     */
+    updateJobState(jobId: string, state: Job['state'], extra?: Partial<Job>): void;
+    private emitEvent;
+    private generateId;
+}

package/dist/runtime/adapters/builtin/memory-queue.js

@@ -0,0 +1,239 @@
+import * as fastq from "fastq";
+export class MemoryQueueAdapter {
+  jobs = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Map();
+  workers = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = {
+      maxQueueSize: options.maxQueueSize || 1e3
+    };
+  }
+  async init() {
+  }
+  async enqueue(queueName, job) {
+    const jobId = job.opts?.jobId || this.generateId();
+    if (this.jobs.has(jobId)) {
+      return jobId;
+    }
+    if (this.jobs.size >= this.options.maxQueueSize) {
+      throw new Error(`Queue ${queueName} is full (max: ${this.options.maxQueueSize})`);
+    }
+    const internalJob = {
+      id: jobId,
+      name: job.name,
+      data: { ...job.data, __queueName: queueName },
+      state: "waiting",
+      timestamp: Date.now()
+    };
+    this.jobs.set(jobId, internalJob);
+    this.emitEvent(queueName, "waiting", { jobId, job: internalJob });
+    const workerInfo = this.workers.get(queueName);
+    if (workerInfo && !workerInfo.paused) {
+      workerInfo.queue.push({ jobId, jobName: job.name, data: job.data }).catch((error) => {
+        console.error(`[MemoryQueueAdapter] Error processing job ${jobId}:`, error);
+      });
+    }
+    return jobId;
+  }
+  async schedule(queueName, job, opts) {
+    if (opts?.delay) {
+      const jobId = this.generateId();
+      const internalJob = {
+        id: jobId,
+        name: job.name,
+        data: { ...job.data, __queueName: queueName },
+        state: "delayed",
+        timestamp: Date.now()
+      };
+      this.jobs.set(jobId, internalJob);
+      this.emitEvent(queueName, "delayed", { jobId, job: internalJob, delay: opts.delay });
+      setTimeout(() => {
+        this.enqueue(queueName, job);
+      }, opts.delay);
+      return jobId;
+    }
+    if (opts?.cron || opts?.repeat) {
+      throw new Error("Cron/repeat scheduling not supported in memory adapter");
+    }
+    return this.enqueue(queueName, job);
+  }
+  async getJob(_queueName, id) {
+    return this.jobs.get(id) || null;
+  }
+  async getJobs(queueName, query) {
+    let jobs = Array.from(this.jobs.values()).filter((j) => j.data?.__queueName === queueName);
+    if (query?.state && query.state.length > 0) {
+      jobs = jobs.filter((j) => query.state.includes(j.state));
+    }
+    if (query?.offset) {
+      jobs = jobs.slice(query.offset);
+    }
+    if (query?.limit) {
+      jobs = jobs.slice(0, query.limit);
+    }
+    return jobs;
+  }
+  on(queueName, event, callback) {
+    const key = `${queueName}:${event}`;
+    if (!this.eventListeners.has(key)) {
+      this.eventListeners.set(key, []);
+    }
+    this.eventListeners.get(key).push(callback);
+    return () => {
+      const listeners = this.eventListeners.get(key);
+      if (listeners) {
+        const index = listeners.indexOf(callback);
+        if (index > -1) {
+          listeners.splice(index, 1);
+        }
+      }
+    };
+  }
+  async isPaused(queueName) {
+    const workerInfo = this.workers.get(queueName);
+    return workerInfo?.paused || false;
+  }
+  async getJobCounts(queueName) {
+    const jobs = Array.from(this.jobs.values()).filter((j) => j.data?.__queueName === queueName);
+    return {
+      active: jobs.filter((j) => j.state === "active").length,
+      completed: jobs.filter((j) => j.state === "completed").length,
+      failed: jobs.filter((j) => j.state === "failed").length,
+      delayed: jobs.filter((j) => j.state === "delayed").length,
+      waiting: jobs.filter((j) => j.state === "waiting").length,
+      paused: jobs.filter((j) => j.state === "paused").length
+    };
+  }
+  async pause(queueName) {
+    const workerInfo = this.workers.get(queueName);
+    if (workerInfo) {
+      workerInfo.paused = true;
+      workerInfo.queue.pause();
+    }
+  }
+  async resume(queueName) {
+    const workerInfo = this.workers.get(queueName);
+    if (workerInfo) {
+      workerInfo.paused = false;
+      workerInfo.queue.resume();
+    }
+  }
+  async close() {
+    const drainPromises = Array.from(this.workers.values()).map((w) => w.queue.drained());
+    await Promise.all(drainPromises);
+    this.jobs.clear();
+    this.eventListeners.clear();
+    this.workers.clear();
+  }
+  // ============================================================
+  // Worker Management (used by worker registration system)
+  // ============================================================
+  /**
+   * Register a worker handler for a queue
+   * This is called by the worker registration system
+   */
+  registerWorker(queueName, jobName, handler, opts) {
+    let workerInfo = this.workers.get(queueName);
+    if (workerInfo) {
+      console.info(`[MemoryQueue] Adding handler for job "${jobName}" to queue "${queueName}"`);
+      workerInfo.handlers.set(jobName, handler);
+      return;
+    }
+    console.info(`[MemoryQueue] Creating new worker for queue: ${queueName}`);
+    const handlers = /* @__PURE__ */ new Map();
+    handlers.set(jobName, handler);
+    const dispatcher = async (task) => {
+      const handler2 = handlers.get(task.jobName);
+      if (!handler2) {
+        const error = `No handler for job "${task.jobName}" on queue "${queueName}". Available: ${Array.from(handlers.keys()).join(", ")}`;
+        console.error(error);
+        throw new Error(error);
+      }
+      this.updateJobState(task.jobId, "active", { processedOn: Date.now() });
+      this.emitEvent(queueName, "active", { jobId: task.jobId });
+      try {
+        const result = await handler2(task.data, {
+          jobId: task.jobId,
+          queueName
+          // Add more context as needed
+        });
+        this.updateJobState(task.jobId, "completed", {
+          returnvalue: result,
+          finishedOn: Date.now()
+        });
+        this.emitEvent(queueName, "completed", { jobId: task.jobId, returnvalue: result });
+        return result;
+      } catch (err) {
+        this.updateJobState(task.jobId, "failed", {
+          failedReason: err.message,
+          finishedOn: Date.now()
+        });
+        this.emitEvent(queueName, "failed", {
+          jobId: task.jobId,
+          failedReason: err.message
+        });
+        throw err;
+      }
+    };
+    const concurrency = opts?.concurrency || 1;
+    const queue = fastq.promise(dispatcher, concurrency);
+    const shouldPause = opts?.autorun === false;
+    workerInfo = {
+      queue,
+      handlers,
+      paused: shouldPause || false,
+      concurrency
+    };
+    if (shouldPause) {
+      queue.pause();
+      console.info(`[MemoryQueue] Worker for "${queueName}" created but paused`);
+    }
+    this.workers.set(queueName, workerInfo);
+  }
+  /**
+   * Start processing waiting jobs for a queue
+   * Should be called after all handlers are registered
+   */
+  startProcessingQueue(queueName) {
+    const workerInfo = this.workers.get(queueName);
+    if (!workerInfo || workerInfo.paused) return;
+    const waitingJobs = Array.from(this.jobs.values()).filter(
+      (j) => j.state === "waiting" && j.data?.__queueName === queueName
+    );
+    for (const job of waitingJobs) {
+      workerInfo.queue.push({ jobId: job.id, jobName: job.name, data: job.data }).catch((error) => {
+        console.error(`[MemoryQueueAdapter] Error processing queued job ${job.id}:`, error);
+      });
+    }
+  }
+  // ============================================================
+  // Helper Methods
+  // ============================================================
+  /**
+   * Update job state (called internally and by worker manager)
+   */
+  updateJobState(jobId, state, extra) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      job.state = state;
+      if (extra) {
+        Object.assign(job, extra);
+      }
+    }
+  }
+  emitEvent(queueName, event, payload) {
+    const key = `${queueName}:${event}`;
+    const listeners = this.eventListeners.get(key) || [];
+    for (const callback of listeners) {
+      try {
+        callback(payload);
+      } catch (error) {
+        console.error(`[MemoryQueueAdapter] Error in event listener for ${key}:`, error);
+      }
+    }
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+}

package/dist/runtime/adapters/builtin/memory-store.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Memory Store Adapter
+ *
+ * In-memory storage implementation for development
+ * Three-tier storage:
+ * 1. Event Stream - Append-only event log
+ * 2. Document Store - Generic document storage
+ * 3. Key-Value Store - Fast lookups
+ *
+ * All data is lost on restart (ephemeral)
+ */
+import type { StoreAdapter, EventRecord, EventReadOptions, EventSubscription, ListOptions } from '../interfaces/store.js';
+export declare class MemoryStoreAdapter implements StoreAdapter {
+    private eventStreams;
+    private eventSubscriptions;
+    private subscriptionCounter;
+    private documents;
+    private kvStore;
+    close(): Promise<void>;
+    append(subject: string, event: Omit<EventRecord, 'id' | 'ts'>): Promise<EventRecord>;
+    read(subject: string, opts?: EventReadOptions): Promise<EventRecord[]>;
+    subscribe(subject: string, onEvent: (event: EventRecord) => void): Promise<EventSubscription>;
+    private notifySubscribers;
+    save(collection: string, id: string, doc: Record<string, any>): Promise<void>;
+    get(collection: string, id: string): Promise<Record<string, any> | null>;
+    list(collection: string, opts?: ListOptions): Promise<Array<{
+        id: string;
+        doc: any;
+    }>>;
+    delete(collection: string, id: string): Promise<void>;
+    kv: {
+        get: <T = any>(key: string) => Promise<T | null>;
+        set: <T = any>(key: string, value: T, _ttl?: number) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        clear: (pattern: string) => Promise<number>;
+        increment: (key: string, by?: number) => Promise<number>;
+    };
+    private sortedIndices;
+    indexAdd(key: string, id: string, score: number, metadata?: Record<string, any>): Promise<void>;
+    indexGet(key: string, id: string): Promise<{
+        id: string;
+        score: number;
+        metadata?: any;
+    } | null>;
+    indexRead(key: string, opts?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<Array<{
+        id: string;
+        score: number;
+        metadata?: any;
+    }>>;
+    indexUpdate(key: string, id: string, metadata: Record<string, any>): Promise<boolean>;
+    indexUpdateWithRetry(key: string, id: string, metadata: Record<string, any>, maxRetries?: number): Promise<void>;
+    indexIncrement(key: string, id: string, field: string, increment?: number): Promise<number>;
+    private generateId;
+}