@livestore/livestore 0.0.41-dev.2 → 0.0.42-dev.0

package/src/{inMemoryDatabase.ts → MainDatabaseWrapper.ts}

@@ -1,17 +1,13 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
+import { type MainDatabase, type PreparedStatement, sql } from '@livestore/common'
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
-import type * as Sqlite from 'sqlite-esm'
 
-// import { EVENTS_TABLE_NAME } from './events.js'
-import { sql } from './index.js'
 import QueryCache from './QueryCache.js'
 import BoundMap, { BoundArray } from './utils/bounded-collections.js'
 import { getDurationMsFromSpan, getStartTimeHighResFromSpan } from './utils/otel.js'
-import type { Bindable, PreparedBindValues } from './utils/util.js'
-
-type DatabaseWithCAPI = Sqlite.Database & { capi: Sqlite.CAPI }
+import { type Bindable, type PreparedBindValues } from './utils/util.js'
 
 export interface DebugInfo {
   slowQueries: BoundArray<SlowQueryInfo>
@@ -36,65 +32,42 @@ export const emptyDebugInfo = (): DebugInfo => ({
   events: new BoundArray(1000),
 })
 
-export class InMemoryDatabase {
+export class MainDatabaseWrapper {
   // TODO: how many unique active statements are expected?
-  private cachedStmts = new BoundMap<string, Sqlite.PreparedStatement>(200)
+  private cachedStmts = new BoundMap<string, PreparedStatement>(200)
   private tablesUsedCache = new BoundMap<string, Set<string>>(200)
   private resultCache = new QueryCache()
+  private db: MainDatabase
+  private otelTracer: otel.Tracer
+  private otelRootSpanContext: otel.Context
   private tablesUsedStmt
   public debugInfo: DebugInfo = emptyDebugInfo()
 
-  constructor(
-    private db: DatabaseWithCAPI,
-    private otelTracer: otel.Tracer,
-    private otelRootSpanContext: otel.Context,
-    public SQL: Sqlite.Sqlite3Static,
-  ) {
-    this.tablesUsedStmt = this.db.prepare(
-      `SELECT tbl_name FROM tables_used(?) AS u JOIN sqlite_master ON sqlite_master.name = u.name WHERE u.schema = 'main';`,
-    )
-  }
-
-  static load({
-    data,
+  constructor({
+    db,
     otelTracer,
     otelRootSpanContext,
-    sqlite3,
   }: {
-    data: Uint8Array | undefined
+    db: MainDatabase
     otelTracer: otel.Tracer
     otelRootSpanContext: otel.Context
-    sqlite3: Sqlite.Sqlite3Static
-  }): InMemoryDatabase {
-    // TODO move WASM init higher up in the init process (to do some other work while it's loading)
-
-    const db = new sqlite3.oo1.DB({ filename: ':memory:', flags: 'c' }) as DatabaseWithCAPI
-    db.capi = sqlite3.capi
-
-    if (data !== undefined) {
-      // Based on https://sqlite.org/forum/forumpost/2119230da8ac5357a13b731f462dc76e08621a4a29724f7906d5f35bb8508465
-      // TODO find cleaner way to do this once possible in sqlite3-wasm
-      const bytes = data
-      const p = sqlite3.wasm.allocFromTypedArray(bytes)
-      const _rc = sqlite3.capi.sqlite3_deserialize(
-        db.pointer,
-        'main',
-        p,
-        bytes.length,
-        bytes.length,
-        sqlite3.capi.SQLITE_DESERIALIZE_FREEONCLOSE && sqlite3.capi.SQLITE_DESERIALIZE_RESIZEABLE,
-      )
-    }
+  }) {
+    this.db = db
+    this.otelTracer = otelTracer
+    this.otelRootSpanContext = otelRootSpanContext
 
-    const inMemoryDatabase = new InMemoryDatabase(db, otelTracer, otelRootSpanContext, sqlite3)
+    this.tablesUsedStmt = db.prepare(
+      `SELECT tbl_name FROM tables_used(?) AS u JOIN sqlite_master ON sqlite_master.name = u.name WHERE u.schema = 'main';`,
+    )
 
-    configureSQLite(inMemoryDatabase)
+    this.cachedStmts.onEvict = (_queryStr, stmt) => stmt.finalize()
 
-    return inMemoryDatabase
+    configureSQLite(this)
   }
 
   txn<TRes>(callback: () => TRes): TRes {
     this.execute(sql`begin transaction;`)
+
     let errored = false
     let result: TRes
 
@@ -114,6 +87,13 @@ export class InMemoryDatabase {
   }
 
   getTablesUsed(query: string) {
+    // It seems that SQLite doesn't properly handle `DELETE FROM SOME_TABLE` queries without a WHERE clause
+    // So we need to handle these queries separately
+    const tableNameFromPlainDeleteQuery = tryGetTableNameFromPlainDeleteQuery(query)
+    if (tableNameFromPlainDeleteQuery !== undefined) {
+      return new Set<string>([tableNameFromPlainDeleteQuery])
+    }
+
     const cached = this.tablesUsedCache.get(query)
     if (cached) {
       return cached
@@ -121,15 +101,14 @@ export class InMemoryDatabase {
     const stmt = this.tablesUsedStmt
     const tablesUsed = new Set<string>()
     try {
-      stmt.bind([query])
-      while (stmt.step()) {
-        tablesUsed.add(stmt.get(0))
+      const results = stmt.select<{ tbl_name: string }>([query] as unknown as PreparedBindValues)
+
+      for (const row of results) {
+        tablesUsed.add(row.tbl_name)
       }
     } catch (e) {
       console.error('Error getting tables used', e, 'for query', query)
       return new Set<string>()
-    } finally {
-      stmt.reset()
     }
     this.tablesUsedCache.set(query, tablesUsed)
     return tablesUsed
@@ -156,19 +135,7 @@ export class InMemoryDatabase {
             this.cachedStmts.set(query, stmt)
           }
 
-          if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
-            stmt.bind(bindValues)
-          }
-
-          if (import.meta.env.DEV) {
-            this.debugInfo.events.push([query, bindValues])
-          }
-
-          try {
-            stmt.step()
-          } finally {
-            stmt.reset() // Reset is needed for next execution
-          }
+          stmt.execute(bindValues)
         } catch (error) {
           shouldNeverHappen(`Error executing query: ${error} \n ${JSON.stringify({ query, bindValues })}`)
         }
@@ -237,34 +204,8 @@ export class InMemoryDatabase {
             stmt = this.db.prepare(query)
             this.cachedStmts.set(query, stmt)
           }
-          if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
-            stmt.bind(bindValues)
-          }
 
-          const result: T[] = []
-
-          try {
-            // NOTE `getColumnNames` only works for `SELECT` statements, ignoring other statements for now
-            let columns = undefined
-            try {
-              columns = stmt.getColumnNames()
-            } catch (_e) {}
-
-            while (stmt.step()) {
-              if (columns !== undefined) {
-                const obj: { [key: string]: any } = {}
-                for (const [i, c] of columns.entries()) {
-                  obj[c] = stmt.get(i)
-                }
-                result.push(obj as unknown as T)
-              }
-            }
-          } finally {
-            // we're caching statements in this iteration. do not free.
-            // stmt.free();
-            // reset the cached statement so we can use it again in the future
-            stmt.reset()
-          }
+          const result = stmt.select<T>(bindValues)
 
           span.setAttribute('sql.rowsCount', result.length)
           span.setAttribute('sql.cached', false)
@@ -308,12 +249,12 @@ export class InMemoryDatabase {
       this.cachedStmts.delete(key)
     }
 
-    return this.db.capi.sqlite3_js_db_export(this.db.pointer)
+    return this.db.export()
   }
 }
 
 /** Set up SQLite performance; hasn't been super carefully optimized yet. */
-const configureSQLite = (db: InMemoryDatabase) => {
+const configureSQLite = (db: MainDatabaseWrapper) => {
   db.execute(
     // TODO: revisit these tuning parameters for max performance
     sql`
@@ -326,3 +267,8 @@ const configureSQLite = (db: InMemoryDatabase) => {
     `,
   )
 }
+
+const tryGetTableNameFromPlainDeleteQuery = (query: string) => {
+  const [_, tableName] = query.trim().match(/^delete\s+from\s+(\w+)$/i) ?? []
+  return tableName
+}

package/src/__tests__/react/fixture.tsx

@@ -1,12 +1,12 @@
+import { Schema as __Schema } from '@livestore/utils/effect'
+import { makeDb } from '@livestore/web'
 import type * as otel from '@opentelemetry/api'
 import React from 'react'
-import initSqlite3Wasm from 'sqlite-esm'
 
 import { globalDbGraph } from '../../global-state.js'
 import type { LiveStoreContext } from '../../index.js'
 import { createStore, DbSchema, makeCudMutations, makeDbGraph, makeSchema, ParseUtils, sql } from '../../index.js'
 import * as LiveStoreReact from '../../react/index.js'
-import { InMemoryStorage } from '../../storage/in-memory/index.js'
 
 export type Todo = {
   id: string
@@ -51,18 +51,12 @@ export const makeTodoMvc = async ({
     username: DbSchema.text({ default: '' }),
   })
 
-  const sqlite3 = await initSqlite3Wasm({
-    print: (message) => console.log(`[livestore sqlite] ${message}`),
-    printErr: (message) => console.error(`[livestore sqlite] ${message}`),
-  })
-
   const dbGraph = useGlobalDbGraph ? globalDbGraph : makeDbGraph()
 
   const store = await createStore({
     schema,
-    loadStorage: () => InMemoryStorage.load(),
     boot: (db) => db.execute(sql`INSERT OR IGNORE INTO app (id, newTodoText, filter) VALUES ('static', '', 'all');`),
-    sqlite3,
+    makeDb: makeDb(),
     dbGraph,
     otelTracer,
     otelRootSpanContext: otelContext,

package/src/cud.ts

@@ -1,12 +1,13 @@
-import * as SqlQueries from '@livestore/sql-queries'
+import { deleteRows, insertRow, updateRows } from '@livestore/common'
+import type { RawSqlMutationEvent } from '@livestore/common/schema'
+import { DbSchema, rawSqlMutation } from '@livestore/common/schema'
+import { isIterable } from '@livestore/utils'
 import type { SqliteDsl } from 'effect-db-schema'
 
 import type { RowResult } from './row-query.js'
-import { rawSqlMutation, type RawSqlMutationEvent } from './schema/index.js'
-import { getDefaultValuesEncoded, type TableDef } from './schema/table-def.js'
-import { type GetValForKey, isIterable } from './utils/util.js'
+import { type GetValForKey } from './utils/util.js'
 
-export const makeCudMutations = <TTableDef extends TableDef>(
+export const makeCudMutations = <TTableDef extends DbSchema.TableDef>(
   tables: Iterable<TTableDef> | Record<string, TTableDef>,
 ): CudMutations<TTableDef> => {
   const cudMutationRecord: CudMutations<TTableDef> = {} as any
@@ -21,16 +22,16 @@ export const makeCudMutations = <TTableDef extends TableDef>(
   return cudMutationRecord
 }
 
-const cudMutationsForTable = <TTableDef extends TableDef>(
+const cudMutationsForTable = <TTableDef extends DbSchema.TableDef>(
   tableDef: TTableDef,
 ): [TTableDef['sqliteDef']['name'], CudMutation<TTableDef>] => {
   const table = tableDef.sqliteDef
   const writeTables = new Set([table.name])
   const api = {
     insert: (values_: any) => {
-      const values = getDefaultValuesEncoded(tableDef, values_)
+      const values = DbSchema.getDefaultValuesDecoded(tableDef, values_)
 
-      const [sql, bindValues] = SqlQueries.insertRow({
+      const [sql, bindValues] = insertRow({
         tableName: table.name,
         columns: table.columns,
         options: { orReplace: false },
@@ -39,7 +40,7 @@ const cudMutationsForTable = <TTableDef extends TableDef>(
       return rawSqlMutation({ sql, bindValues, writeTables })
     },
     update: ({ where, values }) => {
-      const [sql, bindValues] = SqlQueries.updateRows({
+      const [sql, bindValues] = updateRows({
         tableName: table.name,
         columns: table.columns,
         where: where,
@@ -48,7 +49,7 @@ const cudMutationsForTable = <TTableDef extends TableDef>(
       return rawSqlMutation({ sql, bindValues, writeTables })
     },
     delete: ({ where }) => {
-      const [sql, bindValues] = SqlQueries.deleteRows({
+      const [sql, bindValues] = deleteRows({
         tableName: table.name,
         columns: table.columns,
         where: where,
@@ -60,28 +61,28 @@ const cudMutationsForTable = <TTableDef extends TableDef>(
   return [tableDef.sqliteDef.name, api]
 }
 
-export type UpdateMutation<TTableDef extends TableDef> = (args: {
+export type UpdateMutation<TTableDef extends DbSchema.TableDef> = (args: {
   // TODO also allow `id` if present in `TTableDef`
   where: Partial<RowResult<TTableDef>>
   values: Partial<RowResult<TTableDef>>
 }) => RawSqlMutationEvent
 
-export type RowInsert<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
+export type RowInsert<TTableDef extends DbSchema.TableDef> = TTableDef['isSingleColumn'] extends true
   ? GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>, 'value'>
   : SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>
 
-export type InsertMutation<TTableDef extends TableDef> = (values: RowInsert<TTableDef>) => RawSqlMutationEvent
+export type InsertMutation<TTableDef extends DbSchema.TableDef> = (values: RowInsert<TTableDef>) => RawSqlMutationEvent
 
-export type DeleteMutation<TTableDef extends TableDef> = (args: {
+export type DeleteMutation<TTableDef extends DbSchema.TableDef> = (args: {
   where: Partial<RowResult<TTableDef>>
 }) => RawSqlMutationEvent
 
-export type CudMutation<TTableDef extends TableDef> = {
+export type CudMutation<TTableDef extends DbSchema.TableDef> = {
   insert: InsertMutation<TTableDef>
   update: UpdateMutation<TTableDef>
   delete: DeleteMutation<TTableDef>
 }
 
-export type CudMutations<TTableDef extends TableDef> = {
+export type CudMutations<TTableDef extends DbSchema.TableDef> = {
   [TTableName in TTableDef['sqliteDef']['name']]: CudMutation<Extract<TTableDef, { sqliteDef: { name: TTableName } }>>
 }

package/src/effect/LiveStore.ts

@@ -1,23 +1,14 @@
+import type { DatabaseFactory, MainDatabase } from '@livestore/common'
+import type { LiveStoreSchema } from '@livestore/common/schema'
 import type { Scope } from '@livestore/utils/effect'
 import { Context, Deferred, Duration, Effect, Layer, OtelTracer, pipe, Runtime } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
-import initSqlite3Wasm from 'sqlite-esm'
 
-import type { InMemoryDatabase } from '../inMemoryDatabase.js'
 import type { LiveQuery } from '../reactiveQueries/base-class.js'
-import type { LiveStoreSchema } from '../schema/index.js'
-import type { StorageInit } from '../storage/index.js'
-import type { BaseGraphQLContext, GraphQLOptions, Store } from '../store.js'
+import type { BaseGraphQLContext, BootDb, GraphQLOptions, Store } from '../store.js'
 import { createStore } from '../store.js'
 
-// NOTE we're starting to initialize the sqlite wasm binary here (already before calling `createStore`),
-// so that it's ready when we need it
-const sqlite3Promise = initSqlite3Wasm({
-  print: (message) => console.log(`[livestore sqlite] ${message}`),
-  printErr: (message) => console.error(`[livestore sqlite] ${message}`),
-})
-
 // TODO get rid of `LiveStoreContext` wrapper and only expose the `Store` directly
 export type LiveStoreContext = {
   store: Store
@@ -27,11 +18,12 @@ export type QueryDefinition = <TResult>(store: Store) => LiveQuery<TResult>
 
 export type LiveStoreCreateStoreOptions<GraphQLContext extends BaseGraphQLContext> = {
   schema: LiveStoreSchema
-  loadStorage: () => StorageInit | Promise<StorageInit>
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelTracer?: otel.Tracer
   otelRootSpanContext?: otel.Context
-  boot?: (db: InMemoryDatabase, parentSpan: otel.Span) => unknown | Promise<unknown>
+  boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
+  makeDb: DatabaseFactory
+  batchUpdates?: (run: () => void) => void
 }
 
 export const LiveStoreContext = Context.GenericTag<LiveStoreContext>('@livestore/livestore/LiveStoreContext')
@@ -45,12 +37,12 @@ export const DeferredStoreContext = Context.GenericTag<DeferredStoreContext>(
 
 export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
   schema: LiveStoreSchema
-  loadStorage: () => StorageInit | Promise<StorageInit>
   graphQLOptions?: {
     schema: Effect.Effect<GraphQLSchema, never, otel.Tracer>
-    makeContext: (db: InMemoryDatabase) => GraphQLContext
+    makeContext: (db: MainDatabase) => GraphQLContext
   }
-  boot?: (db: InMemoryDatabase) => Effect.Effect<void>
+  boot?: (db: BootDb) => Effect.Effect<void>
+  makeDb: DatabaseFactory
 }
 
 export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>(
@@ -65,9 +57,9 @@ export const LiveStoreContextDeferred = Layer.effect(DeferredStoreContext, Defer
 
 export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>({
   schema,
-  loadStorage,
   graphQLOptions: graphQLOptions_,
   boot: boot_,
+  makeDb,
 }: LiveStoreContextProps<GraphQLContext>): Effect.Effect<
   LiveStoreContext,
   never,
@@ -88,22 +80,18 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
       )
 
       const boot = boot_
-        ? (db: InMemoryDatabase) =>
-            boot_(db).pipe(Effect.withSpan('boot'), Effect.tapCauseLogPretty, Runtime.runPromise(runtime))
+        ? (db: BootDb) => boot_(db).pipe(Effect.withSpan('boot'), Effect.tapCauseLogPretty, Runtime.runPromise(runtime))
         : undefined
 
-      const sqlite3 = yield* $(Effect.promise(() => sqlite3Promise))
-
       const store = yield* $(
         Effect.tryPromise(() =>
           createStore({
             schema,
-            loadStorage,
             graphQLOptions,
             otelTracer,
             otelRootSpanContext,
             boot,
-            sqlite3,
+            makeDb,
           }),
         ),
         Effect.acquireRelease((store) => Effect.sync(() => store.destroy())),

package/src/global-state.ts

@@ -11,9 +11,10 @@
  *
  */
 
+import type { DbSchema } from '@livestore/common/schema'
+
 import { makeDbGraph } from './reactiveQueries/base-class.js'
-import type { TableDef } from './schema/table-def.js'
 
 export const globalDbGraph = makeDbGraph()
 
-export const dynamicallyRegisteredTables: Map<string, TableDef> = new Map()
+export const dynamicallyRegisteredTables: Map<string, DbSchema.TableDef> = new Map()

package/src/index.ts

@@ -1,11 +1,9 @@
 export { Store, createStore } from './store.js'
-export type { BaseGraphQLContext, QueryDebugInfo, RefreshReason } from './store.js'
+export type { BaseGraphQLContext, QueryDebugInfo, RefreshReason, BootDb } from './store.js'
 
 export type { QueryDefinition, LiveStoreCreateStoreOptions, LiveStoreContext } from './effect/LiveStore.js'
 
-export { InMemoryDatabase, type DebugInfo, emptyDebugInfo } from './inMemoryDatabase.js'
-
-export type { Storage, StorageType, StorageInit } from './storage/index.js'
+export { MainDatabaseWrapper as InMemoryDatabase, type DebugInfo, emptyDebugInfo } from './MainDatabaseWrapper.js'
 
 export type { GetAtom, AtomDebugInfo, RefreshDebugInfo, SerializedAtom, Atom, Node, Ref, Effect } from './reactive.js'
 export { LiveStoreJSQuery, computed } from './reactiveQueries/js.js'
@@ -19,26 +17,12 @@ export { type RowResult, type RowResultEncoded, rowQuery, deriveColQuery } from
 
 export * from './cud.js'
 
-export {
-  makeSchema,
-  DbSchema,
-  ParseUtils,
-  defineMutation,
-  rawSqlMutation,
-  makeMutationEventSchema,
-  makeMutationDefRecord,
-} from './schema/index.js'
-
-export type {
-  LiveStoreSchema,
-  InputSchema,
-  SchemaMetaRow,
-  MutationDef,
-  MutationEvent,
-  MutationDefMap,
-} from './schema/index.js'
+export * from '@livestore/common/schema'
+export { sql } from '@livestore/common'
 
 export { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
-export { prepareBindValues, sql, type Bindable, type PreparedBindValues } from './utils/util.js'
+export { prepareBindValues, type Bindable, type PreparedBindValues } from './utils/util.js'
 export { isEqual } from 'lodash-es'
+
+export type { DatabaseImpl, DatabaseFactory, PreparedStatement } from '@livestore/common'

package/src/migrations.ts

@@ -1,36 +1,60 @@
+import { type DatabaseImpl, sql } from '@livestore/common'
+import type { LiveStoreSchema, SchemaMetaRow } from '@livestore/common/schema'
+import { SCHEMA_META_TABLE, systemTables } from '@livestore/common/schema'
 import { Schema as EffectSchema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 import { memoize } from 'lodash-es'
 
-import { dynamicallyRegisteredTables } from './global-state.js'
-import type { InMemoryDatabase } from './index.js'
-import type { LiveStoreSchema, SchemaMetaRow } from './schema/index.js'
-import { SCHEMA_META_TABLE, systemTables } from './schema/index.js'
-import type { PreparedBindValues } from './utils/util.js'
-import { sql } from './utils/util.js'
+import type { ParamsObject } from './utils/util.js'
+import { prepareBindValues } from './utils/util.js'
 
 const getMemoizedTimestamp = memoize(() => new Date().toISOString())
 
+// TODO bring back statement caching
+// const cachedStmts = new Map<string, PreparedStatement>()
+
+const dbExecute = (db: DatabaseImpl, queryStr: string, bindValues?: ParamsObject) => {
+  // let stmt = cachedStmts.get(queryStr)
+  // if (!stmt) {
+  const stmt = db.mainDb.prepare(queryStr)
+  // cachedStmts.set(queryStr, stmt)
+  // }
+
+  const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
+
+  stmt.execute(preparedBindValues)
+
+  void db.storageDb.execute(queryStr, preparedBindValues, undefined)
+}
+
+const dbSelect = <T>(db: DatabaseImpl, queryStr: string, bindValues?: ParamsObject) => {
+  // let stmt = cachedStmts.get(queryStr)
+  // if (!stmt) {
+  const stmt = db.mainDb.prepare(queryStr)
+  // cachedStmts.set(queryStr, stmt)
+  // }
+
+  return stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
+}
+
 // TODO more graceful DB migration (e.g. backup DB before destructive migrations)
 export const migrateDb = ({
   db,
   otelContext,
   schema,
 }: {
-  db: InMemoryDatabase
+  db: DatabaseImpl
   otelContext: otel.Context
   schema: LiveStoreSchema
 }) => {
-  db.execute(
+  dbExecute(
+    db,
     // TODO use schema migration definition from schema.ts instead
     sql`create table if not exists ${SCHEMA_META_TABLE} (tableName text primary key, schemaHash text, updatedAt text);`,
-    undefined,
-    new Set(),
-    { otelContext },
   )
 
-  const schemaMetaRows = db.select<SchemaMetaRow>(sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
+  const schemaMetaRows = dbSelect<SchemaMetaRow>(db, sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
 
   const dbSchemaHashByTable = Object.fromEntries(
     schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
@@ -40,7 +64,6 @@ export const migrateDb = ({
     // 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),
-    ...dynamicallyRegisteredTables.values(),
   ])
 
   for (const tableDef of tableDefs) {
@@ -48,18 +71,12 @@ export const migrateDb = ({
     const tableName = tableAst.name
     const dbSchemaHash = dbSchemaHashByTable[tableName]
     const schemaHash = SqliteAst.hash(tableAst)
-    if (schemaHash !== dbSchemaHash) {
-      if (import.meta.env.VITE_LIVESTORE_SKIP_MIGRATIONS) {
-        console.log(
-          `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), skipping migration...`,
-        )
-      } else {
-        console.log(
-          `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
-        )
-
-        migrateTable({ db, tableAst, otelContext, schemaHash })
-      }
+    if (schemaHash !== dbSchemaHash && import.meta.env.VITE_LIVESTORE_SKIP_MIGRATIONS === undefined) {
+      console.log(
+        `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
+      )
+
+      migrateTable({ db, tableAst, otelContext, schemaHash })
     }
   }
 }
@@ -67,10 +84,10 @@ export const migrateDb = ({
 export const migrateTable = ({
   db,
   tableAst,
-  otelContext,
+  // otelContext,
   schemaHash,
 }: {
-  db: InMemoryDatabase
+  db: DatabaseImpl
   tableAst: SqliteAst.Table
   otelContext: otel.Context
   schemaHash: number
@@ -80,22 +97,22 @@ export const migrateTable = ({
   const columnSpec = makeColumnSpec(tableAst)
 
   // TODO need to possibly handle cascading deletes due to foreign keys
-  db.execute(sql`drop table if exists ${tableName}`, undefined, new Set(), { otelContext })
-  db.execute(sql`create table if not exists ${tableName} (${columnSpec});`, undefined, new Set(), { otelContext })
+  dbExecute(db, sql`drop table if exists ${tableName}`)
+  dbExecute(db, sql`create table if not exists ${tableName} (${columnSpec})`)
 
   for (const index of tableAst.indexes) {
-    db.execute(createIndexFromDefinition(tableName, index), undefined, new Set(), { otelContext })
+    dbExecute(db, createIndexFromDefinition(tableName, index))
   }
 
   const updatedAt = getMemoizedTimestamp()
-  db.execute(
+
+  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: tableName, $schemaHash: schemaHash, $updatedAt: updatedAt } as unknown as PreparedBindValues,
-    new Set(),
-    { otelContext },
+    { tableName, schemaHash, updatedAt },
   )
 }