@livestore/common 0.0.0-snapshot-068f5fa8d02cd26bb64eb4e052900feac9ae59ff → 0.0.0-snapshot-6c61bcbb96b4666b347d3a9845d9f909cf96ae6d

package/src/leader-thread/LeaderSyncProcessor.ts

@@ -18,18 +18,12 @@ import type * as otel from '@opentelemetry/api'
 import type { SqliteDb } from '../adapter-types.js'
 import { UnexpectedError } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
-import {
-  EventId,
-  getEventDef,
-  LEADER_MERGE_COUNTER_TABLE,
-  LiveStoreEvent,
-  SESSION_CHANGESET_META_TABLE,
-} from '../schema/mod.js'
+import { EventId, getEventDef, LiveStoreEvent, SystemTables } from '../schema/mod.js'
 import { LeaderAheadError } from '../sync/sync.js'
 import * as SyncState from '../sync/syncstate.js'
 import { sql } from '../util.js'
-import { rollback } from './apply-event.js'
 import * as Eventlog from './eventlog.js'
+import { rollback } from './materialize-event.js'
 import type { InitialBlockingSyncContext, LeaderSyncProcessor } from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
@@ -73,8 +67,8 @@ export const makeLeaderSyncProcessor = ({
   schema,
   dbEventlogMissing,
   dbEventlog,
-  dbReadModel,
-  dbReadModelMissing,
+  dbState,
+  dbStateMissing,
   initialBlockingSyncContext,
   onError,
   params,
@@ -84,9 +78,9 @@ export const makeLeaderSyncProcessor = ({
   /** Only used to know whether we can safely query dbEventlog during setup execution */
   dbEventlogMissing: boolean
   dbEventlog: SqliteDb
-  dbReadModel: SqliteDb
-  /** Only used to know whether we can safely query dbReadModel during setup execution */
-  dbReadModelMissing: boolean
+  dbState: SqliteDb
+  /** Only used to know whether we can safely query dbState during setup execution */
+  dbStateMissing: boolean
   initialBlockingSyncContext: InitialBlockingSyncContext
   onError: 'shutdown' | 'ignore'
   params: {
@@ -128,7 +122,7 @@ export const makeLeaderSyncProcessor = ({
     const currentLocalPushGenerationRef = { current: 0 }
 
     type MergeCounter = number
-    const mergeCounterRef = { current: dbReadModelMissing ? 0 : yield* getMergeCounterFromDb(dbReadModel) }
+    const mergeCounterRef = { current: dbStateMissing ? 0 : yield* getMergeCounterFromDb(dbState) }
     const mergePayloads = new Map<MergeCounter, typeof SyncState.PayloadUpstream.Type>()
 
     // This context depends on data from `boot`, we should find a better implementation to avoid this ref indirection.
@@ -552,14 +546,14 @@ const backgroundApplyLocalPushes = ({
 
       yield* BucketQueue.offerAll(syncBackendPushQueue, filteredBatch)
 
-      yield* applyEventsBatch({ batchItems: mergeResult.newEvents, deferreds })
+      yield* materializeEventsBatch({ batchItems: mergeResult.newEvents, deferreds })
 
       // Allow the backend pulling to start
       yield* pullLatch.open
     }
   })
 
-type ApplyEventsBatch = (_: {
+type MaterializeEventsBatch = (_: {
   batchItems: ReadonlyArray<LiveStoreEvent.EncodedWithMeta>
   /**
    * The deferreds are used by the caller to know when the mutation has been processed.
@@ -569,9 +563,9 @@ type ApplyEventsBatch = (_: {
 }) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx>
 
 // TODO how to handle errors gracefully
-const applyEventsBatch: ApplyEventsBatch = ({ batchItems, deferreds }) =>
+const materializeEventsBatch: MaterializeEventsBatch = ({ batchItems, deferreds }) =>
   Effect.gen(function* () {
-    const { dbReadModel: db, dbEventlog, applyEvent } = yield* LeaderThreadCtx
+    const { dbState: db, dbEventlog, materializeEvent } = yield* LeaderThreadCtx
 
     // NOTE We always start a transaction to ensure consistency between db and eventlog (even for single-item batches)
     db.execute('BEGIN TRANSACTION', undefined) // Start the transaction
@@ -588,7 +582,7 @@ const applyEventsBatch: ApplyEventsBatch = ({ batchItems, deferreds }) =>
     )
 
     for (let i = 0; i < batchItems.length; i++) {
-      const { sessionChangeset } = yield* applyEvent(batchItems[i]!)
+      const { sessionChangeset } = yield* materializeEvent(batchItems[i]!)
       batchItems[i]!.meta.sessionChangeset = sessionChangeset
 
       if (deferreds?.[i] !== undefined) {
@@ -601,7 +595,7 @@ const applyEventsBatch: ApplyEventsBatch = ({ batchItems, deferreds }) =>
   }).pipe(
     Effect.uninterruptible,
     Effect.scoped,
-    Effect.withSpan('@livestore/common:LeaderSyncProcessor:applyEventItems', {
+    Effect.withSpan('@livestore/common:LeaderSyncProcessor:materializeEventItems', {
       attributes: { batchSize: batchItems.length },
     }),
     Effect.tapCauseLogPretty,
@@ -640,7 +634,7 @@ const backgroundBackendPulling = ({
   advancePushHead: (eventId: EventId.EventId) => void
 }) =>
   Effect.gen(function* () {
-    const { syncBackend, dbReadModel: db, dbEventlog, schema } = yield* LeaderThreadCtx
+    const { syncBackend, dbState: db, dbEventlog, schema } = yield* LeaderThreadCtx
 
     if (syncBackend === undefined) return
 
@@ -700,7 +694,11 @@ const backgroundBackendPulling = ({
           yield* restartBackendPushing(globalRebasedPendingEvents)
 
           if (mergeResult.rollbackEvents.length > 0) {
-            yield* rollback({ db, dbEventlog, eventIdsToRollback: mergeResult.rollbackEvents.map((_) => _.id) })
+            yield* rollback({
+              dbState: db,
+              dbEventlog,
+              eventIdsToRollback: mergeResult.rollbackEvents.map((_) => _.id),
+            })
           }
 
           yield* connectedClientSessionPullQueues.offer({
@@ -744,7 +742,7 @@ const backgroundBackendPulling = ({
 
         advancePushHead(mergeResult.newSyncState.localHead)
 
-        yield* applyEventsBatch({ batchItems: mergeResult.newEvents, deferreds: undefined })
+        yield* materializeEventsBatch({ batchItems: mergeResult.newEvents, deferreds: undefined })
 
         yield* SubscriptionRef.set(syncStateSref, mergeResult.newSyncState)
 
@@ -833,7 +831,7 @@ const backgroundBackendPushing = ({
 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}`)
+  db.execute(sql`DELETE FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE idGlobal < ${newHead.global}`)
 }
 
 interface PullQueueSet {
@@ -894,18 +892,18 @@ const makePullQueueSet = Effect.gen(function* () {
 
 const incrementMergeCounter = (mergeCounterRef: { current: number }) =>
   Effect.gen(function* () {
-    const { dbReadModel } = yield* LeaderThreadCtx
+    const { dbState } = yield* LeaderThreadCtx
     mergeCounterRef.current++
-    dbReadModel.execute(
-      sql`INSERT OR REPLACE INTO ${LEADER_MERGE_COUNTER_TABLE} (id, mergeCounter) VALUES (0, ${mergeCounterRef.current})`,
+    dbState.execute(
+      sql`INSERT OR REPLACE INTO ${SystemTables.LEADER_MERGE_COUNTER_TABLE} (id, mergeCounter) VALUES (0, ${mergeCounterRef.current})`,
     )
     return mergeCounterRef.current
   })
 
-const getMergeCounterFromDb = (dbReadModel: SqliteDb) =>
+const getMergeCounterFromDb = (dbState: SqliteDb) =>
   Effect.gen(function* () {
-    const result = dbReadModel.select<{ mergeCounter: number }>(
-      sql`SELECT mergeCounter FROM ${LEADER_MERGE_COUNTER_TABLE} WHERE id = 0`,
+    const result = dbState.select<{ mergeCounter: number }>(
+      sql`SELECT mergeCounter FROM ${SystemTables.LEADER_MERGE_COUNTER_TABLE} WHERE id = 0`,
     )
     return result[0]?.mergeCounter ?? 0
   })

package/src/leader-thread/eventlog.ts

@@ -50,14 +50,14 @@ export const getEventsSince = (
   since: EventId.EventId,
 ): Effect.Effect<ReadonlyArray<LiveStoreEvent.EncodedWithMeta>, never, LeaderThreadCtx> =>
   Effect.gen(function* () {
-    const { dbEventlog, dbReadModel } = yield* LeaderThreadCtx
+    const { dbEventlog, dbState } = yield* LeaderThreadCtx
 
     const query = eventlogMetaTable.where('idGlobal', '>=', since.global).asSql()
     const pendingEventsRaw = dbEventlog.select(query.query, prepareBindValues(query.bindValues, query.query))
     const pendingEvents = Schema.decodeUnknownSync(eventlogMetaTable.rowSchema.pipe(Schema.Array))(pendingEventsRaw)
 
     const sessionChangesetRows = sessionChangesetMetaTable.where('idGlobal', '>=', since.global).asSql()
-    const sessionChangesetRowsRaw = dbReadModel.select(
+    const sessionChangesetRowsRaw = dbState.select(
       sessionChangesetRows.query,
       prepareBindValues(sessionChangesetRows.bindValues, sessionChangesetRows.query),
     )

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

@@ -2,7 +2,7 @@ import { Effect, FiberMap, Option, Stream, SubscriptionRef } from '@livestore/ut
 import { nanoid } from '@livestore/utils/nanoid'
 
 import { Devtools, IntentionalShutdownCause, liveStoreVersion, UnexpectedError } from '../index.js'
-import { EVENTLOG_META_TABLE, SCHEMA_EVENT_DEFS_META_TABLE, SCHEMA_META_TABLE } from '../schema/mod.js'
+import { SystemTables } from '../schema/mod.js'
 import type { DevtoolsOptions, PersistenceInfoPair } from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
@@ -62,7 +62,7 @@ const listenToDevtools = ({
     const {
       syncBackend,
       makeSqliteDb,
-      dbReadModel,
+      dbState,
       dbEventlog,
       shutdownStateSubRef,
       shutdownChannel,
@@ -109,7 +109,7 @@ const listenToDevtools = ({
               return
             }
             case 'LSD.Leader.SnapshotReq': {
-              const snapshot = dbReadModel.export()
+              const snapshot = dbState.export()
 
               yield* sendMessage(Devtools.Leader.SnapshotRes.make({ snapshot, ...reqPayload }))
 
@@ -143,18 +143,21 @@ const listenToDevtools = ({
               }
 
               try {
-                if (tableNames.has(EVENTLOG_META_TABLE)) {
-                  // Is eventlog
+                if (tableNames.has(SystemTables.EVENTLOG_META_TABLE)) {
+                  // Is eventlog db
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
                   dbEventlog.import(data)
 
-                  dbReadModel.destroy()
-                } else if (tableNames.has(SCHEMA_META_TABLE) && tableNames.has(SCHEMA_EVENT_DEFS_META_TABLE)) {
-                  // Is read model
+                  dbState.destroy()
+                } else if (
+                  tableNames.has(SystemTables.SCHEMA_META_TABLE) &&
+                  tableNames.has(SystemTables.SCHEMA_EVENT_DEFS_META_TABLE)
+                ) {
+                  // Is state db
                   yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-                  dbReadModel.import(data)
+                  dbState.import(data)
 
                   dbEventlog.destroy()
                 } else {
@@ -187,7 +190,7 @@ const listenToDevtools = ({
 
               yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
 
-              dbReadModel.destroy()
+              dbState.destroy()
 
               if (mode === 'all-data') {
                 dbEventlog.destroy()
@@ -206,7 +209,7 @@ const listenToDevtools = ({
               }
 
               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 dbFileSize = dbState.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
               const eventlogFileSize = dbEventlog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
 
               yield* sendMessage(

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

@@ -8,10 +8,10 @@ import type { LiveStoreSchema } from '../schema/mod.js'
 import { LiveStoreEvent } from '../schema/mod.js'
 import type { InvalidPullError, IsOfflineError, SyncOptions } from '../sync/sync.js'
 import { sql } from '../util.js'
-import { makeApplyEvent } from './apply-event.js'
 import * as Eventlog from './eventlog.js'
 import { bootDevtools } from './leader-worker-devtools.js'
 import { makeLeaderSyncProcessor } from './LeaderSyncProcessor.js'
+import { makeMaterializeEvent } from './materialize-event.js'
 import { recreateDb } from './recreate-db.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
 import type {
@@ -30,7 +30,7 @@ export interface MakeLeaderThreadLayerParams {
   schema: LiveStoreSchema
   makeSqliteDb: MakeSqliteDb
   syncOptions: SyncOptions | undefined
-  dbReadModel: LeaderSqliteDb
+  dbState: LeaderSqliteDb
   dbEventlog: LeaderSqliteDb
   devtoolsOptions: DevtoolsOptions
   shutdownChannel: ShutdownChannel
@@ -54,7 +54,7 @@ export const makeLeaderThreadLayer = ({
   syncPayload,
   makeSqliteDb,
   syncOptions,
-  dbReadModel,
+  dbState,
   dbEventlog,
   devtoolsOptions,
   shutdownChannel,
@@ -69,8 +69,8 @@ export const makeLeaderThreadLayer = ({
     const dbEventlogMissing =
       dbEventlog.select<{ count: number }>(sql`select count(*) as count from sqlite_master`)[0]!.count === 0
 
-    const dbReadModelMissing =
-      dbReadModel.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?.backend === undefined
@@ -91,8 +91,8 @@ export const makeLeaderThreadLayer = ({
       schema,
       dbEventlogMissing,
       dbEventlog,
-      dbReadModel,
-      dbReadModelMissing,
+      dbState,
+      dbStateMissing,
       initialBlockingSyncContext,
       onError: syncOptions?.onSyncError ?? 'ignore',
       params: {
@@ -116,14 +116,14 @@ export const makeLeaderThreadLayer = ({
         }
       : { enabled: false as const }
 
-    const applyEvent = yield* makeApplyEvent({ schema, dbReadModel, dbEventlog })
+    const materializeEvent = yield* makeMaterializeEvent({ schema, dbState, dbEventlog })
 
     const ctx = {
       schema,
       bootStatusQueue,
       storeId,
       clientId,
-      dbReadModel,
+      dbState,
       dbEventlog,
       makeSqliteDb,
       eventSchema: LiveStoreEvent.makeEventDefSchema(schema),
@@ -131,7 +131,7 @@ export const makeLeaderThreadLayer = ({
       shutdownChannel,
       syncBackend,
       syncProcessor,
-      applyEvent,
+      materializeEvent,
       extraIncomingMessagesQueue,
       devtools: devtoolsContext,
       // State will be set during `bootLeaderThread`
@@ -144,7 +144,7 @@ export const makeLeaderThreadLayer = ({
     const layer = Layer.succeed(LeaderThreadCtx, ctx)
 
     ctx.initialState = yield* bootLeaderThread({
-      dbReadModelMissing,
+      dbStateMissing,
       initialBlockingSyncContext,
       devtoolsOptions,
     }).pipe(Effect.provide(layer))
@@ -210,11 +210,11 @@ const makeInitialBlockingSyncContext = ({
  * It also starts various background processes (e.g. syncing)
  */
 const bootLeaderThread = ({
-  dbReadModelMissing,
+  dbStateMissing,
   initialBlockingSyncContext,
   devtoolsOptions,
 }: {
-  dbReadModelMissing: boolean
+  dbStateMissing: boolean
   initialBlockingSyncContext: InitialBlockingSyncContext
   devtoolsOptions: DevtoolsOptions
 }): Effect.Effect<
@@ -228,7 +228,7 @@ const bootLeaderThread = ({
     yield* Eventlog.initEventlogDb(dbEventlog)
 
     let migrationsReport: MigrationsReport
-    if (dbReadModelMissing) {
+    if (dbStateMissing) {
       const recreateResult = yield* recreateDb
       migrationsReport = recreateResult.migrationsReport
     } else {

package/src/leader-thread/{apply-event.ts → materialize-event.ts}

@@ -3,29 +3,23 @@ import { Effect, ReadonlyArray, Schema } from '@livestore/utils/effect'
 
 import type { SqliteDb } from '../adapter-types.js'
 import { getExecArgsFromEvent } from '../materializer-helper.js'
-import type { LiveStoreSchema, SessionChangesetMetaRow } from '../schema/mod.js'
-import {
-  EventId,
-  EVENTLOG_META_TABLE,
-  getEventDef,
-  SESSION_CHANGESET_META_TABLE,
-  sessionChangesetMetaTable,
-} from '../schema/mod.js'
+import type { LiveStoreSchema } from '../schema/mod.js'
+import { EventId, 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 { ApplyEvent } from './types.js'
+import type { MaterializeEvent } from './types.js'
 
-export const makeApplyEvent = ({
+export const makeMaterializeEvent = ({
   schema,
-  dbReadModel: db,
+  dbState: db,
   dbEventlog,
 }: {
   schema: LiveStoreSchema
-  dbReadModel: SqliteDb
+  dbState: SqliteDb
   dbEventlog: SqliteDb
-}): Effect.Effect<ApplyEvent, never> =>
+}): 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
@@ -55,7 +49,7 @@ export const makeApplyEvent = ({
         //   },
         // })
 
-        // console.group('[@livestore/common:leader-thread:applyEvent]', { eventName })
+        // console.group('[@livestore/common:leader-thread:materializeEvent]', { eventName })
 
         const session = db.session()
 
@@ -72,8 +66,8 @@ export const makeApplyEvent = ({
         yield* execSql(
           db,
           ...insertRow({
-            tableName: SESSION_CHANGESET_META_TABLE,
-            columns: sessionChangesetMetaTable.sqliteDef.columns,
+            tableName: SystemTables.SESSION_CHANGESET_META_TABLE,
+            columns: SystemTables.sessionChangesetMetaTable.sqliteDef.columns,
             values: {
               idGlobal: eventEncoded.id.global,
               idClient: eventEncoded.id.client,
@@ -113,30 +107,30 @@ export const makeApplyEvent = ({
             : { _tag: 'no-op' as const },
         }
       }).pipe(
-        Effect.withSpan(`@livestore/common:leader-thread:applyEvent`, {
+        Effect.withSpan(`@livestore/common:leader-thread:materializeEvent`, {
           attributes: {
             eventName: eventEncoded.name,
-            mutationId: eventEncoded.id,
+            eventId: eventEncoded.id,
             'span.label': `${EventId.toString(eventEncoded.id)} ${eventEncoded.name}`,
           },
         }),
-        // Effect.logDuration('@livestore/common:leader-thread:applyEvent'),
+        // Effect.logDuration('@livestore/common:leader-thread:materializeEvent'),
       )
   })
 
 export const rollback = ({
-  db,
+  dbState,
   dbEventlog,
   eventIdsToRollback,
 }: {
-  db: SqliteDb
+  dbState: SqliteDb
   dbEventlog: SqliteDb
   eventIdsToRollback: EventId.EventId[]
 }) =>
   Effect.gen(function* () {
-    const rollbackEvents = db
-      .select<SessionChangesetMetaRow>(
-        sql`SELECT * FROM ${SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
+    const rollbackEvents = dbState
+      .select<SystemTables.SessionChangesetMetaRow>(
+        sql`SELECT * FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdsToRollback.map((id) => `(${id.global}, ${id.client})`).join(', ')})`,
       )
       .map((_) => ({ id: { global: _.idGlobal, client: _.idClient }, changeset: _.changeset, debug: _.debug }))
       .toSorted((a, b) => EventId.compare(a.id, b.id))
@@ -145,7 +139,7 @@ export const rollback = ({
     for (let i = rollbackEvents.length - 1; i >= 0; i--) {
       const { changeset } = rollbackEvents[i]!
       if (changeset !== null) {
-        db.makeChangeset(changeset).invert().apply()
+        dbState.makeChangeset(changeset).invert().apply()
       }
     }
 
@@ -155,15 +149,15 @@ export const rollback = ({
 
     // Delete the changeset rows
     for (const eventIdPairChunk of eventIdPairChunks) {
-      db.execute(
-        sql`DELETE FROM ${SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdPairChunk.join(', ')})`,
+      dbState.execute(
+        sql`DELETE FROM ${SystemTables.SESSION_CHANGESET_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdPairChunk.join(', ')})`,
       )
     }
 
     // Delete the eventlog rows
     for (const eventIdPairChunk of eventIdPairChunks) {
       dbEventlog.execute(
-        sql`DELETE FROM ${EVENTLOG_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdPairChunk.join(', ')})`,
+        sql`DELETE FROM ${SystemTables.EVENTLOG_META_TABLE} WHERE (idGlobal, idClient) IN (${eventIdPairChunk.join(', ')})`,
       )
     }
   }).pipe(

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

@@ -3,7 +3,7 @@ import type { HttpClient } from '@livestore/utils/effect'
 import { Effect, Queue } from '@livestore/utils/effect'
 
 import type { InvalidPullError, IsOfflineError, MigrationHooks, MigrationsReport, SqliteError } from '../index.js'
-import { migrateDb, rehydrateFromEventlog, UnexpectedError } from '../index.js'
+import { migrateDb, rematerializeFromEventlog, UnexpectedError } from '../index.js'
 import { configureConnection } from './connection.js'
 import { LeaderThreadCtx } from './types.js'
 
@@ -12,14 +12,14 @@ export const recreateDb: Effect.Effect<
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | HttpClient.HttpClient
 > = Effect.gen(function* () {
-  const { dbReadModel, dbEventlog, schema, bootStatusQueue, applyEvent } = yield* LeaderThreadCtx
+  const { dbState, dbEventlog, schema, bootStatusQueue, materializeEvent } = yield* LeaderThreadCtx
 
   const migrationOptions = schema.migrationOptions
   let migrationsReport: MigrationsReport
 
   yield* Effect.addFinalizer(
     Effect.fn('recreateDb:finalizer')(function* (ex) {
-      if (ex._tag === 'Failure') dbReadModel.destroy()
+      if (ex._tag === 'Failure') dbState.destroy()
     }),
   )
 
@@ -27,7 +27,7 @@ export const recreateDb: Effect.Effect<
   // 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
+  const tmpDb = dbState
   yield* configureConnection(tmpDb, { foreignKeys: true })
 
   const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
@@ -53,11 +53,11 @@ export const recreateDb: Effect.Effect<
 
       migrationsReport = initResult.migrationsReport
 
-      yield* rehydrateFromEventlog({
+      yield* rematerializeFromEventlog({
         // db: initResult.tmpDb,
         dbEventlog,
         schema,
-        applyEvent,
+        materializeEvent,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
       })
@@ -79,7 +79,7 @@ export const recreateDb: Effect.Effect<
       break
     }
     case 'manual': {
-      const oldDbData = dbReadModel.export()
+      const oldDbData = dbState.export()
 
       migrationsReport = { migrations: [] }
 

package/src/leader-thread/types.ts

@@ -89,7 +89,7 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
     storeId: string
     clientId: string
     makeSqliteDb: MakeSqliteDb
-    dbReadModel: LeaderSqliteDb
+    dbState: LeaderSqliteDb
     dbEventlog: LeaderSqliteDb
     bootStatusQueue: Queue.Queue<BootStatus>
     // TODO we should find a more elegant way to handle cases which need this ref for their implementation
@@ -99,7 +99,7 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
     devtools: DevtoolsContext
     syncBackend: SyncBackend | undefined
     syncProcessor: LeaderSyncProcessor
-    applyEvent: ApplyEvent
+    materializeEvent: MaterializeEvent
     initialState: {
       leaderHead: EventId.EventId
       migrationsReport: MigrationsReport
@@ -113,10 +113,10 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
   }
 >() {}
 
-export type ApplyEvent = (
+export type MaterializeEvent = (
   eventEncoded: LiveStoreEvent.EncodedWithMeta,
   options?: {
-    /** Needed for rehydrateFromEventlog */
+    /** Needed for rematerializeFromEventlog */
     skipEventlog?: boolean
   },
 ) => Effect.Effect<