Simplify: one abstract base class per layer

- BaseKVStorage / BaseEventStorage / BaseDocumentStorage define the API once;
  implementations provide only raw primitives (client and server share an API)
- Drop KV indexes, query planner, unique indexes; document stores take index fields
- Escape every char <= '/' so child keys stay contiguous; skip-scan is now simple
- Event-sourced documents = event storage + any document store for projections
- New folder layout (kv-storage, event-storage, document-storage, utils); tests only in test/

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017Qxbkp4tA7G5SCWjzWuxmE

test/helpers.ts

@@ -1,83 +1,45 @@
-import { BaseKVDriver, type BatchOp, type KVDriver, type ScanOptions } from '../src/kv/driver.js'
-import { InMemoryKVDriver } from '../src/kv/memory.js'
+import { BaseKVStorage, type ScanOptions } from '../src/kv-storage/base-kv-storage.js'
+import { KVStorageInMemory } from '../src/kv-storage/kv-storage-in-memory.js'
 
-/** A minimal driver implementing only the four required methods, over a plain Map. */
-export class MinimalDriver extends BaseKVDriver {
-  readonly map = new Map<string, string>()
-  async getMany(keys: string[]) {
-    return keys.map((k) => (this.map.has(k) ? JSON.parse(this.map.get(k)!) : undefined))
-  }
-  async setMany(entries: [string, unknown][]) {
-    for (const [k, v] of entries) this.map.set(k, JSON.stringify(v))
-  }
-  async deleteMany(keys: string[]) {
-    for (const k of keys) this.map.delete(k)
-  }
-  async *scan({ gte, lt, limit = Infinity, reverse, values }: ScanOptions): AsyncGenerator<[string, unknown]> {
-    let keys = [...this.map.keys()].filter((k) => (gte === undefined || k >= gte) && (lt === undefined || k < lt)).sort()
-    if (reverse) keys.reverse()
-    keys = keys.slice(0, limit)
-    for (const k of keys) {
-      if (!this.map.has(k)) continue
-      yield [k, values ? JSON.parse(this.map.get(k)!) : undefined]
-    }
-  }
+export async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
+  const out: T[] = []
+  for await (const item of iterable) out.push(item)
+  return out
 }
 
-export type Capability = 'setIfAbsent' | 'batch' | 'deleteRange'
-
 /**
- * Wraps a driver, counting calls per method and optionally hiding optional capabilities.
- * `scan` counts each scan started (i.e. each seek).
+ * Wraps another KV storage and counts primitive calls. Also shows the wrapper pattern
+ * (e.g. an encryption layer): extend BaseKVStorage and delegate the five primitives.
  */
-export class CountingDriver implements KVDriver {
+export class KVStorageCounting extends BaseKVStorage {
   calls: Record<string, number> = {}
-  setIfAbsent?: KVDriver['setIfAbsent']
-  batch?: KVDriver['batch']
-  deleteRange?: KVDriver['deleteRange']
 
-  constructor(
-    readonly inner: KVDriver = new InMemoryKVDriver(),
-    hide: Capability[] = [],
-  ) {
-    if (inner.setIfAbsent && !hide.includes('setIfAbsent')) this.setIfAbsent = (e: [string, unknown][]) => (this.#count('setIfAbsent'), inner.setIfAbsent!(e))
-    if (inner.batch && !hide.includes('batch')) this.batch = (ops: BatchOp[]) => (this.#count('batch'), inner.batch!(ops))
-    if (inner.deleteRange && !hide.includes('deleteRange'))
-      this.deleteRange = (gte: string, lt: string) => (this.#count('deleteRange'), inner.deleteRange!(gte, lt))
-  }
-
-  #count(m: string): void {
-    this.calls[m] = (this.calls[m] ?? 0) + 1
+  constructor(readonly inner: BaseKVStorage = new KVStorageInMemory()) {
+    super()
   }
 
   reset(): void {
     this.calls = {}
   }
 
-  get total(): number {
-    return Object.values(this.calls).reduce((a, b) => a + b, 0)
+  readMany(keys: string[]) {
+    return this.count('readMany', () => this.inner.readMany(keys))
+  }
+  writeMany(entries: [string, unknown][]) {
+    return this.count('writeMany', () => this.inner.writeMany(entries))
+  }
+  removeMany(keys: string[]) {
+    return this.count('removeMany', () => this.inner.removeMany(keys))
+  }
+  writeIfAbsent(entries: [string, unknown][]) {
+    return this.count('writeIfAbsent', () => this.inner.writeIfAbsent(entries))
+  }
+  scan(options?: ScanOptions) {
+    return this.count('scan', () => this.inner.scan(options))
   }
 
-  getMany(keys: string[]) {
-    this.#count('getMany')
-    return this.inner.getMany(keys)
-  }
-  setMany(entries: [string, unknown][]) {
-    this.#count('setMany')
-    return this.inner.setMany(entries)
-  }
-  deleteMany(keys: string[]) {
-    this.#count('deleteMany')
-    return this.inner.deleteMany(keys)
-  }
-  scan(opts: ScanOptions) {
-    this.#count('scan')
-    return this.inner.scan(opts)
+  private count<T>(name: string, fn: () => T): T {
+    this.calls[name] = (this.calls[name] ?? 0) + 1
+    return fn()
   }
 }
-
-export async function collect<T>(it: AsyncIterable<T>): Promise<T[]> {
-  const out: T[] = []
-  for await (const x of it) out.push(x)
-  return out
-}