nvent 0.4.5 → 0.5.0

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

@@ -4,30 +4,28 @@
  * In-memory storage implementation for development
  * Three-tier storage:
  * 1. Event Stream - Append-only event log
- * 2. Document Store - Generic document storage
+ * 2. Sorted Index - Time-ordered metadata 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';
+import type { StoreAdapter, EventRecord, EventReadOptions, EventSubscription } from '../interfaces/store.js';
 export declare class MemoryStoreAdapter implements StoreAdapter {
     private eventStreams;
     private eventSubscriptions;
     private subscriptionCounter;
-    private documents;
     private kvStore;
+    private sortedIndices;
+    protected validator: import("../base/index.js").StoreValidator;
+    private indexLocks;
     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>;
+    stream: {
+        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>;
+        delete: (subject: string) => Promise<boolean>;
+    };
     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>;
@@ -35,23 +33,36 @@ export declare class MemoryStoreAdapter implements StoreAdapter {
         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>;
+    index: {
+        add: (key: string, id: string, score: number, metadata?: Record<string, any>) => Promise<void>;
+        get: (key: string, id: string) => Promise<{
+            id: string;
+            score: number;
+            metadata?: any;
+        } | null>;
+        read: (key: string, opts?: {
+            offset?: number;
+            limit?: number;
+        }) => Promise<Array<{
+            id: string;
+            score: number;
+            metadata?: any;
+        }>>;
+        update: (key: string, id: string, metadata: Record<string, any>) => Promise<boolean>;
+        updateWithRetry: (key: string, id: string, metadata: Record<string, any>, maxRetries?: number) => Promise<void>;
+        increment: (key: string, id: string, field: string, increment?: number) => Promise<number>;
+        delete: (key: string, id: string) => Promise<boolean>;
+    };
+    /**
+     * Acquire a lock for atomic index operations
+     * Protected to allow access from FileStoreAdapter
+     */
+    protected acquireIndexLock(key: string): Promise<() => void>;
+    /**
+     * Convert dot notation keys to nested objects
+     * e.g., { 'stats.totalFires': 5 } -> { stats: { totalFires: 5 } }
+     * null values are preserved for deletion
+     */
+    private expandDotNotation;
     private generateId;
 }

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

@@ -1,88 +1,104 @@
+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;
-  // Document Store storage: collection -> id -> document
-  documents = /* @__PURE__ */ new Map();
   // 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.documents.clear();
     this.kvStore.clear();
+    this.sortedIndices.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);
+  stream = {
+    append: async (subject, event) => {
+      const eventRecord = {
+        id: this.generateId(),
+        ts: Date.now(),
+        ...event
+      };
+      if (!this.eventStreams.has(subject)) {
+        this.eventStreams.set(subject, []);
       }
-    }
-    if (opts?.before) {
-      const beforeIndex = events.findIndex((e) => e.id === opts.before);
-      if (beforeIndex >= 0) {
-        events = events.slice(0, beforeIndex);
+      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?.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);
+      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) {
@@ -96,62 +112,6 @@ export class MemoryStoreAdapter {
     }
   }
   // ============================================================
-  // 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 = {
@@ -184,75 +144,185 @@ export class MemoryStoreAdapter {
     }
   };
   // ============================================================
-  // Sorted Index (optional, for time-ordered listings)
+  // Sorted Index (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, []);
+  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;
     }
-    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);
+  };
+  /**
+   * 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);
     }
-    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
+    let releaseLock;
+    const lockPromise = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    this.indexLocks.set(key, lockPromise);
+    return () => {
+      this.indexLocks.delete(key);
+      releaseLock();
     };
-    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)));
+  /**
+   * 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;
+      }
     }
-    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 };
+    if (deleteMarkers.length > 0) {
+      result.__deleteMarkers = deleteMarkers;
     }
-    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;
+    return result;
   }
   // ============================================================
   // Helpers

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

@@ -1,5 +1,5 @@
 /**
- * Adapter Factory (v0.4.1)
+ * Adapter Factory
  *
  * Creates adapters independently without dependencies
  * StoreAdapter is pure storage - streaming handled by wiring layer
@@ -17,7 +17,7 @@ export interface AdapterSet {
     store: StoreAdapter;
 }
 /**
- * Create a complete set of adapters (v0.4.1)
+ * Create a complete set of adapters
  * All adapters are independent - wiring layer handles coordination
  */
 export declare function createAdapters(config: {