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

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

@@ -1,11 +1,18 @@
-import { Effect, FiberMap, Option, Stream, SubscriptionRef } from '@livestore/utils/effect'
+import { Effect, FiberMap, Option, PubSub, Queue, Stream, SubscriptionRef } from '@livestore/utils/effect'
 
 import { Devtools, IntentionalShutdownCause, liveStoreVersion, UnexpectedError } from '../index.js'
 import { MUTATION_LOG_META_TABLE, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE } from '../schema/mod.js'
+import type { ShutdownChannel } from './shutdown-channel.js'
 import type { DevtoolsOptions, PersistenceInfoPair } from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
-type SendMessageToDevtools = (message: Devtools.MessageFromAppLeader) => Effect.Effect<void>
+type SendMessageToDevtools = (
+  message: Devtools.MessageFromAppLeader,
+  options?: {
+    /** Send message even if not connected (e.g. for initial broadcast messages) */
+    force: boolean
+  },
+) => Effect.Effect<void>
 
 // TODO bind scope to the webchannel lifetime
 export const bootDevtools = (options: DevtoolsOptions) =>
@@ -14,24 +21,44 @@ export const bootDevtools = (options: DevtoolsOptions) =>
       return
     }
 
-    const { connectedClientSessionPullQueues, syncProcessor, extraIncomingMessagesQueue } = yield* LeaderThreadCtx
+    const { persistenceInfo, shutdownChannel, devtoolsWebChannel } = yield* options.makeContext
 
-    yield* listenToDevtools({
-      incomingMessages: Stream.fromQueue(extraIncomingMessagesQueue),
-      sendMessage: () => Effect.void,
-    }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+    const isConnected = yield* SubscriptionRef.make(true)
+
+    const incomingMessagesPubSub = yield* PubSub.unbounded<Devtools.MessageToAppLeader>().pipe(
+      Effect.acquireRelease(PubSub.shutdown),
+    )
 
-    const { persistenceInfo, devtoolsWebChannel } = yield* options.makeBootContext
+    const incomingMessages = Stream.fromPubSub(incomingMessagesPubSub)
 
-    const sendMessage: SendMessageToDevtools = (message) =>
-      devtoolsWebChannel
-        .send(message)
-        .pipe(
-          Effect.withSpan('@livestore/common:leader-thread:devtools:sendToDevtools'),
-          Effect.interruptible,
-          Effect.ignoreLogged,
-        )
+    const outgoingMessagesQueue = yield* Queue.unbounded<Devtools.MessageFromAppLeader>().pipe(
+      Effect.acquireRelease(Queue.shutdown),
+    )
 
+    const devtoolsCoordinatorChannel = devtoolsWebChannel
+    // coordinatorMessagePortOrChannel instanceof MessagePort
+    //   ? yield* WebChannel.messagePortChannel({
+    //       port: coordinatorMessagePortOrChannel,
+    //       schema: { send: Devtools.MessageFromAppLeader, listen: Devtools.MessageToAppLeader },
+    //     })
+    //   : coordinatorMessagePortOrChannel
+
+    const sendMessage: SendMessageToDevtools = (message, options) =>
+      Effect.gen(function* () {
+        if (options?.force === true || (yield* isConnected)) {
+          yield* devtoolsCoordinatorChannel.send(message)
+        } else {
+          yield* Queue.offer(outgoingMessagesQueue, message)
+        }
+      }).pipe(
+        Effect.withSpan('@livestore/common:leader-thread:devtools:sendToDevtools'),
+        Effect.interruptible,
+        Effect.ignoreLogged,
+      )
+
+    // broadcastCallbacks.add((message) => sendMessage(message))
+
+    const { connectedClientSessionPullQueues, syncProcessor } = yield* LeaderThreadCtx
     const { localHead } = yield* syncProcessor.syncState
 
     // TODO close queue when devtools disconnects
@@ -42,8 +69,13 @@ export const bootDevtools = (options: DevtoolsOptions) =>
         Effect.gen(function* () {
           if (msg.payload._tag === 'upstream-advance') {
             for (const mutationEventEncoded of msg.payload.newEvents) {
-              // TODO refactor with push semantics
-              yield* sendMessage(Devtools.MutationBroadcast.make({ mutationEventEncoded, liveStoreVersion }))
+              yield* sendMessage(
+                Devtools.MutationBroadcast.make({
+                  mutationEventEncoded,
+
+                  liveStoreVersion,
+                }),
+              )
             }
           } else {
             yield* Effect.logWarning('TODO implement rebases in devtools')
@@ -54,32 +86,68 @@ export const bootDevtools = (options: DevtoolsOptions) =>
       Effect.forkScoped,
     )
 
+    yield* devtoolsCoordinatorChannel.listen.pipe(
+      Stream.flatten(),
+      // Stream.tapLogWithLabel('@livestore/common:leader-thread:devtools:onPortMessage'),
+      Stream.tap((msg) =>
+        Effect.gen(function* () {
+          // yield* Effect.logDebug(`[@livestore/common:leader-thread:devtools] message from port: ${msg._tag}`, msg)
+          // if (msg._tag === 'LSD.MessagePortForStoreRes') {
+          //   yield* Deferred.succeed(storeMessagePortDeferred, msg.port)
+          // } else {
+          yield* PubSub.publish(incomingMessagesPubSub, msg)
+          // }
+        }),
+      ),
+      Stream.runDrain,
+      Effect.withSpan(`@livestore/common:leader-thread:devtools:onPortMessage`),
+      Effect.ignoreLogged,
+      Effect.forkScoped,
+    )
+
+    // yield* sendMessage(Devtools.AppHostReady.make({ appHostId, liveStoreVersion, isLeader }), { force: true })
+
+    // yield* sendMessage(Devtools.MessagePortForStoreReq.make({ appHostId, liveStoreVersion, requestId: nanoid() }), {
+    //   force: true,
+    // })
+
     yield* listenToDevtools({
-      incomingMessages: devtoolsWebChannel.listen.pipe(Stream.flatten(), Stream.orDie),
+      incomingMessages,
       sendMessage,
+      // isConnected,
+      // disconnect,
+      // storeId,
+      // appHostId,
+      // isLeader,
       persistenceInfo,
-    }).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+      shutdownChannel,
+    })
   }).pipe(Effect.withSpan('@livestore/common:leader-thread:devtools:boot'))
 
 const listenToDevtools = ({
   incomingMessages,
   sendMessage,
+  // isConnected,
+  // disconnect,
+  // appHostId,
+  // storeId,
+  // isLeader,
   persistenceInfo,
+  shutdownChannel,
 }: {
   incomingMessages: Stream.Stream<Devtools.MessageToAppLeader>
   sendMessage: SendMessageToDevtools
-  persistenceInfo?: PersistenceInfoPair
+  // isConnected: SubscriptionRef.SubscriptionRef<boolean>
+  // disconnect: Effect.Effect<void>
+  // appHostId: string
+  // storeId: string
+  // isLeader: boolean
+  persistenceInfo: PersistenceInfoPair
+  shutdownChannel: ShutdownChannel
 }) =>
   Effect.gen(function* () {
-    const {
-      syncBackend,
-      makeSqliteDb,
-      dbReadModel,
-      dbMutationLog,
-      shutdownStateSubRef,
-      shutdownChannel,
-      syncProcessor,
-    } = yield* LeaderThreadCtx
+    const innerWorkerCtx = yield* LeaderThreadCtx
+    const { syncBackend, makeSyncDb, db, dbLog, shutdownStateSubRef, syncProcessor } = innerWorkerCtx
 
     type RequestId = string
     const subscriptionFiberMap = yield* FiberMap.make<RequestId>()
@@ -90,6 +158,15 @@ const listenToDevtools = ({
           // yield* Effect.logDebug('[@livestore/common:leader-thread:devtools] incomingMessage', decodedEvent)
 
           if (decodedEvent._tag === 'LSD.Disconnect') {
+            // yield* SubscriptionRef.set(isConnected, false)
+
+            // yield* disconnect
+
+            // TODO is there a better place for this?
+            // yield* sendMessage(Devtools.AppHostReady.make({ appHostId, liveStoreVersion, isLeader }), {
+            //   force: true,
+            // })
+
             return
           }
 
@@ -102,7 +179,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.SnapshotReq': {
-              const snapshot = dbReadModel.export()
+              const snapshot = db.export()
 
               yield* sendMessage(Devtools.SnapshotRes.make({ snapshot, ...reqPayload }))
 
@@ -114,15 +191,15 @@ const listenToDevtools = ({
               let tableNames: Set<string>
 
               try {
-                const tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
-                tmpDb.import(data)
-                const tableNameResults = tmpDb.select<{ name: string }>(
+                const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
+                tmpSyncDb.import(data)
+                const tableNameResults = tmpSyncDb.select<{ name: string }>(
                   `select name from sqlite_master where type = 'table'`,
                 )
 
                 tableNames = new Set(tableNameResults.map((_) => _.name))
 
-                tmpDb.close()
+                tmpSyncDb.close()
               } catch (e) {
                 yield* Effect.logError(`Error importing database file`, e)
                 yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-file' }))
@@ -133,15 +210,15 @@ const listenToDevtools = ({
               if (tableNames.has(MUTATION_LOG_META_TABLE)) {
                 yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-                dbMutationLog.import(data)
+                dbLog.import(data)
 
-                dbReadModel.destroy()
+                db.destroy()
               } else if (tableNames.has(SCHEMA_META_TABLE) && tableNames.has(SCHEMA_MUTATIONS_META_TABLE)) {
                 yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-                dbReadModel.import(data)
+                db.import(data)
 
-                dbMutationLog.destroy()
+                dbLog.destroy()
               } else {
                 yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-database' }))
                 return
@@ -149,7 +226,7 @@ const listenToDevtools = ({
 
               yield* sendMessage(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'ok' }))
 
-              yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' })) ?? Effect.void
+              yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-import' }))
 
               return
             }
@@ -158,31 +235,26 @@ const listenToDevtools = ({
 
               yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-              dbReadModel.destroy()
+              db.destroy()
 
               if (mode === 'all-data') {
-                dbMutationLog.destroy()
+                dbLog.destroy()
               }
 
               yield* sendMessage(Devtools.ResetAllDataRes.make({ ...reqPayload }))
 
-              yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-reset' })) ?? Effect.void
+              yield* shutdownChannel.send(IntentionalShutdownCause.make({ reason: 'devtools-reset' }))
 
               return
             }
             case 'LSD.Leader.DatabaseFileInfoReq': {
-              if (persistenceInfo === undefined) {
-                console.log('[@livestore/common:leader-thread:devtools] persistenceInfo is required for this request')
-                return
-              }
-
               const dbSizeQuery = `SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size();`
-              const dbFileSize = dbReadModel.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
-              const mutationLogFileSize = dbMutationLog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
+              const dbFileSize = db.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
+              const mutationLogFileSize = dbLog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
 
               yield* sendMessage(
                 Devtools.DatabaseFileInfoRes.make({
-                  readModel: { fileSize: dbFileSize, persistenceInfo: persistenceInfo.readModel },
+                  db: { fileSize: dbFileSize, persistenceInfo: persistenceInfo.db },
                   mutationLog: { fileSize: mutationLogFileSize, persistenceInfo: persistenceInfo.mutationLog },
                   ...reqPayload,
                 }),
@@ -191,7 +263,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.MutationLogReq': {
-              const mutationLog = dbMutationLog.export()
+              const mutationLog = dbLog.export()
 
               yield* sendMessage(Devtools.MutationLogRes.make({ mutationLog, ...reqPayload }))
 

package/src/leader-thread/make-leader-thread-layer.ts

@@ -1,100 +1,68 @@
-import type { HttpClient, Scope } from '@livestore/utils/effect'
-import { Deferred, Effect, Layer, Queue, SubscriptionRef } from '@livestore/utils/effect'
+import type { HttpClient, Scope, WebChannel } from '@livestore/utils/effect'
+import { Deferred, Effect, FiberSet, Layer, Queue, SubscriptionRef } from '@livestore/utils/effect'
 
-import type { BootStatus, MakeSqliteDb, SqliteError } from '../adapter-types.js'
+import type { BootStatus, MakeSynchronousDatabase, SqliteError, SynchronousDatabase } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
-import type * as Devtools from '../devtools/index.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
 import { EventId, MutationEvent, mutationLogMetaTable, SYNC_STATUS_TABLE, syncStatusTable } from '../schema/mod.js'
 import { migrateTable } from '../schema-management/migrations.js'
-import type { InvalidPullError, IsOfflineError, SyncOptions } from '../sync/sync.js'
+import type { InvalidPullError, IsOfflineError, SyncBackend } from '../sync/sync.js'
 import { sql } from '../util.js'
 import { execSql } from './connection.js'
+import { makeLeaderSyncProcessor } from './leader-sync-processor.js'
 import { bootDevtools } from './leader-worker-devtools.js'
-import { makeLeaderSyncProcessor } from './LeaderSyncProcessor.js'
 import { makePullQueueSet } from './pull-queue-set.js'
 import { recreateDb } from './recreate-db.js'
-import type { ShutdownChannel } from './shutdown-channel.js'
-import type {
-  DevtoolsOptions,
-  InitialBlockingSyncContext,
-  InitialSyncOptions,
-  LeaderSqliteDb,
-  ShutdownState,
-} from './types.js'
+import type { DevtoolsOptions, InitialBlockingSyncContext, InitialSyncOptions, ShutdownState } from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
 export const makeLeaderThreadLayer = ({
   schema,
   storeId,
-  clientId,
-  makeSqliteDb,
-  syncOptions,
-  dbReadModel,
-  dbMutationLog,
+  originId,
+  makeSyncDb,
+  makeSyncBackend,
+  db,
+  dbLog,
   devtoolsOptions,
-  shutdownChannel,
+  initialSyncOptions = { _tag: 'Skip' },
 }: {
   storeId: string
-  clientId: string
+  originId: string
   schema: LiveStoreSchema
-  makeSqliteDb: MakeSqliteDb
-  syncOptions: SyncOptions | undefined
-  dbReadModel: LeaderSqliteDb
-  dbMutationLog: LeaderSqliteDb
+  makeSyncDb: MakeSynchronousDatabase
+  makeSyncBackend: Effect.Effect<SyncBackend, UnexpectedError, Scope.Scope> | undefined
+  db: SynchronousDatabase
+  dbLog: SynchronousDatabase
   devtoolsOptions: DevtoolsOptions
-  shutdownChannel: ShutdownChannel
+  initialSyncOptions: InitialSyncOptions | undefined
 }): Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient> =>
   Effect.gen(function* () {
     const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
 
     // TODO do more validation here than just checking the count of tables
     // Either happens on initial boot or if schema changes
-    const dbMissing =
-      dbReadModel.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
+    const dbMissing = db.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
 
-    const syncBackend = syncOptions === undefined ? undefined : yield* syncOptions.makeBackend({ storeId, clientId })
+    const syncBackend = makeSyncBackend === undefined ? undefined : yield* makeSyncBackend
 
-    const initialBlockingSyncContext = yield* makeInitialBlockingSyncContext({
-      initialSyncOptions: syncOptions?.initialSyncOptions ?? { _tag: 'Skip' },
-      bootStatusQueue,
-    })
-
-    const syncProcessor = yield* makeLeaderSyncProcessor({
-      schema,
-      dbMissing,
-      dbMutationLog,
-      initialBlockingSyncContext,
-    })
-
-    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.MessageToAppLeader>().pipe(
-      Effect.acquireRelease(Queue.shutdown),
-    )
+    const initialBlockingSyncContext = yield* makeInitialBlockingSyncContext({ initialSyncOptions, bootStatusQueue })
 
-    const devtoolsContext = devtoolsOptions.enabled
-      ? {
-          enabled: true as const,
-          syncBackendPullLatch: yield* Effect.makeLatch(true),
-          syncBackendPushLatch: yield* Effect.makeLatch(true),
-        }
-      : { enabled: false as const }
+    const syncProcessor = yield* makeLeaderSyncProcessor({ schema, dbMissing, dbLog, initialBlockingSyncContext })
 
     const ctx = {
       schema,
       bootStatusQueue,
       storeId,
-      clientId,
-      dbReadModel,
-      dbMutationLog,
-      makeSqliteDb,
+      originId,
+      db,
+      dbLog,
+      makeSyncDb,
       mutationEventSchema: MutationEvent.makeMutationEventSchema(schema),
       shutdownStateSubRef: yield* SubscriptionRef.make<ShutdownState>('running'),
-      shutdownChannel,
       syncBackend,
       syncProcessor,
       connectedClientSessionPullQueues: yield* makePullQueueSet,
-      extraIncomingMessagesQueue,
-      devtools: devtoolsContext,
     } satisfies typeof LeaderThreadCtx.Service
 
     // @ts-expect-error For debugging purposes
@@ -177,17 +145,17 @@ const bootLeaderThread = ({
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
   Effect.gen(function* () {
-    const { dbMutationLog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
+    const { dbLog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
 
     yield* migrateTable({
-      db: dbMutationLog,
+      db: dbLog,
       behaviour: 'create-if-not-exists',
       tableAst: mutationLogMetaTable.sqliteDef.ast,
       skipMetaTable: true,
     })
 
     yield* migrateTable({
-      db: dbMutationLog,
+      db: dbLog,
       behaviour: 'create-if-not-exists',
       tableAst: syncStatusTable.sqliteDef.ast,
       skipMetaTable: true,
@@ -195,7 +163,7 @@ const bootLeaderThread = ({
 
     // Create sync status row if it doesn't exist
     yield* execSql(
-      dbMutationLog,
+      dbLog,
       sql`INSERT INTO ${SYNC_STATUS_TABLE} (head)
           SELECT ${EventId.ROOT.global}
           WHERE NOT EXISTS (SELECT 1 FROM ${SYNC_STATUS_TABLE})`,

package/src/leader-thread/mutationlog.ts

@@ -1,20 +1,17 @@
 import { Effect, Schema } from '@livestore/utils/effect'
 
-import type { SqliteDb } from '../adapter-types.js'
+import type { SynchronousDatabase } from '../adapter-types.js'
 import * as EventId from '../schema/EventId.js'
-import type * as MutationEvent from '../schema/MutationEvent.js'
 import { MUTATION_LOG_META_TABLE, mutationLogMetaTable, SYNC_STATUS_TABLE } from '../schema/system-tables.js'
 import { prepareBindValues, sql } from '../util.js'
 import { LeaderThreadCtx } from './types.js'
 
-export const getMutationEventsSince = (
-  since: EventId.EventId,
-): Effect.Effect<ReadonlyArray<MutationEvent.AnyEncoded>, never, LeaderThreadCtx> =>
+export const getMutationEventsSince = (since: EventId.EventId) =>
   Effect.gen(function* () {
-    const { dbMutationLog } = yield* LeaderThreadCtx
+    const { dbLog } = yield* LeaderThreadCtx
 
     const query = mutationLogMetaTable.query.where('idGlobal', '>=', since.global).asSql()
-    const pendingMutationEventsRaw = dbMutationLog.select(query.query, prepareBindValues(query.bindValues, query.query))
+    const pendingMutationEventsRaw = dbLog.select(query.query, prepareBindValues(query.bindValues, query.query))
     const pendingMutationEvents = Schema.decodeUnknownSync(mutationLogMetaTable.schema.pipe(Schema.Array))(
       pendingMutationEventsRaw,
     )
@@ -29,18 +26,17 @@ export const getMutationEventsSince = (
       .filter((_) => EventId.compare(_.id, since) > 0)
   })
 
-export const getLocalHeadFromDb = (dbMutationLog: SqliteDb): EventId.EventId => {
-  const res = dbMutationLog.select<{ idGlobal: EventId.GlobalEventId; idLocal: EventId.LocalEventId }>(
+export const getLocalHeadFromDb = (dbLog: SynchronousDatabase) => {
+  const res = dbLog.select<{ idGlobal: number; idLocal: number }>(
     sql`select idGlobal, idLocal from ${MUTATION_LOG_META_TABLE} order by idGlobal DESC, idLocal DESC limit 1`,
   )[0]
 
   return res ? { global: res.idGlobal, local: res.idLocal } : EventId.ROOT
 }
 
-export const getBackendHeadFromDb = (dbMutationLog: SqliteDb): EventId.GlobalEventId =>
-  dbMutationLog.select<{ head: EventId.GlobalEventId }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ??
-  EventId.ROOT.global
+export const getBackendHeadFromDb = (dbLog: SynchronousDatabase) =>
+  dbLog.select<{ head: number }>(sql`select head from ${SYNC_STATUS_TABLE}`)[0]?.head ?? EventId.ROOT.global
 
 // TODO use prepared statements
-export const updateBackendHead = (dbMutationLog: SqliteDb, head: EventId.EventId) =>
-  dbMutationLog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)
+export const updateBackendHead = (dbLog: SynchronousDatabase, head: EventId.EventId) =>
+  dbLog.execute(sql`UPDATE ${SYNC_STATUS_TABLE} SET head = ${head.global}`)

package/src/leader-thread/recreate-db.ts

@@ -12,56 +12,54 @@ export const recreateDb: Effect.Effect<
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | HttpClient.HttpClient
 > = Effect.gen(function* () {
-  const { dbReadModel, dbMutationLog, schema, bootStatusQueue } = yield* LeaderThreadCtx
+  const { db, dbLog, makeSyncDb, schema, bootStatusQueue } = yield* LeaderThreadCtx
 
   const migrationOptions = schema.migrationOptions
 
   yield* Effect.addFinalizer(
     Effect.fn('recreateDb:finalizer')(function* (ex) {
-      if (ex._tag === 'Failure') dbReadModel.destroy()
+      if (ex._tag === 'Failure') db.destroy()
     }),
   )
 
   // NOTE to speed up the operations below, we're creating a temporary in-memory database
   // and later we'll overwrite the persisted database with the new data
-  // TODO bring back this optimization
-  // const tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
-  const tmpDb = dbReadModel
-  yield* configureConnection(tmpDb, { fkEnabled: true })
+  const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
+  yield* configureConnection(tmpSyncDb, { fkEnabled: true })
 
   const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
     Effect.gen(function* () {
-      yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.init?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       yield* migrateDb({
-        db: tmpDb,
+        db: tmpSyncDb,
         schema,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
       })
 
-      initializeSingletonTables(schema, tmpDb)
+      initializeSingletonTables(schema, tmpSyncDb)
 
-      yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.pre?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      return tmpDb
+      return tmpSyncDb
     })
 
   switch (migrationOptions.strategy) {
     case 'from-mutation-log': {
       const hooks = migrationOptions.hooks
-      const tmpDb = yield* initDb(hooks)
+      const tmpSyncDb = yield* initDb(hooks)
 
       yield* rehydrateFromMutationLog({
-        db: tmpDb,
-        logDb: dbMutationLog,
+        db: tmpSyncDb,
+        logDb: dbLog,
         schema,
         migrationOptions,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
       })
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
@@ -76,13 +74,13 @@ export const recreateDb: Effect.Effect<
       break
     }
     case 'manual': {
-      const oldDbData = dbReadModel.export()
+      const oldDbData = db.export()
 
       const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
         UnexpectedError.mapToUnexpectedError,
       )
 
-      tmpDb.import(newDbData)
+      tmpSyncDb.import(newDbData)
 
       // TODO validate schema
 
@@ -93,19 +91,17 @@ export const recreateDb: Effect.Effect<
     }
   }
 
-  // TODO bring back
   // Import the temporary in-memory database into the persistent database
-  // yield* Effect.sync(() => db.import(tmpDb)).pipe(
-  //   Effect.withSpan('@livestore/common:leader-thread:recreateDb:import'),
-  // )
+  yield* Effect.sync(() => db.import(tmpSyncDb)).pipe(
+    Effect.withSpan('@livestore/common:leader-thread:recreateDb:import'),
+  )
 
   // TODO maybe bring back re-using this initial snapshot to avoid calling `.export()` again
   // We've disabled this for now as it made the code too complex, as we often run syncing right after
   // so the snapshot is no longer up to date
-  // const snapshotFromTmpDb = tmpDb.export()
+  // const snapshotFromTmpDb = tmpSyncDb.export()
 
-  // TODO bring back
-  // tmpDb.close()
+  tmpSyncDb.close()
 }).pipe(
   Effect.scoped, // NOTE we're closing the scope here so finalizers are called when the effect is done
   Effect.withSpan('@livestore/common:leader-thread:recreateDb'),