mvcc-api 1.2.0 → 1.2.1

package/README.md

@@ -74,9 +74,10 @@ import { AsyncMVCCTransaction } from 'mvcc-api'
 const root = new AsyncMVCCTransaction(new FileStrategy())
 const tx = root.createNested()
 
-tx.create('new.json', '{}')        // Create new key
-tx.write('config.json', '{"v":2}') // Update existing key
-tx.delete('old.json')              // Delete key
+await tx.create('new.json', '{}')        // Create new key
+await tx.write('config.json', '{"v":2}') // Update existing key
+await tx.delete('old.json')              // Delete key
+await tx.exists('config.json')           // true
 
 const result = await tx.commit()
 // result.created = [{ key: 'new.json', data: '{}' }]
@@ -177,6 +178,7 @@ const bResult = b.commit()
 | `write(key, value)` | Update existing key | `this` |
 | `delete(key)` | Delete key | `this` |
 | `read(key)` | Read value | `T \| null` |
+| `exists(key)` | Check if key exists | `boolean` |
 | `commit()` | Apply changes | `TransactionResult<K, T>` |
 | `rollback()` | Discard changes | `TransactionResult<K, T>` |
 | `createNested()` | Create child transaction | `MVCCTransaction` |
@@ -201,4 +203,5 @@ type TransactionEntry<K, T> = { key: K, data: T }
 Bug reports, feature suggestions, and PRs are always welcome! Please feel free to leave your feedback via GitHub Issues.
 
 ## License
+
 MIT

package/dist/cjs/index.cjs

@@ -186,6 +186,12 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (this.deleteBuffer.has(key)) return null;
     return this.root._diskRead(key, this.snapshotVersion);
   }
+  exists(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.deleteBuffer.has(key)) return false;
+    if (this.writeBuffer.has(key)) return true;
+    return this.root._diskExists(key, this.snapshotVersion);
+  }
   _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -350,6 +356,24 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     return null;
   }
+  _diskExists(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key);
+    }
+    let targetVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        break;
+      }
+    }
+    if (!targetVerObj) return strategy.exists(key);
+    return targetVerObj.exists;
+  }
   _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
@@ -704,6 +728,12 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (this.deleteBuffer.has(key)) return null;
     return this.root._diskRead(key, this.snapshotVersion);
   }
+  async exists(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.deleteBuffer.has(key)) return false;
+    if (this.writeBuffer.has(key)) return true;
+    return this.root._diskExists(key, this.snapshotVersion);
+  }
   async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -872,6 +902,24 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     }
     return null;
   }
+  async _diskExists(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key);
+    }
+    let targetVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        break;
+      }
+    }
+    if (!targetVerObj) return strategy.exists(key);
+    return targetVerObj.exists;
+  }
   async _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");

package/dist/esm/index.mjs

@@ -157,6 +157,12 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (this.deleteBuffer.has(key)) return null;
     return this.root._diskRead(key, this.snapshotVersion);
   }
+  exists(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.deleteBuffer.has(key)) return false;
+    if (this.writeBuffer.has(key)) return true;
+    return this.root._diskExists(key, this.snapshotVersion);
+  }
   _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -321,6 +327,24 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     return null;
   }
+  _diskExists(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key);
+    }
+    let targetVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        break;
+      }
+    }
+    if (!targetVerObj) return strategy.exists(key);
+    return targetVerObj.exists;
+  }
   _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
@@ -675,6 +699,12 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (this.deleteBuffer.has(key)) return null;
     return this.root._diskRead(key, this.snapshotVersion);
   }
+  async exists(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.deleteBuffer.has(key)) return false;
+    if (this.writeBuffer.has(key)) return true;
+    return this.root._diskExists(key, this.snapshotVersion);
+  }
   async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -843,6 +873,24 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     }
     return null;
   }
+  async _diskExists(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key);
+    }
+    let targetVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        break;
+      }
+    }
+    if (!targetVerObj) return strategy.exists(key);
+    return targetVerObj.exists;
+  }
   async _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");

package/dist/types/core/async/Transaction.d.ts

@@ -9,11 +9,13 @@ export declare class AsyncMVCCTransaction<S extends AsyncMVCCStrategy<K, T>, K,
     delete(key: K): Promise<this>;
     createNested(): this;
     read(key: K): Promise<T | null>;
+    exists(key: K): Promise<boolean>;
     _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): Promise<T | null>;
     commit(): Promise<TransactionResult<K, T>>;
     _merge(child: MVCCTransaction<S, K, T>): Promise<string | null>;
     _diskWrite(key: K, value: T, version: number): Promise<void>;
     _diskRead(key: K, snapshotVersion: number): Promise<T | null>;
+    _diskExists(key: K, snapshotVersion: number): Promise<boolean>;
     _diskDelete(key: K, snapshotVersion: number): Promise<void>;
     _cleanupDeletedCache(): void;
 }

package/dist/types/core/base/Transaction.d.ts

@@ -71,6 +71,12 @@ export declare abstract class MVCCTransaction<S extends MVCCStrategy<K, T>, K, T
      * @returns The value, or null if not found.
      */
     abstract read(key: K): Deferred<T | null>;
+    /**
+     * Checks if a key exists in the transaction's snapshot.
+     * @param key The key to check.
+     * @returns True if the key exists, false otherwise.
+     */
+    abstract exists(key: K): Deferred<boolean>;
     /**
      * Commits the transaction.
      * If root, persists to storage.

package/dist/types/core/sync/Transaction.d.ts

@@ -7,11 +7,13 @@ export declare class SyncMVCCTransaction<S extends SyncMVCCStrategy<K, T>, K, T>
     delete(key: K): this;
     createNested(): this;
     read(key: K): T | null;
+    exists(key: K): boolean;
     _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): T | null;
     commit(): TransactionResult<K, T>;
     _merge(child: MVCCTransaction<S, K, T>): string | null;
     _diskWrite(key: K, value: T, version: number): void;
     _diskRead(key: K, snapshotVersion: number): T | null;
+    _diskExists(key: K, snapshotVersion: number): boolean;
     _diskDelete(key: K, snapshotVersion: number): void;
     _cleanupDeletedCache(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mvcc-api",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Multiversion Concurrency Control (MVCC) API for TypeScript",
   "license": "MIT",
   "author": "izure <admin@izure.org>",