@livestore/livestore 0.0.12 → 0.0.14

package/src/inMemoryDatabase.ts

@@ -1,33 +1,17 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
 import { shouldNeverHappen } from '@livestore/utils'
-import { identity } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
-import type * as SqliteWasm from 'sqlite-esm'
-import initSqlJs from 'sqlite-esm'
+import type * as Sqlite from 'sqlite-esm'
 
 import BoundMap, { BoundArray } from './bounded-collections.js'
-import type { LiveStoreEvent } from './events.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 { ActionDefinition } from './schema.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>
@@ -38,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,
 ]
 
@@ -54,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()
@@ -63,21 +47,21 @@ export class InMemoryDatabase {
     private db: DatabaseWithCAPI,
     private otelTracer: otel.Tracer,
     private otelRootSpanContext: otel.Context,
-    public SQL: SqliteWasm.Sqlite3Static,
+    public SQL: Sqlite.Sqlite3Static,
   ) {}
 
-  static async load(
-    data: Uint8Array | undefined,
-    otelTracer: otel.Tracer,
-    otelRootSpanContext: otel.Context,
-  ): Promise<InMemoryDatabase> {
-    const sqlite3 = await initSqlJs({
-      // Required to load the wasm binary asynchronously. Of course, you can host it wherever you want
-      // You can omit locateFile completely when running in node
-      // locateFile: () => `/sql-wasm.wasm`,
-      print: (message) => console.log(`[sql-client] ${message}`),
-      printErr: (message) => console.error(`[sql-client] ${message}`),
-    })
+  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
     db.capi = sqlite3.capi
@@ -97,7 +81,11 @@ export class InMemoryDatabase {
       )
     }
 
-    return new InMemoryDatabase(db, otelTracer, otelRootSpanContext, sqlite3)
+    const inMemoryDatabase = new InMemoryDatabase(db, otelTracer, otelRootSpanContext, sqlite3)
+
+    configureSQLite(inMemoryDatabase)
+
+    return inMemoryDatabase
   }
 
   txn<TRes>(callback: () => TRes): TRes {
@@ -141,56 +129,81 @@ export class InMemoryDatabase {
     return tablesUsed as string[]
   }
 
-  /**
-   * NOTE `execute` is untraced since it's usually called from `applyEvent` which is traced
-   */
   execute(
     query: string,
-    bindValues?: ParamsObject,
+    bindValues?: PreparedBindValues,
     writeTables?: string[],
-    options?: { hasNoEffects?: boolean },
-  ): void {
-    try {
-      let stmt = this.cachedStmts.get(query)
-      if (stmt === undefined) {
-        stmt = this.db.prepare(query)
-        this.cachedStmts.set(query, stmt)
-      }
+    options?: { hasNoEffects?: boolean; otelContext: otel.Context },
+  ): { durationMs: number } {
+    return this.otelTracer.startActiveSpan(
+      'livestore.in-memory-db:execute',
+      // TODO truncate query string
+      { attributes: { 'sql.query': query } },
+      options?.otelContext ?? this.otelRootSpanContext,
+      (span) => {
+        try {
+          let stmt = this.cachedStmts.get(query)
+          if (stmt === undefined) {
+            stmt = this.db.prepare(query)
+            this.cachedStmts.set(query, stmt)
+          }
 
-      if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
-        stmt.bind(prepareBindValues(bindValues, query))
-      }
+          if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
+            stmt.bind(bindValues)
+          }
 
-      try {
-        stmt.step()
-      } finally {
-        stmt.reset() // Reset is needed for next execution
-      }
-    } catch (error) {
-      shouldNeverHappen(
-        `Error executing query: ${error} \n ${JSON.stringify({
-          query,
-          bindValues,
-        })}`,
-      )
-    }
+          if (import.meta.env.DEV) {
+            this.debugInfo.events.push([query, bindValues])
+          }
 
-    if (options?.hasNoEffects !== true && !this.resultCache.ignoreQuery(query)) {
-      // TODO use write tables instead
-      // check what queries actually end up here.
-      this.resultCache.invalidate(writeTables ?? this.getTablesUsed(query))
-    }
+          try {
+            stmt.step()
+          } finally {
+            stmt.reset() // Reset is needed for next execution
+          }
+        } catch (error) {
+          shouldNeverHappen(
+            `Error executing query: ${error} \n ${JSON.stringify({
+              query,
+              bindValues,
+            })}`,
+          )
+        }
 
-    if (options?.hasNoEffects === true) {
-      return
-    }
+        if (options?.hasNoEffects !== true && !this.resultCache.ignoreQuery(query)) {
+          // TODO use write tables instead
+          // check what queries actually end up here.
+          this.resultCache.invalidate(writeTables ?? this.getTablesUsed(query))
+        }
+
+        span.end()
+
+        const durationMs = getDurationMsFromSpan(span)
+
+        this.debugInfo.queryFrameDuration += durationMs
+        this.debugInfo.queryFrameCount++
+
+        if (durationMs > 5 && import.meta.env.DEV) {
+          this.debugInfo.slowQueries.push([
+            query,
+            bindValues,
+            durationMs,
+            undefined,
+            [],
+            getStartTimeHighResFromSpan(span),
+          ])
+        }
+
+        return { durationMs }
+      },
+    )
   }
 
   select<T = any>(
     query: string,
     options?: {
-      queriedTables?: string[]
-      bindValues?: Bindable
+      queriedTables?: ReadonlyArray<string>
+      bindValues?: PreparedBindValues
       skipCache?: boolean
       otelContext?: otel.Context
     },
@@ -218,19 +231,27 @@ export class InMemoryDatabase {
             stmt = this.db.prepare(query)
             this.cachedStmts.set(query, stmt)
           }
-          if (bindValues) {
-            stmt.bind(bindValues ?? {})
+          if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
+            stmt.bind(bindValues)
           }
 
           const result: T[] = []
+
           try {
-            const columns = stmt.getColumnNames()
+            // NOTE `getColumnNames` only works for `SELECT` statements, ignoring other statements for now
+            let columns = undefined
+            try {
+              columns = stmt.getColumnNames()
+            } catch (_e) {}
+
             while (stmt.step()) {
-              const obj: { [key: string]: any } = {}
-              for (const [i, c] of columns.entries()) {
-                obj[c] = stmt.get(i)
+              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)
               }
-              result.push(obj as unknown as T)
             }
           } finally {
             // we're caching statements in this iteration. do not free.
@@ -275,67 +296,6 @@ export class InMemoryDatabase {
     )
   }
 
-  // TODO move `applyEvent` logic to Store and only call `execute` here
-  applyEvent(
-    event: LiveStoreEvent,
-    eventDefinition: ActionDefinition,
-    otelContext: otel.Context,
-  ): { durationMs: number } {
-    return this.otelTracer.startActiveSpan('livestore.in-memory-db:applyEvent', {}, otelContext, (span) => {
-      // TODO: in the future, we'll do more CRDT-style stuff here to decide whether to run effects of the event
-
-      // NOTE: These two updates should happen transactionally;
-      // we don't create a transaction here because that's handled in the caller.
-      // The reason for this is that sometimes we want to apply multiple events in a larger transaction.
-
-      // Insert into the events table
-      // this.execute(sql`insert into ${EVENTS_TABLE_NAME} (id, type, args) values ($id, $type, $args)`, {
-      //   id: event.id,
-      //   type: event.type,
-      //   args: JSON.stringify(event.args ?? {}),
-      // })
-
-      const statement =
-        typeof eventDefinition.statement === 'function'
-          ? eventDefinition.statement(event.args)
-          : eventDefinition.statement
-
-      const prepareBindValues = eventDefinition.prepareBindValues ?? identity
-
-      const bindValues =
-        typeof eventDefinition.statement === 'function' && statement.argsAlreadyBound
-          ? {}
-          : prepareBindValues(event.args)
-
-      if (import.meta.env.DEV) {
-        this.debugInfo.events.push([statement.sql, bindValues])
-      }
-
-      // Run the effects of the event
-      this.execute(statement.sql, bindValues, statement.writeTables)
-
-      span.end()
-
-      const durationMs = getDurationMsFromSpan(span)
-
-      this.debugInfo.queryFrameDuration += durationMs
-      this.debugInfo.queryFrameCount++
-
-      if (durationMs > 5 && import.meta.env.DEV) {
-        this.debugInfo.slowQueries.push([
-          statement.sql,
-          bindValues,
-          durationMs,
-          undefined,
-          [],
-          getStartTimeHighResFromSpan(span),
-        ])
-      }
-
-      return { durationMs }
-    })
-  }
-
   export() {
     // Clear statement cache because exporting frees statements
     for (const key of this.cachedStmts.keys()) {
@@ -345,3 +305,18 @@ export class InMemoryDatabase {
     return this.db.capi.sqlite3_js_db_export(this.db.pointer)
   }
 }
+
+/** Set up SQLite performance; hasn't been super carefully optimized yet. */
+const configureSQLite = (db: InMemoryDatabase) => {
+  db.execute(
+    // TODO: revisit these tuning parameters for max performance
+    sql`
+      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
+    `,
+  )
+}

package/src/index.ts

@@ -1,23 +1,18 @@
-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,
-  defineSchema,
   defineAction,
   defineActions,
   defineTables,
   defineMaterializedViews,
+  makeSchema,
 } from './schema.js'
 export { InMemoryDatabase, type DebugInfo, emptyDebugInfo } from './inMemoryDatabase.js'
-export { createBackend, IndexType } from './backends/index.js'
-export type { BackendOptions, Backend, BackendType } from './backends/index.js'
-export { isBackendType } from './backends/index.js'
-export type { SelectResponse } from './backends/index.js'
-export { WebWorkerBackend } from './backends/web.js'
+export type { Storage, StorageType, StorageInit } from './storage/index.js'
 export type {
   GetAtom,
   AtomDebugInfo,
@@ -25,23 +20,24 @@ 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'
-export type {
-  Schema,
-  TableDefinition,
-  GetActionArgs,
-  GetApplyEventArgs,
-  ColumnDefinition,
-  Index,
-  ActionDefinition,
-  ActionDefinitions,
-} from './schema.js'
+export type { Schema, GetActionArgs, GetApplyEventArgs, Index, ActionDefinition, ActionDefinitions } from './schema.js'
+
+export { SqliteAst, SqliteDsl } from 'effect-db-schema'
+
+import type { SqliteAst } from 'effect-db-schema'
+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

@@ -0,0 +1,119 @@
+import type * as otel from '@opentelemetry/api'
+import { SqliteAst } from 'effect-db-schema'
+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,
+  otelContext,
+  schema,
+}: {
+  db: InMemoryDatabase
+  otelContext: otel.Context
+  schema: Schema
+}) => {
+  db.execute(
+    // 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,
+    [],
+    { otelContext },
+  )
+
+  const schemaMetaRows = db.select<SchemaMetaRow>(sql`SELECT * FROM ${SCHEMA_META_TABLE}`)
+
+  const dbSchemaHashByTable = Object.fromEntries(
+    schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
+  )
+
+  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],
+    ...omit(schema.tables, [SCHEMA_META_TABLE]),
+    ...componentStateTables,
+  }
+
+  for (const [tableName, tableDef] of Object.entries(tableDefs)) {
+    const dbSchemaHash = dbSchemaHashByTable[tableName]
+    const schemaHash = SqliteAst.hash(tableDef)
+    if (schemaHash !== dbSchemaHash) {
+      console.log(
+        `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
+      )
+
+      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(', ')})`
+}
+
+const makeColumnSpec = (tableDef: SqliteAst.Table) => {
+  const primaryKeys = tableDef.columns.filter((_) => _.primaryKey).map((_) => _.name)
+  const columnDefStrs = tableDef.columns.map(toSqliteColumnSpec)
+  if (primaryKeys.length > 0) {
+    columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
+  }
+
+  return columnDefStrs.join(', ')
+}
+
+const toSqliteColumnSpec = (column: SqliteAst.Column) => {
+  const columnType = column.type._tag
+  // const primaryKey = column.primaryKey ? 'primary key' : ''
+  const nullable = column.nullable === false ? 'not null' : ''
+  const defaultValue =
+    column.default === undefined
+      ? ''
+      : columnType === 'text'
+      ? `default '${column.default}'`
+      : `default ${column.default}`
+
+  return `${column.name} ${columnType} ${nullable} ${defaultValue}`
+}

package/src/otel.ts

@@ -1,16 +1,5 @@
 import type * as otel from '@opentelemetry/api'
 
-// TODO improve - see https://www.notion.so/schickling/Better-solution-for-globalThis-inProgressSpans-503cd7a5f4fc4fb8bdec2e60bde1be1f
-export const TODO_REMOVE_trackLongRunningSpan = (span: otel.Span): void => {
-  // @ts-expect-error TODO get rid of this coupling
-  if (window.inProgressSpans !== undefined && window.inProgressSpans instanceof Set) {
-    // @ts-expect-error TODO get rid of this coupling
-    window.inProgressSpans.add(span)
-  } else {
-    // debugger
-  }
-}
-
 export const getDurationMsFromSpan = (span: otel.Span): number => {
   const durationHr: [seconds: number, nanos: number] = (span as any)._duration
   return durationHr[0] * 1000 + durationHr[1] / 1_000_000

package/src/react/LiveStoreProvider.tsx

@@ -1,24 +1,28 @@
 import type * as otel from '@opentelemetry/api'
-import { mapValues } from 'lodash-es'
 import type { ReactElement, ReactNode } from 'react'
 import React from 'react'
+import initSqlite3Wasm from 'sqlite-esm'
 
-import type { Backend, BackendOptions } from '../backends/index.js'
-import type {
-  GlobalQueryDefs,
-  LiveStoreContext as StoreContext_,
-  LiveStoreCreateStoreOptions,
-} from '../effect/LiveStore.js'
+// TODO refactor so the `react` module doesn't depend on `effect` module
+import type { LiveStoreContext as StoreContext_, LiveStoreCreateStoreOptions } from '../effect/LiveStore.js'
+import type { InMemoryDatabase } from '../inMemoryDatabase.js'
 import type { Schema } from '../schema.js'
+import type { StorageInit } from '../storage/index.js'
 import type { BaseGraphQLContext, GraphQLOptions } from '../store.js'
 import { createStore } from '../store.js'
 import { LiveStoreContext } from './LiveStoreContext.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}`),
+})
+
 interface LiveStoreProviderProps<GraphQLContext> {
   schema: Schema
-  backendOptions: BackendOptions
-  boot?: (backend: Backend, parentSpan: otel.Span) => Promise<void>
-  globalQueryDefs: GlobalQueryDefs
+  loadStorage: () => StorageInit | Promise<StorageInit>
+  boot?: (db: InMemoryDatabase, parentSpan: otel.Span) => unknown | Promise<unknown>
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelTracer?: otel.Tracer
   otelRootSpanContext?: otel.Context
@@ -27,8 +31,7 @@ interface LiveStoreProviderProps<GraphQLContext> {
 
 export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   fallback,
-  globalQueryDefs,
-  backendOptions,
+  loadStorage,
   graphQLOptions,
   otelTracer,
   otelRootSpanContext,
@@ -38,8 +41,7 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
 }: LiveStoreProviderProps<GraphQLContext> & { children?: ReactNode }): JSX.Element => {
   const store = useCreateStore({
     schema,
-    globalQueryDefs,
-    backendOptions,
+    loadStorage,
     graphQLOptions,
     otelTracer,
     otelRootSpanContext,
@@ -50,13 +52,14 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
     return fallback
   }
 
+  window.__debugLiveStore = store.store
+
   return <LiveStoreContext.Provider value={store}>{children}</LiveStoreContext.Provider>
 }
 
 const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   schema,
-  globalQueryDefs,
-  backendOptions,
+  loadStorage,
   graphQLOptions,
   otelTracer,
   otelRootSpanContext,
@@ -67,19 +70,17 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   React.useEffect(() => {
     void (async () => {
       try {
+        const sqlite3 = await sqlite3Promise
         const store = await createStore({
           schema,
-          backendOptions,
+          loadStorage,
           graphQLOptions,
           otelTracer,
           otelRootSpanContext,
           boot,
+          sqlite3,
         })
-        store.otel.tracer.startActiveSpan('LiveStore:makeGlobalQueries', {}, store.otel.queriesSpanContext, (span) => {
-          const globalQueries = mapValues(globalQueryDefs, (queryDef) => queryDef(store))
-          setCtxValue({ store, globalQueries })
-          span.end()
-        })
+        setCtxValue({ store })
       } catch (e) {
         console.error(`Error creating LiveStore store:`, e)
         throw e
@@ -87,7 +88,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
     })()
 
     // TODO: do we need to return any cleanup function here?
-  }, [schema, backendOptions, globalQueryDefs, graphQLOptions, otelTracer, otelRootSpanContext, boot])
+  }, [schema, loadStorage, graphQLOptions, otelTracer, otelRootSpanContext, boot])
 
   return ctxValue
 }

package/src/react/index.ts

@@ -1,11 +1,16 @@
 export type {
-  UseLiveStoreComponentProps as LiveStoreComponentConfig,
-  ReactiveGraphQL,
-  ReactiveSQL,
   Setters,
-} from './useLiveStoreComponent.js'
+  ComponentKeyConfig,
+  QueryDefinitions,
+  ComponentColumns,
+  GetStateType,
+  GetStateTypeEncoded,
+} from './useComponentState.js'
 export { LiveStoreContext, useStore } from './LiveStoreContext.js'
 export { LiveStoreProvider } from './LiveStoreProvider.js'
-export { useLiveStoreComponent } from './useLiveStoreComponent.js'
-export { useGraphQL } from './useGraphQL.js'
-export { useGlobalQuery } from './useGlobalQuery.js'
+export { useComponentState } from './useComponentState.js'
+export { useQuery } from './useQuery.js'
+export { useTemporaryQuery } from './useTemporaryQuery.js'
+
+// Needed to make TS happy
+export type { TypedDocumentNode } from '@graphql-typed-document-node/core'