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

package/src/leader-thread/mutationlog.ts

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

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

@@ -12,54 +12,56 @@ export const recreateDb: Effect.Effect<
   UnexpectedError | SqliteError | IsOfflineError | InvalidPullError,
   LeaderThreadCtx | HttpClient.HttpClient
 > = Effect.gen(function* () {
-  const { db, dbLog, makeSyncDb, schema, bootStatusQueue } = yield* LeaderThreadCtx
+  const { dbReadModel, dbMutationLog, schema, bootStatusQueue } = yield* LeaderThreadCtx
 
   const migrationOptions = schema.migrationOptions
 
   yield* Effect.addFinalizer(
     Effect.fn('recreateDb:finalizer')(function* (ex) {
-      if (ex._tag === 'Failure') db.destroy()
+      if (ex._tag === 'Failure') dbReadModel.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
-  const tmpSyncDb = yield* makeSyncDb({ _tag: 'in-memory' })
-  yield* configureConnection(tmpSyncDb, { fkEnabled: true })
+  // TODO bring back this optimization
+  // const tmpDb = yield* makeSqliteDb({ _tag: 'in-memory' })
+  const tmpDb = dbReadModel
+  yield* configureConnection(tmpDb, { fkEnabled: 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,
+        db: tmpDb,
         schema,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
       })
 
-      initializeSingletonTables(schema, tmpSyncDb)
+      initializeSingletonTables(schema, tmpDb)
 
-      yield* Effect.tryAll(() => hooks?.pre?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
-      return tmpSyncDb
+      return tmpDb
     })
 
   switch (migrationOptions.strategy) {
     case 'from-mutation-log': {
       const hooks = migrationOptions.hooks
-      const tmpSyncDb = yield* initDb(hooks)
+      const tmpDb = yield* initDb(hooks)
 
       yield* rehydrateFromMutationLog({
-        db: tmpSyncDb,
-        logDb: dbLog,
+        db: tmpDb,
+        logDb: dbMutationLog,
         schema,
         migrationOptions,
         onProgress: ({ done, total }) =>
           Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
       })
 
-      yield* Effect.tryAll(() => hooks?.post?.(tmpSyncDb)).pipe(UnexpectedError.mapToUnexpectedError)
+      yield* Effect.tryAll(() => hooks?.post?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
 
       break
     }
@@ -74,13 +76,13 @@ export const recreateDb: Effect.Effect<
       break
     }
     case 'manual': {
-      const oldDbData = db.export()
+      const oldDbData = dbReadModel.export()
 
       const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
         UnexpectedError.mapToUnexpectedError,
       )
 
-      tmpSyncDb.import(newDbData)
+      tmpDb.import(newDbData)
 
       // TODO validate schema
 
@@ -91,17 +93,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(
-    Effect.withSpan('@livestore/common:leader-thread:recreateDb:import'),
-  )
+  // 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()
 
-  tmpSyncDb.close()
+  // TODO bring back
+  // tmpDb.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,6 +6,7 @@ import type {
   Option,
   Queue,
   Scope,
+  Subscribable,
   SubscriptionRef,
   WebChannel,
 } from '@livestore/utils/effect'
@@ -15,14 +16,14 @@ import type {
   BootStatus,
   Devtools,
   InvalidPushError,
-  MakeSynchronousDatabase,
+  MakeSqliteDb,
   PersistenceInfo,
+  SqliteDb,
   SyncBackend,
-  SynchronousDatabase,
   UnexpectedError,
 } from '../index.js'
 import type { EventId, LiveStoreSchema, MutationEvent } from '../schema/mod.js'
-import type { PayloadUpstream, SyncState } from '../sync/syncstate.js'
+import type * as SyncState from '../sync/syncstate.js'
 import type { ShutdownChannel } from './shutdown-channel.js'
 
 export type ShutdownState = 'running' | 'shutting-down'
@@ -55,8 +56,8 @@ export type InitialSyncInfo = Option.Option<{
 //   | { _tag: 'Recreate'; snapshotRef: Ref.Ref<Uint8Array | undefined>; syncInfo: InitialSyncInfo }
 //   | { _tag: 'Reuse'; syncInfo: InitialSyncInfo }
 
-export type LeaderDatabase = SynchronousDatabase<{ dbPointer: number; persistenceInfo: PersistenceInfo }>
-export type PersistenceInfoPair = { db: PersistenceInfo; mutationLog: PersistenceInfo }
+export type LeaderSqliteDb = SqliteDb<{ dbPointer: number; persistenceInfo: PersistenceInfo }>
+export type PersistenceInfoPair = { readModel: PersistenceInfo; mutationLog: PersistenceInfo }
 
 export type DevtoolsOptions =
   | {
@@ -64,10 +65,9 @@ export type DevtoolsOptions =
     }
   | {
       enabled: true
-      makeContext: Effect.Effect<
+      makeBootContext: Effect.Effect<
         {
           devtoolsWebChannel: WebChannel.WebChannel<Devtools.MessageToAppLeader, Devtools.MessageFromAppLeader>
-          shutdownChannel: ShutdownChannel
           persistenceInfo: PersistenceInfoPair
         },
         UnexpectedError,
@@ -75,23 +75,40 @@ export type DevtoolsOptions =
       >
     }
 
+export type DevtoolsContext =
+  | {
+      enabled: true
+      syncBackendPullLatch: Effect.Latch
+      syncBackendPushLatch: Effect.Latch
+    }
+  | {
+      enabled: false
+    }
+
 export class LeaderThreadCtx extends Context.Tag('LeaderThreadCtx')<
   LeaderThreadCtx,
   {
     schema: LiveStoreSchema
     storeId: string
-    originId: string
-    makeSyncDb: MakeSynchronousDatabase
-    db: LeaderDatabase
-    dbLog: LeaderDatabase
+    clientId: string
+    makeSqliteDb: MakeSqliteDb
+    dbReadModel: LeaderSqliteDb
+    dbMutationLog: LeaderSqliteDb
     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
+    devtools: DevtoolsContext
     syncBackend: SyncBackend | undefined
-    syncProcessor: SyncProcessor
+    syncProcessor: LeaderSyncProcessor
     connectedClientSessionPullQueues: PullQueueSet
+    /**
+     * e.g. used for `store._dev` APIs
+     *
+     * This is currently separated from `.devtools` as it also needs to work when devtools are disabled
+     */
+    extraIncomingMessagesQueue: Queue.Queue<Devtools.MessageToAppLeader>
   }
 >() {}
 
@@ -101,24 +118,28 @@ export type InitialBlockingSyncContext = {
 }
 
 export type PullQueueItem = {
-  // mutationEvents: ReadonlyArray<MutationEvent.AnyEncoded>
-  // backendHead: number
-  payload: PayloadUpstream
-  // TODO move `remaining` into `PayloadUpstream`
+  payload: SyncState.PayloadUpstream
   remaining: number
 }
 
-export interface SyncProcessor {
+export interface LeaderSyncProcessor {
   push: (
     /** `batch` needs to follow the same rules as `batch` in `SyncBackend.push` */
     batch: ReadonlyArray<MutationEvent.EncodedWithMeta>,
-  ) => Effect.Effect<void, UnexpectedError | InvalidPushError, HttpClient.HttpClient | LeaderThreadCtx>
+    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>
 
   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: Effect.Effect<SyncState, UnexpectedError>
+  syncState: Subscribable.Subscribable<SyncState.SyncState>
 }
 
 export interface PullQueueSet {

package/src/mutation.ts

@@ -8,10 +8,19 @@ import { prepareBindValues } from './util.js'
 
 export const getExecArgsFromMutation = ({
   mutationDef,
-  mutationEventDecoded,
+  mutationEvent,
 }: {
   mutationDef: MutationDef.Any
-  mutationEventDecoded: MutationEvent.Any | MutationEvent.PartialAny
+  /** 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
+      }
 }): ReadonlyArray<{
   statementSql: string
   bindValues: PreparedBindValues
@@ -23,7 +32,9 @@ export const getExecArgsFromMutation = ({
 
   switch (typeof mutationDef.sql) {
     case 'function': {
-      const res = mutationDef.sql(mutationEventDecoded.args)
+      const mutationArgsDecoded =
+        mutationEvent.decoded?.args ?? Schema.decodeUnknownSync(mutationDef.schema)(mutationEvent.encoded!.args)
+      const res = mutationDef.sql(mutationArgsDecoded)
       statementRes = Array.isArray(res) ? res : [res]
       break
     }
@@ -40,10 +51,9 @@ export const getExecArgsFromMutation = ({
   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 mutationArgsEncoded =
+      mutationEvent.encoded?.args ?? Schema.encodeUnknownSync(mutationDef.schema)(mutationEvent.decoded!.args)
+    const bindValues = typeof statementRes === 'string' ? mutationArgsEncoded : statementRes.bindValues
 
     const writeTables = typeof statementRes === 'string' ? undefined : statementRes.writeTables
 

package/src/rehydrate-from-mutationlog.ts

@@ -1,8 +1,8 @@
-import { isDevEnv, memoizeByRef, shouldNeverHappen } from '@livestore/utils'
+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 MigrationOptionsFromMutationLog, type SqliteDb, UnexpectedError } from './adapter-types.js'
+import { makeApplyMutation } from './leader-thread/apply-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,13 +10,14 @@ import { sql } from './util.js'
 
 export const rehydrateFromMutationLog = ({
   logDb,
-  db,
+  // TODO re-use this db when bringing back the boot in-memory db implementation
+  // db,
   schema,
   migrationOptions,
   onProgress,
 }: {
-  logDb: SynchronousDatabase
-  db: SynchronousDatabase
+  logDb: SqliteDb
+  db: SqliteDb
   schema: LiveStoreSchema
   migrationOptions: MigrationOptionsFromMutationLog
   onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
@@ -28,6 +29,8 @@ 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}`)
@@ -40,7 +43,10 @@ export const rehydrateFromMutationLog = ({
           )
         }
 
-        const argsDecoded = yield* Schema.decodeUnknown(Schema.parseJson(mutationDef.schema))(row.argsJson).pipe(
+        const args = JSON.parse(row.argsJson)
+
+        // Checking whether the schema has changed in an incompatible way
+        yield* Schema.decodeUnknown(mutationDef.schema)(args).pipe(
           Effect.mapError((cause) =>
             UnexpectedError.make({
               cause,
@@ -53,28 +59,14 @@ This likely means the schema has changed in an incompatible way.
           ),
         )
 
-        const mutationEventDecoded = {
+        const mutationEventEncoded = {
           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, isDevEnv() ? makeExecuteOptions(statementSql, bindValues) : undefined)
-          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
-        }
+          args,
+        } satisfies MutationEvent.AnyEncoded
+
+        yield* applyMutation(mutationEventEncoded, { skipMutationLog: true })
       }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
 
     const CHUNK_SIZE = 100

package/src/schema/EventId.test.ts

@@ -0,0 +1,12 @@
+import { Vitest } from '@livestore/utils/node-vitest'
+import { expect } from 'vitest'
+
+import { EventId } from './mod.js'
+
+Vitest.describe('EventId', () => {
+  Vitest.test('nextPair', () => {
+    const e_0_0 = EventId.make({ global: 0, local: 0 })
+    expect(EventId.nextPair(e_0_0, false).id).toStrictEqual({ global: 1, local: 0 })
+    expect(EventId.nextPair(e_0_0, true).id).toStrictEqual({ global: 0, local: 1 })
+  })
+})

package/src/schema/EventId.ts

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

package/src/schema/MutationEvent.ts

@@ -1,5 +1,4 @@
 import { memoizeByRef } from '@livestore/utils'
-import type { Deferred } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
 import * as EventId from './EventId.js'
@@ -30,10 +29,31 @@ export type MutationEventEncoded<TMutationsDef extends MutationDef.Any> = {
   parentId: EventId.EventId
 }
 
-export type Any = MutationEvent<MutationDef.Any>
+export type AnyDecoded = MutationEvent<MutationDef.Any>
+export const AnyDecoded = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: EventId.EventId,
+  parentId: EventId.EventId,
+}).annotations({ title: 'MutationEvent.AnyDecoded' })
+
 export type AnyEncoded = MutationEventEncoded<MutationDef.Any>
+export const AnyEncoded = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: EventId.EventId,
+  parentId: EventId.EventId,
+}).annotations({ title: 'MutationEvent.AnyEncoded' })
+
+export const AnyEncodedGlobal = Schema.Struct({
+  mutation: Schema.String,
+  args: Schema.Any,
+  id: EventId.GlobalEventId,
+  parentId: EventId.GlobalEventId,
+}).annotations({ title: 'MutationEvent.AnyEncodedGlobal' })
+export type AnyEncodedGlobal = typeof AnyEncodedGlobal.Type
 
-export type PartialAny = MutationEventPartial<MutationDef.Any>
+export type PartialAnyDecoded = MutationEventPartial<MutationDef.Any>
 export type PartialAnyEncoded = MutationEventPartialEncoded<MutationDef.Any>
 
 export type PartialForSchema<TSchema extends LiveStoreSchema> = {
@@ -44,8 +64,9 @@ export type ForSchema<TSchema extends LiveStoreSchema> = {
   [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
 }[keyof TSchema['_MutationDefMapType']]
 
-export const isPartialMutationEvent = (mutationEvent: Any | PartialAny): mutationEvent is PartialAny =>
-  'id' in mutationEvent === false && 'parentId' in mutationEvent === false
+export const isPartialMutationEvent = (
+  mutationEvent: AnyDecoded | PartialAnyDecoded,
+): mutationEvent is PartialAnyDecoded => 'id' in mutationEvent === false && 'parentId' in mutationEvent === false
 
 export type ForMutationDefRecord<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
   {
@@ -105,33 +126,21 @@ export const makeMutationEventPartialSchema = <TSchema extends LiveStoreSchema>(
         args: def.schema,
       }),
     ),
-  ).annotations({ title: 'MutationEventSchemaPartial' }) as any
+  ).annotations({ title: 'MutationEventPartial' }) as any
 
 export const makeMutationEventSchemaMemo = memoizeByRef(makeMutationEventSchema)
 
-export const Any = Schema.Struct({
-  mutation: Schema.String,
-  args: Schema.Any,
-  id: EventId.EventId,
-  parentId: EventId.EventId,
-}).annotations({ title: 'MutationEvent.Any' })
-
-export const DecodedAny = Schema.typeSchema(Any).annotations({
-  title: 'MutationEvent.DecodedAny',
-})
-
-export const EncodedAny = Schema.encodedSchema(Any).annotations({
-  title: 'MutationEvent.EncodedAny',
-})
-
-/** Equivalent to EncodedAny but with a meta field and some convenience methods */
+/** Equivalent to AnyEncoded but with a meta field and some convenience methods */
 export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEvent.EncodedWithMeta')({
   mutation: Schema.String,
   args: Schema.Any,
   id: EventId.EventId,
   parentId: EventId.EventId,
+  // TODO get rid of `meta` again by cleaning up the usage implementations
   meta: Schema.optionalWith(
-    Schema.Any as Schema.Schema<{ deferred?: Deferred.Deferred<void>; sessionChangeset?: Uint8Array }>,
+    Schema.Any as Schema.Schema<{
+      sessionChangeset?: Uint8Array
+    }>,
     { default: () => ({}) },
   ),
 }) {
@@ -149,8 +158,21 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('MutationEven
   rebase = (parentId: EventId.EventId, isLocal: boolean) =>
     new EncodedWithMeta({
       ...this,
-      ...EventId.nextPair(this.id, isLocal),
+      ...EventId.nextPair(parentId, isLocal),
     })
+
+  static fromGlobal = (mutationEvent: AnyEncodedGlobal) =>
+    new EncodedWithMeta({
+      ...mutationEvent,
+      id: { global: mutationEvent.id, local: EventId.localDefault },
+      parentId: { global: mutationEvent.parentId, local: EventId.localDefault },
+    })
+
+  toGlobal = (): AnyEncodedGlobal => ({
+    ...this,
+    id: this.id.global,
+    parentId: this.parentId.global,
+  })
 }
 
 export const isEqualEncoded = (a: AnyEncoded, b: AnyEncoded) =>

package/src/schema/system-tables.ts

@@ -1,6 +1,7 @@
 import { type SqliteAst as __SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { Schema } from '@livestore/utils/effect'
 
+import * as EventId from './EventId.js'
 import type { FromTable } from './table-def.js'
 import { table } from './table-def.js'
 
@@ -46,14 +47,15 @@ export const sessionChangesetMetaTable = table(
   SESSION_CHANGESET_META_TABLE,
   {
     // TODO bring back primary key
-    idGlobal: SqliteDsl.integer({}),
-    idLocal: SqliteDsl.integer({}),
-    // idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    // idLocal: SqliteDsl.integer({ primaryKey: true }),
-    changeset: SqliteDsl.blob({}),
+    idGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
+    idLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
+    changeset: SqliteDsl.blob({ nullable: true }),
     debug: SqliteDsl.json({ nullable: true }),
   },
-  { disableAutomaticIdColumn: true },
+  {
+    disableAutomaticIdColumn: true,
+    indexes: [{ columns: ['idGlobal', 'idLocal'], name: 'idx_session_changeset_id' }],
+  },
 )
 
 export type SessionChangesetMetaRow = FromTable.RowDecoded<typeof sessionChangesetMetaTable>
@@ -70,16 +72,22 @@ export const MUTATION_LOG_META_TABLE = 'mutation_log'
 export const mutationLogMetaTable = table(
   MUTATION_LOG_META_TABLE,
   {
-    idGlobal: SqliteDsl.integer({ primaryKey: true }),
-    idLocal: SqliteDsl.integer({ primaryKey: true }),
-    parentIdGlobal: SqliteDsl.integer({}),
-    parentIdLocal: SqliteDsl.integer({}),
+    idGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventId.GlobalEventId }),
+    idLocal: SqliteDsl.integer({ primaryKey: true, schema: EventId.LocalEventId }),
+    parentIdGlobal: SqliteDsl.integer({ schema: EventId.GlobalEventId }),
+    parentIdLocal: SqliteDsl.integer({ schema: EventId.LocalEventId }),
     mutation: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
     schemaHash: SqliteDsl.integer({}),
     syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
   },
-  { disableAutomaticIdColumn: true, indexes: [] },
+  {
+    disableAutomaticIdColumn: true,
+    indexes: [
+      { columns: ['idGlobal'], name: 'idx_idGlobal' },
+      { columns: ['idGlobal', 'idLocal'], name: 'idx_mutationlog_id' },
+    ],
+  },
 )
 
 export type MutationLogMetaRow = FromTable.RowDecoded<typeof mutationLogMetaTable>