@loro-dev/flock-sqlite 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loro-dev/flock-sqlite",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "SQLite-backed Flock CRDT replica for Node, browsers, and Cloudflare Workers.",
   "type": "module",
   "exports": {
@@ -37,10 +37,10 @@
     "access": "public"
   },
   "peerDependencies": {
+    "@loro-dev/unisqlite": "^0.4.0",
     "@sqlite.org/sqlite-wasm": "3.50.1-build1",
     "better-sqlite3": "^11.7.0",
-    "broadcast-channel": "^7.0.0",
-    "@loro-dev/unisqlite": "0.2.0"
+    "broadcast-channel": "^7.0.0"
   },
   "peerDependenciesMeta": {
     "@loro-dev/unisqlite": {
@@ -64,7 +64,7 @@
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
     "@loro-dev/flock": "4.4.0",
-    "@loro-dev/unisqlite": "0.2.0"
+    "@loro-dev/unisqlite": "0.6.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/event-batcher.ts

@@ -0,0 +1,189 @@
+import type { FlockRuntime, TimeoutHandle } from "./multi-tab-env";
+
+export class EventBatcher<TEvent> {
+  private txnEventSink: TEvent[] | undefined;
+  private debounceState:
+    | {
+        timeout: number;
+        maxDebounceTime: number;
+        timerId: TimeoutHandle;
+        maxTimerId: TimeoutHandle;
+        pendingEvents: TEvent[];
+      }
+    | undefined;
+
+  private readonly runtime: FlockRuntime;
+  private readonly emit: (source: string, events: TEvent[]) => void;
+
+  constructor(options: {
+    runtime: FlockRuntime;
+    emit: (source: string, events: TEvent[]) => void;
+  }) {
+    this.runtime = options.runtime;
+    this.emit = options.emit;
+    this.txnEventSink = undefined;
+    this.debounceState = undefined;
+  }
+
+  handleCommitEvents(
+    source: string,
+    events: TEvent[],
+    bufferable: boolean,
+  ): void {
+    if (events.length === 0) {
+      return;
+    }
+
+    if (bufferable && this.txnEventSink) {
+      this.txnEventSink.push(...events);
+      return;
+    }
+    if (bufferable && this.debounceState) {
+      this.debounceState.pendingEvents.push(...events);
+      this.resetDebounceTimer();
+      return;
+    }
+    this.emit(source, events);
+  }
+
+  beforeImport(): void {
+    if (this.debounceState !== undefined) {
+      this.commit();
+    }
+  }
+
+  async txn<T>(callback: () => Promise<T>): Promise<T> {
+    if (this.txnEventSink !== undefined) {
+      throw new Error("Nested transactions are not supported");
+    }
+    if (this.debounceState !== undefined) {
+      throw new Error(
+        "Cannot start transaction while autoDebounceCommit is active",
+      );
+    }
+
+    const eventSink: TEvent[] = [];
+    this.txnEventSink = eventSink;
+
+    try {
+      const result = await callback();
+      if (eventSink.length > 0) {
+        this.emit("local", eventSink);
+      }
+      return result;
+    } finally {
+      this.txnEventSink = undefined;
+    }
+  }
+
+  isInTxn(): boolean {
+    return this.txnEventSink !== undefined;
+  }
+
+  autoDebounceCommit(
+    timeout: number,
+    options?: { maxDebounceTime?: number },
+  ): void {
+    if (this.txnEventSink !== undefined) {
+      throw new Error(
+        "Cannot enable autoDebounceCommit while transaction is active",
+      );
+    }
+    if (this.debounceState !== undefined) {
+      throw new Error("autoDebounceCommit is already active");
+    }
+
+    const maxDebounceTime = options?.maxDebounceTime ?? 10000;
+
+    this.debounceState = {
+      timeout,
+      maxDebounceTime,
+      timerId: undefined,
+      maxTimerId: undefined,
+      pendingEvents: [],
+    };
+  }
+
+  disableAutoDebounceCommit(): void {
+    if (this.debounceState === undefined) {
+      return;
+    }
+
+    const { timerId, maxTimerId, pendingEvents } = this.debounceState;
+    if (timerId !== undefined) {
+      this.runtime.clearTimeout(timerId);
+    }
+    if (maxTimerId !== undefined) {
+      this.runtime.clearTimeout(maxTimerId);
+    }
+    this.debounceState = undefined;
+
+    if (pendingEvents.length > 0) {
+      this.emit("local", pendingEvents);
+    }
+  }
+
+  commit(): void {
+    if (this.debounceState === undefined) {
+      return;
+    }
+
+    const { timerId, maxTimerId, pendingEvents } = this.debounceState;
+    if (timerId !== undefined) {
+      this.runtime.clearTimeout(timerId);
+      this.debounceState.timerId = undefined;
+    }
+    if (maxTimerId !== undefined) {
+      this.runtime.clearTimeout(maxTimerId);
+      this.debounceState.maxTimerId = undefined;
+    }
+
+    if (pendingEvents.length > 0) {
+      this.emit("local", pendingEvents);
+      this.debounceState.pendingEvents = [];
+    }
+  }
+
+  isAutoDebounceActive(): boolean {
+    return this.debounceState !== undefined;
+  }
+
+  close(): void {
+    // Commit any pending debounced events
+    if (this.debounceState !== undefined) {
+      this.disableAutoDebounceCommit();
+    }
+
+    // Commit any transaction events (edge case: close during txn)
+    if (this.txnEventSink !== undefined) {
+      const pending = this.txnEventSink;
+      this.txnEventSink = undefined;
+      if (pending.length > 0) {
+        this.emit("local", pending);
+      }
+    }
+  }
+
+  private resetDebounceTimer(): void {
+    if (this.debounceState === undefined) {
+      return;
+    }
+
+    if (this.debounceState.timerId !== undefined) {
+      this.runtime.clearTimeout(this.debounceState.timerId);
+    }
+
+    this.debounceState.timerId = this.runtime.setTimeout(() => {
+      this.commit();
+    }, this.debounceState.timeout);
+
+    if (
+      this.debounceState.maxTimerId === undefined &&
+      this.debounceState.pendingEvents.length === 1
+    ) {
+      this.debounceState.maxTimerId = this.runtime.setTimeout(() => {
+        this.commit();
+      }, this.debounceState.maxDebounceTime);
+    }
+  }
+}