@livestore/common 0.3.0-dev.9 → 0.3.1-dev.0

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

@@ -1,79 +1,141 @@
-import type { HttpClient, Scope } from '@livestore/utils/effect'
+import type { HttpClient, Schema, Scope } from '@livestore/utils/effect'
 import { Deferred, Effect, Layer, Queue, SubscriptionRef } from '@livestore/utils/effect'
 
-import type { BootStatus, MakeSynchronousDatabase, SqliteError, SynchronousDatabase } from '../adapter-types.js'
+import type { BootStatus, MakeSqliteDb, SqliteError } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
-import type * as Devtools from '../devtools/index.js'
+import type * as Devtools from '../devtools/mod.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 { LiveStoreEvent } from '../schema/mod.js'
 import type { InvalidPullError, IsOfflineError, SyncOptions } from '../sync/sync.js'
 import { sql } from '../util.js'
-import { execSql } from './connection.js'
+import * as Eventlog from './eventlog.js'
 import { bootDevtools } from './leader-worker-devtools.js'
 import { makeLeaderSyncProcessor } from './LeaderSyncProcessor.js'
-import { makePullQueueSet } from './pull-queue-set.js'
+import { makeMaterializeEvent } from './materialize-event.js'
 import { recreateDb } from './recreate-db.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
-import type { DevtoolsOptions, InitialBlockingSyncContext, InitialSyncOptions, ShutdownState } from './types.js'
+import type {
+  DevtoolsOptions,
+  InitialBlockingSyncContext,
+  InitialSyncOptions,
+  LeaderSqliteDb,
+  ShutdownState,
+} from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
+export interface MakeLeaderThreadLayerParams {
+  storeId: string
+  syncPayload: Schema.JsonValue | undefined
+  clientId: string
+  schema: LiveStoreSchema
+  makeSqliteDb: MakeSqliteDb
+  syncOptions: SyncOptions | undefined
+  dbState: LeaderSqliteDb
+  dbEventlog: LeaderSqliteDb
+  devtoolsOptions: DevtoolsOptions
+  shutdownChannel: ShutdownChannel
+  params?: {
+    localPushBatchSize?: number
+    backendPushBatchSize?: number
+  }
+  testing?: {
+    syncProcessor?: {
+      delays?: {
+        localPushProcessing?: Effect.Effect<void>
+      }
+    }
+  }
+}
+
 export const makeLeaderThreadLayer = ({
   schema,
   storeId,
   clientId,
-  makeSyncDb,
+  syncPayload,
+  makeSqliteDb,
   syncOptions,
-  db,
-  dbLog,
+  dbState,
+  dbEventlog,
   devtoolsOptions,
   shutdownChannel,
-}: {
-  storeId: string
-  clientId: string
-  schema: LiveStoreSchema
-  makeSyncDb: MakeSynchronousDatabase
-  syncOptions: SyncOptions | undefined
-  db: SynchronousDatabase
-  dbLog: SynchronousDatabase
-  devtoolsOptions: DevtoolsOptions
-  shutdownChannel: ShutdownChannel
-}): Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient> =>
+  params,
+  testing,
+}: MakeLeaderThreadLayerParams): 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 = db.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
+    const dbEventlogMissing =
+      dbEventlog.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
+
+    const dbStateMissing =
+      dbState.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 =
+      syncOptions?.backend === undefined
+        ? undefined
+        : yield* syncOptions.backend({ storeId, clientId, payload: syncPayload })
+
+    if (syncBackend !== undefined) {
+      // We're already connecting to the sync backend concurrently
+      yield* syncBackend.connect.pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+    }
 
     const initialBlockingSyncContext = yield* makeInitialBlockingSyncContext({
       initialSyncOptions: syncOptions?.initialSyncOptions ?? { _tag: 'Skip' },
       bootStatusQueue,
     })
 
-    const syncProcessor = yield* makeLeaderSyncProcessor({ schema, dbMissing, dbLog, initialBlockingSyncContext })
+    const syncProcessor = yield* makeLeaderSyncProcessor({
+      schema,
+      dbEventlogMissing,
+      dbEventlog,
+      dbState,
+      dbStateMissing,
+      initialBlockingSyncContext,
+      onError: syncOptions?.onSyncError ?? 'ignore',
+      params: {
+        localPushBatchSize: params?.localPushBatchSize,
+        backendPushBatchSize: params?.backendPushBatchSize,
+      },
+      testing: {
+        delays: testing?.syncProcessor?.delays,
+      },
+    })
 
-    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.MessageToAppLeader>().pipe(
+    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.Leader.MessageToApp>().pipe(
       Effect.acquireRelease(Queue.shutdown),
     )
 
+    const devtoolsContext = devtoolsOptions.enabled
+      ? {
+          enabled: true as const,
+          syncBackendLatch: yield* Effect.makeLatch(true),
+          syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
+        }
+      : { enabled: false as const }
+
+    const materializeEvent = yield* makeMaterializeEvent({ schema, dbState, dbEventlog })
+
     const ctx = {
       schema,
       bootStatusQueue,
       storeId,
       clientId,
-      db,
-      dbLog,
-      makeSyncDb,
-      mutationEventSchema: MutationEvent.makeMutationEventSchema(schema),
+      dbState,
+      dbEventlog,
+      makeSqliteDb,
+      eventSchema: LiveStoreEvent.makeEventDefSchema(schema),
       shutdownStateSubRef: yield* SubscriptionRef.make<ShutdownState>('running'),
       shutdownChannel,
       syncBackend,
       syncProcessor,
-      connectedClientSessionPullQueues: yield* makePullQueueSet,
+      materializeEvent,
       extraIncomingMessagesQueue,
+      devtools: devtoolsContext,
+      // State will be set during `bootLeaderThread`
+      initialState: {} as any as LeaderThreadCtx['Type']['initialState'],
     } satisfies typeof LeaderThreadCtx.Service
 
     // @ts-expect-error For debugging purposes
@@ -81,13 +143,18 @@ export const makeLeaderThreadLayer = ({
 
     const layer = Layer.succeed(LeaderThreadCtx, ctx)
 
-    yield* bootLeaderThread({ dbMissing, initialBlockingSyncContext, devtoolsOptions }).pipe(Effect.provide(layer))
+    ctx.initialState = yield* bootLeaderThread({
+      dbStateMissing,
+      initialBlockingSyncContext,
+      devtoolsOptions,
+    }).pipe(Effect.provide(layer))
 
     return layer
   }).pipe(
     Effect.withSpan('@livestore/common:leader-thread:boot'),
     Effect.withSpanScoped('@livestore/common:leader-thread'),
     UnexpectedError.mapToUnexpectedError,
+    Effect.tapCauseLogPretty,
     Layer.unwrapScoped,
   )
 
@@ -101,7 +168,7 @@ const makeInitialBlockingSyncContext = ({
   Effect.gen(function* () {
     const ctx = {
       isDone: false,
-      processedMutations: 0,
+      processedEvents: 0,
       total: -1,
     }
 
@@ -124,10 +191,10 @@ const makeInitialBlockingSyncContext = ({
             ctx.total = remaining + processed
           }
 
-          ctx.processedMutations += processed
+          ctx.processedEvents += processed
           yield* Queue.offer(bootStatusQueue, {
             stage: 'syncing',
-            progress: { done: ctx.processedMutations, total: ctx.total },
+            progress: { done: ctx.processedEvents, total: ctx.total },
           })
 
           if (remaining === 0 && blockingDeferred !== undefined) {
@@ -143,61 +210,43 @@ const makeInitialBlockingSyncContext = ({
  * It also starts various background processes (e.g. syncing)
  */
 const bootLeaderThread = ({
-  dbMissing,
+  dbStateMissing,
   initialBlockingSyncContext,
   devtoolsOptions,
 }: {
-  dbMissing: boolean
+  dbStateMissing: boolean
   initialBlockingSyncContext: InitialBlockingSyncContext
   devtoolsOptions: DevtoolsOptions
 }): Effect.Effect<
-  void,
+  LeaderThreadCtx['Type']['initialState'],
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
   Effect.gen(function* () {
-    const { dbLog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
-
-    yield* migrateTable({
-      db: dbLog,
-      behaviour: 'create-if-not-exists',
-      tableAst: mutationLogMetaTable.sqliteDef.ast,
-      skipMetaTable: true,
-    })
+    const { dbEventlog, bootStatusQueue, syncProcessor } = yield* LeaderThreadCtx
 
-    yield* migrateTable({
-      db: dbLog,
-      behaviour: 'create-if-not-exists',
-      tableAst: syncStatusTable.sqliteDef.ast,
-      skipMetaTable: true,
-    })
-
-    // Create sync status row if it doesn't exist
-    yield* execSql(
-      dbLog,
-      sql`INSERT INTO ${SYNC_STATUS_TABLE} (head)
-          SELECT ${EventId.ROOT.global}
-          WHERE NOT EXISTS (SELECT 1 FROM ${SYNC_STATUS_TABLE})`,
-      {},
-    )
-
-    const dbReady = yield* Deferred.make<void>()
+    yield* Eventlog.initEventlogDb(dbEventlog)
 
-    // We're already starting pulling from the sync backend concurrently but wait until the db is ready before
-    // processing any incoming mutations
-    yield* syncProcessor.boot({ dbReady })
+    const { migrationsReport } = dbStateMissing ? yield* recreateDb : { migrationsReport: { migrations: [] } }
 
-    if (dbMissing) {
-      yield* recreateDb
-    }
-
-    yield* Deferred.succeed(dbReady, void 0)
+    // NOTE the sync processor depends on the dbs being initialized properly
+    const { initialLeaderHead } = yield* syncProcessor.boot
 
     if (initialBlockingSyncContext.blockingDeferred !== undefined) {
-      yield* initialBlockingSyncContext.blockingDeferred
+      // Provides a syncing status right away before the first pull response comes in
+      yield* Queue.offer(bootStatusQueue, {
+        stage: 'syncing',
+        progress: { done: 0, total: -1 },
+      })
+
+      yield* initialBlockingSyncContext.blockingDeferred.pipe(
+        Effect.withSpan('@livestore/common:leader-thread:initial-sync-blocking'),
+      )
     }
 
     yield* Queue.offer(bootStatusQueue, { stage: 'done' })
 
     yield* bootDevtools(devtoolsOptions).pipe(Effect.tapCauseLogPretty, Effect.forkScoped)
+
+    return { migrationsReport, leaderHead: initialLeaderHead }
   })

package/src/leader-thread/materialize-event.ts

@@ -0,0 +1,173 @@
+import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
+import { Effect, ReadonlyArray, Schema } from '@livestore/utils/effect'
+
+import type { SqliteDb } from '../adapter-types.js'
+import { getExecArgsFromEvent } from '../materializer-helper.js'
+import type { LiveStoreSchema } from '../schema/mod.js'
+import { EventSequenceNumber, getEventDef, SystemTables } from '../schema/mod.js'
+import { insertRow } from '../sql-queries/index.js'
+import { sql } from '../util.js'
+import { execSql, execSqlPrepared } from './connection.js'
+import * as Eventlog from './eventlog.js'
+import type { MaterializeEvent } from './types.js'
+
+export const makeMaterializeEvent = ({
+  schema,
+  dbState: db,
+  dbEventlog,
+}: {
+  schema: LiveStoreSchema
+  dbState: SqliteDb
+  dbEventlog: SqliteDb
+}): Effect.Effect<MaterializeEvent, never> =>
+  Effect.gen(function* () {
+    const eventDefSchemaHashMap = new Map(
+      // TODO Running `Schema.hash` can be a bottleneck for larger schemas. There is an opportunity to run this
+      // at build time and lookup the pre-computed hash at runtime.
+      // Also see https://github.com/Effect-TS/effect/issues/2719
+      [...schema.eventsDefsMap.entries()].map(([k, v]) => [k, Schema.hash(v.schema)] as const),
+    )
+
+    return (eventEncoded, options) =>
+      Effect.gen(function* () {
+        const skipEventlog = options?.skipEventlog ?? false
+
+        const eventName = eventEncoded.name
+        const { eventDef, materializer } = getEventDef(schema, eventName)
+
+        const execArgsArr = getExecArgsFromEvent({
+          eventDef,
+          materializer,
+          db,
+          event: { decoded: undefined, encoded: eventEncoded },
+        })
+
+        // NOTE we might want to bring this back if we want to debug no-op events
+        // const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
+        //   onRowsChanged: (rowsChanged: number) => {
+        //     if (rowsChanged === 0) {
+        //       console.warn(`Event "${eventDef.name}" did not affect any rows:`, statementSql, bindValues)
+        //     }
+        //   },
+        // })
+
+        // console.group('[@livestore/common:leader-thread:materializeEvent]', { eventName })
+
+        const session = db.session()
+
+        for (const { statementSql, bindValues } of execArgsArr) {
+          // console.debug(eventName, statementSql, bindValues)
+          // TODO use cached prepared statements instead of exec
+          yield* execSqlPrepared(db, statementSql, bindValues)
+        }
+
+        const changeset = session.changeset()
+        session.finish()
+
+        // TODO use prepared statements
+        yield* execSql(
+          db,
+          ...insertRow({
+            tableName: SystemTables.SESSION_CHANGESET_META_TABLE,
+            columns: SystemTables.sessionChangesetMetaTable.sqliteDef.columns,
+            values: {
+              seqNumGlobal: eventEncoded.seqNum.global,
+              seqNumClient: eventEncoded.seqNum.client,
+              // NOTE the changeset will be empty (i.e. null) for no-op events
+              changeset: changeset ?? null,
+              debug: LS_DEV ? execArgsArr : null,
+            },
+          }),
+        )
+
+        // console.groupEnd()
+
+        // write to eventlog
+        if (skipEventlog === false) {
+          const eventName = eventEncoded.name
+          const eventDefSchemaHash =
+            eventDefSchemaHashMap.get(eventName) ?? shouldNeverHappen(`Unknown event definition: ${eventName}`)
+
+          yield* Eventlog.insertIntoEventlog(
+            eventEncoded,
+            dbEventlog,
+            eventDefSchemaHash,
+            eventEncoded.clientId,
+            eventEncoded.sessionId,
+          )
+        } else {
+          //   console.debug('[@livestore/common:leader-thread] skipping eventlog write', mutation, statementSql, bindValues)
+        }
+
+        return {
+          sessionChangeset: changeset
+            ? {
+                _tag: 'sessionChangeset' as const,
+                data: changeset,
+                debug: LS_DEV ? execArgsArr : null,
+              }
+            : { _tag: 'no-op' as const },
+        }
+      }).pipe(
+        Effect.withSpan(`@livestore/common:leader-thread:materializeEvent`, {
+          attributes: {
+            eventName: eventEncoded.name,
+            eventNum: eventEncoded.seqNum,
+            'span.label': `${EventSequenceNumber.toString(eventEncoded.seqNum)} ${eventEncoded.name}`,
+          },
+        }),
+        // Effect.logDuration('@livestore/common:leader-thread:materializeEvent'),
+      )
+  })
+
+export const rollback = ({
+  dbState,
+  dbEventlog,
+  eventNumsToRollback,
+}: {
+  dbState: SqliteDb
+  dbEventlog: SqliteDb
+  eventNumsToRollback: EventSequenceNumber.EventSequenceNumber[]
+}) =>
+  Effect.gen(function* () {
+    const rollbackEvents = dbState
+      .select<SystemTables.SessionChangesetMetaRow>(
+        sql`SELECT * FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (seqNumGlobal, seqNumClient) IN (${eventNumsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
+      )
+      .map((_) => ({
+        seqNum: { global: _.seqNumGlobal, client: _.seqNumClient },
+        changeset: _.changeset,
+        debug: _.debug,
+      }))
+      .toSorted((a, b) => EventSequenceNumber.compare(a.seqNum, b.seqNum))
+
+    // Apply changesets in reverse order
+    for (let i = rollbackEvents.length - 1; i >= 0; i--) {
+      const { changeset } = rollbackEvents[i]!
+      if (changeset !== null) {
+        dbState.makeChangeset(changeset).invert().apply()
+      }
+    }
+
+    const eventNumPairChunks = ReadonlyArray.chunksOf(100)(
+      eventNumsToRollback.map((seqNum) => `(${seqNum.global}, ${seqNum.client})`),
+    )
+
+    // Delete the changeset rows
+    for (const eventNumPairChunk of eventNumPairChunks) {
+      dbState.execute(
+        sql`DELETE FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (seqNumGlobal, seqNumClient) IN (${eventNumPairChunk.join(', ')})`,
+      )
+    }
+
+    // Delete the eventlog rows
+    for (const eventNumPairChunk of eventNumPairChunks) {
+      dbEventlog.execute(
+        sql`DELETE FROM ${SystemTables.EVENTLOG_META_TABLE} WHERE (seqNumGlobal, seqNumClient) IN (${eventNumPairChunk.join(', ')})`,
+      )
+    }
+  }).pipe(
+    Effect.withSpan('@livestore/common:LeaderSyncProcessor:rollback', {
+      attributes: { count: eventNumsToRollback.length },
+    }),
+  )

package/src/leader-thread/mod.ts

@@ -3,4 +3,4 @@ export * from './types.js'
 export * as ShutdownChannel from './shutdown-channel.js'
 export * from './leader-worker-devtools.js'
 export * from './make-leader-thread-layer.js'
-export * from './mutationlog.js'
+export * as Eventlog from './eventlog.js'

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

@@ -2,87 +2,80 @@ import { casesHandled } from '@livestore/utils'
 import type { HttpClient } from '@livestore/utils/effect'
 import { Effect, Queue } from '@livestore/utils/effect'
 
-import type { InvalidPullError, IsOfflineError, MigrationHooks, SqliteError } from '../index.js'
-import { initializeSingletonTables, migrateDb, rehydrateFromMutationLog, UnexpectedError } from '../index.js'
+import type { InvalidPullError, IsOfflineError, MigrationHooks, MigrationsReport, SqliteError } from '../index.js'
+import { migrateDb, rematerializeFromEventlog, UnexpectedError } from '../index.js'
 import { configureConnection } from './connection.js'
 import { LeaderThreadCtx } from './types.js'
 
 export const recreateDb: Effect.Effect<
-  void,
+  { migrationsReport: MigrationsReport },
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | HttpClient.HttpClient
 > = Effect.gen(function* () {
-  const { db, dbLog, makeSyncDb, schema, bootStatusQueue } = yield* LeaderThreadCtx
+  const { dbState, dbEventlog, schema, bootStatusQueue, materializeEvent } = yield* LeaderThreadCtx
 
-  const migrationOptions = schema.migrationOptions
+  const migrationOptions = schema.state.sqlite.migrations
+  let migrationsReport: MigrationsReport
 
   yield* Effect.addFinalizer(
     Effect.fn('recreateDb:finalizer')(function* (ex) {
-      if (ex._tag === 'Failure') db.destroy()
+      if (ex._tag === 'Failure') dbState.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 tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
-  const tmpSyncDb = db
-  yield* configureConnection(tmpSyncDb, { fkEnabled: true })
+  // const tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
+  const tmpDb = dbState
+  yield* configureConnection(tmpDb, { foreignKeys: true })
 
   const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
     Effect.gen(function* () {
-      yield* Effect.tryAll(() => hooks?.init?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      yield* migrateDb({
-        db: tmpSyncDb,
+      const migrationsReport = yield* migrateDb({
+        db: tmpDb,
         schema,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
       })
 
-      initializeSingletonTables(schema, tmpSyncDb)
+      yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      yield* Effect.tryAll(() => hooks?.pre?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
-
-      return tmpSyncDb
+      return { migrationsReport, tmpDb }
     })
 
   switch (migrationOptions.strategy) {
-    case 'from-mutation-log': {
+    case 'auto': {
       const hooks = migrationOptions.hooks
-      const tmpSyncDb = yield* initDb(hooks)
+      const initResult = yield* initDb(hooks)
+
+      migrationsReport = initResult.migrationsReport
 
-      yield* rehydrateFromMutationLog({
-        db: tmpSyncDb,
-        logDb: dbLog,
+      yield* rematerializeFromEventlog({
+        // db: initResult.tmpDb,
+        dbEventlog,
         schema,
-        migrationOptions,
+        materializeEvent,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
       })
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
-
-      break
-    }
-    case 'hard-reset': {
-      const hooks = migrationOptions.hooks
-      const tmpInMemoryDb = yield* initDb(hooks)
-
-      // The database is migrated but empty now, so nothing else to do
-
-      yield* Effect.tryAll(() => hooks?.post?.(tmpInMemoryDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
     case 'manual': {
-      const oldDbData = db.export()
+      const oldDbData = dbState.export()
+
+      migrationsReport = { migrations: [] }
 
       const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
         UnexpectedError.mapToUnexpectedError,
       )
 
-      tmpSyncDb.import(newDbData)
+      tmpDb.import(newDbData)
 
       // TODO validate schema
 
@@ -95,17 +88,19 @@ export const recreateDb: Effect.Effect<
 
   // TODO bring back
   // Import the temporary in-memory database into the persistent database
-  // yield* Effect.sync(() => db.import(tmpSyncDb)).pipe(
+  // yield* Effect.sync(() => db.import(tmpDb)).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 = tmpSyncDb.export()
+  // const snapshotFromTmpDb = tmpDb.export()
 
   // TODO bring back
-  // tmpSyncDb.close()
+  // tmpDb.close()
+
+  return { migrationsReport }
 }).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'),

package/src/leader-thread/shutdown-channel.ts

@@ -1,11 +1,9 @@
 import type { WebChannel } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
-import { IntentionalShutdownCause } from '../index.js'
+import { IntentionalShutdownCause, UnexpectedError } from '../index.js'
 
-export class DedicatedWorkerDisconnectBroadcast extends Schema.TaggedStruct('DedicatedWorkerDisconnectBroadcast', {}) {}
-
-export class All extends Schema.Union(IntentionalShutdownCause, DedicatedWorkerDisconnectBroadcast) {}
+export class All extends Schema.Union(IntentionalShutdownCause, UnexpectedError) {}
 
 /**
  * Used internally by an adapter to shutdown gracefully.