nvent 0.4.4 → 0.5.0

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

@@ -0,0 +1,333 @@
+import { defu } from "defu";
+import { createStoreValidator } from "../base/store-validator.js";
+export class MemoryStoreAdapter {
+  // Event Stream storage: subject -> events
+  eventStreams = /* @__PURE__ */ new Map();
+  eventSubscriptions = /* @__PURE__ */ new Map();
+  subscriptionCounter = 0;
+  // Key-Value Store storage: key -> value
+  kvStore = /* @__PURE__ */ new Map();
+  // Sorted index storage: key -> sorted array of {id, score, metadata}
+  sortedIndices = /* @__PURE__ */ new Map();
+  // Validator for update operations
+  validator = createStoreValidator("MemoryStoreAdapter");
+  // Lock mechanism for atomic index operations
+  indexLocks = /* @__PURE__ */ new Map();
+  async close() {
+    this.eventStreams.clear();
+    this.eventSubscriptions.clear();
+    this.kvStore.clear();
+    this.sortedIndices.clear();
+  }
+  // ============================================================
+  // Event Stream
+  // ============================================================
+  stream = {
+    append: async (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;
+    },
+    read: async (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;
+    },
+    subscribe: async (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);
+            }
+          }
+        }
+      };
+    },
+    delete: async (subject) => {
+      const existed = this.eventStreams.has(subject);
+      if (existed) {
+        this.eventStreams.delete(subject);
+        this.eventSubscriptions.delete(subject);
+      }
+      return existed;
+    }
+  };
+  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);
+        }
+      });
+    }
+  }
+  // ============================================================
+  // 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 (for time-ordered listings)
+  // ============================================================
+  index = {
+    add: async (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 expandedMetadata = metadata ? this.expandDotNotation(metadata) : void 0;
+      const entry = {
+        id,
+        score,
+        metadata: expandedMetadata ? { version: 0, ...expandedMetadata } : void 0
+      };
+      if (existingIndex >= 0) {
+        index[existingIndex] = entry;
+      } else {
+        index.push(entry);
+      }
+      index.sort((a, b) => b.score - a.score);
+    },
+    get: async (key, id) => {
+      const index = this.sortedIndices.get(key);
+      if (!index) return null;
+      const entry = index.find((e) => e.id === id);
+      return entry ? { ...entry } : null;
+    },
+    read: async (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 }));
+    },
+    update: async (key, id, metadata) => {
+      this.validator.validateUpdatePayload(metadata, "index.update");
+      const lockKey = `${key}:${id}`;
+      const release = await this.acquireIndexLock(lockKey);
+      try {
+        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 updates = this.expandDotNotation(metadata);
+        const deleteMarkers = updates.__deleteMarkers;
+        delete updates.__deleteMarkers;
+        entry.metadata = defu(updates, entry.metadata);
+        if (deleteMarkers) {
+          for (const { path } of deleteMarkers) {
+            let current = entry.metadata;
+            for (let i = 0; i < path.length - 1; i++) {
+              if (!current[path[i]]) break;
+              current = current[path[i]];
+            }
+            if (current) {
+              const lastKey = path[path.length - 1];
+              Reflect.deleteProperty(current, lastKey);
+            }
+          }
+        }
+        entry.metadata.version = currentVersion + 1;
+        return true;
+      } finally {
+        release();
+      }
+    },
+    updateWithRetry: async (key, id, metadata, maxRetries = 3) => {
+      this.validator.validateUpdatePayload(metadata, "index.updateWithRetry");
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        const success = await this.index.update(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`);
+    },
+    increment: async (key, id, field, increment = 1) => {
+      const lockKey = `${key}:${id}`;
+      const release = await this.acquireIndexLock(lockKey);
+      try {
+        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 };
+        }
+        let currentValue;
+        let newValue;
+        if (field.includes(".")) {
+          const keys = field.split(".");
+          let current = entry.metadata;
+          for (let i = 0; i < keys.length - 1; i++) {
+            const k = keys[i];
+            if (!current[k] || typeof current[k] !== "object") {
+              current[k] = {};
+            }
+            current = current[k];
+          }
+          const lastKey = keys[keys.length - 1];
+          currentValue = current[lastKey] || 0;
+          newValue = (typeof currentValue === "number" ? currentValue : 0) + increment;
+          current[lastKey] = newValue;
+        } else {
+          currentValue = entry.metadata[field] || 0;
+          newValue = (typeof currentValue === "number" ? currentValue : 0) + increment;
+          entry.metadata[field] = newValue;
+        }
+        entry.metadata.version = (entry.metadata.version || 0) + 1;
+        return newValue;
+      } finally {
+        release();
+      }
+    },
+    delete: async (key, id) => {
+      const index = this.sortedIndices.get(key);
+      if (!index) return false;
+      const initialLength = index.length;
+      const filtered = index.filter((e) => e.id !== id);
+      if (filtered.length === initialLength) {
+        return false;
+      }
+      this.sortedIndices.set(key, filtered);
+      return true;
+    }
+  };
+  /**
+   * Acquire a lock for atomic index operations
+   * Protected to allow access from FileStoreAdapter
+   */
+  async acquireIndexLock(key) {
+    while (this.indexLocks.has(key)) {
+      await this.indexLocks.get(key);
+    }
+    let releaseLock;
+    const lockPromise = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    this.indexLocks.set(key, lockPromise);
+    return () => {
+      this.indexLocks.delete(key);
+      releaseLock();
+    };
+  }
+  /**
+   * Convert dot notation keys to nested objects
+   * e.g., { 'stats.totalFires': 5 } -> { stats: { totalFires: 5 } }
+   * null values are preserved for deletion
+   */
+  expandDotNotation(obj) {
+    const result = {};
+    const deleteMarkers = [];
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "version") {
+        continue;
+      }
+      if (key.includes(".")) {
+        const keys = key.split(".");
+        if (value === null || value === void 0) {
+          deleteMarkers.push({ path: keys, delete: true });
+          continue;
+        }
+        let current = result;
+        for (let i = 0; i < keys.length - 1; i++) {
+          const k = keys[i];
+          if (!current[k]) {
+            current[k] = {};
+          }
+          current = current[k];
+        }
+        current[keys[keys.length - 1]] = value;
+      } else {
+        result[key] = value;
+      }
+    }
+    if (deleteMarkers.length > 0) {
+      result.__deleteMarkers = deleteMarkers;
+    }
+    return result;
+  }
+  // ============================================================
+  // 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
+ *
+ * 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
+ * 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,134 @@
+import { useAdapterRegistry } from "./registry.js";
+import { useStreamTopics, $useAnalyzedFlows } from "#imports";
+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();
+  let adapter;
+  if (registry.hasStore(type)) {
+    adapter = registry.getStore(type);
+  } else {
+    switch (type) {
+      case "memory": {
+        adapter = new MemoryStoreAdapter();
+        break;
+      }
+      case "file": {
+        const dataDir = config.file?.dataDir || ".data/store";
+        const fileAdapter = new FileStoreAdapter({
+          dataDir
+        });
+        await fileAdapter.init();
+        adapter = fileAdapter;
+        break;
+      }
+      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}`);
+    }
+  }
+  try {
+    const { StoreSubjects } = useStreamTopics();
+    const flowIndexKey = StoreSubjects.flowIndex();
+    const existingFlows = await adapter.index.read(flowIndexKey, { limit: 1 });
+    if (existingFlows.length === 0) {
+      const analyzedFlows = $useAnalyzedFlows();
+      if (analyzedFlows && analyzedFlows.length > 0) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        for (const flow of analyzedFlows) {
+          await adapter.index.add(flowIndexKey, flow.id, Date.now(), {
+            name: flow.id,
+            displayName: flow.id,
+            registeredAt: now,
+            stats: {
+              total: 0,
+              success: 0,
+              failure: 0,
+              cancel: 0,
+              running: 0,
+              awaiting: 0
+            },
+            version: 1
+          });
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("[factory] Failed to initialize flow index:", err?.message);
+  }
+  return adapter;
+}
+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 not registered. Install @nvent/adapter-queue-postgres and add it to your nuxt.config modules.");
+    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";