@livestore/common 0.0.54-dev.22 → 0.0.54-dev.23

package/src/devtools/devtools-messages.ts

@@ -1,11 +1,10 @@
-import { version as pkgVersion } from '@livestore/common/package.json'
-import { Schema } from '@livestore/utils/effect'
-import { type SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+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 channelId = Schema.String
@@ -20,20 +19,21 @@ export class SnapshotReq extends Schema.TaggedStruct('LSD.SnapshotReq', {
 export class SnapshotRes extends Schema.TaggedStruct('LSD.SnapshotRes', {
   liveStoreVersion,
   requestId,
-  snapshot: Schema.Uint8Array,
+  snapshot: Transferable.Uint8Array,
 }).annotations({ identifier: 'LSD.SnapshotRes' }) {}
 
-export class LoadSnapshotReq extends Schema.TaggedStruct('LSD.LoadSnapshotReq', {
+export class LoadDatabaseFileReq extends Schema.TaggedStruct('LSD.LoadDatabaseFileReq', {
   liveStoreVersion,
   requestId,
   channelId,
-  snapshot: Schema.Uint8Array,
-}).annotations({ identifier: 'LSD.LoadSnapshotReq' }) {}
+  data: Transferable.Uint8Array,
+}).annotations({ identifier: 'LSD.LoadDatabaseFileReq' }) {}
 
-export class LoadSnapshotRes extends Schema.TaggedStruct('LSD.LoadSnapshotRes', {
+export class LoadDatabaseFileRes extends Schema.TaggedStruct('LSD.LoadDatabaseFileRes', {
   liveStoreVersion,
   requestId,
-}).annotations({ identifier: 'LSD.LoadSnapshotRes' }) {}
+  status: Schema.Literal('ok', 'unsupported-file', 'unsupported-database'),
+}).annotations({ identifier: 'LSD.LoadDatabaseFileRes' }) {}
 
 export class DebugInfoReq extends Schema.TaggedStruct('LSD.DebugInfoReq', {
   liveStoreVersion,
@@ -102,21 +102,9 @@ export class MutationLogRes extends Schema.TaggedStruct('LSD.MutationLogRes', {
   liveStoreVersion,
   requestId,
   channelId,
-  mutationLog: Schema.Uint8Array,
+  mutationLog: Transferable.Uint8Array,
 }).annotations({ identifier: 'LSD.MutationLogRes' }) {}
 
-export class LoadMutationLogReq extends Schema.TaggedStruct('LSD.LoadMutationLogReq', {
-  liveStoreVersion,
-  requestId,
-  channelId,
-  mutationLog: Schema.Uint8Array,
-}).annotations({ identifier: 'LSD.LoadMutationLogReq' }) {}
-
-export class LoadMutationLogRes extends Schema.TaggedStruct('LSD.LoadMutationLogRes', {
-  liveStoreVersion,
-  requestId,
-}).annotations({ identifier: 'LSD.LoadMutationLogRes' }) {}
-
 export class ReactivityGraphSubscribe extends Schema.TaggedStruct('LSD.ReactivityGraphSubscribe', {
   liveStoreVersion,
   requestId,
@@ -178,6 +166,19 @@ export class ResetAllDataRes extends Schema.TaggedStruct('LSD.ResetAllDataRes',
   requestId,
 }).annotations({ identifier: 'LSD.ResetAllDataRes' }) {}
 
+export class MessagePortForStoreReq extends Schema.TaggedStruct('LSD.MessagePortForStoreReq', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+}).annotations({ identifier: 'LSD.MessagePortForStoreReq' }) {}
+
+export class MessagePortForStoreRes extends Schema.TaggedStruct('LSD.MessagePortForStoreRes', {
+  liveStoreVersion,
+  requestId,
+  channelId,
+  port: Transferable.MessagePort,
+}).annotations({ identifier: 'LSD.MessagePortForStoreRes' }) {}
+
 export class NetworkStatusChanged extends Schema.TaggedStruct('LSD.NetworkStatusChanged', {
   liveStoreVersion,
   channelId,
@@ -215,11 +216,22 @@ export class Pong extends Schema.TaggedStruct('LSD.Pong', {
   requestId,
 }).annotations({ identifier: 'LSD.Pong' }) {}
 
-export const MessageToAppHost = Schema.Union(
+export const MessageToAppHostCoordinator = Schema.Union(
   SnapshotReq,
-  LoadSnapshotReq,
+  LoadDatabaseFileReq,
   MutationLogReq,
-  LoadMutationLogReq,
+  ResetAllDataReq,
+  MessagePortForStoreRes,
+  DevtoolsReady,
+  Disconnect,
+  DevtoolsConnected,
+  RunMutationReq,
+  Ping,
+).annotations({ identifier: 'LSD.MessageToAppHostCoordinator' })
+
+export type MessageToAppHostCoordinator = typeof MessageToAppHostCoordinator.Type
+
+export const MessageToAppHostStore = Schema.Union(
   DebugInfoReq,
   DebugInfoResetReq,
   DebugInfoRerunQueryReq,
@@ -227,39 +239,34 @@ export const MessageToAppHost = Schema.Union(
   ReactivityGraphUnsubscribe,
   LiveQueriesSubscribe,
   LiveQueriesUnsubscribe,
-  ResetAllDataReq,
-  DevtoolsReady,
-  Disconnect,
-  DevtoolsConnected,
-  RunMutationReq,
-  Ping,
-).annotations({ identifier: 'LSD.MessageToAppHost' })
+  // Ping,
+).annotations({ identifier: 'LSD.MessageToAppHostStore' })
 
-export type MessageToAppHost = typeof MessageToAppHost.Type
+export type MessageToAppHostStore = typeof MessageToAppHostStore.Type
 
-export const MessageFromAppHost = Schema.Union(
+export const MessageFromAppHostCoordinator = Schema.Union(
   SnapshotRes,
-  LoadSnapshotRes,
+  LoadDatabaseFileRes,
   MutationLogRes,
-  LoadMutationLogRes,
-  DebugInfoRes,
-  DebugInfoResetRes,
-  DebugInfoRerunQueryRes,
-  ReactivityGraphRes,
-  LiveQueriesRes,
   ResetAllDataRes,
+  MessagePortForStoreReq,
   Disconnect,
   MutationBroadcast,
   AppHostReady,
   NetworkStatusChanged,
   RunMutationRes,
   Pong,
-).annotations({ identifier: 'LSD.MessageFromAppHost' })
+).annotations({ identifier: 'LSD.MessageFromAppHostCoordinator' })
+
+export type MessageFromAppHostCoordinator = typeof MessageFromAppHostCoordinator.Type
 
-export type MessageFromAppHost = typeof MessageFromAppHost.Type
+export const MessageFromAppHostStore = Schema.Union(
+  DebugInfoRes,
+  DebugInfoResetRes,
+  DebugInfoRerunQueryRes,
+  ReactivityGraphRes,
+  LiveQueriesRes,
+  // Pong,
+).annotations({ identifier: 'LSD.MessageFromAppHostStore' })
 
-// TODO make specific over app key
-export const makeBroadcastChannels = () => ({
-  fromAppHost: new BroadcastChannel(`livestore-devtools-from-app-host`),
-  toAppHost: new BroadcastChannel(`livestore-devtools-to-app-host`),
-})
+export type MessageFromAppHostStore = typeof MessageFromAppHostStore.Type

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

@@ -0,0 +1,25 @@
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+const channelId = 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.MessagePortForStore', {
+    port: Transferable.MessagePort,
+    channelId,
+  }) {}
+
+  export class ContentscriptListening extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptListening', {}) {}
+
+  // export class ContentscriptReady extends Schema.TaggedStruct('LSD.WindowMessage.ContentscriptReady', {
+  // 	channelId,
+  // }) {}
+
+  export class StoreReady extends Schema.TaggedStruct('LSD.WindowMessage.StoreReady', {
+    channelId,
+  }) {}
+
+  export class MessageForStore extends Schema.Union(MessagePortReady, ContentscriptListening) {}
+
+  export class MessageForContentscript extends Schema.Union(StoreReady) {}
+}

package/src/devtools/index.ts

@@ -1 +1,2 @@
 export * from './devtools-messages.js'
+export * from './devtools-window-message.js'

package/src/index.ts

@@ -11,3 +11,4 @@ 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'

package/src/rehydrate-from-mutationlog.ts

@@ -1,91 +1,127 @@
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
+import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
-import type { InMemoryDatabase, MigrationOptionsFromMutationLog } from './adapter-types.js'
+import { type InMemoryDatabase, type MigrationOptionsFromMutationLog, SqliteError } from './adapter-types.js'
 import { getExecArgsFromMutation } from './mutation.js'
 import type { LiveStoreSchema, 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 = async ({
+export const rehydrateFromMutationLog = ({
   logDb,
   db,
   schema,
   migrationOptions,
+  onProgress,
 }: {
   logDb: InMemoryDatabase
   db: InMemoryDatabase
   schema: LiveStoreSchema
   migrationOptions: MigrationOptionsFromMutationLog
-}) => {
-  try {
-    // TODO possibly implement this in a streaming fashion
-    const stmt = logDb.prepare(`SELECT * FROM ${MUTATION_LOG_META_TABLE} ORDER BY id ASC`)
-    const results = stmt.select<MutationLogMetaRow>(undefined)
+  onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
+}) =>
+  Effect.gen(function* () {
+    const mutationsCount = logDb
+      .prepare(`SELECT COUNT(*) AS count FROM ${MUTATION_LOG_META_TABLE}`)
+      .select<{ count: number }>(undefined)[0]!.count
 
-    performance.mark('livestore:hydrate-from-mutationlog:start')
+    const processMutation = (row: MutationLogMetaRow) =>
+      Effect.gen(function* () {
+        const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
 
-    for (const row of results) {
-      const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
+        if (migrationOptions.excludeMutations?.has(row.mutation) === true) return
 
-      if (migrationOptions.excludeMutations?.has(row.mutation) === true) continue
-
-      if (Schema.hash(mutationDef.schema) !== row.schemaHash) {
-        console.warn(`Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`)
-      }
+        if (Schema.hash(mutationDef.schema) !== row.schemaHash) {
+          console.warn(`Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`)
+        }
 
-      const argsDecodedEither = Schema.decodeUnknownEither(Schema.parseJson(mutationDef.schema))(row.argsJson)
-      if (argsDecodedEither._tag === 'Left') {
-        return shouldNeverHappen(`\
+        const argsDecodedEither = Schema.decodeUnknownEither(Schema.parseJson(mutationDef.schema))(row.argsJson)
+        if (argsDecodedEither._tag === 'Left') {
+          return shouldNeverHappen(`\
 There was an error decoding the persisted mutation event args for mutation "${row.mutation}".
 This likely means the schema has changed in an incompatible way.
 
 Error: ${argsDecodedEither.left}
         `)
-      }
-
-      const mutationEventDecoded = {
-        id: row.id,
-        mutation: row.mutation,
-        args: argsDecodedEither.right,
-      }
-      // const argsEncoded = JSON.parse(row.args_json)
-      // const mutationSqlRes =
-      //   typeof mutation.sql === 'string'
-      //     ? mutation.sql
-      //     : mutation.sql(Schema.decodeUnknownSync(mutation.schema)(argsEncoded))
-      // const mutationSql = typeof mutationSqlRes === 'string' ? mutationSqlRes : mutationSqlRes.sql
-      // const bindValues = typeof mutationSqlRes === 'string' ? argsEncoded : mutationSqlRes.bindValues
-
-      const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-      for (const { statementSql, bindValues } of execArgsArr) {
-        try {
-          const getRowsChanged = db.execute(statementSql, bindValues)
-          if (
-            import.meta.env.DEV &&
-            getRowsChanged() === 0 &&
-            migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true
-          ) {
-            console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
+        }
+
+        const mutationEventDecoded = {
+          id: row.id,
+          mutation: row.mutation,
+          args: argsDecodedEither.right,
+        }
+        // const argsEncoded = JSON.parse(row.args_json)
+        // const mutationSqlRes =
+        //   typeof mutation.sql === 'string'
+        //     ? mutation.sql
+        //     : mutation.sql(Schema.decodeUnknownSync(mutation.schema)(argsEncoded))
+        // const mutationSql = typeof mutationSqlRes === 'string' ? mutationSqlRes : mutationSqlRes.sql
+        // const bindValues = typeof mutationSqlRes === 'string' ? argsEncoded : mutationSqlRes.bindValues
+
+        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+
+        for (const { statementSql, bindValues } of execArgsArr) {
+          try {
+            // TODO cache prepared statements for mutations
+            const getRowsChanged = db.execute(statementSql, bindValues)
+            if (
+              import.meta.env.DEV &&
+              getRowsChanged() === 0 &&
+              migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true
+            ) {
+              console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
+            }
+            // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
+          } catch (e) {
+            yield* new SqliteError({
+              sql: statementSql,
+              bindValues,
+              code: (e as any).resultCode,
+              cause: e,
+            })
           }
-          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
-        } catch (e) {
-          console.error(`Error executing migration for mutation ${statementSql}`, bindValues, e)
-          debugger
-          throw e
         }
-      }
-    }
-  } catch (e) {
-    console.error('Error while rehydrating database from mutation log', e)
-    debugger
-    throw e
-  } finally {
-    performance.mark('livestore:hydrate-from-mutationlog:end')
-    performance.measure(
-      'livestore:hydrate-from-mutationlog',
-      'livestore:hydrate-from-mutationlog:start',
-      'livestore:hydrate-from-mutationlog:end',
+      }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
+
+    const CHUNK_SIZE = 100
+
+    const stmt = logDb.prepare(sql`\
+SELECT * FROM ${MUTATION_LOG_META_TABLE} 
+WHERE id > COALESCE($id, '') 
+ORDER BY id 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.getOrUndefined)?.id : undefined
+        const nextItem = Chunk.fromIterable(
+          stmt.select<MutationLogMetaRow>({ $id: lastId } 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'),
+  )

package/src/schema/table-def.ts

@@ -86,8 +86,6 @@ export type TableOptions = {
    * @default false
    */
   isSingleton: boolean
-  // TODO remove
-  dynamicRegistration: boolean
   disableAutomaticIdColumn: boolean
   /**
    * Setting this to true will automatically derive insert, update and delete mutations for this table. Example:
@@ -139,7 +137,6 @@ export const table = <
 
   const options_: TableOptions = {
     isSingleton: options?.isSingleton ?? false,
-    dynamicRegistration: options?.dynamicRegistration ?? false,
     disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
     deriveMutations:
       options?.deriveMutations === true
@@ -239,7 +236,6 @@ type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> =
 
 type WithDefaults<TOptionsInput extends TableOptionsInput, TIsSingleColumn extends boolean> = {
   isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
-  dynamicRegistration: TOptionsInput['dynamicRegistration'] extends true ? true : false
   disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
   deriveMutations: TOptionsInput['deriveMutations'] extends true
     ? { enabled: true; localOnly: boolean }

package/src/schema-management/migrations.ts

@@ -1,5 +1,5 @@
 import { memoizeByStringifyArgs } from '@livestore/utils'
-import { Schema as EffectSchema } from '@livestore/utils/effect'
+import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
@@ -20,85 +20,104 @@ import { validateSchema } from './validate-mutation-defs.js'
 
 const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
 
-export const makeSchemaManager = (db: InMemoryDatabase): SchemaManager => {
-  migrateTable({
-    db,
-    otelContext: otel.context.active(),
-    tableAst: schemaMutationsMetaTable.sqliteDef.ast,
-    behaviour: 'create-if-not-exists',
+export const makeSchemaManager = (db: InMemoryDatabase): Effect.Effect<SchemaManager> =>
+  Effect.gen(function* () {
+    yield* migrateTable({
+      db,
+      otelContext: otel.context.active(),
+      tableAst: schemaMutationsMetaTable.sqliteDef.ast,
+      behaviour: 'create-if-not-exists',
+    })
+
+    return {
+      getMutationDefInfos: () => {
+        const schemaMutationsMetaRows = dbSelect<SchemaMutationsMetaRow>(
+          db,
+          sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`,
+        )
+
+        return schemaMutationsMetaRows
+      },
+      setMutationDefInfo: (info) => {
+        dbExecute(
+          db,
+          sql`INSERT OR REPLACE INTO ${SCHEMA_MUTATIONS_META_TABLE} (mutationName, schemaHash, updatedAt) VALUES ($mutationName, $schemaHash, $updatedAt)`,
+          {
+            mutationName: info.mutationName,
+            schemaHash: info.schemaHash,
+            updatedAt: new Date().toISOString(),
+          },
+        )
+      },
+    }
   })
 
-  return {
-    getMutationDefInfos: () => {
-      const schemaMutationsMetaRows = dbSelect<SchemaMutationsMetaRow>(
-        db,
-        sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`,
-      )
-
-      return schemaMutationsMetaRows
-    },
-    setMutationDefInfo: (info) => {
-      dbExecute(
-        db,
-        sql`INSERT OR REPLACE INTO ${SCHEMA_MUTATIONS_META_TABLE} (mutationName, schemaHash, updatedAt) VALUES ($mutationName, $schemaHash, $updatedAt)`,
-        {
-          mutationName: info.mutationName,
-          schemaHash: info.schemaHash,
-          updatedAt: new Date().toISOString(),
-        },
-      )
-    },
-  }
-}
-
 // TODO more graceful DB migration (e.g. backup DB before destructive migrations)
 export const migrateDb = ({
   db,
   otelContext = otel.context.active(),
   schema,
+  onProgress,
 }: {
   db: InMemoryDatabase
   otelContext?: otel.Context
   schema: LiveStoreSchema
-}) => {
-  migrateTable({
-    db,
-    otelContext,
-    tableAst: schemaMetaTable.sqliteDef.ast,
-    behaviour: 'create-if-not-exists',
-  })
+  onProgress?: (opts: { done: number; total: number }) => Effect.Effect<void>
+}) =>
+  Effect.gen(function* () {
+    yield* migrateTable({
+      db,
+      otelContext,
+      tableAst: schemaMetaTable.sqliteDef.ast,
+      behaviour: 'create-if-not-exists',
+    })
 
-  validateSchema(schema, makeSchemaManager(db))
+    // TODO enforce that migrating tables isn't allowed once the store is running
 
-  const schemaMetaRows = dbSelect<SchemaMetaRow>(db, sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
+    const schemaManager = yield* makeSchemaManager(db)
+    validateSchema(schema, schemaManager)
 
-  const dbSchemaHashByTable = Object.fromEntries(
-    schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
-  )
+    const schemaMetaRows = dbSelect<SchemaMetaRow>(db, sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
 
-  const tableDefs = new Set([
-    // NOTE it's important the `SCHEMA_META_TABLE` comes first since we're writing to it below
-    ...systemTables,
-    ...Array.from(schema.tables.values()).filter((_) => _.sqliteDef.name !== SCHEMA_META_TABLE),
-  ])
+    const dbSchemaHashByTable = Object.fromEntries(
+      schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
+    )
 
-  for (const tableDef of tableDefs) {
-    const tableAst = tableDef.sqliteDef.ast
-    const tableName = tableAst.name
-    const dbSchemaHash = dbSchemaHashByTable[tableName]
-    const schemaHash = SqliteAst.hash(tableAst)
+    const tableDefs = new Set([
+      // NOTE it's important the `SCHEMA_META_TABLE` comes first since we're writing to it below
+      ...systemTables,
+      ...Array.from(schema.tables.values()).filter((_) => _.sqliteDef.name !== SCHEMA_META_TABLE),
+    ])
 
-    const skipMigrations = import.meta.env.VITE_LIVESTORE_SKIP_MIGRATIONS !== undefined
+    const tablesToMigrate = new Set<{ tableAst: SqliteAst.Table; schemaHash: number }>()
 
-    if (schemaHash !== dbSchemaHash && skipMigrations === false) {
-      console.log(
-        `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
-      )
+    for (const tableDef of tableDefs) {
+      const tableAst = tableDef.sqliteDef.ast
+      const tableName = tableAst.name
+      const dbSchemaHash = dbSchemaHashByTable[tableName]
+      const schemaHash = SqliteAst.hash(tableAst)
+
+      if (schemaHash !== dbSchemaHash) {
+        tablesToMigrate.add({ tableAst, schemaHash })
 
-      migrateTable({ db, tableAst, otelContext, schemaHash, behaviour: 'drop-and-recreate' })
+        console.log(
+          `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
+        )
+      }
     }
-  }
-}
+
+    let processedTables = 0
+    const tablesCount = tablesToMigrate.size
+
+    for (const { tableAst, schemaHash } of tablesToMigrate) {
+      yield* migrateTable({ db, tableAst, otelContext, schemaHash, behaviour: 'create-if-not-exists' })
+
+      if (onProgress !== undefined) {
+        processedTables++
+        yield* onProgress({ done: processedTables, total: tablesCount })
+      }
+    }
+  })
 
 export const migrateTable = ({
   db,
@@ -114,36 +133,37 @@ export const migrateTable = ({
   schemaHash?: number
   behaviour: 'drop-and-recreate' | 'create-if-not-exists'
   skipMetaTable?: boolean
-}) => {
-  console.log(`Migrating table '${tableAst.name}'...`)
-  const tableName = tableAst.name
-  const columnSpec = makeColumnSpec(tableAst)
-
-  if (behaviour === 'drop-and-recreate') {
-    // TODO need to possibly handle cascading deletes due to foreign keys
-    dbExecute(db, sql`drop table if exists ${tableName}`)
-    dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
-  } else if (behaviour === 'create-if-not-exists') {
-    dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
-  }
+}) =>
+  Effect.gen(function* () {
+    console.log(`Migrating table '${tableAst.name}'...`)
+    const tableName = tableAst.name
+    const columnSpec = makeColumnSpec(tableAst)
+
+    if (behaviour === 'drop-and-recreate') {
+      // TODO need to possibly handle cascading deletes due to foreign keys
+      dbExecute(db, sql`drop table if exists ${tableName}`)
+      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+    } else if (behaviour === 'create-if-not-exists') {
+      dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec}) strict`)
+    }
 
-  for (const index of tableAst.indexes) {
-    dbExecute(db, createIndexFromDefinition(tableName, index))
-  }
+    for (const index of tableAst.indexes) {
+      dbExecute(db, createIndexFromDefinition(tableName, index))
+    }
 
-  if (skipMetaTable !== true) {
-    const updatedAt = getMemoizedTimestamp()
+    if (skipMetaTable !== true) {
+      const updatedAt = getMemoizedTimestamp()
 
-    dbExecute(
-      db,
-      sql`
+      dbExecute(
+        db,
+        sql`
       INSERT INTO ${SCHEMA_META_TABLE} (tableName, schemaHash, updatedAt) VALUES ($tableName, $schemaHash, $updatedAt)
         ON CONFLICT (tableName) DO UPDATE SET schemaHash = $schemaHash, updatedAt = $updatedAt;
     `,
-      { tableName, schemaHash, updatedAt },
-    )
-  }
-}
+        { tableName, schemaHash, updatedAt },
+      )
+    }
+  }).pipe(Effect.withSpan('@livestore/common:migrateTable', { attributes: { tableName: tableAst.name } }))
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
   const uniqueStr = index.unique ? 'UNIQUE' : ''

package/src/version.ts

@@ -0,0 +1,3 @@
+import packageJson from '../package.json' assert { type: 'json' }
+
+export const liveStoreVersion = packageJson.version