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

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.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

@@ -3,13 +3,13 @@ import { migrateTable, sql } from '@livestore/common'
 import { DbSchema, SCHEMA_META_TABLE } from '@livestore/common/schema'
 import type { GetValForKey } from '@livestore/utils'
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Effect, 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'
@@ -17,7 +17,7 @@ import type { RefreshReason, Store } from './store.js'
 export type RowQueryOptions = {
   otelContext?: otel.Context
   skipInsertDefaultRow?: boolean
-  dbGraph?: DbGraph
+  reactivityGraph?: ReactivityGraph
 }
 
 export type RowQueryOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
@@ -76,7 +76,7 @@ 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,
@@ -145,7 +145,7 @@ const makeExecBeforeFirstRun =
     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
@@ -163,7 +163,7 @@ const makeExecBeforeFirstRun =
               ...mainStmt,
               execute: (bindValues) => {
                 const getRowsChanged = mainStmt.execute(bindValues)
-                store.adapter.coordinator.execute(query, bindValues, undefined)
+                store.adapter.coordinator.execute(query, bindValues).pipe(Effect.tapCauseLogPretty, Effect.runFork)
                 return getRowsChanged
               },
             }
@@ -182,9 +182,9 @@ const makeExecBeforeFirstRun =
       const label = `tableRef:${tableName}`
 
       // TODO find a better implementation for this
-      const existingTableRefFromGraph = Array.from(store.graph.atoms.values()).find(
+      const existingTableRefFromGraph = Array.from(store.reactivityGraph.atoms.values()).find(
         (_) => _._tag === 'ref' && _.label === label,
-      ) as Ref<null, DbContext, RefreshReason> | undefined
+      ) as Ref<null, QueryContext, RefreshReason> | undefined
 
       store.tableRefs[tableName] = existingTableRefFromGraph ?? store.makeTableRef(tableName)
     }