@livestore/livestore 0.0.10 → 0.0.13

package/src/react/useLiveStoreComponent.ts

@@ -1,6 +1,9 @@
 import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core'
-import { type LiteralUnion, omit, shouldNeverHappen } from '@livestore/utils'
+import type { LiteralUnion, PrettifyFlat } from '@livestore/utils'
+import { omit, shouldNeverHappen } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
+import { SqliteDsl } from 'effect-db-schema'
 import { isEqual, mapValues } from 'lodash-es'
 import type { DependencyList } from 'react'
 import React from 'react'
@@ -12,8 +15,8 @@ import type { GetAtom } from '../reactive.js'
 import type { LiveStoreGraphQLQuery } from '../reactiveQueries/graphql.js'
 import type { LiveStoreJSQuery } from '../reactiveQueries/js.js'
 import type { LiveStoreSQLQuery } from '../reactiveQueries/sql.js'
-import type { ComponentStateSchema } from '../schema.js'
 import type { BaseGraphQLContext, LiveStoreQuery, QueryResult, Store } from '../store.js'
+import type { Bindable } from '../util.js'
 import { sql } from '../util.js'
 import { useStore } from './LiveStoreContext.js'
 import { useStateRefWithReactiveInput } from './utils/useStateRefWithReactiveInput.js'
@@ -21,11 +24,13 @@ import { useStateRefWithReactiveInput } from './utils/useStateRefWithReactiveInp
 export interface QueryDefinitions {
   [queryName: string]: LiveStoreQuery
 }
-export type QueryResults<TQuery> = { [queryName in keyof TQuery]: QueryResult<TQuery[queryName]> }
+
+export type QueryResults<TQuery> = { [queryName in keyof TQuery]: PrettifyFlat<QueryResult<TQuery[queryName]>> }
 
 export type ReactiveSQL = <TResult>(
   genQuery: (get: GetAtom) => string,
   queriedTables: string[],
+  bindValues?: Bindable | undefined,
 ) => LiveStoreSQLQuery<TResult>
 export type ReactiveGraphQL = <
   TResult extends Record<string, any>,
@@ -48,14 +53,18 @@ type GenQueries<TQueries, TStateResult> = (args: {
   rxGraphQL: ReactiveGraphQL
   globalQueries: QueryDefinitions
   state$: LiveStoreJSQuery<TStateResult>
-  /** Registers a subscription */
+  /**
+   * Registers a subscription.
+   *
+   * Passed down for some manual subscribing. Use carefully.
+   */
   subscribe: RegisterSubscription
   isTemporaryQuery: boolean
 }) => TQueries
 
-export type UseLiveStoreComponentProps<TQueries, TComponentState> = {
-  stateSchema?: ComponentStateSchema<TComponentState>
-  queries?: GenQueries<TQueries, TComponentState>
+export type UseLiveStoreComponentProps<TQueries, TColumns extends ComponentColumns> = {
+  stateSchema?: SqliteDsl.TableDefinition<string, TColumns>
+  queries?: GenQueries<TQueries, SqliteDsl.FromColumns.RowDecoded<TColumns>>
   reactDeps?: React.DependencyList
   componentKey: ComponentKeyConfig
 }
@@ -70,12 +79,17 @@ export type ComponentKeyConfig = {
   id: LiteralUnion<'singleton' | '__ephemeral__', string>
 }
 
-type ComponentState = {
-  /** Equivalent to `componentKey.key` */
-  id: string
-  [key: string]: string | number | boolean | null
+// TODO enforce columns are non-nullable or have a default
+export interface ComponentColumns extends SqliteDsl.Columns {
+  id: SqliteDsl.ColumnDefinition<SqliteDsl.FieldType.FieldTypeText<string, string>, false>
 }
 
+// type ComponentState = {
+//   /** Equivalent to `componentKey.key` */
+//   id: string
+//   [key: string]: string | number | boolean | null
+// }
+
 /**
  * This is needed because the `React.useMemo` call below, can sometimes be called multiple times 🤷,
  * so we need to "cache" the fact that we've already started a span for this component.
@@ -88,23 +102,33 @@ type UseLiveStoreJsonState<TState> = <TResult>(
   parse?: (_: unknown) => TResult,
 ) => [value: TResult, setValue: (newVal: TResult | ((prevVal: TResult) => TResult)) => void]
 
+export type GetStateType<TTableDef extends SqliteDsl.TableDefinition<any, any>> = SqliteDsl.FromColumns.RowDecoded<
+  TTableDef['columns']
+>
+
+export type GetStateTypeEncoded<TTableDef extends SqliteDsl.TableDefinition<any, any>> =
+  SqliteDsl.FromColumns.RowEncoded<TTableDef['columns']>
+
 /**
  * Create reactive queries within a component.
  * @param config.queries A function that returns a map of named reactive queries.
  * @param config.componentKey A function that returns a unique key for this component.
  * @param config.reactDeps A list of React-level dependencies that will refresh the queries.
  */
-export const useLiveStoreComponent = <TComponentState extends ComponentState, TQueries extends QueryDefinitions>({
+export const useLiveStoreComponent = <TColumns extends ComponentColumns, TQueries extends QueryDefinitions>({
   stateSchema: stateSchema_,
   queries = () => ({}) as TQueries,
   componentKey: componentKeyConfig,
   reactDeps = [],
-}: UseLiveStoreComponentProps<TQueries, TComponentState>): {
+}: UseLiveStoreComponentProps<TQueries, TColumns>): {
   queryResults: QueryResults<TQueries>
-  state: TComponentState
-  setState: Setters<TComponentState>
-  useLiveStoreJsonState: UseLiveStoreJsonState<TComponentState>
+  state: SqliteDsl.FromColumns.RowDecoded<TColumns>
+  setState: Setters<SqliteDsl.FromColumns.RowDecoded<TColumns>>
+  useLiveStoreJsonState: UseLiveStoreJsonState<SqliteDsl.FromColumns.RowDecoded<TColumns>>
 } => {
+  type TComponentState = SqliteDsl.FromColumns.RowDecoded<TColumns>
+
+  // TODO validate schema to make sure each column has a default value
   // TODO we should clean up the state schema handling to remove this special handling for the `id` column
   const stateSchema = React.useMemo(
     () => (stateSchema_ ? { ...stateSchema_, columns: omit(stateSchema_.columns, 'id' as any) } : undefined),
@@ -156,8 +180,8 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
       isTemporaryQuery: boolean
     }) =>
       queries({
-        rxSQL: <T>(genQuery: (get: GetAtom) => string, queriedTables: string[]) =>
-          store.querySQL<T>(genQuery, { queriedTables, otelContext }),
+        rxSQL: <T>(genQuery: (get: GetAtom) => string, queriedTables: string[], bindValues?: Bindable) =>
+          store.querySQL<T>(genQuery, { queriedTables, bindValues, otelContext, componentKey }),
         rxGraphQL: <Result extends Record<string, any>, Variables extends Record<string, any>>(
           query: DocumentNode<Result, Variables>,
           genVariableValues: (get: GetAtom) => Variables,
@@ -183,11 +207,17 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
       stateSchema === undefined ? {} : mapValues(stateSchema.columns, (c) => c.default)
     ) as TComponentState
 
+    // @ts-expect-error TODO fix typing
     defaultState.id = componentKeyConfig.id
 
     return defaultState
   }, [componentKeyConfig.id, stateSchema])
 
+  const componentStateEffectSchema = React.useMemo(
+    () => (stateSchema ? SqliteDsl.structSchemaForTable(stateSchema) : Schema.any),
+    [stateSchema],
+  )
+
   // Step 1:
   // Synchronously create state and queries for initial render pass.
   // We do this in a temporary query context which cleans up after itself, making it idempotent
@@ -199,29 +229,34 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
       return store.inTempQueryContext(() => {
         try {
           // create state query
-          let stateQuery: LiveStoreJSQuery<TComponentState>
+          let state$: LiveStoreJSQuery<TComponentState>
           if (stateSchema === undefined) {
             // TODO don't set up a query if there's no state schema (keeps the graph more clean)
-            stateQuery = store.queryJS(() => ({}), {
+            state$ = store.queryJS(() => ({}), {
               componentKey,
               otelContext,
             }) as unknown as LiveStoreJSQuery<TComponentState>
           } else {
             const componentTableName = tableNameForComponentKey(componentKey)
             const whereClause = componentKey._tag === 'singleton' ? '' : `where id = '${componentKey.id}'`
-            stateQuery = store
-              .querySQL<TComponentState>(() => sql`select * from ${componentTableName} ${whereClause} limit 1`, {
+            state$ = store
+              .querySQL(() => sql`select * from ${componentTableName} ${whereClause} limit 1`, {
                 queriedTables: [componentTableName],
                 componentKey,
                 label: `localState:query:${componentKeyLabel}`,
                 otelContext,
               })
-              .getFirstRow({ defaultValue: defaultComponentState })
+              // TODO consider to instead of just returning the default value, to write the default component state to the DB
+              .pipe<TComponentState>((results) =>
+                results.length === 1
+                  ? Schema.parseSync(componentStateEffectSchema)(results[0]!)
+                  : defaultComponentState,
+              )
           }
-          const initialComponentState = stateQuery.results$.result
+          const initialComponentState = state$.results$.result
 
           const queries = generateQueries({
-            state$: stateQuery,
+            state$: state$,
             otelContext,
             registerSubscription: () => {},
             isTemporaryQuery: true,
@@ -229,7 +264,11 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
           for (const [name, query] of Object.entries(queries)) {
             query.label = name
           }
-          const initialQueryResults = mapValues(queries, (query) => query.results$.result) as QueryResults<TQueries>
+          const initialQueryResults = mapValues(
+            queries,
+            (query) => query.results$.result,
+            // TODO improve typing
+          ) as unknown as QueryResults<TQueries>
 
           return { initialComponentState, initialQueryResults }
         } finally {
@@ -237,7 +276,16 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
         }
       })
     })
-  }, [store, otelContext, stateSchema, generateQueries, componentKey, componentKeyLabel, defaultComponentState])
+  }, [
+    store,
+    otelContext,
+    stateSchema,
+    generateQueries,
+    componentKey,
+    componentKeyLabel,
+    componentStateEffectSchema,
+    defaultComponentState,
+  ])
 
   // Now that we've computed the initial state synchronously,
   // we can set up our useState calls w/ a default value populated...
@@ -249,10 +297,13 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
     stateSchema === undefined
       ? {}
       : // TODO: do we have a better type for the values that can go in SQLite?
-        mapValues(stateSchema.columns, (_, columnName) => (value: string | number) => {
+        mapValues(stateSchema.columns, (column, columnName) => (value: string | number) => {
           // Don't update the state if it's the same as the value already seen in the component
+          // @ts-expect-error TODO fix typing
           if (componentStateRef.current[columnName] === value) return
 
+          const encodedValue = Schema.encodeSync(column.type.codec)(value)
+
           if (['componentKey', 'columnNames'].includes(columnName)) {
             shouldNeverHappen(`Can't use reserved column name ${columnName}`)
           }
@@ -260,7 +311,7 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
           return store.applyEvent('updateComponentState', {
             componentKey,
             columnNames: [columnName],
-            [columnName]: value,
+            [columnName]: encodedValue,
           })
         })
   ) as Setters<TComponentState>
@@ -268,6 +319,7 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
   setState.setMany = (columnValues: Partial<TComponentState>) => {
     // TODO use hashing instead
     // Don't update the state if it's the same as the value already seen in the component
+    // @ts-expect-error TODO fix typing
     if (Object.entries(columnValues).every(([columnName, value]) => componentStateRef.current[columnName] === value)) {
       return
     }
@@ -291,7 +343,12 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
         // create state query
         let state$: LiveStoreJSQuery<TComponentState>
         if (stateSchema === undefined) {
-          state$ = store.queryJS(() => ({}) as TComponentState, { componentKey, otelContext })
+          // TODO remove this query
+          state$ = store.queryJS(() => ({}) as TComponentState, {
+            componentKey,
+            otelContext,
+            label: 'empty-component-state',
+          })
         } else {
           const componentTableName = tableNameForComponentKey(componentKey)
           insertRowForComponentInstance({ store, componentKey, stateSchema })
@@ -304,7 +361,10 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
               label: `localState:query:${componentKeyLabel}`,
               otelContext,
             })
-            .getFirstRow({ defaultValue: defaultComponentState })
+            // TODO consider to instead of just returning the default value, to write the default component state to the DB
+            .pipe<TComponentState>((results) =>
+              results.length === 1 ? Schema.parseSync(componentStateEffectSchema)(results[0]!) : defaultComponentState,
+            )
         }
 
         unsubs.push(
@@ -334,11 +394,11 @@ export const useLiveStoreComponent = <TComponentState extends ComponentState, TQ
         }
 
         const queries = generateQueries({ state$, otelContext, registerSubscription, isTemporaryQuery: false })
-        // Use the name given to this query in the useQueries hook as its label
-        for (const [name, query] of Object.entries(queries)) {
-          query.label = name
-        }
+
         for (const [key, query] of Object.entries(queries)) {
+          // Use the field name given to this query in the useQueries hook as its label
+          query.label = key
+
           unsubs.push(
             store.subscribe(
               query,
@@ -445,14 +505,14 @@ export const useComponentKey = ({ name, id }: ComponentKeyConfig, deps: Dependen
  * Create a row storing the state for a component instance, if none exists yet.
  * Initialized with default values, and keyed on the component key.
  */
-const insertRowForComponentInstance = <T>({
+const insertRowForComponentInstance = ({
   store,
   componentKey,
   stateSchema,
 }: {
   store: Store<BaseGraphQLContext>
   componentKey: ComponentKey
-  stateSchema: ComponentStateSchema<T>
+  stateSchema: SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
 }) => {
   const columnNames = ['id', ...Object.keys(stateSchema.columns)]
   const columnValues = columnNames.map((name) => `$${name}`).join(', ')
@@ -465,8 +525,8 @@ const insertRowForComponentInstance = <T>({
   void store.execute(
     insertQuery,
     {
-      id: componentKey.id,
       ...mapValues(stateSchema.columns, (column) => prepareValueForSql(column.default ?? null)),
+      id: componentKey.id,
     },
     [tableName],
   )

package/src/reactive.ts

@@ -350,7 +350,8 @@ export class ReactiveGraph<TDebugRefreshReason extends Taggable, TDebugThunkInfo
       )
     }
 
-    return atom.result!
+    // TODO handle case when `atom.result` is undefined
+    return atom.result
   }
 
   /**

package/src/schema.ts

@@ -1,45 +1,10 @@
-import type { Backend } from './backends/index.js'
-import { EVENTS_TABLE_NAME } from './events.js'
-import type { InMemoryDatabase } from './inMemoryDatabase.js'
-import { sql } from './util.js'
-
-export type ColumnDefinition = {
-  nullable?: boolean
-  primaryKey?: boolean
-} & (
-  | { type: 'text'; default?: string }
-  | { type: 'json'; default?: string }
-  | { type: 'integer'; default?: number }
-  | { type: 'boolean'; default?: boolean }
-  | { type: 'real'; default?: number }
-  | { type: 'blob'; default?: any }
-) // sqlite uses numbers for booleans but we fake it
-
-// TODO: defaults should be nullable for nullable columns
-type ColumnDefinitionWithDefault = {
-  primaryKey?: boolean
-} & (
-  | { type: 'text'; nullable?: true; default: string }
-  | { type: 'json'; nullable?: true; default: string }
-  | { type: 'integer'; nullable?: true; default: number }
-  | { type: 'boolean'; nullable?: true; default: boolean }
-  | { type: 'real'; nullable: true; default: number | null }
-  | { type: 'blob'; nullable: true; default: any | null }
-)
-
-export type TableDefinition = {
-  columns: {
-    [key: string]: ColumnDefinition
-  }
-  /**
-   * Can be used for various purposes e.g. to provide a foreign key constraint like below:
-   * ```ts
-   * columnsRaw: (columnsStr) => `${columnsStr}, foreign key (userId) references users(id)`
-   * ```
-   */
-  columnsRaw?: (columnsStr: string) => string
-  indexes?: Index[]
-}
+import type { PrettifyFlat } from '@livestore/utils'
+import { mapObjectValues } from '@livestore/utils'
+import type { Schema } from '@livestore/utils/effect'
+import type { SqliteAst } from 'effect-db-schema'
+import { SqliteDsl } from 'effect-db-schema'
+
+import { DbSchema } from './index.js'
 
 export type Index = {
   name: string
@@ -48,35 +13,60 @@ export type Index = {
   isUnique?: boolean
 }
 
-export type ComponentStateSchema<T> = {
-  componentType: string
-  columns: {
-    [k in keyof T]: ColumnDefinitionWithDefault
+// A global variable representing component state tables we should create in the database
+export const componentStateTables: { [key: string]: SqliteAst.Table } = {}
+
+export type InputSchema = {
+  tables: {
+    [tableName: string]: SqliteDsl.TableDefinition<any, any>
   }
+  materializedViews?: MaterializedViewDefinitions
+  actions: ActionDefinitions<any>
 }
 
-// A global variable representing component state tables we should create in the database
-export const componentStateTables: { [key: string]: TableDefinition } = {}
+export const makeSchema = <TSchema extends InputSchema>(schema: TSchema): Schema =>
+  ({
+    tables: { ...mapObjectValues(schema.tables, (_tableName, table) => table.ast), ...systemTables },
+    materializedViews: schema.materializedViews ?? {},
+    actions: schema.actions,
+  }) satisfies Schema
 
-export const defineComponentStateSchema = <T>(
-  schema: ComponentStateSchema<T>,
-): ComponentStateSchema<T & { id: string }> => {
-  const tablePath = `components__${schema.componentType}`
+export type ComponentStateSchema = SqliteDsl.TableDefinition<any, any> & {
+  // TODO
+  register: () => void
+}
+
+// TODO get rid of "side effect" in this function (via explicit register fn)
+export const defineComponentStateSchema = <TName extends string, TColumns extends SqliteDsl.Columns>(
+  name: TName,
+  columns: TColumns,
+): SqliteDsl.TableDefinition<
+  `components__${TName}`,
+  PrettifyFlat<TColumns & { id: SqliteDsl.ColumnDefinition<SqliteDsl.FieldType.FieldTypeText<string, string>, false> }>
+> => {
+  const tablePath = `components__${name}` as const
   if (Object.keys(componentStateTables).includes(tablePath)) {
     // throw new Error(`Can't register duplicate component: ${name}`)
     console.error(`Can't register duplicate component: ${tablePath}`)
   }
 
-  const schemaWithId = schema as ComponentStateSchema<T & { id: string }>
+  const schemaWithId = columns as unknown as PrettifyFlat<
+    TColumns & {
+      id: SqliteDsl.ColumnDefinition<SqliteDsl.FieldType.FieldTypeText<string, string>, false>
+    }
+  >
+
+  schemaWithId.id = DbSchema.text({ primaryKey: true })
 
-  schemaWithId.columns.id = { type: 'text', primaryKey: true } as any
+  const tableDef = SqliteDsl.table(tablePath, schemaWithId, [])
 
-  componentStateTables[tablePath] = schemaWithId as any
+  // TODO move into register fn
+  componentStateTables[tablePath] = tableDef.ast
 
-  return schemaWithId
+  return tableDef
 }
 
-type SQLWriteStatement = {
+export type SQLWriteStatement = {
   sql: string
 
   /** Tables written by the statement */
@@ -96,31 +86,36 @@ export type Schema = {
   actions: ActionDefinitions<any>
 }
 
-export type TableDefinitions = { [key: string]: TableDefinition }
+export type TableDefinitions = { [key: string]: SqliteAst.Table }
 export type MaterializedViewDefinitions = { [key: string]: {} }
 export type ActionDefinitions<TArgsMap extends Record<string, any>> = {
   [key in keyof TArgsMap]: ActionDefinition<TArgsMap[key]>
 }
 
-export const EVENT_CURSOR_TABLE = 'livestore__event_cursor'
-
-const systemTables = {
-  [EVENTS_TABLE_NAME]: {
-    columns: {
-      id: { type: 'text', primaryKey: true },
-      type: { type: 'text', nullable: false },
-      args: { type: 'text', nullable: false },
-    },
-  },
-  [EVENT_CURSOR_TABLE]: {
-    columns: {
-      id: { type: 'text', primaryKey: true },
-      cursor: { type: 'text', nullable: false },
-    },
-  },
-} as const
-
-export const defineSchema = <S extends Schema>(schema: S) => mergeSystemSchema(schema)
+export const EVENT_CURSOR_TABLE = '__livestore_event_cursor'
+export const SCHEMA_META_TABLE = '__livestore_schema'
+
+const schemaMetaTable = SqliteDsl.table(SCHEMA_META_TABLE, {
+  tableName: SqliteDsl.text({ primaryKey: true }),
+  schemaHash: SqliteDsl.integer({ nullable: false }),
+  /** ISO date format */
+  updatedAt: SqliteDsl.text({ nullable: false }),
+})
+
+export type SchemaMetaRow = SqliteDsl.FromTable.RowDecoded<typeof schemaMetaTable>
+
+export const systemTables = {
+  // [EVENTS_TABLE_NAME]: SqliteDsl.table(EVENTS_TABLE_NAME, {
+  //   id: SqliteDsl.text({ primaryKey: true }),
+  //   type: SqliteDsl.text({ nullable: false }),
+  //   args: SqliteDsl.text({ nullable: false }),
+  // }).ast,
+  [EVENT_CURSOR_TABLE]: SqliteDsl.table(EVENT_CURSOR_TABLE, {
+    id: SqliteDsl.text({ primaryKey: true }),
+    cursor: SqliteDsl.text({ nullable: false }),
+  }).ast,
+  [SCHEMA_META_TABLE]: schemaMetaTable.ast,
+} satisfies TableDefinitions
 
 export const defineTables = <T extends TableDefinitions>(tables: T) => tables
 
@@ -149,71 +144,3 @@ declare global {
     [key: string]: ActionDefinition
   }
 }
-
-const mergeSystemSchema = <S extends Schema>(schema: S) => {
-  return {
-    ...schema,
-    tables: {
-      ...schema.tables,
-      ...systemTables,
-    },
-  }
-}
-
-/**
- * Destructively load a schema into a database,
- * dropping any existing tables and creating new ones.
- */
-export const loadSchema = async (backend: InMemoryDatabase | Backend, schema: Schema) => {
-  const fullSchemaWithComponents = { ...schema, tables: { ...schema.tables, ...componentStateTables } }
-
-  // Loop through all the tables and create them in the SQLite database
-  for (const [tableName, tableDefinition] of Object.entries(fullSchemaWithComponents.tables)) {
-    const primaryKeys = Object.entries(tableDefinition.columns)
-      .filter(([_, columnDef]) => columnDef.primaryKey)
-      .map(([columnName, _]) => columnName)
-    const columnDefStrs = Object.entries(tableDefinition.columns).map(([columnName, column]) =>
-      toSqliteColumnSpec(columnName, column),
-    )
-    if (primaryKeys.length > 0) {
-      columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
-    }
-    const mapColumns = tableDefinition.columnsRaw ?? ((_) => _)
-    const columnSpec = mapColumns(columnDefStrs.join(', '))
-
-    backend.execute(sql`drop table if exists ${tableName}`)
-
-    backend.execute(sql`create table if not exists ${tableName} (${columnSpec});`)
-  }
-
-  await createIndexes(backend, schema)
-}
-
-const toSqliteColumnSpec = (columnName: string, column: ColumnDefinition) => {
-  const columnType = column.type === 'boolean' ? 'integer' : column.type
-  // const primaryKey = column.primaryKey ? 'primary key' : ''
-  const nullable = column.nullable === false ? 'not null' : ''
-  const defaultValue =
-    column.default === undefined
-      ? ''
-      : column.type === 'text'
-      ? `default '${column.default}'`
-      : `default ${column.default}`
-
-  return `${columnName} ${columnType} ${nullable} ${defaultValue}`
-}
-
-const createIndexFromDefinition = (tableName: string, index: Index) => {
-  const uniqueStr = index.isUnique ? 'UNIQUE' : ''
-  return sql`create ${uniqueStr} index ${index.name} on ${tableName} (${index.columns.join(', ')})`
-}
-
-const createIndexes = async (db: Backend | InMemoryDatabase, schema: Schema) => {
-  for (const [tableName, tableDefinition] of Object.entries(schema.tables)) {
-    if (tableDefinition.indexes !== undefined) {
-      for (const index of tableDefinition.indexes) {
-        db.execute(createIndexFromDefinition(tableName, index))
-      }
-    }
-  }
-}

package/src/storage/in-memory/index.ts

@@ -0,0 +1,21 @@
+import type * as otel from '@opentelemetry/api'
+
+import type { ParamsObject } from '../../util.js'
+import type { Storage, StorageOtelProps } from '../index.js'
+
+export type StorageOptionsWebInMemory = {
+  type: 'web-in-memory'
+}
+
+/** NOTE: This storage is currently only used for testing */
+export class InMemoryStorage implements Storage {
+  constructor(readonly otelTracer: otel.Tracer) {}
+
+  static load = async (_options?: StorageOptionsWebInMemory) => {
+    return ({ otelTracer }: StorageOtelProps) => new InMemoryStorage(otelTracer)
+  }
+
+  execute = (_query: string, _bindValues?: ParamsObject): void => {}
+
+  getPersistedData = async (): Promise<Uint8Array> => new Uint8Array()
+}

package/src/storage/index.ts

@@ -0,0 +1,27 @@
+// A storage represents a raw SQLite database.
+// Examples include:
+// - A native SQLite process running in a Tauri Rust process
+// - A SQL.js WASM version of SQLite running in a web worker
+//
+// We can send commands to execute various kinds of queries,
+// and respond to various events from the database.
+
+import type * as otel from '@opentelemetry/api'
+
+import type { ParamsObject } from '../util.js'
+
+export type StorageInit = (otelProps: StorageOtelProps) => Promise<Storage> | Storage
+
+export interface Storage {
+  execute(query: string, bindValues?: ParamsObject, parentSpan?: otel.Span): void
+
+  /** Return a snapshot of persisted data from the storage */
+  getPersistedData(parentSpan?: otel.Span): Promise<Uint8Array>
+}
+
+export type StorageType = 'tauri' | 'web' | 'web-in-memory'
+
+export type StorageOtelProps = {
+  otelTracer: otel.Tracer
+  parentSpan: otel.Span
+}