@livestore/common 0.3.0-dev.10 → 0.3.0-dev.11

package/src/leader-thread/LeaderSyncProcessor.ts

@@ -1,5 +1,5 @@
 import { isNotUndefined, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
-import type { HttpClient, Scope } from '@livestore/utils/effect'
+import type { HttpClient, Scope, Tracer } from '@livestore/utils/effect'
 import {
   BucketQueue,
   Deferred,
@@ -16,7 +16,7 @@ import {
 } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
 import type { LiveStoreSchema, SessionChangesetMetaRow } from '../schema/mod.js'
 import {
@@ -67,13 +67,13 @@ type PushQueueItem = [
 export const makeLeaderSyncProcessor = ({
   schema,
   dbMissing,
-  dbLog,
+  dbMutationLog,
   initialBlockingSyncContext,
 }: {
   schema: LiveStoreSchema
-  /** Only used to know whether we can safely query dbLog during setup execution */
+  /** Only used to know whether we can safely query dbMutationLog during setup execution */
   dbMissing: boolean
-  dbLog: SynchronousDatabase
+  dbMutationLog: SqliteDb
   initialBlockingSyncContext: InitialBlockingSyncContext
 }): Effect.Effect<LeaderSyncProcessor, UnexpectedError, Scope.Scope> =>
   Effect.gen(function* () {
@@ -86,7 +86,17 @@ export const makeLeaderSyncProcessor = ({
       return mutationDef.options.localOnly
     }
 
-    const spanRef = { current: undefined as otel.Span | undefined }
+    // This context depends on data from `boot`, we should find a better implementation to avoid this ref indirection.
+    const ctxRef = {
+      current: undefined as
+        | undefined
+        | {
+            otelSpan: otel.Span | undefined
+            span: Tracer.Span
+            devtoolsPullLatch: Effect.Latch | undefined
+            devtoolsPushLatch: Effect.Latch | undefined
+          },
+    }
 
     const localPushesQueue = yield* BucketQueue.make<PushQueueItem>()
     const localPushesLatch = yield* Effect.makeLatch(true)
@@ -97,6 +107,10 @@ export const makeLeaderSyncProcessor = ({
         // TODO validate batch
         if (newEvents.length === 0) return
 
+        if (ctxRef.current?.devtoolsPushLatch !== undefined) {
+          yield* ctxRef.current.devtoolsPushLatch.await
+        }
+
         const waitForProcessing = options?.waitForProcessing ?? false
 
         if (waitForProcessing) {
@@ -119,9 +133,7 @@ export const makeLeaderSyncProcessor = ({
             batchSize: newEvents.length,
             batch: TRACE_VERBOSE ? newEvents : undefined,
           },
-          links: spanRef.current
-            ? [{ _tag: 'SpanLink', span: OtelTracer.makeExternalSpan(spanRef.current.spanContext()), attributes: {} }]
-            : undefined,
+          links: ctxRef.current?.span ? [{ _tag: 'SpanLink', span: ctxRef.current.span, attributes: {} }] : undefined,
         }),
       )
 
@@ -145,11 +157,19 @@ export const makeLeaderSyncProcessor = ({
     // Starts various background loops
     const boot: LeaderSyncProcessor['boot'] = ({ dbReady }) =>
       Effect.gen(function* () {
-        const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.catchAll(() => Effect.succeed(undefined)))
-        spanRef.current = span
+        const span = yield* Effect.currentSpan.pipe(Effect.orDie)
+        const otelSpan = yield* OtelTracer.currentOtelSpan.pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+        const { devtools } = yield* LeaderThreadCtx
 
-        const initialBackendHead = dbMissing ? EventId.ROOT.global : getBackendHeadFromDb(dbLog)
-        const initialLocalHead = dbMissing ? EventId.ROOT : getLocalHeadFromDb(dbLog)
+        ctxRef.current = {
+          otelSpan,
+          span,
+          devtoolsPullLatch: devtools.enabled ? devtools.syncBackendPullLatch : undefined,
+          devtoolsPushLatch: devtools.enabled ? devtools.syncBackendPushLatch : undefined,
+        }
+
+        const initialBackendHead = dbMissing ? EventId.ROOT.global : getBackendHeadFromDb(dbMutationLog)
+        const initialLocalHead = dbMissing ? EventId.ROOT : getLocalHeadFromDb(dbMutationLog)
 
         if (initialBackendHead > initialLocalHead.global) {
           return shouldNeverHappen(
@@ -193,14 +213,14 @@ export const makeLeaderSyncProcessor = ({
           syncBackendQueue,
           schema,
           isLocalEvent,
-          span,
+          otelSpan,
         }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
 
         const backendPushingFiberHandle = yield* FiberHandle.make()
 
         yield* FiberHandle.run(
           backendPushingFiberHandle,
-          backgroundBackendPushing({ dbReady, syncBackendQueue, span }).pipe(Effect.tapCauseLogPretty),
+          backgroundBackendPushing({ dbReady, syncBackendQueue, otelSpan }).pipe(Effect.tapCauseLogPretty),
         )
 
         yield* backgroundBackendPulling({
@@ -219,14 +239,15 @@ export const makeLeaderSyncProcessor = ({
               // Restart pushing fiber
               yield* FiberHandle.run(
                 backendPushingFiberHandle,
-                backgroundBackendPushing({ dbReady, syncBackendQueue, span }).pipe(Effect.tapCauseLogPretty),
+                backgroundBackendPushing({ dbReady, syncBackendQueue, otelSpan }).pipe(Effect.tapCauseLogPretty),
               )
             }),
           syncStateSref,
           localPushesLatch,
           pullLatch,
-          span,
+          otelSpan,
           initialBlockingSyncContext,
+          devtoolsPullLatch: ctxRef.current?.devtoolsPullLatch,
         }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
       }).pipe(Effect.withSpanScoped('@livestore/common:leader-thread:syncing'))
 
@@ -253,7 +274,7 @@ const backgroundApplyLocalPushes = ({
   syncBackendQueue,
   schema,
   isLocalEvent,
-  span,
+  otelSpan,
 }: {
   pullLatch: Effect.Latch
   localPushesLatch: Effect.Latch
@@ -262,7 +283,7 @@ const backgroundApplyLocalPushes = ({
   syncBackendQueue: BucketQueue.BucketQueue<MutationEvent.EncodedWithMeta>
   schema: LiveStoreSchema
   isLocalEvent: (mutationEventEncoded: MutationEvent.EncodedWithMeta) => boolean
-  span: otel.Span | undefined
+  otelSpan: otel.Span | undefined
 }) =>
   Effect.gen(function* () {
     const { connectedClientSessionPullQueues } = yield* LeaderThreadCtx
@@ -293,7 +314,7 @@ const backgroundApplyLocalPushes = ({
       if (updateResult._tag === 'rebase') {
         return shouldNeverHappen('The leader thread should never have to rebase due to a local push')
       } else if (updateResult._tag === 'reject') {
-        span?.addEvent('local-push:reject', {
+        otelSpan?.addEvent('local-push:reject', {
           batchSize: newEvents.length,
           updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
         })
@@ -331,7 +352,7 @@ const backgroundApplyLocalPushes = ({
         remaining: 0,
       })
 
-      span?.addEvent('local-push', {
+      otelSpan?.addEvent('local-push', {
         batchSize: newEvents.length,
         updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
       })
@@ -361,14 +382,14 @@ type ApplyMutationItems = (_: {
 const makeApplyMutationItems: Effect.Effect<ApplyMutationItems, UnexpectedError, LeaderThreadCtx | Scope.Scope> =
   Effect.gen(function* () {
     const leaderThreadCtx = yield* LeaderThreadCtx
-    const { db, dbLog } = leaderThreadCtx
+    const { dbReadModel: db, dbMutationLog } = leaderThreadCtx
 
     const applyMutation = yield* makeApplyMutation
 
     return ({ batchItems, deferreds }) =>
       Effect.gen(function* () {
         db.execute('BEGIN TRANSACTION', undefined) // Start the transaction
-        dbLog.execute('BEGIN TRANSACTION', undefined) // Start the transaction
+        dbMutationLog.execute('BEGIN TRANSACTION', undefined) // Start the transaction
 
         yield* Effect.addFinalizer((exit) =>
           Effect.gen(function* () {
@@ -376,7 +397,7 @@ const makeApplyMutationItems: Effect.Effect<ApplyMutationItems, UnexpectedError,
 
             // Rollback in case of an error
             db.execute('ROLLBACK', undefined)
-            dbLog.execute('ROLLBACK', undefined)
+            dbMutationLog.execute('ROLLBACK', undefined)
           }),
         )
 
@@ -389,7 +410,7 @@ const makeApplyMutationItems: Effect.Effect<ApplyMutationItems, UnexpectedError,
         }
 
         db.execute('COMMIT', undefined) // Commit the transaction
-        dbLog.execute('COMMIT', undefined) // Commit the transaction
+        dbMutationLog.execute('COMMIT', undefined) // Commit the transaction
       }).pipe(
         Effect.uninterruptible,
         Effect.scoped,
@@ -406,10 +427,11 @@ const backgroundBackendPulling = ({
   initialBackendHead,
   isLocalEvent,
   restartBackendPushing,
-  span,
+  otelSpan,
   syncStateSref,
   localPushesLatch,
   pullLatch,
+  devtoolsPullLatch,
   initialBlockingSyncContext,
 }: {
   dbReady: Deferred.Deferred<void>
@@ -418,14 +440,21 @@ const backgroundBackendPulling = ({
   restartBackendPushing: (
     filteredRebasedPending: ReadonlyArray<MutationEvent.EncodedWithMeta>,
   ) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx | HttpClient.HttpClient>
-  span: otel.Span | undefined
+  otelSpan: otel.Span | undefined
   syncStateSref: SubscriptionRef.SubscriptionRef<SyncState.SyncState | undefined>
   localPushesLatch: Effect.Latch
   pullLatch: Effect.Latch
+  devtoolsPullLatch: Effect.Latch | undefined
   initialBlockingSyncContext: InitialBlockingSyncContext
 }) =>
   Effect.gen(function* () {
-    const { syncBackend, db, dbLog, connectedClientSessionPullQueues, schema } = yield* LeaderThreadCtx
+    const {
+      syncBackend,
+      dbReadModel: db,
+      dbMutationLog,
+      connectedClientSessionPullQueues,
+      schema,
+    } = yield* LeaderThreadCtx
 
     if (syncBackend === undefined) return
 
@@ -437,6 +466,10 @@ const backgroundBackendPulling = ({
       Effect.gen(function* () {
         if (newEvents.length === 0) return
 
+        if (devtoolsPullLatch !== undefined) {
+          yield* devtoolsPullLatch.await
+        }
+
         // Prevent more local pushes from being processed until this pull is finished
         yield* localPushesLatch.close
 
@@ -462,10 +495,10 @@ const backgroundBackendPulling = ({
 
         const newBackendHead = newEvents.at(-1)!.id
 
-        updateBackendHead(dbLog, newBackendHead)
+        updateBackendHead(dbMutationLog, newBackendHead)
 
         if (updateResult._tag === 'rebase') {
-          span?.addEvent('backend-pull:rebase', {
+          otelSpan?.addEvent('backend-pull:rebase', {
             newEventsCount: newEvents.length,
             newEvents: TRACE_VERBOSE ? JSON.stringify(newEvents) : undefined,
             rollbackCount: updateResult.eventsToRollback.length,
@@ -479,7 +512,7 @@ const backgroundBackendPulling = ({
           yield* restartBackendPushing(filteredRebasedPending)
 
           if (updateResult.eventsToRollback.length > 0) {
-            yield* rollback({ db, dbLog, eventIdsToRollback: updateResult.eventsToRollback.map((_) => _.id) })
+            yield* rollback({ db, dbMutationLog, eventIdsToRollback: updateResult.eventsToRollback.map((_) => _.id) })
           }
 
           yield* connectedClientSessionPullQueues.offer({
@@ -492,7 +525,7 @@ const backgroundBackendPulling = ({
             remaining,
           })
         } else {
-          span?.addEvent('backend-pull:advance', {
+          otelSpan?.addEvent('backend-pull:advance', {
             newEventsCount: newEvents.length,
             updateResult: TRACE_VERBOSE ? JSON.stringify(updateResult) : undefined,
           })
@@ -549,11 +582,11 @@ const backgroundBackendPulling = ({
 
 const rollback = ({
   db,
-  dbLog,
+  dbMutationLog,
   eventIdsToRollback,
 }: {
-  db: SynchronousDatabase
-  dbLog: SynchronousDatabase
+  db: SqliteDb
+  dbMutationLog: SqliteDb
   eventIdsToRollback: EventId.EventId[]
 }) =>
   Effect.gen(function* () {
@@ -578,7 +611,7 @@ const rollback = ({
     )
 
     // Delete the mutation log rows
-    dbLog.execute(
+    dbMutationLog.execute(
       sql`DELETE FROM ${MUTATION_LOG_META_TABLE} WHERE (idGlobal, idLocal) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.local})`).join(', ')})`,
     )
   }).pipe(
@@ -589,7 +622,7 @@ const rollback = ({
 
 const getCursorInfo = (remoteHead: EventId.GlobalEventId) =>
   Effect.gen(function* () {
-    const { dbLog } = yield* LeaderThreadCtx
+    const { dbMutationLog } = yield* LeaderThreadCtx
 
     if (remoteHead === EventId.ROOT.global) return Option.none()
 
@@ -598,7 +631,7 @@ const getCursorInfo = (remoteHead: EventId.GlobalEventId) =>
     }).pipe(Schema.pluck('syncMetadataJson'), Schema.Array, Schema.head)
 
     const syncMetadataOption = yield* Effect.sync(() =>
-      dbLog.select<{ syncMetadataJson: string }>(
+      dbMutationLog.select<{ syncMetadataJson: string }>(
         sql`SELECT syncMetadataJson FROM ${MUTATION_LOG_META_TABLE} WHERE idGlobal = ${remoteHead} ORDER BY idLocal ASC LIMIT 1`,
       ),
     ).pipe(Effect.andThen(Schema.decode(MutationlogQuerySchema)), Effect.map(Option.flatten), Effect.orDie)
@@ -612,14 +645,14 @@ const getCursorInfo = (remoteHead: EventId.GlobalEventId) =>
 const backgroundBackendPushing = ({
   dbReady,
   syncBackendQueue,
-  span,
+  otelSpan,
 }: {
   dbReady: Deferred.Deferred<void>
   syncBackendQueue: BucketQueue.BucketQueue<MutationEvent.EncodedWithMeta>
-  span: otel.Span | undefined
+  otelSpan: otel.Span | undefined
 }) =>
   Effect.gen(function* () {
-    const { syncBackend, dbLog } = yield* LeaderThreadCtx
+    const { syncBackend, dbMutationLog } = yield* LeaderThreadCtx
     if (syncBackend === undefined) return
 
     yield* dbReady
@@ -632,7 +665,7 @@ const backgroundBackendPushing = ({
 
       yield* SubscriptionRef.waitUntil(syncBackend.isConnected, (isConnected) => isConnected === true)
 
-      span?.addEvent('backend-push', {
+      otelSpan?.addEvent('backend-push', {
         batchSize: queueItems.length,
         batch: TRACE_VERBOSE ? JSON.stringify(queueItems) : undefined,
       })
@@ -641,7 +674,7 @@ const backgroundBackendPushing = ({
       const pushResult = yield* syncBackend.push(queueItems.map((_) => _.toGlobal())).pipe(Effect.either)
 
       if (pushResult._tag === 'Left') {
-        span?.addEvent('backend-push-error', { error: pushResult.left.toString() })
+        otelSpan?.addEvent('backend-push-error', { error: pushResult.left.toString() })
         // wait for interrupt caused by background pulling which will then restart pushing
         return yield* Effect.never
       }
@@ -652,7 +685,7 @@ const backgroundBackendPushing = ({
       for (let i = 0; i < queueItems.length; i++) {
         const mutationEventEncoded = queueItems[i]!
         yield* execSql(
-          dbLog,
+          dbMutationLog,
           ...updateRows({
             tableName: MUTATION_LOG_META_TABLE,
             columns: mutationLogMetaTable.sqliteDef.columns,
@@ -664,7 +697,7 @@ const backgroundBackendPushing = ({
     }
   }).pipe(Effect.interruptible, Effect.withSpan('@livestore/common:leader-thread:syncing:backend-pushing'))
 
-const trimChangesetRows = (db: SynchronousDatabase, newHead: EventId.EventId) => {
+const trimChangesetRows = (db: SqliteDb, newHead: EventId.EventId) => {
   // Since we're using the session changeset rows to query for the current head,
   // we're keeping at least one row for the current head, and thus are using `<` instead of `<=`
   db.execute(sql`DELETE FROM ${SESSION_CHANGESET_META_TABLE} WHERE idGlobal < ${newHead.global}`)

package/src/leader-thread/apply-mutation.ts

@@ -2,7 +2,7 @@ import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
 import { Effect, Option, Schema } from '@livestore/utils/effect'
 
-import type { SqliteError, SynchronousDatabase, UnexpectedError } from '../index.js'
+import type { SqliteDb, SqliteError, UnexpectedError } from '../index.js'
 import { getExecArgsFromMutation } from '../mutation.js'
 import {
   type LiveStoreSchema,
@@ -38,7 +38,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
 
     return (mutationEventEncoded, options) =>
       Effect.gen(function* () {
-        const { schema, db, dbLog } = leaderThreadCtx
+        const { schema, dbReadModel: db, dbMutationLog } = leaderThreadCtx
         const skipMutationLog = options?.skipMutationLog ?? false
 
         const mutationName = mutationEventEncoded.mutation
@@ -92,7 +92,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
         // write to mutation_log
         const excludeFromMutationLog = shouldExcludeMutationFromLog(mutationName, mutationEventEncoded)
         if (skipMutationLog === false && excludeFromMutationLog === false) {
-          yield* insertIntoMutationLog(mutationEventEncoded, dbLog, mutationDefSchemaHashMap)
+          yield* insertIntoMutationLog(mutationEventEncoded, dbMutationLog, mutationDefSchemaHashMap)
         } else {
           //   console.debug('[@livestore/common:leader-thread] skipping mutation log write', mutation, statementSql, bindValues)
         }
@@ -111,7 +111,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
 
 const insertIntoMutationLog = (
   mutationEventEncoded: MutationEvent.AnyEncoded,
-  dbLog: SynchronousDatabase,
+  dbMutationLog: SqliteDb,
   mutationDefSchemaHashMap: Map<string, number>,
 ) =>
   Effect.gen(function* () {
@@ -121,7 +121,7 @@ const insertIntoMutationLog = (
 
     // TODO use prepared statements
     yield* execSql(
-      dbLog,
+      dbMutationLog,
       ...insertRow({
         tableName: MUTATION_LOG_META_TABLE,
         columns: mutationLogMetaTable.sqliteDef.columns,

package/src/leader-thread/connection.ts

@@ -1,7 +1,7 @@
 // import type { WaSqlite } from '@livestore/sqlite-wasm'
 import { Effect } from '@livestore/utils/effect'
 
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
 import { SqliteError } from '../adapter-types.js'
 import type { BindValues } from '../sql-queries/index.js'
 import type { PreparedBindValues } from '../util.js'
@@ -12,9 +12,9 @@ namespace WaSqlite {
   export type SQLiteError = any
 }
 
-export const configureConnection = (syncDb: SynchronousDatabase, { fkEnabled }: { fkEnabled: boolean }) =>
+export const configureConnection = (sqliteDb: SqliteDb, { fkEnabled }: { fkEnabled: boolean }) =>
   execSql(
-    syncDb,
+    sqliteDb,
     sql`
     PRAGMA page_size=8192;
     PRAGMA journal_mode=MEMORY;
@@ -23,10 +23,10 @@ export const configureConnection = (syncDb: SynchronousDatabase, { fkEnabled }:
     {},
   )
 
-export const execSql = (syncDb: SynchronousDatabase, sql: string, bind: BindValues) => {
+export const execSql = (sqliteDb: SqliteDb, sql: string, bind: BindValues) => {
   const bindValues = prepareBindValues(bind, sql)
   return Effect.try({
-    try: () => syncDb.execute(sql, bindValues),
+    try: () => sqliteDb.execute(sql, bindValues),
     catch: (cause) =>
       new SqliteError({ cause, query: { bindValues, sql }, code: (cause as WaSqlite.SQLiteError).code }),
   }).pipe(
@@ -48,9 +48,9 @@ export const execSql = (syncDb: SynchronousDatabase, sql: string, bind: BindValu
 // }
 
 // TODO actually use prepared statements
-export const execSqlPrepared = (syncDb: SynchronousDatabase, sql: string, bindValues: PreparedBindValues) => {
+export const execSqlPrepared = (sqliteDb: SqliteDb, sql: string, bindValues: PreparedBindValues) => {
   return Effect.try({
-    try: () => syncDb.execute(sql, bindValues),
+    try: () => sqliteDb.execute(sql, bindValues),
     catch: (cause) =>
       new SqliteError({ cause, query: { bindValues, sql }, code: (cause as WaSqlite.SQLiteError).code }),
   }).pipe(

package/src/leader-thread/leader-worker-devtools.ts

@@ -21,7 +21,7 @@ export const bootDevtools = (options: DevtoolsOptions) =>
       sendMessage: () => Effect.void,
     }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
 
-    const { persistenceInfo, devtoolsWebChannel } = yield* options.makeContext
+    const { persistenceInfo, devtoolsWebChannel } = yield* options.makeBootContext
 
     const sendMessage: SendMessageToDevtools = (message) =>
       devtoolsWebChannel
@@ -71,8 +71,15 @@ const listenToDevtools = ({
   persistenceInfo?: PersistenceInfoPair
 }) =>
   Effect.gen(function* () {
-    const { syncBackend, makeSyncDb, db, dbLog, shutdownStateSubRef, shutdownChannel, syncProcessor } =
-      yield* LeaderThreadCtx
+    const {
+      syncBackend,
+      makeSqliteDb,
+      dbReadModel,
+      dbMutationLog,
+      shutdownStateSubRef,
+      shutdownChannel,
+      syncProcessor,
+    } = yield* LeaderThreadCtx
 
     type RequestId = string
     const subscriptionFiberMap = yield* FiberMap.make<RequestId>()
@@ -95,7 +102,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.SnapshotReq': {
-              const snapshot = db.export()
+              const snapshot = dbReadModel.export()
 
               yield* sendMessage(Devtools.SnapshotRes.make({ snapshot, ...reqPayload }))
 
@@ -107,15 +114,15 @@ const listenToDevtools = ({
               let tableNames: Set<string>
 
               try {
-                const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
-                tmpSyncDb.import(data)
-                const tableNameResults = tmpSyncDb.select<{ name: string }>(
+                const tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
+                tmpDb.import(data)
+                const tableNameResults = tmpDb.select<{ name: string }>(
                   `select name from sqlite_master where type = 'table'`,
                 )
 
                 tableNames = new Set(tableNameResults.map((_) => _.name))
 
-                tmpSyncDb.close()
+                tmpDb.close()
               } catch (e) {
                 yield* Effect.logError(`Error importing database file`, e)
                 yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-file' }))
@@ -126,15 +133,15 @@ const listenToDevtools = ({
               if (tableNames.has(MUTATION_LOG_META_TABLE)) {
                 yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-                dbLog.import(data)
+                dbMutationLog.import(data)
 
-                db.destroy()
+                dbReadModel.destroy()
               } else if (tableNames.has(SCHEMA_META_TABLE) && tableNames.has(SCHEMA_MUTATIONS_META_TABLE)) {
                 yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-                db.import(data)
+                dbReadModel.import(data)
 
-                dbLog.destroy()
+                dbMutationLog.destroy()
               } else {
                 yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-database' }))
                 return
@@ -151,10 +158,10 @@ const listenToDevtools = ({
 
               yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-              db.destroy()
+              dbReadModel.destroy()
 
               if (mode === 'all-data') {
-                dbLog.destroy()
+                dbMutationLog.destroy()
               }
 
               yield* sendMessage(Devtools.ResetAllDataRes.make({ ...reqPayload }))
@@ -170,12 +177,12 @@ const listenToDevtools = ({
               }
 
               const dbSizeQuery = `SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size();`
-              const dbFileSize = db.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
-              const mutationLogFileSize = dbLog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
+              const dbFileSize = dbReadModel.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
+              const mutationLogFileSize = dbMutationLog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
 
               yield* sendMessage(
                 Devtools.DatabaseFileInfoRes.make({
-                  db: { fileSize: dbFileSize, persistenceInfo: persistenceInfo.db },
+                  readModel: { fileSize: dbFileSize, persistenceInfo: persistenceInfo.readModel },
                   mutationLog: { fileSize: mutationLogFileSize, persistenceInfo: persistenceInfo.mutationLog },
                   ...reqPayload,
                 }),
@@ -184,7 +191,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.MutationLogReq': {
-              const mutationLog = dbLog.export()
+              const mutationLog = dbMutationLog.export()
 
               yield* sendMessage(Devtools.MutationLogRes.make({ mutationLog, ...reqPayload }))