localspace 0.2.2 → 0.3.1

package/README.md

@@ -35,6 +35,7 @@ Starting fresh let us eliminate technical debt while maintaining API compatibili
   - [Configure isolated stores for clear data boundaries](#configure-isolated-stores-for-clear-data-boundaries)
   - [Choose drivers with predictable fallbacks](#choose-drivers-with-predictable-fallbacks)
   - [Handle binary data across browsers](#handle-binary-data-across-browsers)
+  - [Advanced: Coalesced Writes (IndexedDB only)](#advanced-coalesced-writes-indexeddb-only)
 - [Migration Guide](#migration-guide)
   - [Note differences from localForage before upgrading](#note-differences-from-localforage-before-upgrading)
   - [Enable compatibility mode for legacy callbacks](#enable-compatibility-mode-for-legacy-callbacks)
@@ -52,25 +53,23 @@ localspace is built on a foundation designed for growth. Here's what's planned:
 - [x] Comprehensive test coverage
 - [x] Modern build pipeline (ES modules, CommonJS, UMD)
 - [x] Batch operations (`setItems()`, `getItems()`, `removeItems()`) for higher throughput
-- [x] Automatic write coalescing (3-10x faster rapid writes, enabled by default)
+- [x] Automatic write coalescing (3-10x faster rapid writes, opt-in for IndexedDB)
 - [x] Connection pooling, transaction batching, and warmup
 - [x] **Improved error handling** - Structured error types with detailed context
 
 ### TODO
-- [ ] **Plugin system** - Middleware architecture for cross-cutting concerns
-- [ ] **Cache API driver** - Native browser caching with automatic HTTP semantics
+- [x] **Plugin system** - Middleware architecture for cross-cutting concerns
 - [ ] **OPFS driver** - Origin Private File System for high-performance file storage
-- [ ] **Memory driver** - In-memory storage for testing and SSR
 - [ ] **Custom driver templates** - Documentation and examples for third-party drivers
 - [ ] **Node.js** - File system and SQLite adapters
 - [ ] **React Native** - AsyncStorage and SQLite drivers
 - [ ] **Electron** - Main and renderer process coordination
 - [ ] **Deno** - Native KV store integration
-- [ ] **TTL plugin** - Time-to-live expiration with automatic cleanup
-- [ ] **Encryption plugin** - Transparent encryption/decryption with Web Crypto API
-- [ ] **Compression plugin** - LZ-string or Brotli compression for large values
-- [ ] **Sync plugin** - Multi-tab synchronization with BroadcastChannel
-- [ ] **Quota plugin** - Automatic quota management and cleanup strategies
+- [x] **TTL plugin** - Time-to-live expiration with automatic cleanup
+- [x] **Encryption plugin** - Transparent encryption/decryption with Web Crypto API
+- [x] **Compression plugin** - LZ-string or Brotli compression for large values
+- [x] **Sync plugin** - Multi-tab synchronization with BroadcastChannel
+- [x] **Quota plugin** - Automatic quota management and cleanup strategies
 
 ### 📊 Community Priorities
 
@@ -124,8 +123,8 @@ localspace.getItem('user', (error, value) => {
 });
 ```
 
-### 🚀 Get automatic performance optimization (enabled by default)
-localspace automatically merges rapid single writes into batched transactions, giving you **3-10x performance improvement** without changing your code. This feature is enabled by default and works transparently in the background.
+### 🚀 Opt into automatic performance optimization (coalesced writes)
+localspace can merge rapid single writes into batched transactions for IndexedDB, giving you **3-10x performance improvement** under write-heavy bursts. This is opt-in so default behavior stays predictable; enable it when you know you have high write pressure.
 
 ```ts
 // Your existing code - unchanged
@@ -139,21 +138,18 @@ await Promise.all([
 // ✅ Zero code changes required
 ```
 
-**How it works**: When using IndexedDB, rapid writes within an 8ms window are automatically merged into a single transaction commit. This is transparent to your application and has no impact on single writes.
+**How it works**: When using IndexedDB, rapid writes within an 8ms window are merged into a single transaction commit. This is transparent to your application and has no impact on single writes.
 
-**Want to customize or disable it?**
+**Turn it on or tune it**
 ```ts
 const instance = localspace.createInstance({
-  coalesceWrites: true,      // enabled by default
+  coalesceWrites: true,      // opt-in (default is false)
   coalesceWindowMs: 8,       // 8ms window (default)
 });
-
-// Or disable if you need strict per-operation durability
-const strict = localspace.createInstance({
-  coalesceWrites: false,
-});
 ```
 
+For consistency modes, batch limits, and failure semantics, see **Advanced: Coalesced Writes** below.
+
 **When is this useful?**
 - Form auto-save that writes multiple fields rapidly
 - Bulk state synchronization loops
@@ -283,6 +279,208 @@ await localspace.setItem('file', file);
 const restored = await localspace.getItem<Blob>('file');
 ```
 
+## Advanced: Coalesced Writes (IndexedDB only)
+
+localspace offers an opt-in, configurable coalesced write path to cut IndexedDB transaction count and improve throughput under heavy write bursts.
+
+> `coalesceWrites` defaults to `false` so behavior stays predictable. Turn it on when you expect high-frequency writes.
+
+### Why coalesce writes?
+
+Each IndexedDB write opens a readwrite transaction. At high frequency, transaction startup overhead becomes a bottleneck. With coalescing enabled, `setItem` and `removeItem` calls that land within a short window (default 8 ms) are merged into fewer transactions:
+- Multiple writes can share one transaction.
+- `coalesceMaxBatchSize` caps how many ops each flush processes.
+- `coalesceReadConsistency` controls when writes resolve and when reads see them.
+
+### Configuration
+
+Relevant `LocalSpaceConfig` fields:
+
+```ts
+interface LocalSpaceConfig {
+  /**
+   * Enable coalesced writes (IndexedDB only).
+   * Default: false
+   */
+  coalesceWrites?: boolean;
+
+  /**
+   * Time window (ms) for merging writes into the same batch.
+   * Default: 8
+   */
+  coalesceWindowMs?: number;
+
+  /**
+   * Maximum operations per flush batch. Beyond this, flush immediately
+   * and split into multiple transactions.
+   * Default: undefined (no limit)
+   */
+  coalesceMaxBatchSize?: number;
+
+  /**
+   * When coalesceWrites is on:
+   * - 'strong' (default): drain pending writes before reads
+   * - 'eventual': reads skip draining; writes only guarantee queueing
+   */
+  coalesceReadConsistency?: 'strong' | 'eventual';
+}
+```
+
+### Consistency modes
+
+#### `coalesceReadConsistency: 'strong'` (default)
+- Writes (`setItem` / `removeItem`): Promises resolve after the data is persisted; flush errors reject.
+- Reads (`getItem`, `iterate`, batch reads): call `drainCoalescedWrites` first so you read what you just wrote.
+
+Use this for user settings, drafts, and any flow where you need read-your-writes.
+
+#### `coalesceReadConsistency: 'eventual'`
+- Writes: queued and resolve immediately once enqueued; flush happens in the background. Errors log `console.warn('[localspace] coalesced write failed (eventual mode)', error)` but do not reject the earlier Promise.
+- Reads: do not flush pending writes, so you may briefly see stale values.
+- Destructive operations still force a flush to avoid dropping queued writes: `removeItems`, `clear`, `dropInstance`.
+
+Use this for logs/analytics or workloads that can tolerate short windows of staleness in exchange for the lightest write path.
+
+### Bounding batch size
+
+```ts
+const store = localspace.createInstance({
+  name: 'logs',
+  storeName: 'events',
+  coalesceWrites: true,
+  coalesceWindowMs: 8,
+  coalesceMaxBatchSize: 64,
+  coalesceReadConsistency: 'eventual',
+});
+```
+
+- When the queue reaches `coalesceMaxBatchSize`, it flushes immediately.
+- Flush splits work into batches of up to 64 ops, each in its own transaction.
+- `getPerformanceStats()` reports `totalWrites`, `coalescedWrites`, and `transactionsSaved` so you can see the gains.
+
+### Recommended recipes
+
+1) Default: coalescing off
+```ts
+const store = localspace.createInstance({
+  name: 'app',
+  storeName: 'keyvaluepairs',
+  // coalesceWrites is false by default
+});
+```
+
+2) High-frequency writes with eventual consistency
+```ts
+const logStore = localspace.createInstance({
+  name: 'analytics',
+  storeName: 'events',
+  coalesceWrites: true,
+  coalesceWindowMs: 8,
+  coalesceMaxBatchSize: 64,
+  coalesceReadConsistency: 'eventual',
+});
+```
+- `setItem` resolves almost immediately.
+- Short windows of stale reads are acceptable.
+- `clear` and `dropInstance` force-flush so queued writes are not lost.
+
+3) Strong consistency with bounded batches
+```ts
+const userStore = localspace.createInstance({
+  name: 'user-data',
+  storeName: 'kv',
+  coalesceWrites: true,
+  coalesceWindowMs: 8,
+  coalesceMaxBatchSize: 32,
+  coalesceReadConsistency: 'strong',
+});
+```
+- Writes resolve after persistence.
+- Reads flush pending writes first.
+- Batching still reduces transaction count.
+
+### Caveats
+
+- Coalesced writes apply to the IndexedDB driver only; localStorage always writes per operation.
+- In `eventual` mode, writes can be lost if the page closes before flush completes, and errors surface only via `console.warn`.
+- For critical durability (orders, payments, irreversible state), avoid `eventual` and consider leaving `coalesceWrites` off entirely.
+
+## Plugin System
+
+localspace now ships with a first-class plugin engine. Attach middleware when creating an instance or call `use()` later; plugins can mutate payloads, observe driver context, and run async interceptors around every storage call.
+
+```ts
+const store = localspace.createInstance({
+  name: 'secure-store',
+  storeName: 'primary',
+  plugins: [
+    ttlPlugin({ defaultTTL: 60_000 }),
+    encryptionPlugin({ key: '0123456789abcdef0123456789abcdef' }),
+    compressionPlugin({ threshold: 1024 }),
+    syncPlugin({ channelName: 'localspace-sync' }),
+    quotaPlugin({ maxSize: 5 * 1024 * 1024, evictionPolicy: 'lru' }),
+  ],
+});
+```
+
+### Lifecycle and hooks
+
+- **Registration** – supply `plugins` when calling `createInstance()` or chain `instance.use(plugin)` later. Each plugin can also expose `enabled` (boolean or function) and `priority` to control execution order.
+- **Lifecycle events** – `onInit(context)` is invoked after `ready()`, and `onDestroy` lets you tear down timers or channels. Call `await instance.destroy()` when disposing of an instance to run every `onDestroy` hook (executed in reverse priority order). Context exposes the active driver, db info, config, and a shared `metadata` bag for cross-plugin coordination.
+- **Interceptors** – hook into `beforeSet/afterSet`, `beforeGet/afterGet`, `beforeRemove/afterRemove`, plus batch-specific methods such as `beforeSetItems` or `beforeGetItems`. Hooks run sequentially: `before*` hooks execute from highest to lowest priority, while `after*` hooks unwind in reverse order so layered transformations (compression → encryption → TTL) remain invertible. Returning a value passes it to the next plugin, while throwing a `LocalSpaceError` aborts the operation.
+- **Per-call state** – plugins can stash data on `context.operationState` (e.g., capture the original value in `beforeSet` and reuse it in `afterSet`). For batch operations, `context.operationState.isBatch` is `true` and `context.operationState.batchSize` provides the total count.
+- **Error handling & init policy** – unexpected exceptions are reported through `plugin.onError`. Throw a `LocalSpaceError` if you need to stop the pipeline (quota violations, failed decryptions, etc.). If a plugin `onInit` throws, the default policy is fail-fast (propagate and abort init). Set `pluginInitPolicy: 'disable-and-continue'` in config to log and skip the failing plugin instead (use with care for critical plugins like encryption).
+
+### Plugin execution order
+
+Plugins are sorted by `priority` (higher runs first in `before*`, last in `after*`). Default priorities:
+
+| Plugin | Priority | Notes |
+|--------|----------|-------|
+| sync | -100 | Runs last in `afterSet` to broadcast original (untransformed) values |
+| quota | -10 | Runs late so it measures final payload sizes |
+| ttl, encryption, compression | 0 | Default; chain in registration order |
+
+**Recommended order**: `[ttlPlugin, encryptionPlugin, compressionPlugin, syncPlugin, quotaPlugin]`
+
+### Built-in plugins
+
+#### TTL plugin
+Wraps values as `{ data, expiresAt }`, invalidates stale reads, and optionally runs background cleanup. Options:
+
+- `defaultTTL` (ms) and `keyTTL` overrides
+- `cleanupInterval` to periodically scan `iterate()` output
+- `onExpire(key, value)` callback before removal
+
+#### Encryption plugin
+Encrypts serialized payloads using the Web Crypto API (AES-GCM by default) and decrypts transparently on reads.
+
+- Provide a `key` (CryptoKey/ArrayBuffer/string) or `keyDerivation` block (PBKDF2)
+- Customize `algorithm`, `ivLength`, `ivGenerator`, or `randomSource`
+- Works in browsers and modern Node runtimes (pass your own `subtle` when needed)
+
+#### Compression plugin
+Runs LZ-string compression (or a custom codec) when payloads exceed a `threshold` and restores them on read.
+
+- `threshold` (bytes) controls when compression kicks in
+- Supply a custom `{ compress, decompress }` codec if you prefer pako/Brotli
+
+#### Sync plugin
+Keeps multiple tabs/processes in sync via `BroadcastChannel` (with `storage`-event fallback).
+
+- `channelName` separates logical buses
+- `syncKeys` lets you scope which keys broadcast
+- `conflictStrategy` defaults to `last-write-wins`; provide `onConflict` (return `false` to drop remote writes) for merge logic
+
+#### Quota plugin
+Tracks approximate storage usage after every mutation and enforces limits.
+
+- `maxSize` (bytes) and optional `useNavigatorEstimate` to read the browser’s quota
+- `evictionPolicy: 'error' | 'lru'` (LRU removes least-recently-used keys automatically)
+- `onQuotaExceeded(info)` fires before throwing so you can log/alert users
+
+> Tip: place quota plugins last so they see the final payload size after other transformations (TTL, encryption, compression, etc.).
+
 ## Migration Guide
 
 ### Note differences from localForage before upgrading
@@ -324,14 +522,15 @@ localspace.setItem('key', 'value', (err, value) => {
 ```
 
 ## Performance notes
-- **Automatic write coalescing (enabled by default):** localspace automatically merges rapid single writes (`setItem`/`removeItem`) within an 8ms window into one transaction, giving you 3-10x performance improvement with zero code changes. This is enabled by default for IndexedDB. Set `coalesceWrites: false` if you need strict per-operation durability.
+- **Automatic write coalescing (opt-in):** localspace can merge rapid single writes (`setItem`/`removeItem`) within an 8ms window into one transaction for IndexedDB, delivering 3-10x speedups under bursty writes. Enable with `coalesceWrites: true` and see **Advanced: Coalesced Writes** for consistency modes.
+- **Read-your-writes consistency with coalescing:** Pending coalesced writes are flushed before reads (`getItem`, `getItems`, `iterate`, `keys`, `length`, `key`) and destructive ops (`clear`, `dropInstance`), so immediate reads always observe the latest value. If you need eventual reads for speed, you can switch `coalesceReadConsistency` to `'eventual'`.
 - **Batch APIs outperform loops:** Playwright benchmark (`test/playwright/benchmark.spec.ts`) on 500 items x 256B showed `setItems()` ~6x faster and `getItems()` ~7.7x faster than per-item loops, with `removeItems()` ~2.8x faster (Chromium, relaxed durability).
 - **Transaction helpers:** `runTransaction()` lets you co-locate reads/writes in a single transaction for atomic migrations and to shorten lock time.
 - **Batch sizing:** Use `maxBatchSize` to split very large batch operations (`setItems`/`removeItems`/`getItems`) and keep transaction size in check. This works independently from `coalesceWrites`, which optimizes single-item operations.
 - **IndexedDB durability defaults:** Chrome 121+ uses relaxed durability by default; keep it for speed or set `durability: 'strict'` in `config` for migration-style writes.
 - **Storage Buckets (Chromium 122+):** supply a `bucket` option to isolate critical data and hint durability/persistence per bucket.
 - **Connection warmup:** IndexedDB instances pre-warm a transaction after init to reduce first-op latency (`prewarmTransactions` enabled by default; set to `false` to skip).
-- **Recommended defaults:** keep `coalesceWrites` enabled (default), `durability` relaxed, and `prewarmTransactions` on. Set `connectionIdleMs` only if you want idle connections to auto-close, and `maxBatchSize` only for very large bulk writes. Prefer IndexedDB for atomic/bulk writes since localStorage batches are non-atomic. Use `maxConcurrentTransactions` to throttle heavy parallel workloads when needed.
+- **Recommended defaults:** leave `coalesceWrites` off unless you know you need higher write throughput; if you enable it, prefer the default `strong` consistency. Keep `durability` relaxed and `prewarmTransactions` on. Set `connectionIdleMs` only if you want idle connections to auto-close, and `maxBatchSize` only for very large bulk writes. Prefer IndexedDB for atomic/bulk writes since localStorage batches are non-atomic. Use `maxConcurrentTransactions` to throttle heavy parallel workloads when needed.
 - **localStorage batch atomicity:** When using localStorage driver, batch operations (`setItems()`, `removeItems()`) are **not atomic**. If an error occurs mid-operation, some items may be written or removed while others are not. In contrast, IndexedDB batch operations use transactions and guarantee atomicity (all-or-nothing). If atomicity is critical for your use case, prefer IndexedDB driver or implement application-level rollback logic.
 
 When `compatibilityMode` is off, driver setup methods also use Node-style callbacks. Promises are recommended for all new code.
@@ -342,6 +541,8 @@ When `compatibilityMode` is off, driver setup methods also use Node-style callba
 - **Read structured errors:** Rejections surface as `LocalSpaceError` with a `code`, contextual `details` (driver, operation, key, attemptedDrivers), and the original `cause`. Branch on `error.code` instead of parsing strings.
 - **Handle quota errors:** Check for `error.code === 'QUOTA_EXCEEDED'` (or inspect `error.cause`) from `setItem` to inform users about storage limits.
 - **Run unit tests:** The project ships with Vitest and Playwright suites covering API behavior; run `yarn test` to verify changes.
+- **Collect Playwright coverage:** Run `yarn test:e2e:coverage` to re-build the bundle, execute the Playwright suite with Chromium V8 coverage enabled, and emit both text + HTML reports via `nyc` (open `coverage/index.html` after the run; raw JSON sits in `.nyc_output`).
+- **Collect combined Vitest + Playwright coverage:** Run `yarn coverage:full` to clean previous artifacts, run `vitest --coverage`, stash its Istanbul JSON into `.nyc_output`, then execute the coverage-enabled Playwright suite and emit merged `nyc` reports.
 
 ## License
 [MIT](./LICENSE)

package/dist/core/plugin-manager.d.ts

@@ -0,0 +1,48 @@
+import type { BatchItems, BatchResponse, DbInfo, LocalSpaceConfig, LocalSpaceInstance, LocalSpacePlugin, PluginContext, PluginOperation } from '../types';
+export declare class PluginAbortError extends Error {
+    constructor(message?: string);
+}
+type PluginHost = LocalSpaceInstance & {
+    _config: LocalSpaceConfig;
+    _dbInfo: DbInfo | null;
+};
+export declare class PluginManager {
+    private readonly host;
+    private readonly sharedMetadata;
+    private readonly pluginRegistry;
+    private readonly initialized;
+    private readonly initPromises;
+    private readonly destroyed;
+    private readonly disabled;
+    private orderCounter;
+    constructor(host: PluginHost, initialPlugins?: LocalSpacePlugin[]);
+    hasPlugins(): boolean;
+    registerPlugins(plugins: LocalSpacePlugin[]): void;
+    private sortPlugins;
+    private getActivePlugins;
+    ensureInitialized(): Promise<void>;
+    createContext(operation: PluginOperation | null): PluginContext;
+    beforeSet<T>(key: string, value: T, context: PluginContext): Promise<T>;
+    afterSet<T>(key: string, value: T, context: PluginContext): Promise<void>;
+    beforeGet(key: string, context: PluginContext): Promise<string>;
+    afterGet<T>(key: string, value: T | null, context: PluginContext): Promise<T | null>;
+    beforeRemove(key: string, context: PluginContext): Promise<string>;
+    afterRemove(key: string, context: PluginContext): Promise<void>;
+    beforeSetItems<T>(entries: BatchItems<T>, context: PluginContext): Promise<BatchItems<T>>;
+    afterSetItems<T>(entries: BatchResponse<T>, context: PluginContext): Promise<BatchResponse<T>>;
+    beforeGetItems(keys: string[], context: PluginContext): Promise<string[]>;
+    afterGetItems<T>(entries: BatchResponse<T>, context: PluginContext): Promise<BatchResponse<T>>;
+    beforeRemoveItems(keys: string[], context: PluginContext): Promise<string[]>;
+    afterRemoveItems(keys: string[], context: PluginContext): Promise<void>;
+    destroy(): Promise<void>;
+    normalizeBatch<T>(items: BatchItems<T>): Array<{
+        key: string;
+        value: T;
+    }>;
+    private shouldPropagate;
+    private dispatchPluginError;
+    private invokeValueHook;
+    private invokeVoidHook;
+}
+export {};
+//# sourceMappingURL=plugin-manager.d.ts.map

package/dist/core/plugin-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-manager.d.ts","sourceRoot":"","sources":["../../src/core/plugin-manager.ts"],"names":[],"mappings":"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"}