@livestore/common 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

package/src/devtools/devtools-messages.ts

@@ -0,0 +1,247 @@
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+import { NetworkStatus } from '../adapter-types.js'
+import { DebugInfo } from '../debug-info.js'
+import { mutationEventSchemaEncodedAny } from '../schema/mutations.js'
+import { PreparedBindValues } from '../util.js'
+import { liveStoreVersion as pkgVersion } from '../version.js'
+
+const requestId = Schema.String
+const appHostId = Schema.String
+const liveStoreVersion = Schema.Literal(pkgVersion)
+
+const LSDMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  Schema.TaggedStruct(tag, {
+    liveStoreVersion,
+    ...fields,
+  }).annotations({ identifier: tag })
+
+const LSDChannelMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  LSDMessage(tag, {
+    appHostId,
+    ...fields,
+  })
+
+const LSDReqResMessage = <Tag extends string, Fields extends Schema.Struct.Fields>(tag: Tag, fields: Fields) =>
+  LSDChannelMessage(tag, {
+    requestId,
+    ...fields,
+  })
+
+export class SnapshotReq extends LSDReqResMessage('LSD.SnapshotReq', {}) {}
+
+export class SnapshotRes extends LSDReqResMessage('LSD.SnapshotRes', {
+  snapshot: Transferable.Uint8Array,
+}) {}
+
+export class LoadDatabaseFileReq extends LSDReqResMessage('LSD.LoadDatabaseFileReq', {
+  data: Transferable.Uint8Array,
+}) {}
+
+export class LoadDatabaseFileRes extends LSDReqResMessage('LSD.LoadDatabaseFileRes', {
+  status: Schema.Literal('ok', 'unsupported-file', 'unsupported-database'),
+}) {}
+
+export class DebugInfoReq extends LSDReqResMessage('LSD.DebugInfoReq', {}) {}
+
+export class DebugInfoRes extends LSDReqResMessage('LSD.DebugInfoRes', {
+  debugInfo: DebugInfo,
+}) {}
+
+export class DebugInfoHistorySubscribe extends LSDReqResMessage('LSD.DebugInfoHistorySubscribe', {}) {}
+
+export class DebugInfoHistoryRes extends LSDReqResMessage('LSD.DebugInfoHistoryRes', {
+  debugInfoHistory: Schema.Array(DebugInfo),
+}) {}
+
+export class DebugInfoHistoryUnsubscribe extends LSDReqResMessage('LSD.DebugInfoHistoryUnsubscribe', {}) {}
+
+export class DebugInfoResetReq extends LSDReqResMessage('LSD.DebugInfoResetReq', {}) {}
+
+export class DebugInfoResetRes extends LSDReqResMessage('LSD.DebugInfoResetRes', {}) {}
+
+export class DebugInfoRerunQueryReq extends LSDReqResMessage('LSD.DebugInfoRerunQueryReq', {
+  queryStr: Schema.String,
+  bindValues: Schema.UndefinedOr(PreparedBindValues),
+  queriedTables: Schema.ReadonlySet(Schema.String),
+}) {}
+
+export class DebugInfoRerunQueryRes extends LSDReqResMessage('LSD.DebugInfoRerunQueryRes', {}) {}
+
+export class MutationBroadcast extends LSDMessage('LSD.MutationBroadcast', {
+  mutationEventEncoded: mutationEventSchemaEncodedAny,
+  persisted: Schema.Boolean,
+}) {}
+
+export class RunMutationReq extends LSDReqResMessage('LSD.RunMutationReq', {
+  mutationEventEncoded: mutationEventSchemaEncodedAny.pipe(Schema.omit('id', 'parentId')),
+  persisted: Schema.Boolean,
+}) {}
+
+export class RunMutationRes extends LSDReqResMessage('LSD.RunMutationRes', {}) {}
+
+export class MutationLogReq extends LSDReqResMessage('LSD.MutationLogReq', {}) {}
+
+export class MutationLogRes extends LSDReqResMessage('LSD.MutationLogRes', {
+  mutationLog: Transferable.Uint8Array,
+}) {}
+
+export class ReactivityGraphSubscribe extends LSDReqResMessage('LSD.ReactivityGraphSubscribe', {
+  includeResults: Schema.Boolean,
+}) {}
+
+export class ReactivityGraphUnsubscribe extends LSDReqResMessage('LSD.ReactivityGraphUnsubscribe', {}) {}
+
+export class ReactivityGraphRes extends LSDReqResMessage('LSD.ReactivityGraphRes', {
+  reactivityGraph: Schema.Any,
+}) {}
+
+export class LiveQueriesSubscribe extends LSDReqResMessage('LSD.LiveQueriesSubscribe', {}) {}
+
+export class LiveQueriesUnsubscribe extends LSDReqResMessage('LSD.LiveQueriesUnsubscribe', {}) {}
+
+export class SerializedLiveQuery extends Schema.Struct({
+  _tag: Schema.Literal('js', 'sql', 'graphql'),
+  id: Schema.Number,
+  label: Schema.String,
+  runs: Schema.Number,
+  executionTimes: Schema.Array(Schema.Number),
+  lastestResult: Schema.Any,
+  activeSubscriptions: Schema.Array(
+    Schema.Struct({ frames: Schema.Array(Schema.Struct({ name: Schema.String, filePath: Schema.String })) }),
+  ),
+}) {}
+
+export class LiveQueriesRes extends LSDReqResMessage('LSD.LiveQueriesRes', {
+  liveQueries: Schema.Array(SerializedLiveQuery),
+}) {}
+
+export class ResetAllDataReq extends LSDReqResMessage('LSD.ResetAllDataReq', {
+  mode: Schema.Literal('all-data', 'only-app-db'),
+}) {}
+
+export class ResetAllDataRes extends LSDReqResMessage('LSD.ResetAllDataRes', {}) {}
+
+export class DatabaseFileInfoReq extends LSDReqResMessage('LSD.DatabaseFileInfoReq', {}) {}
+
+export class DatabaseFileInfo extends Schema.Struct({
+  fileSize: Schema.Number,
+  persistenceInfo: Schema.Struct({ fileName: Schema.String }, { key: Schema.String, value: Schema.Any }),
+}) {}
+
+export class DatabaseFileInfoRes extends LSDReqResMessage('LSD.DatabaseFileInfoRes', {
+  db: DatabaseFileInfo,
+  mutationLog: DatabaseFileInfo,
+}) {}
+
+export class MessagePortForStoreReq extends LSDReqResMessage('LSD.MessagePortForStoreReq', {}) {}
+
+export class MessagePortForStoreRes extends LSDReqResMessage('LSD.MessagePortForStoreRes', {
+  port: Transferable.MessagePort,
+}) {}
+
+export class NetworkStatusSubscribe extends LSDReqResMessage('LSD.NetworkStatusSubscribe', {}) {}
+export class NetworkStatusUnsubscribe extends LSDReqResMessage('LSD.NetworkStatusUnsubscribe', {}) {}
+
+export class NetworkStatusRes extends LSDReqResMessage('LSD.NetworkStatusRes', {
+  networkStatus: NetworkStatus,
+}) {}
+
+export class SyncingInfoReq extends LSDReqResMessage('LSD.SyncingInfoReq', {}) {}
+
+export class SyncingInfo extends Schema.Struct({
+  enabled: Schema.Boolean,
+  metadata: Schema.Record({ key: Schema.String, value: Schema.Any }),
+}) {}
+
+export class SyncingInfoRes extends LSDReqResMessage('LSD.SyncingInfoRes', {
+  syncingInfo: SyncingInfo,
+}) {}
+
+export class SyncHistorySubscribe extends LSDReqResMessage('LSD.SyncHistorySubscribe', {}) {}
+export class SyncHistoryUnsubscribe extends LSDReqResMessage('LSD.SyncHistoryUnsubscribe', {}) {}
+export class SyncHistoryRes extends LSDReqResMessage('LSD.SyncHistoryRes', {
+  mutationEventEncoded: mutationEventSchemaEncodedAny,
+  metadata: Schema.Option(Schema.JsonValue),
+}) {}
+
+export class DevtoolsReady extends LSDMessage('LSD.DevtoolsReady', {}) {}
+
+export class DevtoolsConnected extends LSDChannelMessage('LSD.DevtoolsConnected', {}) {}
+
+export class AppHostReady extends LSDChannelMessage('LSD.AppHostReady', {
+  isLeader: Schema.Boolean,
+}) {}
+
+export class Disconnect extends LSDChannelMessage('LSD.Disconnect', {}) {}
+
+export class Ping extends LSDReqResMessage('LSD.Ping', {}) {}
+
+export class Pong extends LSDReqResMessage('LSD.Pong', {}) {}
+
+export const MessageToAppHostCoordinator = Schema.Union(
+  SnapshotReq,
+  LoadDatabaseFileReq,
+  MutationLogReq,
+  ResetAllDataReq,
+  MessagePortForStoreRes,
+  NetworkStatusSubscribe,
+  NetworkStatusUnsubscribe,
+  DevtoolsReady,
+  Disconnect,
+  DevtoolsConnected,
+  RunMutationReq,
+  Ping,
+  DatabaseFileInfoReq,
+  SyncHistorySubscribe,
+  SyncHistoryUnsubscribe,
+  SyncingInfoReq,
+).annotations({ identifier: 'LSD.MessageToAppHostCoordinator' })
+
+export type MessageToAppHostCoordinator = typeof MessageToAppHostCoordinator.Type
+
+export const MessageToAppHostStore = Schema.Union(
+  DebugInfoReq,
+  DebugInfoHistorySubscribe,
+  DebugInfoHistoryUnsubscribe,
+  DebugInfoResetReq,
+  DebugInfoRerunQueryReq,
+  ReactivityGraphSubscribe,
+  ReactivityGraphUnsubscribe,
+  LiveQueriesSubscribe,
+  LiveQueriesUnsubscribe,
+  // Ping,
+).annotations({ identifier: 'LSD.MessageToAppHostStore' })
+
+export type MessageToAppHostStore = typeof MessageToAppHostStore.Type
+
+export const MessageFromAppHostCoordinator = Schema.Union(
+  SnapshotRes,
+  LoadDatabaseFileRes,
+  MutationLogRes,
+  ResetAllDataRes,
+  MessagePortForStoreReq,
+  Disconnect,
+  MutationBroadcast,
+  AppHostReady,
+  NetworkStatusRes,
+  RunMutationRes,
+  Pong,
+  DatabaseFileInfoRes,
+  SyncHistoryRes,
+  SyncingInfoRes,
+).annotations({ identifier: 'LSD.MessageFromAppHostCoordinator' })
+
+export type MessageFromAppHostCoordinator = typeof MessageFromAppHostCoordinator.Type
+
+export const MessageFromAppHostStore = Schema.Union(
+  DebugInfoRes,
+  DebugInfoHistoryRes,
+  DebugInfoResetRes,
+  DebugInfoRerunQueryRes,
+  ReactivityGraphRes,
+  LiveQueriesRes,
+  // Pong,
+).annotations({ identifier: 'LSD.MessageFromAppHostStore' })
+
+export type MessageFromAppHostStore = typeof MessageFromAppHostStore.Type

package/src/devtools/devtools-window-message.ts

@@ -0,0 +1,27 @@
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+const appHostId = Schema.String
+
+export namespace DevtoolsWindowMessage {
+  /** Message is being created in contentscript-iframe, sent to contentscript and then sent to Store */
+  export class MessagePortReady extends Schema.TaggedStruct('LSD.WindowMessage.MessagePortReady', {
+    port: Transferable.MessagePort,
+    appHostId,
+  }) {}
+
+  export class ContentscriptListening extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptListening', {}) {}
+
+  // export class ContentscriptReady extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptReady', {
+  // 	appHostId,
+  // }) {}
+
+  export class LoadIframe extends Schema.TaggedStruct('LSD.WindowMessage.LoadIframe', {}) {}
+
+  export class StoreReady extends Schema.TaggedStruct('LSD.WindowMessage.StoreReady', {
+    appHostId,
+  }) {}
+
+  export class MessageForStore extends Schema.Union(MessagePortReady, ContentscriptListening) {}
+
+  export class MessageForContentscript extends Schema.Union(StoreReady, LoadIframe) {}
+}

package/src/devtools/index.ts

@@ -0,0 +1,49 @@
+import type { Effect, Scope } from '@livestore/utils/effect'
+import { Schema, WebChannel } from '@livestore/utils/effect'
+
+export * from './devtools-messages.js'
+export * from './devtools-window-message.js'
+export * from './devtools-bridge.js'
+
+export namespace WebBridge {
+  export class AppHostReady extends Schema.TaggedStruct('LSD.WebBridge.AppHostReady', {
+    appHostId: Schema.String,
+    // storeId: Schema.String,
+    isLeader: Schema.Boolean,
+  }) {}
+
+  export class DevtoolsReady extends Schema.TaggedStruct('LSD.WebBridge.DevtoolsReady', {
+    devtoolsId: Schema.String,
+  }) {}
+
+  export class ConnectToDevtools extends Schema.TaggedStruct('LSD.WebBridge.ConnectToDevtools', {
+    devtoolsId: Schema.String,
+    appHostId: Schema.String,
+    /**
+     * Given the m:n relationship between devtools and app hosts and the fact that appHostIds are usually
+     * sticky, we generate a new unique id for the lifetime of the web bridge.
+     */
+    webBridgeId: Schema.String,
+    isLeader: Schema.Boolean,
+    storeId: Schema.String,
+  }) {}
+
+  export class AppHostWillDisconnect extends Schema.TaggedStruct('LSD.WebBridge.AppHostWillDisconnect', {
+    appHostId: Schema.String,
+  }) {}
+
+  // export class DevtoolsWillDisconnect extends Schema.TaggedStruct('LSD.WebBridge.DevtoolsWillDisconnect', {
+  //   appHostId: Schema.String,
+  // }) {}
+
+  export class All extends Schema.Union(AppHostReady, DevtoolsReady, ConnectToDevtools, AppHostWillDisconnect) {}
+
+  export const makeBroadcastChannel = (
+    key?: string,
+  ): Effect.Effect<WebChannel.WebChannel<typeof All.Type, typeof All.Type>, never, Scope.Scope> =>
+    WebChannel.broadcastChannel({
+      channelName: `livestore-web-bridge-devtools${key ? `-${key}` : ''}`,
+      listenSchema: All,
+      sendSchema: All,
+    })
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+export * from './schema/system-tables.js'
+export * from './util.js'
+export * from './adapter-types.js'
+export * from './schema-management/migrations.js'
+export * from './mutation.js'
+export * from './init-singleton-tables.js'
+export * from './rehydrate-from-mutationlog.js'
+export * from './query-info.js'
+export * from './derived-mutations.js'
+export * from './sync/index.js'
+export * as Devtools from './devtools/index.js'
+export * from './debug-info.js'
+export * from './bounded-collections.js'
+export * from './version.js'
+
+declare global {
+  interface LiveStoreGlobal {
+    // syncBackend: never
+  }
+}

package/src/init-singleton-tables.ts

@@ -0,0 +1,24 @@
+import type { SynchronousDatabase } from './adapter-types.js'
+import type { LiveStoreSchema } from './schema/index.js'
+import { getDefaultValuesEncoded } from './schema/schema-helpers.js'
+import { prepareBindValues, sql } from './util.js'
+
+export const initializeSingletonTables = (schema: LiveStoreSchema, db: SynchronousDatabase) => {
+  for (const [, tableDef] of schema.tables) {
+    if (tableDef.options.isSingleton) {
+      const defaultValues = getDefaultValuesEncoded(tableDef, undefined)
+
+      const defaultColumnNames = [...Object.keys(defaultValues), 'id']
+      const columnValues = defaultColumnNames.map((name) => `$${name}`).join(', ')
+
+      const tableName = tableDef.sqliteDef.name
+      const insertQuery = sql`insert into ${tableName} (${defaultColumnNames.join(
+        ', ',
+      )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = 'singleton')`
+
+      const bindValues = prepareBindValues({ ...defaultValues, id: 'singleton' }, insertQuery)
+
+      db.execute(insertQuery, bindValues)
+    }
+  }
+}

package/src/mutation.ts

@@ -0,0 +1,69 @@
+import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
+
+import type { LiveStoreSchema } from './schema/index.js'
+import type { MutationDef, MutationEvent } from './schema/mutations.js'
+import type { PreparedBindValues } from './util.js'
+import { prepareBindValues } from './util.js'
+
+export const getExecArgsFromMutation = ({
+  mutationDef,
+  mutationEventDecoded,
+}: {
+  mutationDef: MutationDef.Any
+  mutationEventDecoded: MutationEvent.Any
+}): ReadonlyArray<{
+  statementSql: string
+  bindValues: PreparedBindValues
+  writeTables: ReadonlySet<string> | undefined
+}> => {
+  let statementRes: ReadonlyArray<
+    string | { sql: string; bindValues: Record<string, unknown>; writeTables?: ReadonlySet<string> }
+  >
+
+  switch (typeof mutationDef.sql) {
+    case 'function': {
+      const res = mutationDef.sql(mutationEventDecoded.args)
+      statementRes = Array.isArray(res) ? res : [res]
+      break
+    }
+    case 'string': {
+      statementRes = [mutationDef.sql]
+      break
+    }
+    default: {
+      statementRes = mutationDef.sql
+      break
+    }
+  }
+
+  return statementRes.map((statementRes) => {
+    const statementSql = typeof statementRes === 'string' ? statementRes : statementRes.sql
+
+    const bindValues =
+      typeof statementRes === 'string'
+        ? Schema.encodeUnknownSync(mutationDef.schema)(mutationEventDecoded.args)
+        : statementRes.bindValues
+
+    const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
+
+    return { statementSql, bindValues: prepareBindValues(bindValues ?? {}, statementSql), writeTables }
+  })
+}
+
+export const makeShouldExcludeMutationFromLog = memoizeByRef((schema: LiveStoreSchema) => {
+  const migrationOptions = schema.migrationOptions
+  const mutationLogExclude =
+    migrationOptions.strategy === 'from-mutation-log'
+      ? (migrationOptions.excludeMutations ?? new Set(['livestore.RawSql']))
+      : new Set(['livestore.RawSql'])
+
+  return (mutationName: string, mutationEventDecoded: MutationEvent.Any): boolean => {
+    if (mutationLogExclude.has(mutationName)) return true
+
+    const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
+    const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+
+    return execArgsArr.some((_) => _.statementSql.includes('__livestore'))
+  }
+})

package/src/query-info.ts

@@ -0,0 +1,104 @@
+import type { Schema } from '@livestore/utils/effect'
+
+import type { DbSchema } from './schema/index.js'
+
+/**
+ * Semantic information about a query with supported cases being:
+ * - a whole row
+ * - a single column value
+ * - a sub value in a JSON column
+ */
+export type QueryInfo<TTableDef extends DbSchema.TableDef = DbSchema.TableDef> =
+  | QueryInfoNone
+  | QueryInfoRow<TTableDef>
+  | QueryInfoColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
+  | QueryInfoCol<TTableDef, keyof TTableDef['sqliteDef']['columns']>
+
+export type QueryInfoNone = {
+  _tag: 'None'
+}
+
+export type QueryInfoRow<TTableDef extends DbSchema.TableDef> = {
+  _tag: 'Row'
+  table: TTableDef
+  id: string
+}
+
+export type QueryInfoCol<
+  TTableDef extends DbSchema.TableDef,
+  TColName extends keyof TTableDef['sqliteDef']['columns'],
+> = {
+  _tag: 'Col'
+  table: TTableDef
+  id: string
+  column: TColName
+}
+
+export type QueryInfoColJsonValue<TTableDef extends DbSchema.TableDef, TColName extends GetJsonColumn<TTableDef>> = {
+  _tag: 'ColJsonValue'
+  table: TTableDef
+  id: string
+  column: TColName
+  /**
+   * example: `$.tabs[3].items[2]` (`$` referring to the column value)
+   */
+  jsonPath: string
+}
+
+type GetJsonColumn<TTableDef extends DbSchema.TableDef> = keyof {
+  [ColName in keyof TTableDef['sqliteDef']['columns'] as TTableDef['sqliteDef']['columns'][ColName]['columnType'] extends 'text'
+    ? ColName
+    : never]: {}
+}
+
+export type UpdateValueForPath<TQueryInfo extends QueryInfo> = TQueryInfo extends { _tag: 'Row' }
+  ? Partial<DbSchema.FromTable.RowDecodedAll<TQueryInfo['table']>>
+  : TQueryInfo extends { _tag: 'Col' }
+    ? Schema.Schema.Type<TQueryInfo['table']['sqliteDef']['columns'][TQueryInfo['column']]['schema']>
+    : TQueryInfo extends { _tag: 'ColJsonValue' }
+      ? { TODO: true }
+      : never
+
+// export const mutationForQueryInfo = <const TQueryInfo extends QueryInfo>(
+//   queryInfo: TQueryInfo,
+//   value: UpdateValueForPath<TQueryInfo>,
+// ): RawSqlMutationEvent => {
+//   if (queryInfo._tag === 'ColJsonValue' || queryInfo._tag === 'None') {
+//     return notYetImplemented('TODO')
+//   }
+
+//   const sqliteTableDef = queryInfo.table.sqliteDef
+//   const id = queryInfo.id
+
+//   const { columnNames, bindValues } = (() => {
+//     if (queryInfo._tag === 'Row') {
+//       const columnNames = Object.keys(value)
+
+//       const partialStructSchema = queryInfo.table.schema.pipe(Schema.pick(...columnNames))
+
+//       // const columnNames = Object.keys(value)
+//       const encodedBindValues = Schema.encodeEither(partialStructSchema)(value)
+//       if (encodedBindValues._tag === 'Left') {
+//         return shouldNeverHappen(encodedBindValues.left.toString())
+//       } else {
+//         return { columnNames, bindValues: encodedBindValues.right }
+//       }
+//     } else if (queryInfo._tag === 'Col') {
+//       const columnName = queryInfo.column
+//       const columnSchema =
+//         sqliteTableDef.columns[columnName]?.schema ?? shouldNeverHappen(`Column ${columnName} not found`)
+//       const bindValues = { [columnName]: Schema.encodeSync(columnSchema)(value) }
+//       return { columnNames: [columnName], bindValues }
+//     } else {
+//       return shouldNeverHappen()
+//     }
+//   })()
+
+//   const updateClause = columnNames.map((columnName) => `${columnName} = $${columnName}`).join(', ')
+
+//   const whereClause = `where id = '${id}'`
+//   const sql = `UPDATE ${sqliteTableDef.name} SET ${updateClause} ${whereClause}`
+//   const writeTables = new Set<string>([queryInfo.table.sqliteDef.name])
+
+//   return rawSqlMutation({ sql, bindValues, writeTables })
+// }

package/src/rehydrate-from-mutationlog.ts

@@ -0,0 +1,131 @@
+import { 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 { getExecArgsFromMutation } from './mutation.js'
+import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/index.js'
+import { MUTATION_LOG_META_TABLE } from './schema/index.js'
+import type { PreparedBindValues } from './util.js'
+import { sql } from './util.js'
+
+export const rehydrateFromMutationLog = ({
+  logDb,
+  db,
+  schema,
+  migrationOptions,
+  onProgress,
+}: {
+  logDb: SynchronousDatabase
+  db: SynchronousDatabase
+  schema: LiveStoreSchema
+  migrationOptions: MigrationOptionsFromMutationLog
+  onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
+}) =>
+  Effect.gen(function* () {
+    const mutationsCount = logDb.select<{ count: number }>(
+      `SELECT COUNT(*) AS count FROM ${MUTATION_LOG_META_TABLE}`,
+    )[0]!.count
+
+    const hashMutation = memoizeByRef((mutation: MutationDef.Any) => Schema.hash(mutation.schema))
+
+    const processMutation = (row: MutationLogMetaRow) =>
+      Effect.gen(function* () {
+        const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
+
+        if (migrationOptions.excludeMutations?.has(row.mutation) === true) return
+
+        if (hashMutation(mutationDef) !== row.schemaHash) {
+          yield* Effect.logWarning(
+            `Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`,
+          )
+        }
+
+        const argsDecoded = yield* Schema.decodeUnknown(Schema.parseJson(mutationDef.schema))(row.argsJson).pipe(
+          Effect.mapError((cause) =>
+            UnexpectedError.make({
+              cause,
+              note: `\
+There was an error during rehydrating from the mutation log while decoding
+the persisted mutation event args for mutation "${row.mutation}".
+This likely means the schema has changed in an incompatible way.
+`,
+            }),
+          ),
+        )
+
+        const mutationEventDecoded = {
+          id: { global: row.idGlobal, local: row.idLocal },
+          parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
+          mutation: row.mutation,
+          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,
+            import.meta.env.DEV ? makeExecuteOptions(statementSql, bindValues) : undefined,
+          )
+          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
+        }
+      }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
+
+    const CHUNK_SIZE = 100
+
+    const stmt = logDb.prepare(sql`\
+SELECT * FROM ${MUTATION_LOG_META_TABLE} 
+WHERE idGlobal > COALESCE($idGlobal, '') AND idLocal > COALESCE($idLocal, '')
+ORDER BY idGlobal ASC, idLocal ASC
+LIMIT ${CHUNK_SIZE}
+`)
+
+    let processedMutations = 0
+
+    yield* Stream.unfoldChunk<Chunk.Chunk<MutationLogMetaRow> | { _tag: 'Initial ' }, MutationLogMetaRow>(
+      { _tag: 'Initial ' },
+      (item) => {
+        // End stream if no more rows
+        if (Chunk.isChunk(item) && item.length === 0) return Option.none()
+
+        const lastId = Chunk.isChunk(item)
+          ? Chunk.last(item).pipe(
+              Option.map((_) => ({ global: _.idGlobal, local: _.idLocal })),
+              Option.getOrUndefined,
+            )
+          : undefined
+        const nextItem = Chunk.fromIterable(
+          stmt.select<MutationLogMetaRow>({
+            $idGlobal: lastId?.global,
+            $idLocal: lastId?.local,
+          } as any as PreparedBindValues),
+        )
+        const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()
+        return Option.some([prevItem, nextItem])
+      },
+    ).pipe(
+      Stream.bufferChunks({ capacity: 2 }),
+      Stream.tap((row) =>
+        Effect.gen(function* () {
+          yield* processMutation(row)
+
+          processedMutations++
+          yield* onProgress({ done: processedMutations, total: mutationsCount })
+        }),
+      ),
+      Stream.runDrain,
+    )
+  }).pipe(
+    Effect.withPerformanceMeasure('@livestore/common:rehydrateFromMutationLog'),
+    Effect.withSpan('@livestore/common:rehydrateFromMutationLog'),
+  )