mvcc-api 1.1.0 → 1.2.1

package/dist/cjs/index.cjs

@@ -38,6 +38,10 @@ var MVCCTransaction = class {
   snapshotLocalVersion;
   writeBuffer;
   deleteBuffer;
+  createdKeys;
+  // create()로 생성된 키 추적
+  deletedValues;
+  // delete 시 삭제 전 값 저장
   // Nested Transaction Properties
   parent;
   localVersion;
@@ -55,6 +59,8 @@ var MVCCTransaction = class {
     this.snapshotVersion = snapshotVersion ?? 0;
     this.writeBuffer = /* @__PURE__ */ new Map();
     this.deleteBuffer = /* @__PURE__ */ new Set();
+    this.createdKeys = /* @__PURE__ */ new Set();
+    this.deletedValues = /* @__PURE__ */ new Map();
     this.committed = false;
     this.parent = parent;
     this.keyVersions = /* @__PURE__ */ new Map();
@@ -75,59 +81,58 @@ var MVCCTransaction = class {
   isRoot() {
     return !this.parent;
   }
-  /**
-   * Schedules a creation (insert) of a key-value pair.
-   * Throws if the transaction is already committed.
-   * @param key The key to create.
-   * @param value The value to store.
-   * @returns The transaction instance for chaining.
-   */
-  create(key, value) {
-    if (this.committed) throw new Error("Transaction already committed");
+  // --- Internal buffer manipulation helpers ---
+  _bufferCreate(key, value) {
+    this.localVersion++;
     this.writeBuffer.set(key, value);
-    return this;
+    this.createdKeys.add(key);
+    this.deleteBuffer.delete(key);
+    this.keyVersions.set(key, this.localVersion);
   }
-  /**
-   * Schedules a write (update) of a key-value pair.
-   * Overwrites any existing value in the buffer.
-   * @param key The key to write.
-   * @param value The value to store.
-   * @returns The transaction instance for chaining.
-   */
-  write(key, value) {
-    if (this.committed) throw new Error("Transaction already committed");
+  _bufferWrite(key, value) {
     this.localVersion++;
     this.writeBuffer.set(key, value);
     this.deleteBuffer.delete(key);
     this.keyVersions.set(key, this.localVersion);
-    return this;
   }
-  /**
-   * Schedules a deletion of a key.
-   * @param key The key to delete.
-   * @returns The transaction instance for chaining.
-   */
-  delete(key) {
-    if (this.committed) throw new Error("Transaction already committed");
+  _bufferDelete(key) {
     this.localVersion++;
     this.deleteBuffer.add(key);
     this.writeBuffer.delete(key);
+    this.createdKeys.delete(key);
     this.keyVersions.set(key, this.localVersion);
-    return this;
   }
   /**
    * Rolls back the transaction.
    * Clears all buffers and marks the transaction as finished.
-   * @returns The transaction instance.
+   * @returns The result object with success, created, updated, and deleted keys.
    */
   rollback() {
+    const created = [];
+    const updated = [];
+    for (const [key, data] of this.writeBuffer.entries()) {
+      if (this.createdKeys.has(key)) {
+        created.push({ key, data });
+      } else {
+        updated.push({ key, data });
+      }
+    }
+    const deleted = [];
+    for (const key of this.deleteBuffer) {
+      const data = this.deletedValues.get(key);
+      if (data !== void 0) {
+        deleted.push({ key, data });
+      }
+    }
     this.writeBuffer.clear();
     this.deleteBuffer.clear();
+    this.createdKeys.clear();
+    this.deletedValues.clear();
     this.committed = true;
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
     }
-    return this;
+    return { success: true, created, updated, deleted };
   }
 };
 
@@ -137,7 +142,39 @@ var SyncMVCCStrategy = class extends MVCCStrategy {
 
 // src/core/sync/Transaction.ts
 var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
+  create(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key) || !this.deleteBuffer.has(key) && this.read(key) !== null) {
+      throw new Error(`Key already exists: ${key}`);
+    }
+    this._bufferCreate(key, value);
+    return this;
+  }
+  write(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (!this.writeBuffer.has(key) && (this.deleteBuffer.has(key) || this.read(key) === null)) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this._bufferWrite(key, value);
+    return this;
+  }
+  delete(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    let valueToDelete = null;
+    if (this.writeBuffer.has(key)) {
+      valueToDelete = this.writeBuffer.get(key);
+    } else if (!this.deleteBuffer.has(key)) {
+      valueToDelete = this.read(key);
+    }
+    if (valueToDelete === null) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this.deletedValues.set(key, valueToDelete);
+    this._bufferDelete(key);
+    return this;
+  }
   createNested() {
+    if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
     const child = new _SyncMVCCTransaction(void 0, this, childVersion);
     this.root.activeTransactions.add(child);
@@ -149,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);
@@ -169,43 +212,79 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
   }
   commit() {
-    if (this.committed) throw new Error("Transaction already committed");
+    if (this.committed) {
+      return { success: false, error: "Transaction already committed", created: [], updated: [], deleted: [] };
+    }
+    const created = [];
+    const updated = [];
+    for (const [key, data] of this.writeBuffer.entries()) {
+      if (this.createdKeys.has(key)) {
+        created.push({ key, data });
+      } else {
+        updated.push({ key, data });
+      }
+    }
+    const deleted = [];
+    for (const key of this.deleteBuffer) {
+      const data = this.deletedValues.get(key);
+      if (data !== void 0) {
+        deleted.push({ key, data });
+      }
+    }
     if (this.parent) {
-      this.parent._merge(this);
+      const error = this.parent._merge(this);
+      if (error) {
+        return { success: false, error, created: [], updated: [], deleted: [] };
+      }
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
-        this._merge(this);
+        const error = this._merge(this);
+        if (error) {
+          return { success: false, error, created: [], updated: [], deleted: [] };
+        }
         this.writeBuffer.clear();
         this.deleteBuffer.clear();
+        this.createdKeys.clear();
+        this.deletedValues.clear();
         this.keyVersions.clear();
         this.localVersion = 0;
       }
     }
-    return this;
+    return { success: true, created, updated, deleted };
   }
   _merge(child) {
     if (this.parent) {
       for (const key of child.writeBuffer.keys()) {
         const lastModLocalVer = this.keyVersions.get(key);
         if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
-          throw new Error(`Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`);
+          return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
         }
       }
       for (const key of child.deleteBuffer) {
         const lastModLocalVer = this.keyVersions.get(key);
         if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
-          throw new Error(`Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`);
+          return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
         }
       }
       const newLocalVersion = this.localVersion + 1;
       for (const key of child.writeBuffer.keys()) {
-        this.write(key, child.writeBuffer.get(key));
+        this.writeBuffer.set(key, child.writeBuffer.get(key));
+        this.deleteBuffer.delete(key);
         this.keyVersions.set(key, newLocalVersion);
+        if (child.createdKeys.has(key)) {
+          this.createdKeys.add(key);
+        }
       }
       for (const key of child.deleteBuffer) {
-        this.delete(key);
+        this.deleteBuffer.add(key);
+        this.writeBuffer.delete(key);
+        this.createdKeys.delete(key);
         this.keyVersions.set(key, newLocalVersion);
+        const deletedValue = child.deletedValues.get(key);
+        if (deletedValue !== void 0) {
+          this.deletedValues.set(key, deletedValue);
+        }
       }
       this.localVersion = newLocalVersion;
       this.root.activeTransactions.delete(child);
@@ -218,7 +297,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         if (versions && versions.length > 0) {
           const lastVer = versions[versions.length - 1].version;
           if (lastVer > child.snapshotVersion) {
-            throw new Error(`Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`);
+            return `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`;
           }
         }
       }
@@ -231,6 +310,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
       this.version = newVersion;
       this._cleanupDeletedCache();
     }
+    return null;
   }
   // --- Internal IO Helpers (Root Only) ---
   _diskWrite(key, value, version) {
@@ -276,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");
@@ -586,7 +684,39 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
       this.lock.writeUnlock(lockId);
     });
   }
+  async create(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key) || !this.deleteBuffer.has(key) && await this.read(key) !== null) {
+      throw new Error(`Key already exists: ${key}`);
+    }
+    this._bufferCreate(key, value);
+    return this;
+  }
+  async write(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (!this.writeBuffer.has(key) && (this.deleteBuffer.has(key) || await this.read(key) === null)) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this._bufferWrite(key, value);
+    return this;
+  }
+  async delete(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    let valueToDelete = null;
+    if (this.writeBuffer.has(key)) {
+      valueToDelete = this.writeBuffer.get(key);
+    } else if (!this.deleteBuffer.has(key)) {
+      valueToDelete = await this.read(key);
+    }
+    if (valueToDelete === null) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this.deletedValues.set(key, valueToDelete);
+    this._bufferDelete(key);
+    return this;
+  }
   createNested() {
+    if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
     const child = new _AsyncMVCCTransaction(void 0, this, childVersion);
     this.root.activeTransactions.add(child);
@@ -598,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);
@@ -619,20 +755,46 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
   }
   async commit() {
     return this.writeLock(async () => {
-      if (this.committed) throw new Error("Transaction already committed");
+      if (this.committed) {
+        return { success: false, error: "Transaction already committed", created: [], updated: [], deleted: [] };
+      }
+      const created = [];
+      const updated = [];
+      for (const [key, data] of this.writeBuffer.entries()) {
+        if (this.createdKeys.has(key)) {
+          created.push({ key, data });
+        } else {
+          updated.push({ key, data });
+        }
+      }
+      const deleted = [];
+      for (const key of this.deleteBuffer) {
+        const data = this.deletedValues.get(key);
+        if (data !== void 0) {
+          deleted.push({ key, data });
+        }
+      }
       if (this.parent) {
-        await this.parent._merge(this);
+        const error = await this.parent._merge(this);
+        if (error) {
+          return { success: false, error, created: [], updated: [], deleted: [] };
+        }
         this.committed = true;
       } else {
         if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
-          await this._merge(this);
+          const error = await this._merge(this);
+          if (error) {
+            return { success: false, error, created: [], updated: [], deleted: [] };
+          }
           this.writeBuffer.clear();
           this.deleteBuffer.clear();
+          this.createdKeys.clear();
+          this.deletedValues.clear();
           this.keyVersions.clear();
           this.localVersion = 0;
         }
       }
-      return this;
+      return { success: true, created, updated, deleted };
     });
   }
   async _merge(child) {
@@ -641,23 +803,33 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         for (const key of child.writeBuffer.keys()) {
           const lastModLocalVer = this.keyVersions.get(key);
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
-            throw new Error(`Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`);
+            return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
           }
         }
         for (const key of child.deleteBuffer) {
           const lastModLocalVer = this.keyVersions.get(key);
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
-            throw new Error(`Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`);
+            return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
           }
         }
         const newLocalVersion = this.localVersion + 1;
         for (const key of child.writeBuffer.keys()) {
-          this.write(key, child.writeBuffer.get(key));
+          this.writeBuffer.set(key, child.writeBuffer.get(key));
+          this.deleteBuffer.delete(key);
           this.keyVersions.set(key, newLocalVersion);
+          if (child.createdKeys.has(key)) {
+            this.createdKeys.add(key);
+          }
         }
         for (const key of child.deleteBuffer) {
-          this.delete(key);
+          this.deleteBuffer.add(key);
+          this.writeBuffer.delete(key);
+          this.createdKeys.delete(key);
           this.keyVersions.set(key, newLocalVersion);
+          const deletedValue = child.deletedValues.get(key);
+          if (deletedValue !== void 0) {
+            this.deletedValues.set(key, deletedValue);
+          }
         }
         this.localVersion = newLocalVersion;
         this.root.activeTransactions.delete(child);
@@ -670,7 +842,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           if (versions && versions.length > 0) {
             const lastVer = versions[versions.length - 1].version;
             if (lastVer > child.snapshotVersion) {
-              throw new Error(`Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`);
+              return `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`;
             }
           }
         }
@@ -683,6 +855,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         this.version = newVersion;
         this._cleanupDeletedCache();
       }
+      return null;
     });
   }
   // --- Internal IO Helpers (Root Only) ---
@@ -729,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");