@loro-dev/flock 4.2.0 → 4.3.0

package/src/index.ts

@@ -23,6 +23,10 @@ import {
   check_consistency_ffi,
   check_invariants_ffi,
   from_json_ffi,
+  txn_begin_ffi,
+  txn_commit_ffi,
+  txn_rollback_ffi,
+  is_in_txn_ffi,
 } from "./_moon_flock";
 
 type RawVersionVector = Record<string, [number, number]>;
@@ -1172,4 +1176,54 @@ export class Flock {
     }
     return unsubscribe as () => void;
   }
+
+  /**
+   * Execute operations within a transaction. All put/delete operations inside
+   * the callback will be batched and emitted as a single EventBatch when the
+   * transaction commits successfully.
+   *
+   * If the callback throws an error, the transaction is rolled back and no
+   * events are emitted. Note: Data changes are NOT rolled back - only event
+   * emission is affected.
+   *
+   * The callback must be synchronous. For async operations, use FlockSQLite.
+   *
+   * @param callback - Synchronous function containing put/delete operations
+   * @returns The return value of the callback
+   * @throws Error if nested transaction attempted
+   * @throws Error if import is called during the transaction (auto-commits first)
+   *
+   * @example
+   * ```ts
+   * flock.txn(() => {
+   *   flock.put(["a"], 1);
+   *   flock.put(["b"], 2);
+   *   flock.put(["c"], 3);
+   * });
+   * // Subscribers receive a single EventBatch with 3 events
+   * ```
+   */
+  txn<T>(callback: () => T): T {
+    txn_begin_ffi(this.inner);
+    try {
+      const result = callback();
+      txn_commit_ffi(this.inner);
+      return result;
+    } catch (e) {
+      // Only rollback if transaction is still active.
+      // import_json auto-commits the transaction before throwing,
+      // so we must check before attempting rollback.
+      if (is_in_txn_ffi(this.inner)) {
+        txn_rollback_ffi(this.inner);
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Check if a transaction is currently active.
+   */
+  isInTxn(): boolean {
+    return Boolean(is_in_txn_ffi(this.inner));
+  }
 }