@livestore/common 0.3.0-dev.10 → 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.makeContext
+    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,25 +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, makeSyncDb, db, dbLog, 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>()
@@ -83,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
           }
 
@@ -142,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
             }
@@ -159,16 +243,11 @@ const listenToDevtools = ({
 
               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 = db.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size
               const mutationLogFileSize = dbLog.select<{ size: number }>(dbSizeQuery, undefined)[0]!.size

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

@@ -1,43 +1,41 @@
-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, 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, ShutdownState } from './types.js'
 import { LeaderThreadCtx } from './types.js'
 
 export const makeLeaderThreadLayer = ({
   schema,
   storeId,
-  clientId,
+  originId,
   makeSyncDb,
-  syncOptions,
+  makeSyncBackend,
   db,
   dbLog,
   devtoolsOptions,
-  shutdownChannel,
+  initialSyncOptions = { _tag: 'Skip' },
 }: {
   storeId: string
-  clientId: string
+  originId: string
   schema: LiveStoreSchema
   makeSyncDb: MakeSynchronousDatabase
-  syncOptions: SyncOptions | undefined
+  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))
@@ -46,34 +44,25 @@ export const makeLeaderThreadLayer = ({
     // 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 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 initialBlockingSyncContext = yield* makeInitialBlockingSyncContext({ initialSyncOptions, bootStatusQueue })
 
     const syncProcessor = yield* makeLeaderSyncProcessor({ schema, dbMissing, dbLog, initialBlockingSyncContext })
 
-    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.MessageToAppLeader>().pipe(
-      Effect.acquireRelease(Queue.shutdown),
-    )
-
     const ctx = {
       schema,
       bootStatusQueue,
       storeId,
-      clientId,
+      originId,
       db,
       dbLog,
       makeSyncDb,
       mutationEventSchema: MutationEvent.makeMutationEventSchema(schema),
       shutdownStateSubRef: yield* SubscriptionRef.make<ShutdownState>('running'),
-      shutdownChannel,
       syncBackend,
       syncProcessor,
       connectedClientSessionPullQueues: yield* makePullQueueSet,
-      extraIncomingMessagesQueue,
     } satisfies typeof LeaderThreadCtx.Service
 
     // @ts-expect-error For debugging purposes

package/src/leader-thread/mutationlog.ts

@@ -2,14 +2,11 @@ import { Effect, Schema } from '@livestore/utils/effect'
 
 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 { dbLog } = yield* LeaderThreadCtx
 
@@ -29,17 +26,16 @@ export const getMutationEventsSince = (
       .filter((_) => EventId.compare(_.id, since) > 0)
   })
 
-export const getLocalHeadFromDb = (dbLog: SynchronousDatabase): EventId.EventId => {
-  const res = dbLog.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 = (dbLog: SynchronousDatabase): EventId.GlobalEventId =>
-  dbLog.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 = (dbLog: SynchronousDatabase, head: EventId.EventId) =>

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

@@ -24,9 +24,7 @@ export const recreateDb: Effect.Effect<
 
   // 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
+  const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
   yield* configureConnection(tmpSyncDb, { fkEnabled: true })
 
   const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
@@ -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(tmpSyncDb)).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 = tmpSyncDb.export()
 
-  // TODO bring back
-  // tmpSyncDb.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'),

package/src/leader-thread/types.ts

@@ -6,7 +6,6 @@ import type {
   Option,
   Queue,
   Scope,
-  Subscribable,
   SubscriptionRef,
   WebChannel,
 } from '@livestore/utils/effect'
@@ -23,7 +22,7 @@ import type {
   UnexpectedError,
 } from '../index.js'
 import type { EventId, LiveStoreSchema, MutationEvent } from '../schema/mod.js'
-import type * as SyncState from '../sync/syncstate.js'
+import type { PayloadUpstream, SyncState } from '../sync/syncstate.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
 
 export type ShutdownState = 'running' | 'shutting-down'
@@ -68,6 +67,7 @@ export type DevtoolsOptions =
       makeContext: Effect.Effect<
         {
           devtoolsWebChannel: WebChannel.WebChannel<Devtools.MessageToAppLeader, Devtools.MessageFromAppLeader>
+          shutdownChannel: ShutdownChannel
           persistenceInfo: PersistenceInfoPair
         },
         UnexpectedError,
@@ -80,21 +80,18 @@ export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
   {
     schema: LiveStoreSchema
     storeId: string
-    clientId: string
+    originId: string
     makeSyncDb: MakeSynchronousDatabase
     db: LeaderDatabase
     dbLog: LeaderDatabase
     bootStatusQueue: Queue.Queue<BootStatus>
     // TODO we should find a more elegant way to handle cases which need this ref for their implementation
     shutdownStateSubRef: SubscriptionRef.SubscriptionRef<ShutdownState>
-    shutdownChannel: ShutdownChannel
     mutationEventSchema: MutationEvent.ForMutationDefRecord<any>
     // devtools: DevtoolsContext
     syncBackend: SyncBackend | undefined
-    syncProcessor: LeaderSyncProcessor
+    syncProcessor: SyncProcessor
     connectedClientSessionPullQueues: PullQueueSet
-    /** e.g. used for `store.__dev` APIs */
-    extraIncomingMessagesQueue: Queue.Queue<Devtools.MessageToAppLeader>
   }
 >() {}
 
@@ -104,28 +101,24 @@ export type InitialBlockingSyncContext = {
 }
 
 export type PullQueueItem = {
-  payload: SyncState.PayloadUpstream
+  // mutationEvents: ReadonlyArray<MutationEvent.AnyEncoded>
+  // backendHead: number
+  payload: PayloadUpstream
+  // TODO move `remaining` into `PayloadUpstream`
   remaining: number
 }
 
-export interface LeaderSyncProcessor {
+export interface SyncProcessor {
   push: (
     /** `batch` needs to follow the same rules as `batch` in `SyncBackend.push` */
     batch: ReadonlyArray<MutationEvent.EncodedWithMeta>,
-    options?: {
-      /**
-       * If true, the effect will only finish when the local push has been processed (i.e. succeeded or was rejected).
-       * @default false
-       */
-      waitForProcessing?: boolean
-    },
-  ) => Effect.Effect<void, InvalidPushError>
+  ) => Effect.Effect<void, UnexpectedError | InvalidPushError, HttpClient.HttpClient | LeaderThreadCtx>
 
   pushPartial: (mutationEvent: MutationEvent.PartialAnyEncoded) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx>
   boot: (args: {
     dbReady: Deferred.Deferred<void>
   }) => Effect.Effect<void, UnexpectedError, LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient>
-  syncState: Subscribable.Subscribable<SyncState.SyncState>
+  syncState: Effect.Effect<SyncState, UnexpectedError>
 }
 
 export interface PullQueueSet {

package/src/mutation.ts

@@ -8,19 +8,10 @@ import { prepareBindValues } from './util.js'
 
 export const getExecArgsFromMutation = ({
   mutationDef,
-  mutationEvent,
+  mutationEventDecoded,
 }: {
   mutationDef: MutationDef.Any
-  /** Both encoded and decoded mutation events are supported to reduce the number of times we need to decode/encode */
-  mutationEvent:
-    | {
-        decoded: MutationEvent.AnyDecoded | MutationEvent.PartialAnyDecoded
-        encoded: undefined
-      }
-    | {
-        decoded: undefined
-        encoded: MutationEvent.AnyEncoded | MutationEvent.PartialAnyEncoded
-      }
+  mutationEventDecoded: MutationEvent.Any | MutationEvent.PartialAny
 }): ReadonlyArray<{
   statementSql: string
   bindValues: PreparedBindValues
@@ -32,9 +23,7 @@ export const getExecArgsFromMutation = ({
 
   switch (typeof mutationDef.sql) {
     case 'function': {
-      const mutationArgsDecoded =
-        mutationEvent.decoded?.args ?? Schema.decodeUnknownSync(mutationDef.schema)(mutationEvent.encoded!.args)
-      const res = mutationDef.sql(mutationArgsDecoded)
+      const res = mutationDef.sql(mutationEventDecoded.args)
       statementRes = Array.isArray(res) ? res : [res]
       break
     }
@@ -51,9 +40,10 @@ export const getExecArgsFromMutation = ({
   return statementRes.map((statementRes) => {
     const statementSql = typeof statementRes === 'string' ? statementRes : statementRes.sql
 
-    const mutationArgsEncoded =
-      mutationEvent.encoded?.args ?? Schema.encodeUnknownSync(mutationDef.schema)(mutationEvent.decoded!.args)
-    const bindValues = typeof statementRes === 'string' ? mutationArgsEncoded : statementRes.bindValues
+    const bindValues =
+      typeof statementRes === 'string'
+        ? Schema.encodeUnknownSync(mutationDef.schema)(mutationEventDecoded.args)
+        : statementRes.bindValues
 
     const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
 

package/src/rehydrate-from-mutationlog.ts

@@ -1,8 +1,8 @@
-import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
+import { isDevEnv, memoizeByRef, shouldNeverHappen } from '@livestore/utils'
 import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
 import { type MigrationOptionsFromMutationLog, type SynchronousDatabase, UnexpectedError } from './adapter-types.js'
-import { makeApplyMutation } from './leader-thread/apply-mutation.js'
+import { getExecArgsFromMutation } from './mutation.js'
 import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/mod.js'
 import { EventId, MUTATION_LOG_META_TABLE } from './schema/mod.js'
 import type { PreparedBindValues } from './util.js'
@@ -10,8 +10,7 @@ import { sql } from './util.js'
 
 export const rehydrateFromMutationLog = ({
   logDb,
-  // TODO re-use this db when bringing back the boot in-memory db implementation
-  // db,
+  db,
   schema,
   migrationOptions,
   onProgress,
@@ -29,8 +28,6 @@ export const rehydrateFromMutationLog = ({
 
     const hashMutation = memoizeByRef((mutation: MutationDef.Any) => Schema.hash(mutation.schema))
 
-    const applyMutation = yield* makeApplyMutation
-
     const processMutation = (row: MutationLogMetaRow) =>
       Effect.gen(function* () {
         const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
@@ -43,10 +40,7 @@ export const rehydrateFromMutationLog = ({
           )
         }
 
-        const args = JSON.parse(row.argsJson)
-
-        // Checking whether the schema has changed in an incompatible way
-        yield* Schema.decodeUnknown(mutationDef.schema)(args).pipe(
+        const argsDecoded = yield* Schema.decodeUnknown(Schema.parseJson(mutationDef.schema))(row.argsJson).pipe(
           Effect.mapError((cause) =>
             UnexpectedError.make({
               cause,
@@ -59,14 +53,28 @@ This likely means the schema has changed in an incompatible way.
           ),
         )
 
-        const mutationEventEncoded = {
+        const mutationEventDecoded = {
           id: { global: row.idGlobal, local: row.idLocal },
           parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
           mutation: row.mutation,
-          args,
-        } satisfies MutationEvent.AnyEncoded
-
-        yield* applyMutation(mutationEventEncoded, { skipMutationLog: true })
+          args: argsDecoded,
+        } satisfies MutationEvent.Any
+
+        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+
+        const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
+          onRowsChanged: (rowsChanged: number) => {
+            if (rowsChanged === 0 && migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true) {
+              console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
+            }
+          },
+        })
+
+        for (const { statementSql, bindValues } of execArgsArr) {
+          // TODO cache prepared statements for mutations
+          db.execute(statementSql, bindValues, isDevEnv() ? makeExecuteOptions(statementSql, bindValues) : undefined)
+          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
+        }
       }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
 
     const CHUNK_SIZE = 100

package/src/schema/EventId.ts

@@ -1,14 +1,4 @@
-import { Brand, Schema } from '@livestore/utils/effect'
-
-export type LocalEventId = Brand.Branded<number, 'LocalEventId'>
-export const localEventId = Brand.nominal<LocalEventId>()
-export const LocalEventId = Schema.fromBrand(localEventId)(Schema.Int)
-
-export type GlobalEventId = Brand.Branded<number, 'GlobalEventId'>
-export const globalEventId = Brand.nominal<GlobalEventId>()
-export const GlobalEventId = Schema.fromBrand(globalEventId)(Schema.Int)
-
-export const localDefault = 0 as any as LocalEventId
+import { Schema } from '@livestore/utils/effect'
 
 /**
  * LiveStore event id value consisting of a globally unique event sequence number
@@ -16,11 +6,11 @@ export const localDefault = 0 as any as LocalEventId
  *
  * The local sequence number is only used for localOnly mutations and starts from 0 for each global sequence number.
  */
-export type EventId = { global: GlobalEventId; local: LocalEventId }
+export type EventId = { global: number; local: number }
 
 export const EventId = Schema.Struct({
-  global: GlobalEventId,
-  local: LocalEventId,
+  global: Schema.Number,
+  local: Schema.Number,
 }).annotations({ title: 'LiveStore.EventId' })
 
 /**
@@ -37,24 +27,20 @@ export const isEqual = (a: EventId, b: EventId) => a.global === b.global && a.lo
 
 export type EventIdPair = { id: EventId; parentId: EventId }
 
-export const ROOT = { global: -1 as any as GlobalEventId, local: localDefault } satisfies EventId
+export const ROOT = { global: -1, local: 0 } satisfies EventId
 
 export const isGreaterThan = (a: EventId, b: EventId) => {
   return a.global > b.global || (a.global === b.global && a.local > b.local)
 }
 
-export const make = (id: EventId | typeof EventId.Encoded): EventId => {
-  return Schema.is(EventId)(id) ? id : Schema.decodeSync(EventId)(id)
-}
-
-export const nextPair = (id: EventId, isLocal: boolean): EventIdPair => {
+export const nextPair = (id: EventId, isLocal: boolean) => {
   if (isLocal) {
-    return { id: { global: id.global, local: (id.local + 1) as any as LocalEventId }, parentId: id }
+    return { id: { global: id.global, local: id.local + 1 }, parentId: id }
   }
 
   return {
-    id: { global: (id.global + 1) as any as GlobalEventId, local: localDefault },
+    id: { global: id.global + 1, local: 0 },
     // NOTE we always point to `local: 0` for non-localOnly mutations
-    parentId: { global: id.global, local: localDefault },
+    parentId: { global: id.global, local: 0 },
   }
 }