rocicorp · 0xcadams · Aug 7, 2025 · Feb 14, 2025 · Jul 23, 2025 · Jul 25, 2025
diff --git a/eslint-config.json b/eslint-config.json
@@ -22,6 +22,7 @@
               "zero/*",
               "zero-cache/*",
               "zero-client/*",
+              "zero-expo/*",
               "zero-protocol/*",
               "zero-react/*",
               "zero-schema/*",
@@ -58,6 +59,7 @@
           {"name": "zero", "message": "Use relative imports instead"},
           {"name": "zero-cache", "message": "Use relative imports instead"},
           {"name": "zero-client", "message": "Use relative imports instead"},
+          {"name": "zero-expo", "message": "Use relative imports instead"},
           {"name": "zero-protocol", "message": "Use relative imports instead"},
           {"name": "zero-react", "message": "Use relative imports instead"},
           {"name": "zero-schema", "message": "Use relative imports instead"},

diff --git a/package-lock.json b/package-lock.json
diff --git a/packages/replicache/.gitignore b/packages/replicache/.gitignore
@@ -8,3 +8,4 @@ perf/index.js.map
 perf/index.js
 tool/bump/bump
 .vscode/launch.json
+src/kv/*.db*
diff --git a/packages/replicache/package.json b/packages/replicache/package.json
@@ -16,6 +16,8 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
+    "bench": "vitest bench --run",
+    "bench:watch": "vitest bench --watch",
     "format": "prettier --write .",
     "check-format": "prettier --check .",
     "check-types": "tsc && tsc --project tool/tsconfig.json",

diff --git a/packages/replicache/src/kv/sqlite-store-test-util.ts b/packages/replicache/src/kv/sqlite-store-test-util.ts
@@ -0,0 +1,54 @@
+/* eslint-disable no-console */
+import sqlite3 from '@rocicorp/zero-sqlite3';
+import fs from 'fs';
+import path from 'path';
+import {SQLiteDatabaseManager} from './sqlite-store.ts';
+
+export const getTestSQLiteDatabaseManager = (logging: boolean = false) =>
+  new SQLiteDatabaseManager({
+    open: name => {
+      const filename = path.resolve(__dirname, `${name}.db`);
+      // this cannot be :memory: because multiple read connections must access
+      // the same database
+      const db = sqlite3(filename);
+      return {
+        close: () => {
+          db.close();
+        },
+        destroy: () => {
+          db.close();
+          if (fs.existsSync(filename)) {
+            fs.unlinkSync(filename);
+          }
+        },
+        prepare: (sql: string) => {
+          const stmt = db.prepare(sql);
+          if (logging) {
+            console.log('prepare', sql);
+          }
+          return {
+            all: <T>(...params: unknown[]): T[] => {
+              const result = params.length ? stmt.all(...params) : stmt.all();
+              if (logging) {
+                console.log('all', sql, params, result);
+              }
+              return result as T[];
+            },
+            run: (...params: unknown[]): void => {
+              if (logging) {
+                console.log('run', sql, params);
+              }
+              if (params.length) {
+                stmt.run(...params);
+              } else {
+                stmt.run();
+              }
+            },
+            finalize: () => {
+              // no-op
+            },
+          };
+        },
+      };
+    },
+  });
diff --git a/packages/replicache/src/kv/sqlite-store.bench.node.ts b/packages/replicache/src/kv/sqlite-store.bench.node.ts
@@ -0,0 +1,202 @@
+import {afterAll, bench, describe, expect} from 'vitest';
+import {withRead, withWrite} from '../with-transactions.ts';
+import {getTestSQLiteDatabaseManager} from './sqlite-store-test-util.ts';
+import {createSQLiteStore} from './sqlite-store.ts';
+
+const walSQLite3DatabaseManager = getTestSQLiteDatabaseManager();
+const createWalStore = createSQLiteStore(walSQLite3DatabaseManager);
+const walStore = createWalStore('bench-wal', {
+  readPoolSize: 2,
+  journalMode: 'WAL',
+  synchronous: 'NORMAL',
+  readUncommitted: false,
+});
+
+const defaultSQLite3DatabaseManager = getTestSQLiteDatabaseManager();
+const createDefaultStore = createSQLiteStore(defaultSQLite3DatabaseManager);
+const defaultStore = createDefaultStore('bench-default', {
+  readPoolSize: 2,
+  synchronous: 'NORMAL',
+  readUncommitted: false,
+});
+
+afterAll(() => {
+  walSQLite3DatabaseManager.clearAllStoresForTesting();
+  defaultSQLite3DatabaseManager.clearAllStoresForTesting();
+});
+
+describe('sqlite tx', () => {
+  bench(
+    `default journal mode`,
+    async () => {
+      await withWrite(defaultStore, async wt => {
+        expect(await wt.get('bar')).equal(undefined);
+        await wt.put('bar', 'baz');
+        expect(await wt.get('bar')).equal('baz');
+        await wt.del('bar');
+        expect(await wt.get('bar')).equal(undefined);
+      });
+    },
+    {
+      throws: true,
+    },
+  );
+
+  bench(
+    `WAL journal mode`,
+    async () => {
+      await withWrite(walStore, async wt => {
+        expect(await wt.get('bar')).equal(undefined);
+        await wt.put('bar', 'baz');
+        expect(await wt.get('bar')).equal('baz');
+        await wt.del('bar');
+        expect(await wt.get('bar')).equal(undefined);
+      });
+    },
+    {
+      throws: true,
+    },
+  );
+});
+
+describe('sqlite write contention', () => {
+  bench(
+    `default journal mode`,
+    async () => {
+      await withWrite(defaultStore, async wt => {
+        await wt.put('foo', 'bar');
+      });
+
+      const readP1 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP2 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP3 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP4 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP5 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const writeP = withWrite(defaultStore, async wt => {
+        await wt.put('foo', 'bar2');
+      });
+
+      await Promise.all([readP1, readP2, readP3, readP4, readP5, writeP]);
+    },
+    {
+      throws: true,
+      teardown: async () => {
+        await withWrite(defaultStore, async wt => {
+          await wt.del('foo');
+        });
+      },
+    },
+  );
+
+  bench(
+    `WAL journal mode`,
+    async () => {
+      await withWrite(walStore, async wt => {
+        await wt.put('foo', 'bar');
+      });
+
+      const readP1 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP2 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP3 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP4 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP5 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const writeP = withWrite(walStore, async wt => {
+        await wt.put('foo', 'bar2');
+      });
+
+      await Promise.all([readP1, readP2, readP3, readP4, readP5, writeP]);
+    },
+    {
+      throws: true,
+      setup: async () => {
+        await withWrite(walStore, async wt => {
+          await wt.del('foo');
+        });
+      },
+    },
+  );
+});
+
+describe('plain read', () => {
+  bench(
+    `default journal mode`,
+    async () => {
+      const readP1 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP2 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP3 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP4 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP5 = withRead(defaultStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+
+      await Promise.all([readP1, readP2, readP3, readP4, readP5]);
+    },
+    {
+      throws: true,
+      setup: async () => {
+        await withWrite(defaultStore, async wt => {
+          await wt.put('foo', 'bar');
+        });
+      },
+    },
+  );
+
+  bench(
+    `WAL journal mode`,
+    async () => {
+      const readP1 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP2 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP3 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP4 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+      const readP5 = withRead(walStore, async rt => {
+        expect(await rt.get('foo')).equal('bar');
+      });
+
+      await Promise.all([readP1, readP2, readP3, readP4, readP5]);
+    },
+    {
+      throws: true,
+      setup: async () => {
+        await withWrite(walStore, async wt => {
+          await wt.put('foo', 'bar');
+        });
+      },
+    },
+  );
+});