nvent 0.4.4 → 0.4.5

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

@@ -0,0 +1,263 @@
+export class MemoryStoreAdapter {
+  // Event Stream storage: subject -> events
+  eventStreams = /* @__PURE__ */ new Map();
+  eventSubscriptions = /* @__PURE__ */ new Map();
+  subscriptionCounter = 0;
+  // Document Store storage: collection -> id -> document
+  documents = /* @__PURE__ */ new Map();
+  // Key-Value Store storage: key -> value
+  kvStore = /* @__PURE__ */ new Map();
+  async close() {
+    this.eventStreams.clear();
+    this.eventSubscriptions.clear();
+    this.documents.clear();
+    this.kvStore.clear();
+  }
+  // ============================================================
+  // Event Stream
+  // ============================================================
+  async append(subject, event) {
+    const eventRecord = {
+      id: this.generateId(),
+      ts: Date.now(),
+      ...event
+    };
+    if (!this.eventStreams.has(subject)) {
+      this.eventStreams.set(subject, []);
+    }
+    const stream = this.eventStreams.get(subject);
+    stream.push(eventRecord);
+    this.notifySubscribers(subject, eventRecord);
+    return eventRecord;
+  }
+  async read(subject, opts) {
+    const stream = this.eventStreams.get(subject) || [];
+    let events = [...stream];
+    if (opts?.types && opts.types.length > 0) {
+      events = events.filter((e) => opts.types.includes(e.type));
+    }
+    if (opts?.after) {
+      const afterIndex = events.findIndex((e) => e.id === opts.after);
+      if (afterIndex >= 0) {
+        events = events.slice(afterIndex + 1);
+      }
+    }
+    if (opts?.before) {
+      const beforeIndex = events.findIndex((e) => e.id === opts.before);
+      if (beforeIndex >= 0) {
+        events = events.slice(0, beforeIndex);
+      }
+    }
+    if (opts?.from) {
+      events = events.filter((e) => e.ts >= opts.from);
+    }
+    if (opts?.to) {
+      events = events.filter((e) => e.ts <= opts.to);
+    }
+    if (opts?.order === "desc") {
+      events.reverse();
+    }
+    if (opts?.limit) {
+      events = events.slice(0, opts.limit);
+    }
+    return events;
+  }
+  async subscribe(subject, onEvent) {
+    const subscriptionId = `sub-${++this.subscriptionCounter}`;
+    if (!this.eventSubscriptions.has(subject)) {
+      this.eventSubscriptions.set(subject, /* @__PURE__ */ new Map());
+    }
+    const subjectSubs = this.eventSubscriptions.get(subject);
+    subjectSubs.set(subscriptionId, onEvent);
+    return {
+      id: subscriptionId,
+      subject,
+      unsubscribe: async () => {
+        const subs = this.eventSubscriptions.get(subject);
+        if (subs) {
+          subs.delete(subscriptionId);
+          if (subs.size === 0) {
+            this.eventSubscriptions.delete(subject);
+          }
+        }
+      }
+    };
+  }
+  notifySubscribers(subject, event) {
+    const subs = this.eventSubscriptions.get(subject);
+    if (subs) {
+      Array.from(subs.values()).forEach((callback) => {
+        try {
+          callback(event);
+        } catch (error) {
+          console.error(`[MemoryStoreAdapter] Error in event subscription for ${subject}:`, error);
+        }
+      });
+    }
+  }
+  // ============================================================
+  // Document Store
+  // ============================================================
+  async save(collection, id, doc) {
+    if (!this.documents.has(collection)) {
+      this.documents.set(collection, /* @__PURE__ */ new Map());
+    }
+    const collectionDocs = this.documents.get(collection);
+    collectionDocs.set(id, doc);
+  }
+  async get(collection, id) {
+    const collectionDocs = this.documents.get(collection);
+    if (!collectionDocs) {
+      return null;
+    }
+    return collectionDocs.get(id) || null;
+  }
+  async list(collection, opts) {
+    const collectionDocs = this.documents.get(collection);
+    if (!collectionDocs) {
+      return [];
+    }
+    let results = Array.from(collectionDocs.entries()).map(([id, doc]) => ({ id, doc }));
+    if (opts?.filter) {
+      results = results.filter((item) => {
+        return Object.entries(opts.filter).every(([key, value]) => {
+          return item.doc[key] === value;
+        });
+      });
+    }
+    if (opts?.sortBy) {
+      results.sort((a, b) => {
+        const aVal = a.doc[opts.sortBy];
+        const bVal = b.doc[opts.sortBy];
+        if (aVal < bVal) return opts.order === "desc" ? 1 : -1;
+        if (aVal > bVal) return opts.order === "desc" ? -1 : 1;
+        return 0;
+      });
+    }
+    if (opts?.offset) {
+      results = results.slice(opts.offset);
+    }
+    if (opts?.limit) {
+      results = results.slice(0, opts.limit);
+    }
+    return results;
+  }
+  async delete(collection, id) {
+    const collectionDocs = this.documents.get(collection);
+    if (collectionDocs) {
+      collectionDocs.delete(id);
+      if (collectionDocs.size === 0) {
+        this.documents.delete(collection);
+      }
+    }
+  }
+  // ============================================================
+  // Key-Value Store
+  // ============================================================
+  kv = {
+    get: async (key) => {
+      return this.kvStore.get(key) || null;
+    },
+    set: async (key, value, _ttl) => {
+      this.kvStore.set(key, value);
+    },
+    delete: async (key) => {
+      this.kvStore.delete(key);
+    },
+    clear: async (pattern) => {
+      const regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
+      const keys = Array.from(this.kvStore.keys());
+      let count = 0;
+      for (const key of keys) {
+        if (regex.test(key)) {
+          this.kvStore.delete(key);
+          count++;
+        }
+      }
+      return count;
+    },
+    increment: async (key, by = 1) => {
+      const current = this.kvStore.get(key) || 0;
+      const newValue = (typeof current === "number" ? current : 0) + by;
+      this.kvStore.set(key, newValue);
+      return newValue;
+    }
+  };
+  // ============================================================
+  // Sorted Index (optional, for time-ordered listings)
+  // ============================================================
+  // Sorted index storage: key -> sorted array of {id, score, metadata}
+  sortedIndices = /* @__PURE__ */ new Map();
+  async indexAdd(key, id, score, metadata) {
+    if (!this.sortedIndices.has(key)) {
+      this.sortedIndices.set(key, []);
+    }
+    const index = this.sortedIndices.get(key);
+    const existingIndex = index.findIndex((entry2) => entry2.id === id);
+    const entry = {
+      id,
+      score,
+      metadata: metadata ? { version: 0, ...metadata } : void 0
+    };
+    if (existingIndex >= 0) {
+      index[existingIndex] = entry;
+    } else {
+      index.push(entry);
+    }
+    index.sort((a, b) => b.score - a.score);
+  }
+  async indexGet(key, id) {
+    const index = this.sortedIndices.get(key);
+    if (!index) return null;
+    const entry = index.find((e) => e.id === id);
+    return entry ? { ...entry } : null;
+  }
+  async indexRead(key, opts) {
+    const index = this.sortedIndices.get(key) || [];
+    const offset = opts?.offset || 0;
+    const limit = opts?.limit || 50;
+    return index.slice(offset, offset + limit).map((e) => ({ ...e }));
+  }
+  async indexUpdate(key, id, metadata) {
+    const index = this.sortedIndices.get(key);
+    if (!index) return false;
+    const entry = index.find((e) => e.id === id);
+    if (!entry || !entry.metadata) return false;
+    const currentVersion = entry.metadata.version || 0;
+    const expectedVersion = currentVersion;
+    entry.metadata = {
+      ...entry.metadata,
+      ...metadata,
+      version: expectedVersion + 1
+    };
+    return true;
+  }
+  async indexUpdateWithRetry(key, id, metadata, maxRetries = 3) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      const success = await this.indexUpdate(key, id, metadata);
+      if (success) return;
+      await new Promise((resolve) => setTimeout(resolve, 10 * Math.pow(2, attempt)));
+    }
+    throw new Error(`Failed to update index after ${maxRetries} retries`);
+  }
+  async indexIncrement(key, id, field, increment = 1) {
+    const index = this.sortedIndices.get(key);
+    if (!index) throw new Error(`Index not found: ${key}`);
+    const entry = index.find((e) => e.id === id);
+    if (!entry) throw new Error(`Entry not found: ${id} in index ${key}`);
+    if (!entry.metadata) {
+      entry.metadata = { version: 0 };
+    }
+    const currentValue = entry.metadata[field] || 0;
+    const newValue = (typeof currentValue === "number" ? currentValue : 0) + increment;
+    entry.metadata[field] = newValue;
+    entry.metadata.version = (entry.metadata.version || 0) + 1;
+    return newValue;
+  }
+  // ============================================================
+  // Helpers
+  // ============================================================
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Memory Stream Adapter
+ *
+ * In-memory pub/sub implementation for development
+ * - Uses EventEmitter pattern
+ * - No external dependencies
+ * - Single instance only
+ * - Data lost on restart
+ */
+import type { StreamAdapter, StreamEvent, SubscribeOptions, SubscriptionHandle } from '../interfaces/stream.js';
+export declare class MemoryStreamAdapter 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/memory-stream.js

@@ -0,0 +1,56 @@
+export class MemoryStreamAdapter {
+  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/factory.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Adapter Factory (v0.4.1)
+ *
+ * Creates adapters independently without dependencies
+ * StoreAdapter is pure storage - streaming handled by wiring layer
+ *
+ * Now supports external adapters via the adapter registry.
+ * External adapters registered via the nvent:registerAdapter hook take precedence.
+ */
+import type { QueueAdapter } from './interfaces/queue.js';
+import type { StreamAdapter } from './interfaces/stream.js';
+import type { StoreAdapter } from './interfaces/store.js';
+import type { QueueConfig, StreamConfig, StoreConfig } from '../config/types.js';
+export interface AdapterSet {
+    queue: QueueAdapter;
+    stream: StreamAdapter;
+    store: StoreAdapter;
+}
+/**
+ * Create a complete set of adapters (v0.4.1)
+ * All adapters are independent - wiring layer handles coordination
+ */
+export declare function createAdapters(config: {
+    queue: QueueConfig;
+    stream: StreamConfig;
+    store: StoreConfig;
+}): Promise<AdapterSet>;
+/**
+ * Shutdown all adapters gracefully
+ */
+export declare function shutdownAdapters(adapters: AdapterSet): Promise<void>;

package/dist/runtime/adapters/factory.js

@@ -0,0 +1,100 @@
+import { useAdapterRegistry } from "./registry.js";
+import {
+  MemoryQueueAdapter,
+  MemoryStreamAdapter,
+  MemoryStoreAdapter,
+  FileQueueAdapter,
+  FileStoreAdapter
+} from "./builtin/index.js";
+export async function createAdapters(config) {
+  const stream = await createStreamAdapter(config.stream);
+  const store = await createStoreAdapter(config.store);
+  const queue = await createQueueAdapter(config.queue);
+  return { queue, stream, store };
+}
+async function createStreamAdapter(config) {
+  const type = config.adapter || "memory";
+  const registry = useAdapterRegistry();
+  if (registry.hasStream(type)) {
+    const adapter = registry.getStream(type);
+    await adapter.init();
+    return adapter;
+  }
+  switch (type) {
+    case "memory": {
+      const adapter = new MemoryStreamAdapter();
+      await adapter.init();
+      return adapter;
+    }
+    case "redis":
+      throw new Error("Redis stream adapter not registered. Install @nvent/adapter-stream-redis and add it to your nuxt.config modules.");
+    case "rabbitmq":
+      throw new Error("RabbitMQ stream adapter not yet implemented");
+    case "kafka":
+      throw new Error("Kafka stream adapter not yet implemented");
+    default:
+      throw new Error(`Unknown stream adapter type: ${type}`);
+  }
+}
+async function createStoreAdapter(config) {
+  const type = config.adapter || "file";
+  const registry = useAdapterRegistry();
+  if (registry.hasStore(type)) {
+    const adapter = registry.getStore(type);
+    return adapter;
+  }
+  switch (type) {
+    case "memory": {
+      return new MemoryStoreAdapter();
+    }
+    case "file": {
+      const dataDir = config.file?.dataDir || ".data/store";
+      const adapter = new FileStoreAdapter({
+        dataDir
+      });
+      await adapter.init();
+      return adapter;
+    }
+    case "redis":
+      throw new Error("Redis store adapter not registered. Install @nvent/adapter-store-redis and add it to your nuxt.config modules.");
+    case "postgres":
+      throw new Error("Postgres store adapter not yet implemented");
+    default:
+      throw new Error(`Unknown store adapter type: ${type}`);
+  }
+}
+async function createQueueAdapter(config) {
+  const type = config.adapter || "file";
+  const registry = useAdapterRegistry();
+  if (registry.hasQueue(type)) {
+    const adapter = registry.getQueue(type);
+    await adapter.init();
+    return adapter;
+  }
+  switch (type) {
+    case "memory": {
+      const adapter = new MemoryQueueAdapter();
+      await adapter.init();
+      return adapter;
+    }
+    case "file": {
+      const dataDir = config.file?.dataDir || ".data/queue";
+      const adapter = new FileQueueAdapter({ dataDir });
+      await adapter.init();
+      return adapter;
+    }
+    case "redis":
+      throw new Error("Redis queue adapter not registered. Install @nvent/adapter-queue-redis and add it to your nuxt.config modules.");
+    case "postgres":
+      throw new Error("Postgres queue adapter (PGBoss) not yet implemented");
+    default:
+      throw new Error(`Unknown queue adapter type: ${type}`);
+  }
+}
+export async function shutdownAdapters(adapters) {
+  await Promise.all([
+    adapters.queue.close(),
+    adapters.stream.shutdown(),
+    adapters.store.close()
+  ]);
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Adapter System Exports
+ *
+ * Re-exports all adapter interfaces, factory, and utilities
+ */
+export * from './interfaces/index.js';
+export * from './factory.js';
+export * from './builtin/index.js';

package/dist/runtime/adapters/index.js

@@ -0,0 +1,3 @@
+export * from "./interfaces/index.js";
+export * from "./factory.js";
+export * from "./builtin/index.js";

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

@@ -0,0 +1,11 @@
+/**
+ * Adapter Interfaces
+ *
+ * Three types of adapters for nvent:
+ * - QueueAdapter: Job execution infrastructure
+ * - StreamAdapter: Cross-instance pub/sub messaging
+ * - StoreAdapter: Three-tier storage (events, documents, key-value)
+ */
+export * from './queue.js';
+export * from './stream.js';
+export * from './store.js';

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

@@ -0,0 +1,3 @@
+export * from "./queue.js";
+export * from "./stream.js";
+export * from "./store.js";

package/dist/runtime/adapters/interfaces/queue.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Queue Adapter Interface
+ *
+ * Handles job queue operations only (enqueue, retrieve, manage)
+ * Does NOT handle event storage, state, or logging - those are separate concerns
+ */
+export interface QueueAdapter {
+    /**
+     * Initialize the queue adapter
+     */
+    init(): Promise<void>;
+    /**
+     * Add a job to the queue
+     * @returns Job ID
+     */
+    enqueue(queueName: string, job: JobInput): Promise<string>;
+    /**
+     * Schedule a job (delayed or recurring)
+     * @returns Job ID
+     */
+    schedule(queueName: string, job: JobInput, opts?: ScheduleOptions): Promise<string>;
+    /**
+     * Get a specific job by ID
+     */
+    getJob(queueName: string, id: string): Promise<Job | null>;
+    /**
+     * Get multiple jobs with optional filtering
+     */
+    getJobs(queueName: string, query?: JobsQuery): Promise<Job[]>;
+    /**
+     * Subscribe to queue events
+     * @returns Unsubscribe function
+     */
+    on(queueName: string, event: QueueEvent, callback: (payload: any) => void): () => void;
+    /**
+     * Check if queue is paused
+     */
+    isPaused(queueName: string): Promise<boolean>;
+    /**
+     * Get job counts by state
+     */
+    getJobCounts(queueName: string): Promise<JobCounts>;
+    /**
+     * Get scheduled/repeatable jobs (cron jobs)
+     */
+    getScheduledJobs?(queueName: string): Promise<ScheduledJobInfo[]>;
+    /**
+     * Remove a scheduled/repeatable job
+     * @returns true if removed, false if not found
+     */
+    removeScheduledJob?(scheduleId: string): Promise<boolean>;
+    /**
+     * Pause the queue
+     */
+    pause(queueName: string): Promise<void>;
+    /**
+     * Resume the queue
+     */
+    resume(queueName: string): Promise<void>;
+    /**
+     * Register a worker handler for processing jobs
+     * 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;
+    /**
+     * Close/cleanup the adapter
+     */
+    close(): Promise<void>;
+}
+export interface JobInput {
+    name: string;
+    data: any;
+    opts?: JobOptions;
+}
+export interface JobOptions {
+    jobId?: string;
+    attempts?: number;
+    backoff?: {
+        type: 'exponential' | 'fixed';
+        delay: number;
+    };
+    delay?: number;
+    priority?: number;
+    timeout?: number;
+    removeOnComplete?: boolean | number;
+    removeOnFail?: boolean | number;
+}
+export interface Job {
+    id: string;
+    name: string;
+    data: any;
+    returnvalue?: any;
+    failedReason?: string;
+    state: 'waiting' | 'active' | 'completed' | 'failed' | 'delayed' | 'paused';
+    timestamp?: number;
+    processedOn?: number;
+    finishedOn?: number;
+    attemptsMade?: number;
+    progress?: number;
+}
+export interface JobsQuery {
+    state?: JobState[];
+    limit?: number;
+    offset?: number;
+}
+export type JobState = 'waiting' | 'active' | 'completed' | 'failed' | 'delayed' | 'paused';
+export interface ScheduleOptions {
+    delay?: number;
+    cron?: string;
+    repeat?: {
+        pattern?: string;
+        limit?: number;
+    };
+}
+export interface JobCounts {
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    waiting: number;
+    paused: number;
+}
+export interface ScheduledJobInfo {
+    id: string;
+    jobName: string;
+    queueName: string;
+    cron?: string;
+    pattern?: string;
+    nextRun?: Date;
+    repeatCount?: number;
+    limit?: number;
+}
+export type QueueEvent = 'waiting' | 'active' | 'progress' | 'completed' | 'failed' | 'delayed' | 'paused' | 'stalled';
+export interface WorkerHandler {
+    (payload: any, ctx: WorkerContext): Promise<any>;
+}
+export interface WorkerContext {
+    jobId: string;
+    queueName: string;
+    [key: string]: any;
+}
+export interface WorkerOptions {
+    concurrency?: number;
+    autorun?: boolean;
+}