@livestore/adapter-cloudflare 0.4.0-dev.21 → 0.4.0-dev.23

package/src/make-adapter.ts

@@ -7,6 +7,7 @@ import {
   type SyncOptions,
   UnknownError,
 } from '@livestore/common'
+import type { CfTypes } from '@livestore/common-cf'
 import {
   type DevtoolsOptions,
   Eventlog,
@@ -14,9 +15,9 @@ import {
   makeLeaderThreadLayer,
   streamEventsWithSyncState,
 } from '@livestore/common/leader-thread'
-import type { CfTypes } from '@livestore/common-cf'
 import { LiveStoreEvent } from '@livestore/livestore'
-import { sqliteDbFactory } from '@livestore/sqlite-wasm/cf'
+import { CF_SQL_VFS_REQUIRED_PRAGMAS, sqliteDbFactory } from '@livestore/sqlite-wasm/cf'
+import { makeSqliteDb as makeDoSqliteDb } from './make-sqlite-db.ts'
 import { loadSqlite3Wasm } from '@livestore/sqlite-wasm/load-wasm'
 import { Effect, FetchHttpClient, Layer, Schedule, SubscriptionRef, WebChannel } from '@livestore/utils/effect'
 
@@ -57,35 +58,33 @@ export const makeAdapter =
       const schemaHashSuffix =
         schema.state.sqlite.migrations.strategy === 'manual' ? 'fixed' : schema.state.sqlite.hash.toString()
 
-      const stateDbFileName = getStateDbFileName(schemaHashSuffix)
-      const eventlogDbFileName = getEventlogDbFileName()
-
       if (resetPersistence === true) {
-        yield* resetDurableObjectPersistence({
-          storage,
-          storeId,
-          dbFileNames: [stateDbFileName, eventlogDbFileName],
-        })
+        yield* resetDurableObjectPersistence({ storage, storeId })
       }
 
+      const stateDbFileName = getStateDbFileName(schemaHashSuffix)
+
       const dbState = yield* makeSqliteDb({
         _tag: 'storage',
         storage,
         fileName: stateDbFileName,
-        configureDb: () => {},
+        configureDb: (db) =>
+          db.execute(
+            [...CF_SQL_VFS_REQUIRED_PRAGMAS, 'cache_size=-8000'].map((p) => `PRAGMA ${p}`).join(';\n'),
+          ),
       }).pipe(UnknownError.mapToUnknownError)
 
-      const dbEventlog = yield* makeSqliteDb({
-        _tag: 'storage',
-        storage,
-        fileName: eventlogDbFileName,
+      // dbEventlog runs on DO SQLite directly (not through the VFS). SQL-level transaction
+      // control (BEGIN/COMMIT/ROLLBACK) is silently dropped — see isTransactionControlStatement
+      // in make-sqlite-db.ts for details on why this is safe.
+      const dbEventlog = yield* makeDoSqliteDb({
+        _tag: 'file',
+        db: storage.sql,
         configureDb: () => {},
       }).pipe(UnknownError.mapToUnknownError)
 
       const shutdownChannel = yield* WebChannel.noopChannel<any, any>()
 
-      // Use Durable Object sync backend if no backend is specified
-
       const layer = yield* Layer.build(
         makeLeaderThreadLayer({
           schema,
@@ -125,7 +124,11 @@ export const makeAdapter =
                   options,
                 }),
             },
-            initialState: { leaderHead: initialLeaderHead, migrationsReport: initialState.migrationsReport },
+            initialState: {
+              leaderHead: initialLeaderHead,
+              migrationsReport: initialState.migrationsReport,
+              storageMode: 'persisted',
+            },
             export: Effect.sync(() => dbState.export()),
             getEventlogData: Effect.sync(() => dbEventlog.export()),
             syncState: syncProcessor.syncState,
@@ -151,7 +154,7 @@ export const makeAdapter =
         sqliteDb: syncInMemoryDb,
         webmeshMode: 'proxy',
         connectWebmeshNode: Effect.fnUntraced(function* ({ webmeshNode }) {
-          if (devtoolsOptions.enabled) {
+          if (devtoolsOptions.enabled === true) {
             console.log('connectWebmeshNode', { webmeshNode })
             //   yield* Webmesh.connectViaWebSocket({
             //     node: webmeshNode,
@@ -178,25 +181,23 @@ export const makeAdapter =
 
 const getStateDbFileName = (suffix: string) => `state${suffix}@${liveStoreStorageFormatVersion}.db`
 
-const getEventlogDbFileName = () => `eventlog@${liveStoreStorageFormatVersion}.db`
-
 const resetDurableObjectPersistence = ({
   storage,
   storeId,
-  dbFileNames,
 }: {
   storage: CfTypes.DurableObjectStorage
   storeId: string
-  dbFileNames: ReadonlyArray<string>
 }) =>
   Effect.try({
     try: () =>
+      // All three tables live in the DO's single storage.sql database but are
+      // owned by different layers during normal operation:
+      // - vfs_pages: written by the wa-sqlite VFS layer (backs dbState)
+      // - eventlog, __livestore_sync_status: written directly by dbEventlog via storage.sql
       storage.transactionSync(() => {
-        for (const baseName of dbFileNames) {
-          const likePattern = `${baseName}%`
-          safeSqlExec(storage, 'DELETE FROM vfs_blocks WHERE file_path LIKE ?', likePattern)
-          safeSqlExec(storage, 'DELETE FROM vfs_files WHERE file_path LIKE ?', likePattern)
-        }
+        safeSqlExec(storage, 'DELETE FROM vfs_pages')
+        safeSqlExec(storage, 'DELETE FROM eventlog')
+        safeSqlExec(storage, 'DELETE FROM __livestore_sync_status')
       }),
     catch: (cause) =>
       new UnknownError({
@@ -208,11 +209,11 @@ const resetDurableObjectPersistence = ({
     Effect.withSpan('@livestore/adapter-cloudflare:resetPersistence', { attributes: { storeId } }),
   )
 
-const safeSqlExec = (storage: CfTypes.DurableObjectStorage, query: string, binding: string) => {
+const safeSqlExec = (storage: CfTypes.DurableObjectStorage, query: string, binding?: string) => {
   try {
-    storage.sql.exec(query, binding)
+    binding !== undefined ? storage.sql.exec(query, binding) : storage.sql.exec(query)
   } catch (error) {
-    if (isMissingVfsTableError(error)) {
+    if (isMissingTableError(error) === true) {
       return
     }
 
@@ -220,5 +221,5 @@ const safeSqlExec = (storage: CfTypes.DurableObjectStorage, query: string, bindi
   }
 }
 
-const isMissingVfsTableError = (error: unknown): boolean =>
+const isMissingTableError = (error: unknown): boolean =>
   error instanceof Error && error.message.toLowerCase().includes('no such table')

package/src/make-sqlite-db.ts

@@ -8,8 +8,8 @@ import type {
   SqliteDbSession,
 } from '@livestore/common'
 import { SqliteDbHelper, SqliteError } from '@livestore/common'
-import { EventSequenceNumber } from '@livestore/common/schema'
 import type { CfTypes } from '@livestore/common-cf'
+import { EventSequenceNumber } from '@livestore/common/schema'
 import { Effect } from '@livestore/utils/effect'
 
 // Simplified prepared statement implementation using only public API
@@ -24,7 +24,10 @@ class CloudflarePreparedStatement implements PreparedStatement {
 
   execute = (bindValues?: PreparedBindValues, options?: { onRowsChanged?: (count: number) => void }) => {
     try {
-      const cursor = this.sqlStorage.exec(this.sql, ...(bindValues ? Object.values(bindValues) : []))
+      if (isTransactionControlStatement(this.sql) === true) return
+
+
+      const cursor = this.sqlStorage.exec(this.sql, ...(bindValues !== undefined ? Object.values(bindValues) : []))
 
       // Count affected rows by iterating through cursor
       let changedCount = 0
@@ -32,7 +35,7 @@ class CloudflarePreparedStatement implements PreparedStatement {
         changedCount++
       }
 
-      if (options?.onRowsChanged) {
+      if (options?.onRowsChanged !== undefined) {
         options.onRowsChanged(changedCount)
       }
     } catch (e) {
@@ -48,7 +51,7 @@ class CloudflarePreparedStatement implements PreparedStatement {
     try {
       const cursor = this.sqlStorage.exec<Record<string, CfTypes.SqlStorageValue>>(
         this.sql,
-        ...(bindValues ? Object.values(bindValues) : []),
+        ...(bindValues !== undefined ? Object.values(bindValues) : []),
       )
       const results: T[] = []
 
@@ -97,14 +100,12 @@ export type MakeCloudflareSqliteDb = MakeSqliteDb<Metadata, CloudflareDatabaseIn
 
 export const makeSqliteDb: MakeCloudflareSqliteDb = (input: CloudflareDatabaseInput) =>
   Effect.gen(function* () {
-    // console.log('makeSqliteDb', input)
     if (input._tag === 'in-memory') {
       return makeSqliteDb_<Metadata>({
         sqlStorage: input.db,
         metadata: {
           _tag: 'file' as const,
           dbPointer: 0,
-          // persistenceInfo: { fileName: ':memory:' },
           persistenceInfo: { fileName: 'cf' },
           input,
           configureDb: input.configureDb,
@@ -118,7 +119,6 @@ export const makeSqliteDb: MakeCloudflareSqliteDb = (input: CloudflareDatabaseIn
         metadata: {
           _tag: 'file' as const,
           dbPointer: 0,
-          // persistenceInfo: { fileName: `${input.directory}/${input.databaseName}` },
           persistenceInfo: { fileName: 'cf' },
           input,
           configureDb: input.configureDb,
@@ -130,7 +130,6 @@ export const makeSqliteDb: MakeCloudflareSqliteDb = (input: CloudflareDatabaseIn
 export const makeSqliteDb_ = <
   TMetadata extends {
     persistenceInfo: PersistenceInfo
-    // deleteDb: () => void
     configureDb: (db: SqliteDb<TMetadata>) => void
   },
 >({
@@ -188,14 +187,13 @@ export const makeSqliteDb_ = <
     destroy: () => {
       sqliteDb.close()
 
-      // metadata.deleteDb()
       throw new SqliteError({
         code: -1,
         cause: 'Database destroy not supported with public SqlStorage API',
       })
     },
     close: () => {
-      if (isClosed) {
+      if (isClosed === true) {
         return
       }
 
@@ -255,3 +253,40 @@ export const makeSqliteDb_ = <
 
   return sqliteDb
 }
+
+/**
+ * CF DO SQLite rejects SQL-level transaction control and requires `storage.transactionSync()` instead.
+ * The current adapter only detects and suppresses those SQL statements. It does not yet translate the
+ * caller's transaction intent into a shared Durable Object storage transaction.
+ *
+ * ## Consistency implications
+ *
+ * `LeaderSyncProcessor.materializeEventsBatch()` wraps both `dbState` and `dbEventlog` in
+ * `BEGIN`/`COMMIT` to keep them consistent. Because this adapter drops those statements,
+ * eventlog INSERTs are auto-committed individually while `dbState` (VFS-backed) still has
+ * real transaction boundaries. If a batch partially fails, earlier eventlog rows survive
+ * while `dbState` rolls back.
+ *
+ * This is safe because:
+ * - The eventlog is append-only and idempotent — replaying already-inserted events is a no-op.
+ * - State is always rebuildable from the eventlog on cold start (`recreateDb`).
+ * - A Durable Object is single-threaded, so no concurrent reader can observe the
+ *   intermediate inconsistency.
+ *
+ * Uses prefix matching to cover all SQLite variants:
+ * - `BEGIN [DEFERRED | IMMEDIATE | EXCLUSIVE] [TRANSACTION]`
+ * - `COMMIT [TRANSACTION]` / `END [TRANSACTION]`
+ * - `ROLLBACK [TRANSACTION] [TO [SAVEPOINT] name]`
+ * - `SAVEPOINT name` / `RELEASE [SAVEPOINT] name`
+ */
+const isTransactionControlStatement = (sql: string): boolean => {
+  const upper = sql.trim().toUpperCase()
+  return (
+    upper.startsWith('BEGIN') === true ||
+    upper.startsWith('COMMIT') === true ||
+    upper.startsWith('END') === true ||
+    upper.startsWith('ROLLBACK') === true ||
+    upper.startsWith('SAVEPOINT') === true ||
+    upper.startsWith('RELEASE') === true
+  )
+}

package/src/mod.ts

@@ -1,10 +1,5 @@
 import './polyfill.ts'
 
 export type { ClientDoWithRpcCallback } from '@livestore/common-cf'
-export {
-  type CreateStoreDoOptions,
-  createStoreDo,
-  createStoreDoPromise,
-  type Env,
-} from './create-store-do.ts'
+export { type CreateStoreDoOptions, createStoreDo, createStoreDoPromise, type Env } from './create-store-do.ts'
 export { makeAdapter } from './make-adapter.ts'