@livestore/livestore 0.0.13 → 0.0.14

package/src/__tests__/reactiveQueries/sql.test.ts

@@ -0,0 +1,372 @@
+import * as otel from '@opentelemetry/api'
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base'
+import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
+import { describe, expect, it } from 'vitest'
+
+import { queryJS, querySQL, sql } from '../../index.js'
+import { makeTodoMvc } from '../react/fixture.js'
+
+describe('otel', () => {
+  let cachedProvider: BasicTracerProvider | undefined
+
+  const makeQuery = async () => {
+    const exporter = new InMemorySpanExporter()
+
+    const provider = cachedProvider ?? new BasicTracerProvider()
+    cachedProvider = provider
+    provider.addSpanProcessor(new SimpleSpanProcessor(exporter))
+    provider.register()
+
+    const tracer = otel.trace.getTracer('test')
+
+    const span = tracer.startSpan('test')
+    const otelContext = otel.trace.setSpan(otel.context.active(), span)
+
+    const { store } = await makeTodoMvc({ otelTracer: tracer, otelContext })
+
+    return { store, tracer, exporter, span, provider }
+  }
+
+  it('otel', async () => {
+    const { store, exporter, span } = await makeQuery()
+
+    const query = querySQL(`select * from todos`, { queriedTables: ['todos'] })
+    expect(query.run()).toMatchInlineSnapshot('[]')
+
+    store.applyEvent('RawSql', {
+      sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);`,
+      bindValues: {},
+      writeTables: ['todos'],
+    })
+
+    expect(query.run()).toMatchInlineSnapshot(`
+      [
+        {
+          "completed": 0,
+          "id": "t1",
+          "text": "buy milk",
+        },
+      ]
+    `)
+
+    store.destroy()
+    query.destroy()
+    span.end()
+
+    expect(getSimplifiedRootSpan(exporter)).toMatchInlineSnapshot(`
+      {
+        "_name": "test",
+        "children": [
+          {
+            "_name": "livestore.in-memory-db:execute",
+            "attributes": {
+              "sql.query": "
+            PRAGMA page_size=32768;
+            PRAGMA cache_size=10000;
+            PRAGMA journal_mode='MEMORY'; -- we don't flush to disk before committing a write
+            PRAGMA synchronous='OFF';
+            PRAGMA temp_store='MEMORY';
+            PRAGMA foreign_keys='ON'; -- we want foreign key constraints to be enforced
+          ",
+            },
+          },
+          {
+            "_name": "sql-in-memory-select",
+            "attributes": {
+              "sql.cached": false,
+              "sql.query": "SELECT * FROM __livestore_schema",
+              "sql.rowsCount": 0,
+            },
+          },
+          {
+            "_name": "livestore.in-memory-db:execute",
+            "attributes": {
+              "sql.query": "INSERT OR IGNORE INTO app (id, newTodoText, filter) VALUES ('static', '', 'all');",
+            },
+          },
+          {
+            "_name": "LiveStore:applyEvents",
+            "children": [
+              {
+                "_name": "LiveStore:applyEvent",
+                "children": [
+                  {
+                    "_name": "LiveStore:applyEventWithoutRefresh",
+                    "attributes": {
+                      "livestore.actionType": "RawSql",
+                      "livestore.args": "{
+        \\"sql\\": \\"INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);\\",
+        \\"bindValues\\": {},
+        \\"writeTables\\": [
+          \\"todos\\"
+        ]
+      }",
+                    },
+                    "children": [
+                      {
+                        "_name": "livestore.in-memory-db:execute",
+                        "attributes": {
+                          "sql.query": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);",
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            "_name": "LiveStore:queries",
+            "children": [
+              {
+                "_name": "sql:select * from todos",
+                "attributes": {
+                  "sql.query": "select * from todos",
+                  "sql.rowsCount": 0,
+                },
+                "children": [
+                  {
+                    "_name": "sql-in-memory-select",
+                    "attributes": {
+                      "sql.cached": false,
+                      "sql.query": "select * from todos",
+                      "sql.rowsCount": 0,
+                    },
+                  },
+                ],
+              },
+              {
+                "_name": "sql:select * from todos",
+                "attributes": {
+                  "sql.query": "select * from todos",
+                  "sql.rowsCount": 1,
+                },
+                "children": [
+                  {
+                    "_name": "sql-in-memory-select",
+                    "attributes": {
+                      "sql.cached": false,
+                      "sql.query": "select * from todos",
+                      "sql.rowsCount": 1,
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      }
+    `)
+  })
+
+  it('with thunks', async () => {
+    const { store, exporter, span } = await makeQuery()
+
+    const defaultTodo = { id: '', text: '', completed: 0 }
+
+    const filter = queryJS(() => `where completed = 0`, { label: 'where-filter' })
+    const query = querySQL((get) => `select * from todos ${get(filter)}`, {
+      queriedTables: ['todos'],
+      label: 'all todos',
+    }).getFirstRow({
+      defaultValue: defaultTodo,
+    })
+
+    expect(query.run()).toMatchInlineSnapshot(`
+      {
+        "completed": 0,
+        "id": "",
+        "text": "",
+      }
+    `)
+
+    store.applyEvent('RawSql', {
+      sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);`,
+      bindValues: {},
+      writeTables: ['todos'],
+    })
+
+    expect(query.run()).toMatchInlineSnapshot(`
+      {
+        "completed": 0,
+        "id": "t1",
+        "text": "buy milk",
+      }
+    `)
+
+    store.destroy()
+    query.destroy()
+    span.end()
+
+    expect(getSimplifiedRootSpan(exporter)).toMatchInlineSnapshot(`
+      {
+        "_name": "test",
+        "children": [
+          {
+            "_name": "livestore.in-memory-db:execute",
+            "attributes": {
+              "sql.query": "
+            PRAGMA page_size=32768;
+            PRAGMA cache_size=10000;
+            PRAGMA journal_mode='MEMORY'; -- we don't flush to disk before committing a write
+            PRAGMA synchronous='OFF';
+            PRAGMA temp_store='MEMORY';
+            PRAGMA foreign_keys='ON'; -- we want foreign key constraints to be enforced
+          ",
+            },
+          },
+          {
+            "_name": "sql-in-memory-select",
+            "attributes": {
+              "sql.cached": false,
+              "sql.query": "SELECT * FROM __livestore_schema",
+              "sql.rowsCount": 0,
+            },
+          },
+          {
+            "_name": "livestore.in-memory-db:execute",
+            "attributes": {
+              "sql.query": "INSERT OR IGNORE INTO app (id, newTodoText, filter) VALUES ('static', '', 'all');",
+            },
+          },
+          {
+            "_name": "LiveStore:applyEvents",
+            "children": [
+              {
+                "_name": "LiveStore:applyEvent",
+                "children": [
+                  {
+                    "_name": "LiveStore:applyEventWithoutRefresh",
+                    "attributes": {
+                      "livestore.actionType": "RawSql",
+                      "livestore.args": "{
+        \\"sql\\": \\"INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);\\",
+        \\"bindValues\\": {},
+        \\"writeTables\\": [
+          \\"todos\\"
+        ]
+      }",
+                    },
+                    "children": [
+                      {
+                        "_name": "livestore.in-memory-db:execute",
+                        "attributes": {
+                          "sql.query": "INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0);",
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            "_name": "LiveStore:queries",
+            "children": [
+              {
+                "_name": "js:all todos:first",
+                "children": [
+                  {
+                    "_name": "sql:select * from todos where completed = 0",
+                    "attributes": {
+                      "sql.query": "select * from todos where completed = 0",
+                      "sql.rowsCount": 0,
+                    },
+                    "children": [
+                      {
+                        "_name": "js:where-filter",
+                      },
+                      {
+                        "_name": "sql-in-memory-select",
+                        "attributes": {
+                          "sql.cached": false,
+                          "sql.query": "select * from todos where completed = 0",
+                          "sql.rowsCount": 0,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+              {
+                "_name": "js:all todos:first",
+                "children": [
+                  {
+                    "_name": "sql:select * from todos where completed = 0",
+                    "attributes": {
+                      "sql.query": "select * from todos where completed = 0",
+                      "sql.rowsCount": 1,
+                    },
+                    "children": [
+                      {
+                        "_name": "sql-in-memory-select",
+                        "attributes": {
+                          "sql.cached": false,
+                          "sql.query": "select * from todos where completed = 0",
+                          "sql.rowsCount": 1,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      }
+    `)
+  })
+})
+
+const compareHrTime = (a: [number, number], b: [number, number]) => {
+  if (a[0] !== b[0]) return a[0] - b[0]
+  return a[1] - b[1]
+}
+
+const omitEmpty = (obj: any) => {
+  const result: any = {}
+  for (const key in obj) {
+    if (
+      obj[key] !== undefined &&
+      !(Array.isArray(obj[key]) && obj[key].length === 0) &&
+      Object.keys(obj[key]).length > 0
+    ) {
+      result[key] = obj[key]
+    }
+  }
+  return result
+}
+
+const getSimplifiedRootSpan = (exporter: InMemorySpanExporter) => {
+  const spans = exporter.getFinishedSpans()
+  const spansMap = new Map<string, NestedSpan>(spans.map((span) => [span.spanContext().spanId, { span, children: [] }]))
+
+  spansMap.forEach((nestedSpan) => {
+    const parentSpan = nestedSpan.span.parentSpanId ? spansMap.get(nestedSpan.span.parentSpanId) : undefined
+    if (parentSpan) {
+      parentSpan.children.push(nestedSpan)
+    }
+  })
+
+  type NestedSpan = { span: ReadableSpan; children: NestedSpan[] }
+  const rootSpan = spansMap.get(spans.find((_) => _.name === 'test')!.spanContext().spanId)!
+
+  type SimplifiedNestedSpan = { _name: string; attributes: any; children: SimplifiedNestedSpan[] }
+
+  const simplifySpan = (span: NestedSpan): SimplifiedNestedSpan =>
+    omitEmpty({
+      _name: span.span.name,
+      attributes: span.span.attributes,
+      children: span.children
+        .filter((_) => _.span.name !== 'createStore')
+        .sort((a, b) => compareHrTime(a.span.startTime, b.span.startTime))
+        .map(simplifySpan),
+    })
+
+  // console.dir(
+  //   spans.map((_) => [_.spanContext().spanId, _.name, _.attributes, _.parentSpanId]),
+  //   { depth: 10 },
+  // )
+
+  return simplifySpan(rootSpan)
+}

package/src/effect/LiveStore.ts

@@ -2,7 +2,7 @@ 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 { mapValues } from 'lodash-es'
+import initSqlite3Wasm from 'sqlite-esm'
 
 import type { InMemoryDatabase } from '../inMemoryDatabase.js'
 import type { Schema } from '../schema.js'
@@ -10,18 +10,22 @@ import type { StorageInit } from '../storage/index.js'
 import type { BaseGraphQLContext, GraphQLOptions, LiveStoreQuery, 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<any>
-  globalQueries: LiveStoreQueryTypes
+  store: Store
 }
 
-export type QueryDefinition = (store: Store<any>) => LiveStoreQuery
-export type GlobalQueryDefs = { [key: string]: QueryDefinition }
+export type QueryDefinition = (store: Store) => LiveStoreQuery
 
 export type LiveStoreCreateStoreOptions<GraphQLContext extends BaseGraphQLContext> = {
   schema: Schema
-  globalQueryDefs: GlobalQueryDefs
   loadStorage: () => StorageInit | Promise<StorageInit>
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelTracer?: otel.Tracer
@@ -40,7 +44,6 @@ export const DeferredStoreContext = Context.Tag<DeferredStoreContext>(
 
 export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
   schema: Schema
-  globalQueryDefs?: Effect.Effect<never, never, GlobalQueryDefs>
   loadStorage: () => StorageInit | Promise<StorageInit>
   graphQLOptions?: {
     schema: Effect.Effect<otel.Tracer, never, GraphQLSchema>
@@ -60,7 +63,6 @@ export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>
 export const LiveStoreContextDeferred = Layer.effect(DeferredStoreContext, Deferred.make<never, LiveStoreContext>())
 
 export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>({
-  globalQueryDefs,
   schema,
   loadStorage,
   graphQLOptions: graphQLOptions_,
@@ -89,6 +91,8 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
             boot_(db).pipe(Effect.withSpan('boot'), Effect.tapCauseLogPretty, Runtime.runPromise(runtime))
         : undefined
 
+      const sqlite3 = yield* $(Effect.promise(() => sqlite3Promise))
+
       const store = yield* $(
         Effect.tryPromise(() =>
           createStore({
@@ -98,6 +102,7 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
             otelTracer,
             otelRootSpanContext,
             boot,
+            sqlite3,
           }),
         ),
         Effect.acquireRelease((store) => Effect.sync(() => store.destroy())),
@@ -105,16 +110,7 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
 
       window.__debugLiveStore = store
 
-      // TODO remove global queries concept
-      const globalQueries = yield* $(
-        globalQueryDefs ?? Effect.succeed({} as GlobalQueryDefs),
-        Effect.map((defs) => mapValues(defs, (queryDef) => queryDef(store))),
-        Effect.withSpan('LiveStore:makeGlobalQueries', {
-          parent: OtelTracer.makeExternalSpan(otel.trace.getSpanContext(store.otel.queriesSpanContext)!),
-        }),
-      )
-
-      return { store, globalQueries }
+      return { store }
     }),
     Effect.tap((storeCtx) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.succeed(def, storeCtx))),
     Effect.timeoutFail({

package/src/inMemoryDatabase.ts

@@ -2,28 +2,16 @@
 
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
-import type * as SqliteWasm from 'sqlite-esm'
+import type * as Sqlite from 'sqlite-esm'
 
 import BoundMap, { BoundArray } from './bounded-collections.js'
 // import { EVENTS_TABLE_NAME } from './events.js'
 import { sql } from './index.js'
 import { getDurationMsFromSpan, getStartTimeHighResFromSpan } from './otel.js'
 import QueryCache from './QueryCache.js'
-import type { Bindable, ParamsObject } from './util.js'
-import { prepareBindValues } from './util.js'
+import type { Bindable, PreparedBindValues } from './util.js'
 
-export enum IndexType {
-  Basic = 'Basic',
-  FullText = 'FullText',
-}
-
-export interface Index {
-  indexType: IndexType
-  name: string
-  columns: string[]
-}
-
-declare type DatabaseWithCAPI = SqliteWasm.Database & { capi: SqliteWasm.CAPI }
+type DatabaseWithCAPI = Sqlite.Database & { capi: Sqlite.CAPI }
 
 export interface DebugInfo {
   slowQueries: BoundArray<SlowQueryInfo>
@@ -34,10 +22,10 @@ export interface DebugInfo {
 
 export type SlowQueryInfo = [
   queryStr: string,
-  bindValues: Bindable | undefined,
+  bindValues: PreparedBindValues | undefined,
   durationMs: number,
   rowsCount: number | undefined,
-  queriedTables: string[],
+  queriedTables: ReadonlyArray<string>,
   startTimePerfNow: DOMHighResTimeStamp,
 ]
 
@@ -50,7 +38,7 @@ export const emptyDebugInfo = (): DebugInfo => ({
 
 export class InMemoryDatabase {
   // TODO: how many unique active statements are expected?
-  private cachedStmts = new BoundMap<string, SqliteWasm.PreparedStatement>(200)
+  private cachedStmts = new BoundMap<string, Sqlite.PreparedStatement>(200)
   private tablesUsedCache = new BoundMap<string, string[]>(200)
   private resultCache = new QueryCache()
   public debugInfo: DebugInfo = emptyDebugInfo()
@@ -59,15 +47,20 @@ export class InMemoryDatabase {
     private db: DatabaseWithCAPI,
     private otelTracer: otel.Tracer,
     private otelRootSpanContext: otel.Context,
-    public SQL: SqliteWasm.Sqlite3Static,
+    public SQL: Sqlite.Sqlite3Static,
   ) {}
 
-  static load(
-    data: Uint8Array | undefined,
-    otelTracer: otel.Tracer,
-    otelRootSpanContext: otel.Context,
-    sqlite3: SqliteWasm.Sqlite3Static,
-  ): InMemoryDatabase {
+  static load({
+    data,
+    otelTracer,
+    otelRootSpanContext,
+    sqlite3,
+  }: {
+    data: Uint8Array | undefined
+    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
@@ -138,7 +131,7 @@ export class InMemoryDatabase {
 
   execute(
     query: string,
-    bindValues?: ParamsObject,
+    bindValues?: PreparedBindValues,
     writeTables?: string[],
     options?: { hasNoEffects?: boolean; otelContext: otel.Context },
   ): { durationMs: number } {
@@ -155,9 +148,8 @@ export class InMemoryDatabase {
             this.cachedStmts.set(query, stmt)
           }
 
-          // TODO check whether we can remove the extra `prepareBindValues` call here (e.g. enforce proper type in API)
           if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
-            stmt.bind(prepareBindValues(bindValues, query))
+            stmt.bind(bindValues)
           }
 
           if (import.meta.env.DEV) {
@@ -210,8 +202,8 @@ export class InMemoryDatabase {
   select<T = any>(
     query: string,
     options?: {
-      queriedTables?: string[]
-      bindValues?: Bindable
+      queriedTables?: ReadonlyArray<string>
+      bindValues?: PreparedBindValues
       skipCache?: boolean
       otelContext?: otel.Context
     },

package/src/index.ts

@@ -1,11 +1,10 @@
-export { Store, createStore, RESET_DB_LOCAL_STORAGE_KEY } from './store.js'
+export { Store, createStore } from './store.js'
 export type { LiveStoreQuery, BaseGraphQLContext, QueryResult, QueryDebugInfo, RefreshReason } from './store.js'
 
 export type { QueryDefinition, LiveStoreCreateStoreOptions, LiveStoreContext } from './effect/LiveStore.js'
 
 export {
   defineComponentStateSchema,
-  EVENT_CURSOR_TABLE,
   defineAction,
   defineActions,
   defineTables,
@@ -21,10 +20,13 @@ export type {
   RefreshReasonWithGenericReasons,
   SerializedAtom,
   SerializedEffect,
+  Atom,
 } from './reactive.js'
-export type { LiveStoreJSQuery } from './reactiveQueries/js.js'
-export type { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
-export type { LiveStoreGraphQLQuery } from './reactiveQueries/graphql.js'
+export { type LiveStoreJSQuery, queryJS } from './reactiveQueries/js.js'
+export { type LiveStoreSQLQuery, querySQL } from './reactiveQueries/sql.js'
+export { type LiveStoreGraphQLQuery, queryGraphQL } from './reactiveQueries/graphql.js'
+export { type GetAtomResult } from './reactiveQueries/base-class.js'
+export { dbGraph } from './reactiveQueries/graph.js'
 
 export { labelForKey } from './componentKey.js'
 export type { ComponentKey } from './componentKey.js'
@@ -37,5 +39,5 @@ export type TableDefinition = SqliteAst.Table
 
 export { SqliteDsl as DbSchema } from 'effect-db-schema'
 
-export { sql, type Bindable } from './util.js'
+export { prepareBindValues, sql, type Bindable, type PreparedBindValues } from './util.js'
 export { isEqual } from 'lodash-es'

package/src/migrations.ts

@@ -5,8 +5,11 @@ import { memoize, omit } from 'lodash-es'
 import type { InMemoryDatabase } from './index.js'
 import type { Schema, SchemaMetaRow } from './schema.js'
 import { componentStateTables, SCHEMA_META_TABLE, systemTables } from './schema.js'
+import type { PreparedBindValues } from './util.js'
 import { sql } from './util.js'
 
+const getMemoizedTimestamp = memoize(() => new Date().toISOString())
+
 // TODO more graceful DB migration (e.g. backup DB before destructive migrations)
 export const migrateDb = ({
   db,
@@ -31,7 +34,6 @@ export const migrateDb = ({
     schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
   )
 
-  const getMemoizedTimestamp = memoize(() => new Date().toISOString())
   const tableDefs = {
     // NOTE it's important the `SCHEMA_META_TABLE` comes first since we're writing to it below
     [SCHEMA_META_TABLE]: systemTables[SCHEMA_META_TABLE],
@@ -47,30 +49,46 @@ export const migrateDb = ({
         `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
       )
 
-      const columnSpec = makeColumnSpec(tableDef)
-
-      // TODO need to possibly handle cascading deletes due to foreign keys
-      db.execute(sql`drop table if exists ${tableName}`, undefined, [], { otelContext })
-      db.execute(sql`create table if not exists ${tableName} (${columnSpec});`, undefined, [], { otelContext })
-
-      for (const index of tableDef.indexes) {
-        db.execute(createIndexFromDefinition(tableName, index), undefined, [], { otelContext })
-      }
-
-      const updatedAt = getMemoizedTimestamp()
-      db.execute(
-        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 },
-        [],
-        { otelContext },
-      )
+      migrateTable({ db, tableDef, otelContext, schemaHash })
     }
   }
 }
 
+export const migrateTable = ({
+  db,
+  tableDef,
+  otelContext,
+  schemaHash,
+}: {
+  db: InMemoryDatabase
+  tableDef: SqliteAst.Table
+  otelContext: otel.Context
+  schemaHash: number
+}) => {
+  console.log(`Migrating table '${tableDef.name}'...`)
+  const tableName = tableDef.name
+  const columnSpec = makeColumnSpec(tableDef)
+
+  // TODO need to possibly handle cascading deletes due to foreign keys
+  db.execute(sql`drop table if exists ${tableName}`, undefined, [], { otelContext })
+  db.execute(sql`create table if not exists ${tableName} (${columnSpec});`, undefined, [], { otelContext })
+
+  for (const index of tableDef.indexes) {
+    db.execute(createIndexFromDefinition(tableName, index), undefined, [], { otelContext })
+  }
+
+  const updatedAt = getMemoizedTimestamp()
+  db.execute(
+    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,
+    [],
+    { otelContext },
+  )
+}
+
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
   const uniqueStr = index.unique ? 'UNIQUE' : ''
   return sql`create ${uniqueStr} index ${index.name} on ${tableName} (${index.columns.join(', ')})`