@livestore/livestore 0.0.54-dev.5 → 0.0.54

package/src/reactiveQueries/base-class.ts

@@ -6,15 +6,15 @@ import type { StackInfo } from '../react/utils/stack-info.js'
 import { type Atom, type GetAtom, ReactiveGraph, throwContextNotSetError, type Thunk } from '../reactive.js'
 import type { QueryDebugInfo, RefreshReason, Store } from '../store.js'
 
-export type DbGraph = ReactiveGraph<RefreshReason, QueryDebugInfo, DbContext>
+export type ReactivityGraph = ReactiveGraph<RefreshReason, QueryDebugInfo, QueryContext>
 
-export const makeDbGraph = (): DbGraph =>
-  new ReactiveGraph<RefreshReason, QueryDebugInfo, DbContext>({
+export const makeReactivityGraph = (): ReactivityGraph =>
+  new ReactiveGraph<RefreshReason, QueryDebugInfo, QueryContext>({
     // TODO also find a better way to only use this effects wrapper when used in a React app
     effectsWrapper: (run) => ReactDOM.unstable_batchedUpdates(() => run()),
   })
 
-export type DbContext = {
+export type QueryContext = {
   store: Store
   otelTracer: otel.Tracer
   rootOtelContext: otel.Context
@@ -37,7 +37,7 @@ export interface LiveQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone
   '__result!': TResult
 
   /** A reactive thunk representing the query results */
-  results$: Thunk<TResult, DbContext, RefreshReason>
+  results$: Thunk<TResult, QueryContext, RefreshReason>
 
   label: string
 
@@ -72,11 +72,11 @@ export abstract class LiveStoreQueryBase<TResult, TQueryInfo extends QueryInfo>
   /** Human-readable label for the query for debugging */
   abstract label: string
 
-  abstract results$: Thunk<TResult, DbContext, RefreshReason>
+  abstract results$: Thunk<TResult, QueryContext, RefreshReason>
 
   activeSubscriptions: Set<StackInfo> = new Set()
 
-  protected abstract dbGraph: DbGraph
+  protected abstract reactivityGraph: ReactivityGraph
 
   abstract queryInfo: TQueryInfo
 
@@ -102,8 +102,8 @@ export abstract class LiveStoreQueryBase<TResult, TQueryInfo extends QueryInfo>
     onUnsubsubscribe?: () => void,
     options?: { label?: string; otelContext?: otel.Context } | undefined,
   ): (() => void) =>
-    this.dbGraph.context?.store.subscribe(this, onNewValue, onUnsubsubscribe, options) ??
-    throwContextNotSetError(this.dbGraph)
+    this.reactivityGraph.context?.store.subscribe(this, onNewValue, onUnsubsubscribe, options) ??
+    throwContextNotSetError(this.reactivityGraph)
 }
 
 export type GetAtomResult = <T>(atom: Atom<T, any, RefreshReason> | LiveQuery<T, any>) => T

package/src/reactiveQueries/graphql.ts

@@ -5,11 +5,11 @@ import { Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import * as graphql from 'graphql'
 
-import { globalDbGraph } from '../global-state.js'
+import { globalReactivityGraph } from '../global-state.js'
 import { isThunk, type Thunk } from '../reactive.js'
 import type { BaseGraphQLContext, RefreshReason, Store } from '../store.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
-import type { DbContext, DbGraph, GetAtomResult, LiveQuery } from './base-class.js'
+import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
 import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
 export type MapResult<To, From> = ((res: From, get: GetAtomResult) => To) | Schema.Schema<To, From>
@@ -21,9 +21,13 @@ export const queryGraphQL = <
 >(
   document: DocumentNode<TResult, TVariableValues>,
   genVariableValues: TVariableValues | ((get: GetAtomResult) => TVariableValues),
-  { label, dbGraph, map }: { label?: string; dbGraph?: DbGraph; map?: MapResult<TResultMapped, TResult> } = {},
+  {
+    label,
+    reactivityGraph,
+    map,
+  }: { label?: string; reactivityGraph?: ReactivityGraph; map?: MapResult<TResultMapped, TResult> } = {},
 ): LiveQuery<TResultMapped, QueryInfoNone> =>
-  new LiveStoreGraphQLQuery({ document, genVariableValues, label, dbGraph, map })
+  new LiveStoreGraphQLQuery({ document, genVariableValues, label, reactivityGraph, map })
 
 export class LiveStoreGraphQLQuery<
   TResult extends Record<string, any>,
@@ -37,13 +41,13 @@ export class LiveStoreGraphQLQuery<
   document: DocumentNode<TResult, TVariableValues>
 
   /** A reactive thunk representing the query results */
-  results$: Thunk<TResultMapped, DbContext, RefreshReason>
+  results$: Thunk<TResultMapped, QueryContext, RefreshReason>
 
-  variableValues$: Thunk<TVariableValues, DbContext, RefreshReason> | undefined
+  variableValues$: Thunk<TVariableValues, QueryContext, RefreshReason> | undefined
 
   label: string
 
-  protected dbGraph: DbGraph
+  protected reactivityGraph: ReactivityGraph
 
   queryInfo: QueryInfoNone = { _tag: 'None' }
 
@@ -53,13 +57,13 @@ export class LiveStoreGraphQLQuery<
     document,
     label,
     genVariableValues,
-    dbGraph,
+    reactivityGraph,
     map,
   }: {
     document: DocumentNode<TResult, TVariableValues>
     genVariableValues: TVariableValues | ((get: GetAtomResult) => TVariableValues)
     label?: string
-    dbGraph?: DbGraph
+    reactivityGraph?: ReactivityGraph
     map?: MapResult<TResultMapped, TResult>
   }) {
     super()
@@ -69,7 +73,7 @@ export class LiveStoreGraphQLQuery<
     this.label = labelWithDefault
     this.document = document
 
-    this.dbGraph = dbGraph ?? globalDbGraph
+    this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
 
     this.mapResult =
       map === undefined
@@ -92,7 +96,7 @@ export class LiveStoreGraphQLQuery<
     let variableValues$OrvariableValues
 
     if (typeof genVariableValues === 'function') {
-      variableValues$OrvariableValues = this.dbGraph.makeThunk(
+      variableValues$OrvariableValues = this.reactivityGraph.makeThunk(
         (get, _setDebugInfo, { rootOtelContext }, otelContext) => {
           return genVariableValues(makeGetAtomResult(get, otelContext ?? rootOtelContext))
         },
@@ -104,7 +108,7 @@ export class LiveStoreGraphQLQuery<
     }
 
     const resultsLabel = `${labelWithDefault}:results`
-    this.results$ = this.dbGraph.makeThunk<TResultMapped>(
+    this.results$ = this.reactivityGraph.makeThunk<TResultMapped>(
       (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) => {
         const variableValues = isThunk(variableValues$OrvariableValues)
           ? (get(variableValues$OrvariableValues) as TVariableValues)
@@ -145,7 +149,7 @@ export class LiveStoreGraphQLQuery<
   //     },
   //     label: `${this.label}:js`,
   //     onDestroy: () => this.destroy(),
-  //     dbGraph: this.dbGraph,
+  //     reactivityGraph: this.reactivityGraph,
   //   })
 
   queryOnce = ({
@@ -217,9 +221,9 @@ export class LiveStoreGraphQLQuery<
 
   destroy = () => {
     if (this.variableValues$ !== undefined) {
-      this.dbGraph.destroyNode(this.variableValues$)
+      this.reactivityGraph.destroyNode(this.variableValues$)
     }
 
-    this.dbGraph.destroyNode(this.results$)
+    this.reactivityGraph.destroyNode(this.results$)
   }
 }

package/src/reactiveQueries/js.ts

@@ -1,25 +1,25 @@
 import type { QueryInfo, QueryInfoNone } from '@livestore/common'
 import * as otel from '@opentelemetry/api'
 
-import { globalDbGraph } from '../global-state.js'
+import { globalReactivityGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
-import type { DbContext, DbGraph, GetAtomResult, LiveQuery } from './base-class.js'
+import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
 import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
 export const computed = <TResult, TQueryInfo extends QueryInfo = QueryInfoNone>(
   fn: (get: GetAtomResult) => TResult,
   options?: {
     label: string
-    dbGraph?: DbGraph
+    reactivityGraph?: ReactivityGraph
     queryInfo?: TQueryInfo
   },
 ): LiveQuery<TResult, TQueryInfo> =>
   new LiveStoreJSQuery<TResult, TQueryInfo>({
     fn,
     label: options?.label ?? fn.toString(),
-    dbGraph: options?.dbGraph,
+    reactivityGraph: options?.reactivityGraph,
     queryInfo: options?.queryInfo,
   })
 
@@ -30,11 +30,11 @@ export class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoN
   _tag: 'js' = 'js'
 
   /** A reactive thunk representing the query results */
-  results$: Thunk<TResult, DbContext, RefreshReason>
+  results$: Thunk<TResult, QueryContext, RefreshReason>
 
   label: string
 
-  protected dbGraph: DbGraph
+  protected reactivityGraph: ReactivityGraph
 
   queryInfo: TQueryInfo
 
@@ -50,14 +50,14 @@ export class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoN
     fn,
     label,
     onDestroy,
-    dbGraph,
+    reactivityGraph,
     queryInfo,
   }: {
     label: string
     fn: (get: GetAtomResult) => TResult
     /** Currently only used for "nested destruction" of piped queries */
     onDestroy?: () => void
-    dbGraph?: DbGraph
+    reactivityGraph?: ReactivityGraph
     queryInfo?: TQueryInfo
   }) {
     super()
@@ -65,12 +65,12 @@ export class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoN
     this.onDestroy = onDestroy
     this.label = label
 
-    this.dbGraph = dbGraph ?? globalDbGraph
+    this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
     this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
 
     const queryLabel = `${label}:results`
 
-    this.results$ = this.dbGraph.makeThunk(
+    this.results$ = this.reactivityGraph.makeThunk(
       (get, setDebugInfo, { otelTracer, rootOtelContext }, otelContext) =>
         otelTracer.startActiveSpan(`js:${label}`, {}, otelContext ?? rootOtelContext, (span) => {
           const otelContext = otel.trace.setSpan(otel.context.active(), span)
@@ -98,11 +98,11 @@ export class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoN
   //     },
   //     label: `${this.label}:js`,
   //     onDestroy: () => this.destroy(),
-  //     dbGraph: this.dbGraph,
+  //     reactivityGraph: this.reactivityGraph,
   //   })
 
   destroy = () => {
-    this.dbGraph.destroyNode(this.results$)
+    this.reactivityGraph.destroyNode(this.results$)
     this.onDestroy?.()
   }
 }

package/src/reactiveQueries/sql.test.ts

@@ -24,17 +24,17 @@ describe('otel', () => {
     provider.addSpanProcessor(new SimpleSpanProcessor(exporter))
     provider.register()
 
-    const tracer = otel.trace.getTracer('test')
+    const otelTracer = otel.trace.getTracer('test')
 
-    const span = tracer.startSpan('test')
+    const span = otelTracer.startSpan('test')
     const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
-    const { store } = await makeTodoMvc({ otelTracer: tracer, otelContext })
+    const { store } = await makeTodoMvc({ otelTracer, otelContext })
 
     return {
       [Symbol.dispose]: () => store.destroy(),
       store,
-      tracer,
+      otelTracer,
       exporter,
       span,
       provider,
@@ -60,7 +60,7 @@ describe('otel', () => {
       ]
     `)
 
-    store.destroy()
+    await store.destroy()
     query.destroy()
     span.end()
 
@@ -193,7 +193,7 @@ describe('otel', () => {
       }
     `)
 
-    store.destroy()
+    await store.destroy()
     query.destroy()
     span.end()
 

package/src/reactiveQueries/sql.ts

@@ -1,15 +1,13 @@
-import type { QueryInfo, QueryInfoNone } from '@livestore/common'
+import { type Bindable, prepareBindValues, type QueryInfo, type QueryInfoNone } from '@livestore/common'
 import { shouldNeverHappen } from '@livestore/utils'
 import { Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
-import { globalDbGraph } from '../global-state.js'
+import { globalReactivityGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
-import type { Bindable } from '../utils/util.js'
-import { prepareBindValues } from '../utils/util.js'
-import type { DbContext, DbGraph, GetAtomResult, LiveQuery } from './base-class.js'
+import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
 import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
 export type MapRows<TResult, TRaw = any> =
@@ -28,7 +26,7 @@ export const querySQL = <TResult, TRaw = any>(
     queriedTables?: Set<string>
     bindValues?: Bindable
     label?: string
-    dbGraph?: DbGraph
+    reactivityGraph?: ReactivityGraph
   },
 ): LiveQuery<TResult, QueryInfoNone> =>
   new LiveStoreSQLQuery<TResult, QueryInfoNone>({
@@ -36,7 +34,7 @@ export const querySQL = <TResult, TRaw = any>(
     genQueryString: query,
     queriedTables: options?.queriedTables,
     bindValues: options?.bindValues,
-    dbGraph: options?.dbGraph,
+    reactivityGraph: options?.reactivityGraph,
     map: options?.map,
     queryInfo: { _tag: 'None' },
   })
@@ -49,14 +47,14 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
   _tag: 'sql' = 'sql'
 
   /** A reactive thunk representing the query text */
-  queryString$: Thunk<string, DbContext, RefreshReason> | undefined
+  queryString$: Thunk<string, QueryContext, RefreshReason> | undefined
 
   /** A reactive thunk representing the query results */
-  results$: Thunk<TResult, DbContext, RefreshReason>
+  results$: Thunk<TResult, QueryContext, RefreshReason>
 
   label: string
 
-  protected dbGraph
+  protected reactivityGraph
 
   /** Currently only used by `rowQuery` for lazy table migrations and eager default row insertion */
   private execBeforeFirstRun
@@ -70,7 +68,7 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     queriedTables,
     bindValues,
     label: label_,
-    dbGraph,
+    reactivityGraph,
     map,
     execBeforeFirstRun,
     queryInfo,
@@ -79,16 +77,16 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     genQueryString: string | ((get: GetAtomResult) => string)
     queriedTables?: Set<string>
     bindValues?: Bindable
-    dbGraph?: DbGraph
+    reactivityGraph?: ReactivityGraph
     map?: MapRows<TResult>
-    execBeforeFirstRun?: (ctx: DbContext) => void
+    execBeforeFirstRun?: (ctx: QueryContext) => void
     queryInfo?: TQueryInfo
   }) {
     super()
 
     const label = label_ ?? genQueryString.toString()
     this.label = `sql(${label})`
-    this.dbGraph = dbGraph ?? globalDbGraph
+    this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
     this.execBeforeFirstRun = execBeforeFirstRun
     this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
     this.mapRows =
@@ -126,9 +124,9 @@ Result:`,
             ? map
             : shouldNeverHappen(`Invalid map function ${map}`)
 
-    let queryString$OrQueryString: string | Thunk<string, DbContext, RefreshReason>
+    let queryString$OrQueryString: string | Thunk<string, QueryContext, RefreshReason>
     if (typeof genQueryString === 'function') {
-      queryString$OrQueryString = this.dbGraph.makeThunk(
+      queryString$OrQueryString = this.reactivityGraph.makeThunk(
         (get, setDebugInfo, { rootOtelContext }, otelContext) => {
           const startMs = performance.now()
           const queryString = genQueryString(makeGetAtomResult(get, otelContext ?? rootOtelContext))
@@ -148,7 +146,7 @@ Result:`,
 
     const queriedTablesRef = { current: queriedTables }
 
-    const results$ = this.dbGraph.makeThunk<TResult>(
+    const results$ = this.reactivityGraph.makeThunk<TResult>(
       (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) =>
         otelTracer.startActiveSpan(
           'sql:...', // NOTE span name will be overridden further down
@@ -219,7 +217,7 @@ Result:`,
   //     },
   //     label: `${this.label}:js`,
   //     onDestroy: () => this.destroy(),
-  //     dbGraph: this.dbGraph,
+  //     reactivityGraph: this.reactivityGraph,
   //     queryInfo: undefined,
   //   })
 
@@ -237,14 +235,14 @@ Result:`,
   //     },
   //     label: `${this.label}:first`,
   //     onDestroy: () => this.destroy(),
-  //     dbGraph: this.dbGraph,
+  //     reactivityGraph: this.reactivityGraph,
   //   })
 
   destroy = () => {
     if (this.queryString$ !== undefined) {
-      this.dbGraph.destroyNode(this.queryString$)
+      this.reactivityGraph.destroyNode(this.queryString$)
     }
 
-    this.dbGraph.destroyNode(this.results$)
+    this.reactivityGraph.destroyNode(this.results$)
   }
 }

package/src/row-query.ts

@@ -1,23 +1,21 @@
-import type { InMemoryDatabase, QueryInfoCol, QueryInfoNone, QueryInfoRow } from '@livestore/common'
-import { migrateTable, sql } from '@livestore/common'
-import { DbSchema, SCHEMA_META_TABLE } from '@livestore/common/schema'
+import type { QueryInfoCol, QueryInfoNone, QueryInfoRow } from '@livestore/common'
+import { sql } from '@livestore/common'
+import { DbSchema } from '@livestore/common/schema'
 import type { GetValForKey } from '@livestore/utils'
 import { shouldNeverHappen } from '@livestore/utils'
 import { Schema, TreeFormatter } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type { SqliteDsl } from 'effect-db-schema'
-import { SqliteAst } from 'effect-db-schema'
 
-import type { Ref } from './reactive.js'
-import type { DbContext, DbGraph, LiveQuery, LiveQueryAny } from './reactiveQueries/base-class.js'
+import type { LiveQuery, LiveQueryAny, QueryContext, ReactivityGraph } from './reactiveQueries/base-class.js'
 import { computed } from './reactiveQueries/js.js'
 import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
-import type { RefreshReason, Store } from './store.js'
+import type { Store } from './store.js'
 
 export type RowQueryOptions = {
   otelContext?: otel.Context
   skipInsertDefaultRow?: boolean
-  dbGraph?: DbGraph
+  reactivityGraph?: ReactivityGraph
 }
 
 export type RowQueryOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
@@ -76,12 +74,11 @@ export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
     label: `rowQuery:query:${tableSchema.name}${id === undefined ? '' : `:${id}`}`,
     genQueryString: queryStr,
     queriedTables: new Set([tableName]),
-    dbGraph: options?.dbGraph,
+    reactivityGraph: options?.reactivityGraph,
     // While this code-path is not needed for singleton tables, it's still needed for `useRow` with non-existing rows for a given ID
     execBeforeFirstRun: makeExecBeforeFirstRun({
       otelContext: options?.otelContext,
       table,
-      tableName,
       defaultValues,
       id,
       skipInsertDefaultRow: options?.skipInsertDefaultRow,
@@ -136,59 +133,16 @@ const makeExecBeforeFirstRun =
     skipInsertDefaultRow,
     otelContext: otelContext_,
     table,
-    tableName,
   }: {
     id?: string
     defaultValues?: any
     skipInsertDefaultRow?: boolean
     otelContext?: otel.Context
-    tableName: string
     table: DbSchema.TableDef
   }) =>
-  ({ store }: DbContext) => {
+  ({ store }: QueryContext) => {
     const otelContext = otelContext_ ?? store.otel.queriesSpanContext
 
-    // TODO we can remove this codepath again when Devtools v2 has landed
-    if (store.tableRefs[tableName] === undefined) {
-      const schemaHash = SqliteAst.hash(table.sqliteDef.ast)
-      const res = store.mainDbWrapper.select<{ schemaHash: number }>(
-        sql`SELECT schemaHash FROM ${SCHEMA_META_TABLE} WHERE tableName = '${tableName}'`,
-      )
-      if (res.length === 0 || res[0]!.schemaHash !== schemaHash) {
-        const db = {
-          ...store.adapter.mainDb,
-          prepare: (query) => {
-            const mainStmt = store.adapter.mainDb.prepare(query)
-            return {
-              ...mainStmt,
-              execute: (bindValues) => {
-                const getRowsChanged = mainStmt.execute(bindValues)
-                store.adapter.coordinator.execute(query, bindValues, undefined)
-                return getRowsChanged
-              },
-            }
-          },
-        } satisfies InMemoryDatabase
-
-        migrateTable({
-          db,
-          tableAst: table.sqliteDef.ast,
-          otelContext,
-          schemaHash,
-          behaviour: 'create-if-not-exists',
-        })
-      }
-
-      const label = `tableRef:${tableName}`
-
-      // TODO find a better implementation for this
-      const existingTableRefFromGraph = Array.from(store.graph.atoms.values()).find(
-        (_) => _._tag === 'ref' && _.label === label,
-      ) as Ref<null, DbContext, RefreshReason> | undefined
-
-      store.tableRefs[tableName] = existingTableRefFromGraph ?? store.makeTableRef(tableName)
-    }
-
     if (skipInsertDefaultRow !== true && table.options.isSingleton === false) {
       insertRowWithDefaultValuesOrIgnore({
         store,