mvcc-api 1.2.0 → 1.2.2

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

@@ -42,6 +42,8 @@ var MVCCTransaction = class {
   // create()로 생성된 키 추적
   deletedValues;
   // delete 시 삭제 전 값 저장
+  originallyExisted;
+  // 트랜잭션 시작 시점에 디스크에 존재했던 키 (deleted 결과 필터링용)
   // Nested Transaction Properties
   parent;
   localVersion;
@@ -61,6 +63,7 @@ var MVCCTransaction = class {
     this.deleteBuffer = /* @__PURE__ */ new Set();
     this.createdKeys = /* @__PURE__ */ new Set();
     this.deletedValues = /* @__PURE__ */ new Map();
+    this.originallyExisted = /* @__PURE__ */ new Set();
     this.committed = false;
     this.parent = parent;
     this.keyVersions = /* @__PURE__ */ new Map();
@@ -87,6 +90,7 @@ var MVCCTransaction = class {
     this.writeBuffer.set(key, value);
     this.createdKeys.add(key);
     this.deleteBuffer.delete(key);
+    this.originallyExisted.delete(key);
     this.keyVersions.set(key, this.localVersion);
   }
   _bufferWrite(key, value) {
@@ -119,6 +123,7 @@ var MVCCTransaction = class {
     }
     const deleted = [];
     for (const key of this.deleteBuffer) {
+      if (!this.originallyExisted.has(key)) continue;
       const data = this.deletedValues.get(key);
       if (data !== void 0) {
         deleted.push({ key, data });
@@ -128,6 +133,7 @@ var MVCCTransaction = class {
     this.deleteBuffer.clear();
     this.createdKeys.clear();
     this.deletedValues.clear();
+    this.originallyExisted.clear();
     this.committed = true;
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
@@ -161,8 +167,10 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
   delete(key) {
     if (this.committed) throw new Error("Transaction already committed");
     let valueToDelete = null;
+    let wasInWriteBuffer = false;
     if (this.writeBuffer.has(key)) {
       valueToDelete = this.writeBuffer.get(key);
+      wasInWriteBuffer = true;
     } else if (!this.deleteBuffer.has(key)) {
       valueToDelete = this.read(key);
     }
@@ -170,6 +178,9 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
       throw new Error(`Key not found: ${key}`);
     }
     this.deletedValues.set(key, valueToDelete);
+    if (!wasInWriteBuffer || !this.createdKeys.has(key)) {
+      this.originallyExisted.add(key);
+    }
     this._bufferDelete(key);
     return this;
   }
@@ -186,6 +197,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);
@@ -220,6 +237,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     const deleted = [];
     for (const key of this.deleteBuffer) {
+      if (!this.originallyExisted.has(key)) continue;
       const data = this.deletedValues.get(key);
       if (data !== void 0) {
         deleted.push({ key, data });
@@ -241,6 +259,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         this.deleteBuffer.clear();
         this.createdKeys.clear();
         this.deletedValues.clear();
+        this.originallyExisted.clear();
         this.keyVersions.clear();
         this.localVersion = 0;
       }
@@ -279,6 +298,9 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         if (deletedValue !== void 0) {
           this.deletedValues.set(key, deletedValue);
         }
+        if (child.originallyExisted.has(key)) {
+          this.originallyExisted.add(key);
+        }
       }
       this.localVersion = newLocalVersion;
       this.root.activeTransactions.delete(child);
@@ -350,6 +372,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");
@@ -679,8 +719,10 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
   async delete(key) {
     if (this.committed) throw new Error("Transaction already committed");
     let valueToDelete = null;
+    let wasInWriteBuffer = false;
     if (this.writeBuffer.has(key)) {
       valueToDelete = this.writeBuffer.get(key);
+      wasInWriteBuffer = true;
     } else if (!this.deleteBuffer.has(key)) {
       valueToDelete = await this.read(key);
     }
@@ -688,6 +730,9 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
       throw new Error(`Key not found: ${key}`);
     }
     this.deletedValues.set(key, valueToDelete);
+    if (!wasInWriteBuffer || !this.createdKeys.has(key)) {
+      this.originallyExisted.add(key);
+    }
     this._bufferDelete(key);
     return this;
   }
@@ -704,6 +749,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);
@@ -739,6 +790,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
       }
       const deleted = [];
       for (const key of this.deleteBuffer) {
+        if (!this.originallyExisted.has(key)) continue;
         const data = this.deletedValues.get(key);
         if (data !== void 0) {
           deleted.push({ key, data });
@@ -760,6 +812,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           this.deleteBuffer.clear();
           this.createdKeys.clear();
           this.deletedValues.clear();
+          this.originallyExisted.clear();
           this.keyVersions.clear();
           this.localVersion = 0;
         }
@@ -800,6 +853,9 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           if (deletedValue !== void 0) {
             this.deletedValues.set(key, deletedValue);
           }
+          if (child.originallyExisted.has(key)) {
+            this.originallyExisted.add(key);
+          }
         }
         this.localVersion = newLocalVersion;
         this.root.activeTransactions.delete(child);
@@ -872,6 +928,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

@@ -13,6 +13,8 @@ var MVCCTransaction = class {
   // create()로 생성된 키 추적
   deletedValues;
   // delete 시 삭제 전 값 저장
+  originallyExisted;
+  // 트랜잭션 시작 시점에 디스크에 존재했던 키 (deleted 결과 필터링용)
   // Nested Transaction Properties
   parent;
   localVersion;
@@ -32,6 +34,7 @@ var MVCCTransaction = class {
     this.deleteBuffer = /* @__PURE__ */ new Set();
     this.createdKeys = /* @__PURE__ */ new Set();
     this.deletedValues = /* @__PURE__ */ new Map();
+    this.originallyExisted = /* @__PURE__ */ new Set();
     this.committed = false;
     this.parent = parent;
     this.keyVersions = /* @__PURE__ */ new Map();
@@ -58,6 +61,7 @@ var MVCCTransaction = class {
     this.writeBuffer.set(key, value);
     this.createdKeys.add(key);
     this.deleteBuffer.delete(key);
+    this.originallyExisted.delete(key);
     this.keyVersions.set(key, this.localVersion);
   }
   _bufferWrite(key, value) {
@@ -90,6 +94,7 @@ var MVCCTransaction = class {
     }
     const deleted = [];
     for (const key of this.deleteBuffer) {
+      if (!this.originallyExisted.has(key)) continue;
       const data = this.deletedValues.get(key);
       if (data !== void 0) {
         deleted.push({ key, data });
@@ -99,6 +104,7 @@ var MVCCTransaction = class {
     this.deleteBuffer.clear();
     this.createdKeys.clear();
     this.deletedValues.clear();
+    this.originallyExisted.clear();
     this.committed = true;
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
@@ -132,8 +138,10 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
   delete(key) {
     if (this.committed) throw new Error("Transaction already committed");
     let valueToDelete = null;
+    let wasInWriteBuffer = false;
     if (this.writeBuffer.has(key)) {
       valueToDelete = this.writeBuffer.get(key);
+      wasInWriteBuffer = true;
     } else if (!this.deleteBuffer.has(key)) {
       valueToDelete = this.read(key);
     }
@@ -141,6 +149,9 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
       throw new Error(`Key not found: ${key}`);
     }
     this.deletedValues.set(key, valueToDelete);
+    if (!wasInWriteBuffer || !this.createdKeys.has(key)) {
+      this.originallyExisted.add(key);
+    }
     this._bufferDelete(key);
     return this;
   }
@@ -157,6 +168,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);
@@ -191,6 +208,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     const deleted = [];
     for (const key of this.deleteBuffer) {
+      if (!this.originallyExisted.has(key)) continue;
       const data = this.deletedValues.get(key);
       if (data !== void 0) {
         deleted.push({ key, data });
@@ -212,6 +230,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         this.deleteBuffer.clear();
         this.createdKeys.clear();
         this.deletedValues.clear();
+        this.originallyExisted.clear();
         this.keyVersions.clear();
         this.localVersion = 0;
       }
@@ -250,6 +269,9 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         if (deletedValue !== void 0) {
           this.deletedValues.set(key, deletedValue);
         }
+        if (child.originallyExisted.has(key)) {
+          this.originallyExisted.add(key);
+        }
       }
       this.localVersion = newLocalVersion;
       this.root.activeTransactions.delete(child);
@@ -321,6 +343,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");
@@ -650,8 +690,10 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
   async delete(key) {
     if (this.committed) throw new Error("Transaction already committed");
     let valueToDelete = null;
+    let wasInWriteBuffer = false;
     if (this.writeBuffer.has(key)) {
       valueToDelete = this.writeBuffer.get(key);
+      wasInWriteBuffer = true;
     } else if (!this.deleteBuffer.has(key)) {
       valueToDelete = await this.read(key);
     }
@@ -659,6 +701,9 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
       throw new Error(`Key not found: ${key}`);
     }
     this.deletedValues.set(key, valueToDelete);
+    if (!wasInWriteBuffer || !this.createdKeys.has(key)) {
+      this.originallyExisted.add(key);
+    }
     this._bufferDelete(key);
     return this;
   }
@@ -675,6 +720,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);
@@ -710,6 +761,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
       }
       const deleted = [];
       for (const key of this.deleteBuffer) {
+        if (!this.originallyExisted.has(key)) continue;
         const data = this.deletedValues.get(key);
         if (data !== void 0) {
           deleted.push({ key, data });
@@ -731,6 +783,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           this.deleteBuffer.clear();
           this.createdKeys.clear();
           this.deletedValues.clear();
+          this.originallyExisted.clear();
           this.keyVersions.clear();
           this.localVersion = 0;
         }
@@ -771,6 +824,9 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           if (deletedValue !== void 0) {
             this.deletedValues.set(key, deletedValue);
           }
+          if (child.originallyExisted.has(key)) {
+            this.originallyExisted.add(key);
+          }
         }
         this.localVersion = newLocalVersion;
         this.root.activeTransactions.delete(child);
@@ -843,6 +899,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

@@ -16,6 +16,7 @@ export declare abstract class MVCCTransaction<S extends MVCCStrategy<K, T>, K, T
     readonly deleteBuffer: Set<K>;
     readonly createdKeys: Set<K>;
     readonly deletedValues: Map<K, T>;
+    readonly originallyExisted: Set<K>;
     readonly parent?: MVCCTransaction<S, K, T>;
     localVersion: number;
     readonly keyVersions: Map<K, number>;
@@ -71,6 +72,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.2",
   "description": "Multiversion Concurrency Control (MVCC) API for TypeScript",
   "license": "MIT",
   "author": "izure <admin@izure.org>",