dataply 0.0.24-alpha.5 → 0.0.24-alpha.6

package/dist/cjs/index.js

@@ -9465,8 +9465,6 @@ var Transaction = class {
   pageLocks = /* @__PURE__ */ new Map();
   /** Dirty Pages modified by the transaction: PageID -> Modified Page Buffer */
   dirtyPages = /* @__PURE__ */ new Map();
-  /** Promise chain for serializing operations on this transaction */
-  serialPromise = Promise.resolve();
   /** Undo pages: PageID -> Original Page Buffer (Snapshot) */
   undoPages = /* @__PURE__ */ new Map();
   /** BPTree Transaction instance */
@@ -9477,6 +9475,8 @@ var Transaction = class {
   commitHooks = [];
   /** Page MVCC Strategy for disk access */
   pageStrategy;
+  /** Release function for global write lock, set by DataplyAPI */
+  _writeLockRelease = null;
   /**
    * Sets the BPTree transaction.
    * @param tx BPTree transaction
@@ -9508,28 +9508,21 @@ var Transaction = class {
    * Registers a commit hook.
    * @param hook Function to execute
    */
+  onCommit(hook) {
+    this.commitHooks.push(hook);
+  }
   /**
-   * Serializes asynchronous operations on this transaction.
-   * Ensures that concurrent calls (e.g., insertBatch + commit) are queued and executed sequentially.
-   * @param fn The async function to serialize
-   * @returns The result of the function
+   * Sets the global write lock release function.
+   * Called by DataplyAPI.runWithDefaultWrite when acquiring the lock.
    */
-  async serialize(fn) {
-    const previous = this.serialPromise;
-    let resolveLock;
-    this.serialPromise = new Promise((resolve) => {
-      resolveLock = resolve;
-    });
-    return previous.then(async () => {
-      try {
-        return await fn();
-      } finally {
-        resolveLock();
-      }
-    });
+  __setWriteLockRelease(release) {
+    this._writeLockRelease = release;
   }
-  onCommit(hook) {
-    this.commitHooks.push(hook);
+  /**
+   * Returns whether this transaction already has a write lock.
+   */
+  __hasWriteLockRelease() {
+    return this._writeLockRelease !== null;
   }
   /**
    * Reads a page. Uses dirty buffer if available, otherwise disk.
@@ -9576,7 +9569,7 @@ var Transaction = class {
    * Commits the transaction.
    */
   async commit() {
-    return this.serialize(async () => {
+    try {
       await this.context.run(this, async () => {
         for (const hook of this.commitHooks) {
           await hook();
@@ -9604,20 +9597,30 @@ var Transaction = class {
       this.dirtyPages.clear();
       this.undoPages.clear();
       this.releaseAllLocks();
-    });
+    } finally {
+      if (this._writeLockRelease) {
+        this._writeLockRelease();
+        this._writeLockRelease = null;
+      }
+    }
   }
   /**
    * Rolls back the transaction.
    */
   async rollback() {
-    return this.serialize(async () => {
+    try {
       if (this.bptreeTx) {
         this.bptreeTx.rollback();
       }
       this.dirtyPages.clear();
       this.undoPages.clear();
       this.releaseAllLocks();
-    });
+    } finally {
+      if (this._writeLockRelease) {
+        this._writeLockRelease();
+        this._writeLockRelease = null;
+      }
+    }
   }
   /**
    * Returns the dirty pages map.
@@ -9698,6 +9701,8 @@ var DataplyAPI = class {
   /** Whether the database was created this time. */
   isNewlyCreated;
   txIdCounter;
+  /** Promise-chain mutex for serializing write operations */
+  writeQueue = Promise.resolve();
   /**
    * Verifies if the page file is a valid Dataply file.
    * The metadata page must be located at the beginning of the Dataply file.
@@ -9855,13 +9860,58 @@ var DataplyAPI = class {
    * @param tx The transaction to use. If not provided, a new transaction is created.
    * @returns The result of the callback function.
    */
+  /**
+   * Acquires the global write lock.
+   * Returns a release function that MUST be called to unlock.
+   * Used internally by runWithDefaultWrite.
+   * @returns A release function
+   */
+  acquireWriteLock() {
+    const previous = this.writeQueue;
+    let release;
+    this.writeQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    return previous.then(() => release);
+  }
+  /**
+   * Runs a write callback within a transaction context with global write serialization.
+   * If no transaction is provided, a new transaction is created, committed on success, rolled back on error.
+   * If a transaction is provided (external), the write lock is acquired on first call and held until commit/rollback.
+   * Subclasses MUST use this method for all write operations instead of runWithDefault.
+   * @param callback The callback function to run.
+   * @param tx Optional external transaction.
+   * @returns The result of the callback.
+   */
+  async runWithDefaultWrite(callback, tx) {
+    if (!tx) {
+      const release = await this.acquireWriteLock();
+      const internalTx = this.createTransaction();
+      internalTx.__setWriteLockRelease(release);
+      const [error2, result2] = await catchPromise(this.txContext.run(internalTx, () => callback(internalTx)));
+      if (error2) {
+        await internalTx.rollback();
+        throw error2;
+      }
+      await internalTx.commit();
+      return result2;
+    }
+    if (!tx.__hasWriteLockRelease()) {
+      const release = await this.acquireWriteLock();
+      tx.__setWriteLockRelease(release);
+    }
+    const [error, result] = await catchPromise(this.txContext.run(tx, () => callback(tx)));
+    if (error) {
+      throw error;
+    }
+    return result;
+  }
   async runWithDefault(callback, tx) {
     const isInternalTx = !tx;
     if (!tx) {
       tx = this.createTransaction();
     }
-    const run = () => catchPromise(this.txContext.run(tx, () => callback(tx)));
-    const [error, result] = isInternalTx ? await run() : await tx.serialize(run);
+    const [error, result] = await catchPromise(this.txContext.run(tx, () => callback(tx)));
     if (error) {
       if (isInternalTx) {
         await tx.rollback();
@@ -9889,20 +9939,6 @@ var DataplyAPI = class {
       tx = this.createTransaction();
     }
     let hasError = false;
-    if (!isInternalTx) {
-      const values = await tx.serialize(async () => {
-        const collected = [];
-        const generator = this.txContext.stream(tx, () => callback(tx));
-        for await (const value of generator) {
-          collected.push(value);
-        }
-        return collected;
-      });
-      for (const value of values) {
-        yield value;
-      }
-      return;
-    }
     try {
       const generator = this.txContext.stream(tx, () => callback(tx));
       for await (const value of generator) {
@@ -9910,10 +9946,12 @@ var DataplyAPI = class {
       }
     } catch (error) {
       hasError = true;
-      await tx.rollback();
+      if (isInternalTx) {
+        await tx.rollback();
+      }
       throw error;
     } finally {
-      if (!hasError) {
+      if (!hasError && isInternalTx) {
         await tx.commit();
       }
     }
@@ -9939,7 +9977,7 @@ var DataplyAPI = class {
     if (!this.initialized) {
       throw new Error("Dataply instance is not initialized");
     }
-    return this.runWithDefault(async (tx2) => {
+    return this.runWithDefaultWrite(async (tx2) => {
       incrementRowCount = incrementRowCount ?? true;
       if (typeof data === "string") {
         data = this.textCodec.encode(data);
@@ -9959,7 +9997,7 @@ var DataplyAPI = class {
     if (!this.initialized) {
       throw new Error("Dataply instance is not initialized");
     }
-    return this.runWithDefault(async (tx2) => {
+    return this.runWithDefaultWrite(async (tx2) => {
       incrementRowCount = incrementRowCount ?? true;
       if (typeof data === "string") {
         data = this.textCodec.encode(data);
@@ -9980,7 +10018,7 @@ var DataplyAPI = class {
     if (!this.initialized) {
       throw new Error("Dataply instance is not initialized");
     }
-    return this.runWithDefault(async (tx2) => {
+    return this.runWithDefaultWrite(async (tx2) => {
       incrementRowCount = incrementRowCount ?? true;
       const encodedList = dataList.map(
         (data) => typeof data === "string" ? this.textCodec.encode(data) : data
@@ -9998,7 +10036,7 @@ var DataplyAPI = class {
     if (!this.initialized) {
       throw new Error("Dataply instance is not initialized");
     }
-    return this.runWithDefault(async (tx2) => {
+    return this.runWithDefaultWrite(async (tx2) => {
       if (typeof data === "string") {
         data = this.textCodec.encode(data);
       }
@@ -10015,7 +10053,7 @@ var DataplyAPI = class {
     if (!this.initialized) {
       throw new Error("Dataply instance is not initialized");
     }
-    return this.runWithDefault(async (tx2) => {
+    return this.runWithDefaultWrite(async (tx2) => {
       decrementRowCount = decrementRowCount ?? true;
       await this.rowTableEngine.delete(pk, decrementRowCount, tx2);
     }, tx);

package/dist/types/core/DataplyAPI.d.ts

@@ -40,6 +40,8 @@ export declare class DataplyAPI {
     /** Whether the database was created this time. */
     private readonly isNewlyCreated;
     private txIdCounter;
+    /** Promise-chain mutex for serializing write operations */
+    private writeQueue;
     constructor(file: string, options: DataplyOptions);
     /**
      * Verifies if the page file is a valid Dataply file.
@@ -91,6 +93,23 @@ export declare class DataplyAPI {
      * @param tx The transaction to use. If not provided, a new transaction is created.
      * @returns The result of the callback function.
      */
+    /**
+     * Acquires the global write lock.
+     * Returns a release function that MUST be called to unlock.
+     * Used internally by runWithDefaultWrite.
+     * @returns A release function
+     */
+    protected acquireWriteLock(): Promise<() => void>;
+    /**
+     * Runs a write callback within a transaction context with global write serialization.
+     * If no transaction is provided, a new transaction is created, committed on success, rolled back on error.
+     * If a transaction is provided (external), the write lock is acquired on first call and held until commit/rollback.
+     * Subclasses MUST use this method for all write operations instead of runWithDefault.
+     * @param callback The callback function to run.
+     * @param tx Optional external transaction.
+     * @returns The result of the callback.
+     */
+    protected runWithDefaultWrite<T>(callback: (tx: Transaction) => Promise<T>, tx?: Transaction): Promise<T>;
     protected runWithDefault<T>(callback: (tx: Transaction) => Promise<T>, tx?: Transaction): Promise<T>;
     /**
      * Runs a generator callback function within a transaction context.

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

@@ -19,8 +19,6 @@ export declare class Transaction {
     private pageLocks;
     /** Dirty Pages modified by the transaction: PageID -> Modified Page Buffer */
     private dirtyPages;
-    /** Promise chain for serializing operations on this transaction */
-    private serialPromise;
     /** Undo pages: PageID -> Original Page Buffer (Snapshot) */
     private undoPages;
     /** BPTree Transaction instance */
@@ -31,6 +29,8 @@ export declare class Transaction {
     private commitHooks;
     /** Page MVCC Strategy for disk access */
     private readonly pageStrategy;
+    /** Release function for global write lock, set by DataplyAPI */
+    private _writeLockRelease;
     /**
      * @param id Transaction ID
      * @param context Transaction context
@@ -62,14 +62,16 @@ export declare class Transaction {
      * Registers a commit hook.
      * @param hook Function to execute
      */
+    onCommit(hook: () => Promise<void>): void;
     /**
-     * Serializes asynchronous operations on this transaction.
-     * Ensures that concurrent calls (e.g., insertBatch + commit) are queued and executed sequentially.
-     * @param fn The async function to serialize
-     * @returns The result of the function
+     * Sets the global write lock release function.
+     * Called by DataplyAPI.runWithDefaultWrite when acquiring the lock.
      */
-    serialize<T>(fn: () => Promise<T>): Promise<T>;
-    onCommit(hook: () => Promise<void>): void;
+    __setWriteLockRelease(release: () => void): void;
+    /**
+     * Returns whether this transaction already has a write lock.
+     */
+    __hasWriteLockRelease(): boolean;
     /**
      * Reads a page. Uses dirty buffer if available, otherwise disk.
      * @param pageId Page ID

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.24-alpha.5",
+  "version": "0.0.24-alpha.6",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",