@livestore/livestore 0.0.54-dev.2 → 0.0.54-dev.22

package/src/MainDatabaseWrapper.ts

@@ -1,13 +1,18 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
-import type { DebugInfo, InMemoryDatabase, MutableDebugInfo, PreparedStatement } from '@livestore/common'
+import type {
+  DebugInfo,
+  InMemoryDatabase,
+  MutableDebugInfo,
+  PreparedBindValues,
+  PreparedStatement,
+} from '@livestore/common'
 import { BoundArray, BoundMap, sql } from '@livestore/common'
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 
 import QueryCache from './QueryCache.js'
 import { getDurationMsFromSpan, getStartTimeHighResFromSpan } from './utils/otel.js'
-import { type PreparedBindValues } from './utils/util.js'
 
 export const emptyDebugInfo = (): DebugInfo => ({
   slowQueries: new BoundArray(200),
@@ -29,16 +34,17 @@ export class MainDatabaseWrapper {
 
   constructor({
     db,
-    otelTracer,
-    otelRootSpanContext,
+    otel,
   }: {
     db: InMemoryDatabase
-    otelTracer: otel.Tracer
-    otelRootSpanContext: otel.Context
+    otel: {
+      tracer: otel.Tracer
+      rootSpanContext: otel.Context
+    }
   }) {
     this.db = db
-    this.otelTracer = otelTracer
-    this.otelRootSpanContext = otelRootSpanContext
+    this.otelTracer = otel.tracer
+    this.otelRootSpanContext = otel.rootSpanContext
 
     this.tablesUsedStmt = db.prepare(
       `SELECT tbl_name FROM tables_used(?) AS u JOIN sqlite_master ON sqlite_master.name = u.name WHERE u.schema = 'main';`,

package/src/QueryCache.ts

@@ -1,7 +1,6 @@
+import type { Bindable } from '@livestore/common'
 import { BoundMap, BoundSet } from '@livestore/common'
 
-import type { Bindable } from './utils/util.js'
-
 type Opaque<BaseType, BrandType = unknown> = BaseType & {
   readonly [Symbols.base]: BaseType
   readonly [Symbols.brand]: BrandType

package/src/__tests__/react/fixture.tsx

@@ -3,9 +3,9 @@ import { makeInMemoryAdapter } from '@livestore/web'
 import type * as otel from '@opentelemetry/api'
 import React from 'react'
 
-import { globalDbGraph } from '../../global-state.js'
+import { globalReactivityGraph } from '../../global-state.js'
 import type { LiveStoreContext } from '../../index.js'
-import { createStore, DbSchema, makeDbGraph, makeSchema, ParseUtils, sql } from '../../index.js'
+import { createStore, DbSchema, makeReactivityGraph, makeSchema, ParseUtils, sql } from '../../index.js'
 import * as LiveStoreReact from '../../react/index.js'
 
 export type Todo = {
@@ -62,15 +62,15 @@ export const parseTodos = ParseUtils.many(todos)
 export const makeTodoMvc = async ({
   otelTracer,
   otelContext,
-  useGlobalDbGraph = true,
+  useGlobalReactivityGraph = true,
   strictMode = process.env.REACT_STRICT_MODE !== undefined,
 }: {
   otelTracer?: otel.Tracer
   otelContext?: otel.Context
-  useGlobalDbGraph?: boolean
+  useGlobalReactivityGraph?: boolean
   strictMode?: boolean
 } = {}) => {
-  const dbGraph = useGlobalDbGraph ? globalDbGraph : makeDbGraph()
+  const reactivityGraph = useGlobalReactivityGraph ? globalReactivityGraph : makeReactivityGraph()
 
   const makeRenderCount = () => {
     let val = 0
@@ -91,9 +91,11 @@ export const makeTodoMvc = async ({
     schema,
     boot: (db) => db.execute(sql`INSERT OR IGNORE INTO app (id, newTodoText, filter) VALUES ('static', '', 'all');`),
     adapter: makeInMemoryAdapter(),
-    dbGraph,
-    otelTracer,
-    otelRootSpanContext: otelContext,
+    reactivityGraph,
+    otelOptions: {
+      tracer: otelTracer,
+      rootSpanContext: otelContext,
+    },
   })
 
   // TODO improve typing of `LiveStoreContext`
@@ -115,7 +117,7 @@ export const makeTodoMvc = async ({
     AppComponentSchema: userInfo,
     AppRouterSchema,
     store,
-    dbGraph,
+    reactivityGraph,
     makeRenderCount,
     strictMode,
   }

package/src/effect/LiveStore.ts

@@ -7,7 +7,7 @@ import type { GraphQLSchema } from 'graphql'
 
 import type { MainDatabaseWrapper } from '../MainDatabaseWrapper.js'
 import type { LiveQuery } from '../reactiveQueries/base-class.js'
-import type { BaseGraphQLContext, GraphQLOptions, Store } from '../store.js'
+import type { BaseGraphQLContext, GraphQLOptions, OtelOptions, Store } from '../store.js'
 import { createStore } from '../store.js'
 
 // TODO get rid of `LiveStoreContext` wrapper and only expose the `Store` directly
@@ -20,8 +20,7 @@ export type QueryDefinition = <TResult>(store: Store) => LiveQuery<TResult>
 export type LiveStoreCreateStoreOptions<GraphQLContext extends BaseGraphQLContext> = {
   schema: LiveStoreSchema
   graphQLOptions?: GraphQLOptions<GraphQLContext>
-  otelTracer?: otel.Tracer
-  otelRootSpanContext?: otel.Context
+  otelOptions?: OtelOptions
   boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
   adapter: StoreAdapterFactory
   batchUpdates?: (run: () => void) => void
@@ -92,8 +91,10 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
           createStore({
             schema,
             graphQLOptions,
-            otelTracer,
-            otelRootSpanContext,
+            otelOptions: {
+              tracer: otelTracer,
+              rootSpanContext: otelRootSpanContext,
+            },
             boot,
             adapter,
             disableDevtools,

package/src/global-state.ts

@@ -13,8 +13,8 @@
 
 import type { DbSchema } from '@livestore/common/schema'
 
-import { makeDbGraph } from './reactiveQueries/base-class.js'
+import { makeReactivityGraph } from './reactiveQueries/base-class.js'
 
-export const globalDbGraph = makeDbGraph()
+export const globalReactivityGraph = makeReactivityGraph()
 
 export const dynamicallyRegisteredTables: Map<string, DbSchema.TableDef> = new Map()

package/src/index.ts

@@ -20,18 +20,31 @@ export type {
 export { LiveStoreJSQuery, computed } from './reactiveQueries/js.js'
 export { LiveStoreSQLQuery, querySQL, type MapRows } from './reactiveQueries/sql.js'
 export { LiveStoreGraphQLQuery, queryGraphQL } from './reactiveQueries/graphql.js'
-export { type GetAtomResult, type DbGraph, makeDbGraph, type LiveQuery } from './reactiveQueries/base-class.js'
+export {
+  type GetAtomResult,
+  type ReactivityGraph,
+  makeReactivityGraph,
+  type LiveQuery,
+} from './reactiveQueries/base-class.js'
 
-export { globalDbGraph, dynamicallyRegisteredTables } from './global-state.js'
+export { globalReactivityGraph, dynamicallyRegisteredTables } from './global-state.js'
 
 export { type RowResult, type RowResultEncoded, rowQuery, deriveColQuery } from './row-query.js'
 
 export * from '@livestore/common/schema'
-export { sql, type BootDb, type InMemoryDatabase, type DebugInfo, type MutableDebugInfo } from '@livestore/common'
+export {
+  sql,
+  type BootDb,
+  type InMemoryDatabase,
+  type DebugInfo,
+  type MutableDebugInfo,
+  prepareBindValues,
+  type Bindable,
+  type PreparedBindValues,
+} from '@livestore/common'
 
 export { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
-export { prepareBindValues, type Bindable, type PreparedBindValues } from './utils/util.js'
 export { isEqual } from 'lodash-es'
 
 export type {

package/src/react/LiveStoreProvider.tsx

@@ -7,7 +7,7 @@ import React from 'react'
 
 // TODO refactor so the `react` module doesn't depend on `effect` module
 import type { LiveStoreContext as StoreContext_, LiveStoreCreateStoreOptions } from '../effect/LiveStore.js'
-import type { BaseGraphQLContext, GraphQLOptions, Store } from '../store.js'
+import type { BaseGraphQLContext, GraphQLOptions, OtelOptions, Store } from '../store.js'
 import { createStore } from '../store.js'
 import { LiveStoreContext } from './LiveStoreContext.js'
 
@@ -15,8 +15,7 @@ interface LiveStoreProviderProps<GraphQLContext> {
   schema: LiveStoreSchema
   boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
   graphQLOptions?: GraphQLOptions<GraphQLContext>
-  otelTracer?: otel.Tracer
-  otelRootSpanContext?: otel.Context
+  otelOptions?: OtelOptions
   fallback: ReactElement
   adapter: StoreAdapterFactory
   batchUpdates?: (run: () => void) => void
@@ -26,8 +25,7 @@ interface LiveStoreProviderProps<GraphQLContext> {
 export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   fallback,
   graphQLOptions,
-  otelTracer,
-  otelRootSpanContext,
+  otelOptions,
   children,
   schema,
   boot,
@@ -38,8 +36,7 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   const storeCtx = useCreateStore({
     schema,
     graphQLOptions,
-    otelTracer,
-    otelRootSpanContext,
+    otelOptions,
     boot,
     adapter,
     batchUpdates,
@@ -58,8 +55,7 @@ export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
 const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   schema,
   graphQLOptions,
-  otelTracer,
-  otelRootSpanContext,
+  otelOptions,
   boot,
   adapter,
   batchUpdates,
@@ -70,8 +66,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   const inputPropsCacheRef = React.useRef({
     schema,
     graphQLOptions,
-    otelTracer,
-    otelRootSpanContext,
+    otelOptions,
     boot,
     adapter,
     batchUpdates,
@@ -81,8 +76,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   if (
     inputPropsCacheRef.current.schema !== schema ||
     inputPropsCacheRef.current.graphQLOptions !== graphQLOptions ||
-    inputPropsCacheRef.current.otelTracer !== otelTracer ||
-    inputPropsCacheRef.current.otelRootSpanContext !== otelRootSpanContext ||
+    inputPropsCacheRef.current.otelOptions !== otelOptions ||
     inputPropsCacheRef.current.boot !== boot ||
     inputPropsCacheRef.current.adapter !== adapter ||
     inputPropsCacheRef.current.batchUpdates !== batchUpdates
@@ -90,8 +84,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
     inputPropsCacheRef.current = {
       schema,
       graphQLOptions,
-      otelTracer,
-      otelRootSpanContext,
+      otelOptions,
       boot,
       adapter,
       batchUpdates,
@@ -109,8 +102,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
         store = await createStore({
           schema,
           graphQLOptions,
-          otelTracer,
-          otelRootSpanContext,
+          otelOptions,
           boot,
           adapter,
           batchUpdates,
@@ -129,7 +121,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
         store?.destroy()
       }
     }
-  }, [schema, graphQLOptions, otelTracer, otelRootSpanContext, boot, adapter, batchUpdates, disableDevtools])
+  }, [schema, graphQLOptions, otelOptions, boot, adapter, batchUpdates, disableDevtools])
 
   return ctxValueRef.current
 }

package/src/react/useRow.test.tsx

@@ -15,9 +15,9 @@ import type { StackInfo } from './utils/stack-info.js'
 // NOTE running tests concurrently doesn't work with the default global db graph
 describe.concurrent('useRow', () => {
   it('should update the data based on component key', async () => {
-    using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
+    using inputs = await makeTodoMvc({ useGlobalReactivityGraph: false })
 
-    const { wrapper, AppComponentSchema, store, dbGraph, makeRenderCount } = inputs
+    const { wrapper, AppComponentSchema, store, reactivityGraph, makeRenderCount } = inputs
 
     const renderCount = makeRenderCount()
 
@@ -25,7 +25,7 @@ describe.concurrent('useRow', () => {
       (userId: string) => {
         renderCount.inc()
 
-        const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { dbGraph })
+        const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { reactivityGraph })
         return { state, setState }
       },
       { wrapper, initialProps: 'u1' },
@@ -53,9 +53,9 @@ describe.concurrent('useRow', () => {
   // TODO add a test that makes sure React doesn't re-render when a setter is used to set the same value
 
   it('should update the data reactively - via setState', async () => {
-    using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
+    using inputs = await makeTodoMvc({ useGlobalReactivityGraph: false })
 
-    const { wrapper, AppComponentSchema, dbGraph, makeRenderCount } = inputs
+    const { wrapper, AppComponentSchema, reactivityGraph, makeRenderCount } = inputs
 
     const renderCount = makeRenderCount()
 
@@ -63,7 +63,7 @@ describe.concurrent('useRow', () => {
       (userId: string) => {
         renderCount.inc()
 
-        const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { dbGraph })
+        const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { reactivityGraph })
         return { state, setState }
       },
       { wrapper, initialProps: 'u1' },
@@ -81,9 +81,9 @@ describe.concurrent('useRow', () => {
   })
 
   it('should update the data reactively - via raw store mutation', async () => {
-    using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
+    using inputs = await makeTodoMvc({ useGlobalReactivityGraph: false })
 
-    const { wrapper, AppComponentSchema, store, dbGraph, makeRenderCount } = inputs
+    const { wrapper, AppComponentSchema, store, reactivityGraph, makeRenderCount } = inputs
 
     const renderCount = makeRenderCount()
 
@@ -91,7 +91,7 @@ describe.concurrent('useRow', () => {
       (userId: string) => {
         renderCount.inc()
 
-        const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { dbGraph })
+        const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { reactivityGraph })
         return { state, setState }
       },
       { wrapper, initialProps: 'u1' },
@@ -115,17 +115,17 @@ describe.concurrent('useRow', () => {
   })
 
   it('should work for a larger app', async () => {
-    using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
-    const { wrapper, store, dbGraph, makeRenderCount, AppRouterSchema } = inputs
+    using inputs = await makeTodoMvc({ useGlobalReactivityGraph: false })
+    const { wrapper, store, reactivityGraph, makeRenderCount, AppRouterSchema } = inputs
 
-    const allTodos$ = LiveStore.querySQL<Todo[]>(`select * from todos`, { label: 'allTodos', dbGraph })
+    const allTodos$ = LiveStore.querySQL<Todo[]>(`select * from todos`, { label: 'allTodos', reactivityGraph })
 
     const appRouterRenderCount = makeRenderCount()
     let globalSetState: LiveStoreReact.StateSetters<typeof AppRouterSchema> | undefined
     const AppRouter: React.FC = () => {
       appRouterRenderCount.inc()
 
-      const [state, setState] = LiveStoreReact.useRow(AppRouterSchema, { dbGraph })
+      const [state, setState] = LiveStoreReact.useRow(AppRouterSchema, { reactivityGraph })
 
       globalSetState = setState
 
@@ -153,7 +153,7 @@ describe.concurrent('useRow', () => {
     }
 
     const TaskDetails: React.FC<{ id: string }> = ({ id }) => {
-      const [todo] = LiveStoreReact.useRow(todos, id, { dbGraph })
+      const [todo] = LiveStoreReact.useRow(todos, id, { reactivityGraph })
       return <div role="content">{JSON.stringify(todo)}</div>
     }
 
@@ -198,8 +198,8 @@ describe.concurrent('useRow', () => {
   })
 
   it('should work for a useRow query chained with a useTemporary query', async () => {
-    using inputs = await makeTodoMvc({ useGlobalDbGraph: false })
-    const { store, wrapper, AppComponentSchema, dbGraph, makeRenderCount } = inputs
+    using inputs = await makeTodoMvc({ useGlobalReactivityGraph: false })
+    const { store, wrapper, AppComponentSchema, reactivityGraph, makeRenderCount } = inputs
     const renderCount = makeRenderCount()
 
     store.mutate(
@@ -211,12 +211,12 @@ describe.concurrent('useRow', () => {
       (userId: string) => {
         renderCount.inc()
 
-        const [_row, _setRow, rowState$] = LiveStoreReact.useRow(AppComponentSchema, userId, { dbGraph })
+        const [_row, _setRow, rowState$] = LiveStoreReact.useRow(AppComponentSchema, userId, { reactivityGraph })
         const todos = LiveStoreReact.useTemporaryQuery(
           () =>
             LiveStore.querySQL<any[]>(
               (get) => LiveStore.sql`select * from todos where text like '%${get(rowState$).text}%'`,
-              { dbGraph, label: 'todosFiltered' },
+              { reactivityGraph, label: 'todosFiltered' },
             ),
           userId,
         )
@@ -262,9 +262,9 @@ describe.concurrent('useRow', () => {
     const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
     it('should update the data based on component key', async () => {
-      using inputs = await makeTodoMvc({ useGlobalDbGraph: false, otelContext, otelTracer })
+      using inputs = await makeTodoMvc({ useGlobalReactivityGraph: false, otelContext, otelTracer })
 
-      const { wrapper, AppComponentSchema, store, dbGraph, makeRenderCount, strictMode } = inputs
+      const { wrapper, AppComponentSchema, store, reactivityGraph, makeRenderCount, strictMode } = inputs
 
       const renderCount = makeRenderCount()
 
@@ -272,7 +272,7 @@ describe.concurrent('useRow', () => {
         (userId: string) => {
           renderCount.inc()
 
-          const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { dbGraph })
+          const [state, setState] = LiveStoreReact.useRow(AppComponentSchema, userId, { reactivityGraph })
           return { state, setState }
         },
         { wrapper, initialProps: 'u1' },

package/src/react/useRow.ts

@@ -8,7 +8,7 @@ import type { SqliteDsl } from 'effect-db-schema'
 import { mapValues } from 'lodash-es'
 import React from 'react'
 
-import type { DbGraph, LiveQuery } from '../index.js'
+import type { LiveQuery, ReactivityGraph } from '../index.js'
 import type { RowResult } from '../row-query.js'
 import { rowQuery } from '../row-query.js'
 import { useStore } from './LiveStoreContext.js'
@@ -26,7 +26,7 @@ export type UseRowOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
 }
 
 export type UseRowOptionsBase = {
-  dbGraph?: DbGraph
+  reactivityGraph?: ReactivityGraph
 }
 
 /**
@@ -76,7 +76,7 @@ export const useRow: {
   const id = typeof idOrOptions === 'string' ? idOrOptions : undefined
   const options: (UseRowOptionsBase & UseRowOptionsDefaulValues<TTableDef>) | undefined =
     typeof idOrOptions === 'string' ? options_ : idOrOptions
-  const { defaultValues, dbGraph } = options ?? {}
+  const { defaultValues, reactivityGraph } = options ?? {}
 
   type TComponentState = SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>
 
@@ -100,11 +100,11 @@ export const useRow: {
   const { query$, otelContext } = useMakeTemporaryQuery(
     (otelContext) =>
       DbSchema.tableIsSingleton(table)
-        ? (rowQuery(table, { otelContext, dbGraph }) as LiveQuery<RowResult<TTableDef>, QueryInfo>)
+        ? (rowQuery(table, { otelContext, reactivityGraph }) as LiveQuery<RowResult<TTableDef>, QueryInfo>)
         : (rowQuery(table as TTableDef & { options: { isSingleton: false } }, id!, {
             otelContext,
             defaultValues: defaultValues!,
-            dbGraph,
+            reactivityGraph,
           }) as any as LiveQuery<RowResult<TTableDef>, QueryInfo>),
     [id!, tableName],
     {

package/src/react/useTemporaryQuery.ts

@@ -53,8 +53,8 @@ export const useMakeTemporaryQuery = <TResult, TQueryInfo extends QueryInfo>(
   const fullKey = React.useMemo(
     // NOTE We're using the `makeQuery` function body string to make sure the key is unique across the app
     // TODO we should figure out whether this could cause some problems and/or if there's a better way to do this
-    () => (Array.isArray(key) ? key.join('-') : key) + '-' + store.graph.id + '-' + makeQuery.toString(),
-    [key, makeQuery, store.graph.id],
+    () => (Array.isArray(key) ? key.join('-') : key) + '-' + store.reactivityGraph.id + '-' + makeQuery.toString(),
+    [key, makeQuery, store.reactivityGraph.id],
   )
   const fullKeyRef = React.useRef<string>()
 

package/src/reactive.ts

@@ -618,7 +618,9 @@ const serializeAtom = (atom: Atom<any, unknown, any>, includeResult: boolean): S
   }
 
   const previousResult: EncodedOption<string> = includeResult
-    ? encodedOptionSome(JSON.stringify(atom.previousResult))
+    ? encodedOptionSome(
+        atom.previousResult === NOT_REFRESHED_YET ? '"SYMBOL_NOT_REFRESHED_YET"' : JSON.stringify(atom.previousResult),
+      )
     : encodedOptionNone()
 
   if (atom._tag === 'ref') {

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$)
   }
 }