@livestore/livestore 0.1.0-dev.9 → 0.2.0-dev.0

package/src/live-queries/db.ts

@@ -0,0 +1,350 @@
+import type { Bindable, QueryBuilder, QueryInfo } from '@livestore/common'
+import {
+  getResultSchema,
+  isQueryBuilder,
+  prepareBindValues,
+  QueryBuilderAstSymbol,
+  replaceSessionIdSymbol,
+} from '@livestore/common'
+import { deepEqual, shouldNeverHappen } from '@livestore/utils'
+import { Predicate, Schema, TreeFormatter } from '@livestore/utils/effect'
+import * as otel from '@opentelemetry/api'
+
+import { globalReactivityGraph } from '../global-state.js'
+import type { Thunk } from '../reactive.js'
+import { isThunk, NOT_REFRESHED_YET } from '../reactive.js'
+import { makeExecBeforeFirstRun, rowQueryLabel } from '../row-query-utils.js'
+import type { RefreshReason } from '../store/store-types.js'
+import { getDurationMsFromSpan } from '../utils/otel.js'
+import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
+import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
+
+export type QueryInputRaw<TDecoded, TEncoded, TQueryInfo extends QueryInfo> = {
+  query: string
+  schema: Schema.Schema<TDecoded, TEncoded>
+  bindValues?: Bindable
+  /**
+   * Can be provided explicitly to slightly speed up initial query performance
+   *
+   * NOTE In the future we want to do this automatically at build time
+   */
+  queriedTables?: Set<string>
+  queryInfo?: TQueryInfo
+  execBeforeFirstRun?: (ctx: QueryContext) => void
+}
+
+export type QueryInput<TDecoded, TEncoded, TQueryInfo extends QueryInfo> =
+  | QueryInputRaw<TDecoded, TEncoded, TQueryInfo>
+  | QueryBuilder<TDecoded, any, any, TQueryInfo>
+
+/**
+ * NOTE `query` is only supposed to read data. Don't use it to insert/update/delete data but use mutations instead.
+ */
+export const queryDb: {
+  <TResultSchema, TResult = TResultSchema, TQueryInfo extends QueryInfo = QueryInfo.None>(
+    queryInput:
+      | QueryInputRaw<TResultSchema, ReadonlyArray<any>, TQueryInfo>
+      | QueryBuilder<TResultSchema, any, any, TQueryInfo>,
+    options?: {
+      map?: (rows: TResultSchema) => TResult
+      /**
+       * Used for debugging / devtools
+       */
+      label?: string
+      reactivityGraph?: ReactivityGraph
+      otelContext?: otel.Context
+    },
+  ): LiveQuery<TResult, TQueryInfo>
+  // NOTE in this "thunk case", we can't directly derive label/queryInfo from the queryInput,
+  // so the caller needs to provide them explicitly otherwise queryInfo will be set to `None`,
+  // and label will be set during the query execution
+  <TResultSchema, TResult = TResultSchema, TQueryInfo extends QueryInfo = QueryInfo.None>(
+    queryInput:
+      | ((get: GetAtomResult) => QueryInputRaw<TResultSchema, ReadonlyArray<any>, TQueryInfo>)
+      | ((get: GetAtomResult) => QueryBuilder<TResultSchema, any, any, TQueryInfo>),
+    options?: {
+      map?: (rows: TResultSchema) => TResult
+      /**
+       * Used for debugging / devtools
+       */
+      label?: string
+      reactivityGraph?: ReactivityGraph
+      queryInfo?: TQueryInfo
+      otelContext?: otel.Context
+    },
+  ): LiveQuery<TResult, TQueryInfo>
+} = (queryInput, options) =>
+  new LiveStoreDbQuery({
+    queryInput,
+    label: options?.label,
+    reactivityGraph: options?.reactivityGraph,
+    map: options?.map,
+    queryInfo: Predicate.hasProperty(options, 'queryInfo') ? (options.queryInfo as QueryInfo) : undefined,
+    otelContext: options?.otelContext,
+  })
+
+/* An object encapsulating a reactive SQL query */
+export class LiveStoreDbQuery<
+  TResultSchema,
+  TResult = TResultSchema,
+  TQueryInfo extends QueryInfo = QueryInfo.None,
+> extends LiveStoreQueryBase<TResult, TQueryInfo> {
+  _tag: 'db' = 'db'
+
+  /** A reactive thunk representing the query text */
+  queryInput$: Thunk<QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>, QueryContext, RefreshReason> | undefined
+
+  /** A reactive thunk representing the query results */
+  results$: Thunk<TResult, QueryContext, RefreshReason>
+
+  label: string
+
+  queryInfo: TQueryInfo
+
+  protected reactivityGraph
+
+  private mapResult: (rows: TResultSchema) => TResult
+
+  constructor({
+    queryInput,
+    label: inputLabel,
+    reactivityGraph,
+    map,
+    queryInfo: inputQueryInfo,
+    otelContext,
+  }: {
+    label?: string
+    queryInput:
+      | QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>
+      | ((get: GetAtomResult, ctx: QueryContext) => QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>)
+    reactivityGraph?: ReactivityGraph
+    map?: (rows: TResultSchema) => TResult
+    queryInfo?: TQueryInfo
+    otelContext?: otel.Context
+  }) {
+    super()
+
+    let label = inputLabel ?? 'db(unknown)'
+    let queryInfo = inputQueryInfo ?? ({ _tag: 'None' } as TQueryInfo)
+    this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
+
+    this.mapResult = map === undefined ? (rows: any) => rows as TResult : map
+
+    const schemaRef: { current: Schema.Schema<any, any> | undefined } = {
+      current:
+        typeof queryInput === 'function' ? undefined : isQueryBuilder(queryInput) ? undefined : queryInput.schema,
+    }
+
+    const execBeforeFirstRunRef: { current: ((ctx: QueryContext, otelContext: otel.Context) => void) | undefined } = {
+      current: undefined,
+    }
+
+    type TQueryInputRaw = QueryInputRaw<any, any, QueryInfo>
+
+    let queryInputRaw$OrQueryInputRaw: TQueryInputRaw | Thunk<TQueryInputRaw, QueryContext, RefreshReason>
+
+    const fromQueryBuilder = (qb: QueryBuilder.Any, otelContext: otel.Context | undefined) => {
+      const qbRes = qb.asSql()
+      const schema = getResultSchema(qb) as Schema.Schema<TResultSchema, ReadonlyArray<any>>
+      const ast = qb[QueryBuilderAstSymbol]
+
+      return {
+        queryInputRaw: {
+          query: qbRes.query,
+          schema,
+          bindValues: qbRes.bindValues,
+          queriedTables: new Set([ast.tableDef.sqliteDef.name]),
+          queryInfo: ast._tag === 'RowQuery' ? { _tag: 'Row', table: ast.tableDef, id: ast.id } : { _tag: 'None' },
+        } satisfies TQueryInputRaw,
+        label: ast._tag === 'RowQuery' ? rowQueryLabel(ast.tableDef, ast.id) : qb.toString(),
+        execBeforeFirstRun:
+          ast._tag === 'RowQuery'
+            ? makeExecBeforeFirstRun({
+                table: ast.tableDef,
+                insertValues: ast.insertValues,
+                id: ast.id,
+                otelContext,
+              })
+            : undefined,
+      }
+    }
+
+    if (typeof queryInput === 'function') {
+      queryInputRaw$OrQueryInputRaw = this.reactivityGraph.makeThunk(
+        (get, setDebugInfo, ctx, otelContext) => {
+          const startMs = performance.now()
+          const queryInputResult = queryInput(makeGetAtomResult(get, otelContext ?? ctx.rootOtelContext), ctx)
+          const durationMs = performance.now() - startMs
+
+          let queryInputRaw: TQueryInputRaw
+
+          if (isQueryBuilder(queryInputResult)) {
+            const res = fromQueryBuilder(queryInputResult, otelContext)
+            queryInputRaw = res.queryInputRaw
+            // setting label dynamically here
+            this.label = res.label
+            execBeforeFirstRunRef.current = res.execBeforeFirstRun
+          } else {
+            queryInputRaw = queryInputResult
+          }
+
+          setDebugInfo({ _tag: 'computed', label: `${this.label}:queryInput`, query: queryInputRaw.query, durationMs })
+
+          schemaRef.current = queryInputRaw.schema
+
+          if (inputQueryInfo === undefined && queryInputRaw.queryInfo !== undefined) {
+            queryInfo = queryInputRaw.queryInfo as TQueryInfo
+          }
+
+          return queryInputRaw
+        },
+        {
+          label: `${label}:query`,
+          meta: { liveStoreThunkType: 'db.query' },
+          // NOTE we're not checking the schema here as we assume the query string to always change when the schema might change
+          equal: (a, b) => a.query === b.query && deepEqual(a.bindValues, b.bindValues),
+        },
+      )
+    } else {
+      let queryInputRaw: TQueryInputRaw
+      if (isQueryBuilder(queryInput)) {
+        const res = fromQueryBuilder(queryInput, otelContext)
+        queryInputRaw = res.queryInputRaw
+        label = res.label
+        execBeforeFirstRunRef.current = res.execBeforeFirstRun
+      } else {
+        queryInputRaw = queryInput
+      }
+
+      schemaRef.current = queryInputRaw.schema
+      queryInputRaw$OrQueryInputRaw = queryInputRaw
+
+      // this.label = inputLabel ? this.label : `db(${})`
+      if (inputLabel === undefined && isQueryBuilder(queryInput)) {
+        const ast = queryInput[QueryBuilderAstSymbol]
+        if (ast._tag === 'RowQuery') {
+          label = `db(${rowQueryLabel(ast.tableDef, ast.id)})`
+        }
+      }
+
+      if (inputQueryInfo === undefined && queryInputRaw.queryInfo !== undefined) {
+        queryInfo = queryInputRaw.queryInfo as TQueryInfo
+      }
+    }
+
+    const queriedTablesRef: { current: Set<string> | undefined } = { current: undefined }
+
+    const makeResultsEqual = (resultSchema: Schema.Schema<any, any>) => (a: TResult, b: TResult) =>
+      a === NOT_REFRESHED_YET || b === NOT_REFRESHED_YET ? false : Schema.equivalence(resultSchema)(a, b)
+
+    // NOTE we try to create the equality function eagerly as it might be expensive
+    // TODO also support derived equality for `map` (probably will depend on having an easy way to transform a schema without an `encode` step)
+    // This would mean dropping the `map` option
+    const resultsEqual =
+      map === undefined
+        ? schemaRef.current === undefined
+          ? (a: TResult, b: TResult) => makeResultsEqual(schemaRef.current!)(a, b)
+          : makeResultsEqual(schemaRef.current)
+        : undefined
+
+    const results$ = this.reactivityGraph.makeThunk<TResult>(
+      (get, setDebugInfo, queryContext, otelContext) =>
+        queryContext.otelTracer.startActiveSpan(
+          'db:...', // NOTE span name will be overridden further down
+          {},
+          otelContext ?? queryContext.rootOtelContext,
+          (span) => {
+            const otelContext = otel.trace.setSpan(otel.context.active(), span)
+            const { store } = queryContext
+
+            if (execBeforeFirstRunRef.current !== undefined) {
+              execBeforeFirstRunRef.current(queryContext, otelContext)
+              execBeforeFirstRunRef.current = undefined
+            }
+
+            const queryInputResult = isThunk(queryInputRaw$OrQueryInputRaw)
+              ? (get(queryInputRaw$OrQueryInputRaw, otelContext) as TQueryInputRaw)
+              : (queryInputRaw$OrQueryInputRaw as TQueryInputRaw)
+
+            const sqlString = queryInputResult.query
+            const bindValues = queryInputResult.bindValues
+
+            if (queriedTablesRef.current === undefined) {
+              queriedTablesRef.current = store.syncDbWrapper.getTablesUsed(sqlString)
+            }
+
+            if (bindValues !== undefined) {
+              replaceSessionIdSymbol(bindValues, store.clientSession.coordinator.sessionId)
+            }
+
+            // Establish a reactive dependency on the tables used in the query
+            for (const tableName of queriedTablesRef.current) {
+              const tableRef = store.tableRefs[tableName] ?? shouldNeverHappen(`No table ref found for ${tableName}`)
+              get(tableRef, otelContext)
+            }
+
+            span.setAttribute('sql.query', sqlString)
+            span.updateName(`db:${sqlString.slice(0, 50)}`)
+
+            const rawDbResults = store.syncDbWrapper.select<any>(sqlString, {
+              queriedTables: queriedTablesRef.current,
+              bindValues: bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
+              otelContext,
+            })
+
+            span.setAttribute('sql.rowsCount', rawDbResults.length)
+
+            const parsedResult = Schema.decodeEither(schemaRef.current!)(rawDbResults)
+
+            if (parsedResult._tag === 'Left') {
+              const parseErrorStr = TreeFormatter.formatErrorSync(parsedResult.left)
+              const expectedSchemaStr = String(schemaRef.current!.ast)
+              const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
+
+              console.error(
+                `\
+Error parsing SQL query result.
+
+Query: ${sqlString}\
+${bindValuesStr}
+
+Expected schema: ${expectedSchemaStr}
+
+Error: ${parseErrorStr}
+
+Result:`,
+                rawDbResults,
+              )
+              return shouldNeverHappen(`Error parsing SQL query result: ${parsedResult.left}`)
+            }
+
+            const result = this.mapResult(parsedResult.right)
+
+            span.end()
+
+            const durationMs = getDurationMsFromSpan(span)
+
+            this.executionTimes.push(durationMs)
+
+            setDebugInfo({ _tag: 'db', label: `${label}:results`, query: sqlString, durationMs })
+
+            return result
+          },
+        ),
+      { label: `${label}:results`, meta: { liveStoreThunkType: 'db.results' }, equal: resultsEqual },
+    )
+
+    this.results$ = results$
+
+    this.label = label
+    this.queryInfo = queryInfo
+  }
+
+  destroy = () => {
+    if (this.queryInput$ !== undefined) {
+      this.reactivityGraph.destroyNode(this.queryInput$)
+    }
+
+    this.reactivityGraph.destroyNode(this.results$)
+  }
+}

package/src/{reactiveQueries → live-queries}/graphql.ts

@@ -1,5 +1,5 @@
 import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core'
-import type { QueryInfoNone } from '@livestore/common'
+import type { QueryInfo } from '@livestore/common'
 import { shouldNeverHappen } from '@livestore/utils'
 import { Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
@@ -31,7 +31,7 @@ export const queryGraphQL = <
     reactivityGraph?: ReactivityGraph
     map?: MapResult<TResultMapped, TResult>
   } = {},
-): LiveQuery<TResultMapped, QueryInfoNone> =>
+): LiveQuery<TResultMapped, QueryInfo.None> =>
   new LiveStoreGraphQLQuery({ document, genVariableValues, label, reactivityGraph, map })
 
 export class LiveStoreGraphQLQuery<
@@ -39,7 +39,7 @@ export class LiveStoreGraphQLQuery<
   TVariableValues extends Record<string, any>,
   TContext extends BaseGraphQLContext,
   TResultMapped extends Record<string, any> = TResult,
-> extends LiveStoreQueryBase<TResultMapped, QueryInfoNone> {
+> extends LiveStoreQueryBase<TResultMapped, QueryInfo.None> {
   _tag: 'graphql' = 'graphql'
 
   /** The abstract GraphQL query */
@@ -54,7 +54,7 @@ export class LiveStoreGraphQLQuery<
 
   protected reactivityGraph: ReactivityGraph
 
-  queryInfo: QueryInfoNone = { _tag: 'None' }
+  queryInfo: QueryInfo.None = { _tag: 'None' }
 
   private mapResult
 
@@ -105,7 +105,7 @@ export class LiveStoreGraphQLQuery<
         (get, _setDebugInfo, { rootOtelContext }, otelContext) => {
           return genVariableValues(makeGetAtomResult(get, otelContext ?? rootOtelContext))
         },
-        { label: `${labelWithDefault}:variableValues`, meta: { liveStoreThunkType: 'graphqlVariableValues' } },
+        { label: `${labelWithDefault}:variableValues`, meta: { liveStoreThunkType: 'graphql.variables' } },
       )
       this.variableValues$ = variableValues$OrvariableValues
     } else {
@@ -137,26 +137,11 @@ export class LiveStoreGraphQLQuery<
 
         return result
       },
-      { label: resultsLabel, meta: { liveStoreThunkType: 'graphqlResults' } },
+      { label: resultsLabel, meta: { liveStoreThunkType: 'graphql.results' } },
       // otelContext,
     )
   }
 
-  /**
-   * Returns a new reactive query that contains the result of
-   * running an arbitrary JS computation on the results of this SQL query.
-   */
-  // pipe = <U>(fn: (result: TResult, get: GetAtomResult) => U): LiveStoreJSQuery<U> =>
-  //   new LiveStoreJSQuery({
-  //     fn: (get) => {
-  //       const results = get(this.results$)
-  //       return fn(results, get)
-  //     },
-  //     label: `${this.label}:js`,
-  //     onDestroy: () => this.destroy(),
-  //     reactivityGraph: this.reactivityGraph,
-  //   })
-
   queryOnce = ({
     document,
     otelContext,

package/src/row-query-utils.ts

@@ -0,0 +1,65 @@
+import type { PreparedBindValues, QueryInfo } from '@livestore/common'
+import { SessionIdSymbol } from '@livestore/common'
+import { DbSchema } from '@livestore/common/schema'
+import { shouldNeverHappen } from '@livestore/utils'
+import type * as otel from '@opentelemetry/api'
+
+import type { LiveQuery, LiveQueryAny, QueryContext } from './live-queries/base-class.js'
+import { computed } from './live-queries/computed.js'
+
+export const rowQueryLabel = (table: DbSchema.TableDefBase, id: string | SessionIdSymbol | undefined) =>
+  `row:${table.sqliteDef.name}${id === undefined ? '' : id === SessionIdSymbol ? `:sessionId` : `:${id}`}`
+
+export const deriveColQuery: {
+  <TQuery extends LiveQuery<any, QueryInfo.None>, TCol extends keyof TQuery['__result!'] & string>(
+    query$: TQuery,
+    colName: TCol,
+  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.None>
+  <TQuery extends LiveQuery<any, QueryInfo.Row>, TCol extends keyof TQuery['__result!'] & string>(
+    query$: TQuery,
+    colName: TCol,
+  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.Col>
+} = (query$: LiveQueryAny, colName: string) => {
+  return computed((get) => get(query$)[colName], {
+    label: `deriveColQuery:${query$.label}:${colName}`,
+    queryInfo:
+      query$.queryInfo._tag === 'Row'
+        ? { _tag: 'Col', table: query$.queryInfo.table, column: colName, id: query$.queryInfo.id }
+        : undefined,
+  }) as any
+}
+
+export const makeExecBeforeFirstRun =
+  ({
+    id,
+    insertValues,
+    table,
+    otelContext: otelContext_,
+  }: {
+    id?: string | SessionIdSymbol
+    insertValues?: any
+    table: DbSchema.TableDefBase
+    otelContext: otel.Context | undefined
+  }) =>
+  ({ store }: QueryContext) => {
+    const otelContext = otelContext_ ?? store.otel.queriesSpanContext
+
+    if (table.options.isSingleton === false) {
+      const idStr = id === SessionIdSymbol ? store.sessionId : id!
+      const rowExists =
+        store.syncDbWrapper.select(`SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`, {
+          bindValues: [idStr] as any as PreparedBindValues,
+        }).length === 1
+
+      if (rowExists) return
+
+      if (DbSchema.tableHasDerivedMutations(table) === false) {
+        return shouldNeverHappen(
+          `Cannot insert row for table "${table.sqliteDef.name}" which does not have 'deriveMutations: true' set`,
+        )
+      }
+
+      // NOTE It's important that we only mutate and don't refresh here, as this function is called during a render
+      store.mutateWithoutRefresh(table.insert({ id, ...insertValues }), { otelContext, coordinatorMode: 'default' })
+    }
+  }

package/src/store/create-store.ts

@@ -28,7 +28,7 @@ import {
 import * as otel from '@opentelemetry/api'
 
 import { globalReactivityGraph } from '../global-state.js'
-import type { ReactivityGraph } from '../reactiveQueries/base-class.js'
+import type { ReactivityGraph } from '../live-queries/base-class.js'
 import { connectDevtoolsToStore } from './devtools.js'
 import { Store } from './store.js'
 import type { BaseGraphQLContext, GraphQLOptions, OtelOptions } from './store-types.js'

package/src/store/devtools.ts

@@ -4,8 +4,8 @@ import { throttle } from '@livestore/utils'
 import type { WebChannel } from '@livestore/utils/effect'
 import { Effect, Stream } from '@livestore/utils/effect'
 
+import type { LiveQuery, ReactivityGraph } from '../live-queries/base-class.js'
 import { NOT_REFRESHED_YET } from '../reactive.js'
-import type { LiveQuery, ReactivityGraph } from '../reactiveQueries/base-class.js'
 import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
 import { emptyDebugInfo as makeEmptyDebugInfo } from '../SynchronousDatabaseWrapper.js'
 import type { ReferenceCountedSet } from '../utils/data-structures.js'

package/src/store/store-types.ts

@@ -5,8 +5,8 @@ import { Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
+import type { ReactivityGraph } from '../live-queries/base-class.js'
 import type { DebugRefreshReasonBase } from '../reactive.js'
-import type { ReactivityGraph } from '../reactiveQueries/base-class.js'
 import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
 import type { StackInfo } from '../utils/stack-info.js'
 import type { Store } from './store.js'
@@ -84,7 +84,7 @@ export type RefreshReason =
   | { _tag: 'manual'; label?: string }
 
 export type QueryDebugInfo = {
-  _tag: 'graphql' | 'sql' | 'computed' | 'unknown'
+  _tag: 'graphql' | 'db' | 'computed' | 'unknown'
   label: string
   query: string
   durationMs: number

package/src/store/store.ts

@@ -1,5 +1,12 @@
-import type { ClientSession, ParamsObject } from '@livestore/common'
-import { getExecArgsFromMutation, prepareBindValues, replaceSessionIdSymbol } from '@livestore/common'
+import type { ClientSession, ParamsObject, PreparedBindValues, QueryBuilder } from '@livestore/common'
+import {
+  getExecArgsFromMutation,
+  getResultSchema,
+  isQueryBuilder,
+  prepareBindValues,
+  QueryBuilderAstSymbol,
+  replaceSessionIdSymbol,
+} from '@livestore/common'
 import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
 import {
   isPartialMutationEvent,
@@ -14,8 +21,9 @@ import { Data, Effect, FiberSet, Inspectable, MutableHashMap, Runtime, Schema, S
 import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
+import type { LiveQuery, QueryContext, ReactivityGraph } from '../live-queries/base-class.js'
 import type { Ref } from '../reactive.js'
-import type { LiveQuery, QueryContext, ReactivityGraph } from '../reactiveQueries/base-class.js'
+import { makeExecBeforeFirstRun } from '../row-query-utils.js'
 import { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
 import { ReferenceCountedSet } from '../utils/data-structures.js'
 import { downloadBlob, exposeDebugUtils } from '../utils/dev.js'
@@ -234,6 +242,39 @@ export class Store<
       },
     )
 
+  query = <TResult>(
+    query: QueryBuilder<TResult, any, any> | LiveQuery<TResult, any> | { query: string; bindValues: ParamsObject },
+    options?: { otelContext?: otel.Context },
+  ): TResult => {
+    if (typeof query === 'object' && 'query' in query && 'bindValues' in query) {
+      return this.syncDbWrapper.select(query.query, {
+        bindValues: prepareBindValues(query.bindValues, query.query),
+        otelContext: options?.otelContext,
+      }) as any
+    } else if (isQueryBuilder(query)) {
+      const ast = query[QueryBuilderAstSymbol]
+      if (ast._tag === 'RowQuery') {
+        makeExecBeforeFirstRun({
+          table: ast.tableDef,
+          id: ast.id,
+          insertValues: ast.insertValues,
+          otelContext: options?.otelContext,
+        })(this.reactivityGraph.context!)
+      }
+
+      const sqlRes = query.asSql()
+      const schema = getResultSchema(query)
+      const rawRes = this.syncDbWrapper.select(sqlRes.query, {
+        bindValues: sqlRes.bindValues as any as PreparedBindValues,
+        otelContext: options?.otelContext,
+        queriedTables: new Set([query[QueryBuilderAstSymbol].tableDef.sqliteDef.name]),
+      })
+      return Schema.decodeSync(schema)(rawRes)
+    } else {
+      return query.run(options?.otelContext)
+    }
+  }
+
   // #region mutate
   mutate: {
     <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(...list: TMutationArg): void
@@ -518,10 +559,6 @@ export class Store<
     this.clientSession.coordinator.execute(query, prepareBindValues(params, query)).pipe(this.runEffectFork)
   }
 
-  __select = (query: string, params: ParamsObject = {}) => {
-    return this.syncDbWrapper.select(query, { bindValues: prepareBindValues(params, query) })
-  }
-
   private makeTableRef = (tableName: string) =>
     this.reactivityGraph.makeRef(null, {
       equal: () => false,

package/dist/reactiveQueries/js.d.ts

@@ -1,35 +0,0 @@
-import type { QueryInfo, QueryInfoNone } from '@livestore/common';
-import type { Thunk } from '../reactive.js';
-import type { RefreshReason } from '../store.js';
-import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js';
-import { LiveStoreQueryBase } from './base-class.js';
-export declare const computed: <TResult, TQueryInfo extends QueryInfo = QueryInfoNone>(fn: (get: GetAtomResult) => TResult, options?: {
-    label: string;
-    reactivityGraph?: ReactivityGraph;
-    queryInfo?: TQueryInfo;
-}) => LiveQuery<TResult, TQueryInfo>;
-export declare class LiveStoreJSQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone> extends LiveStoreQueryBase<TResult, TQueryInfo> {
-    _tag: 'js';
-    /** A reactive thunk representing the query results */
-    results$: Thunk<TResult, QueryContext, RefreshReason>;
-    label: string;
-    protected reactivityGraph: ReactivityGraph;
-    queryInfo: TQueryInfo;
-    /**
-     * Currently only used for "nested destruction" of piped queries
-     *
-     * i.e. when doing something like `const q = querySQL(...).pipe(...)`
-     * we need to also destory the SQL query when the JS query `q` is destroyed
-     */
-    private onDestroy;
-    constructor({ fn, label, onDestroy, reactivityGraph, queryInfo, }: {
-        label: string;
-        fn: (get: GetAtomResult) => TResult;
-        /** Currently only used for "nested destruction" of piped queries */
-        onDestroy?: () => void;
-        reactivityGraph?: ReactivityGraph;
-        queryInfo?: TQueryInfo;
-    });
-    destroy: () => void;
-}
-//# sourceMappingURL=js.d.ts.map

package/dist/reactiveQueries/js.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"js.d.ts","sourceRoot":"","sources":["../../src/reactiveQueries/js.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAIjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAC9F,OAAO,EAAE,kBAAkB,EAAqB,MAAM,iBAAiB,CAAA;AAEvE,eAAO,MAAM,QAAQ,GAAI,OAAO,EAAE,UAAU,SAAS,SAAS,sBACxD,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,YACzB;IACR,KAAK,EAAE,MAAM,CAAA;IACb,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,SAAS,CAAC,EAAE,UAAU,CAAA;CACvB,KACA,SAAS,CAAC,OAAO,EAAE,UAAU,CAM5B,CAAA;AAEJ,qBAAa,gBAAgB,CAAC,OAAO,EAAE,UAAU,SAAS,SAAS,GAAG,aAAa,CAAE,SAAQ,kBAAkB,CAC7G,OAAO,EACP,UAAU,CACX;IACC,IAAI,EAAE,IAAI,CAAO;IAEjB,sDAAsD;IACtD,QAAQ,EAAE,KAAK,CAAC,OAAO,EAAE,YAAY,EAAE,aAAa,CAAC,CAAA;IAErD,KAAK,EAAE,MAAM,CAAA;IAEb,SAAS,CAAC,eAAe,EAAE,eAAe,CAAA;IAE1C,SAAS,EAAE,UAAU,CAAA;IAErB;;;;;OAKG;IACH,OAAO,CAAC,SAAS,CAA0B;gBAE/B,EACV,EAAE,EACF,KAAK,EACL,SAAS,EACT,eAAe,EACf,SAAS,GACV,EAAE;QACD,KAAK,EAAE,MAAM,CAAA;QACb,EAAE,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAA;QACnC,oEAAoE;QACpE,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;QACtB,eAAe,CAAC,EAAE,eAAe,CAAA;QACjC,SAAS,CAAC,EAAE,UAAU,CAAA;KACvB;IA0CD,OAAO,aAGN;CACF"}

package/dist/reactiveQueries/js.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"js.js","sourceRoot":"","sources":["../../src/reactiveQueries/js.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,oBAAoB,CAAA;AAE1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAG1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAExD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAEvE,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,EAAmC,EACnC,OAIC,EAC+B,EAAE,CAClC,IAAI,gBAAgB,CAAsB;IACxC,EAAE;IACF,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,CAAC,QAAQ,EAAE;IACtC,eAAe,EAAE,OAAO,EAAE,eAAe;IACzC,SAAS,EAAE,OAAO,EAAE,SAAS;CAC9B,CAAC,CAAA;AAEJ,MAAM,OAAO,gBAAwE,SAAQ,kBAG5F;IACC,IAAI,GAAS,IAAI,CAAA;IAEjB,sDAAsD;IACtD,QAAQ,CAA6C;IAErD,KAAK,CAAQ;IAEH,eAAe,CAAiB;IAE1C,SAAS,CAAY;IAErB;;;;;OAKG;IACK,SAAS,CAA0B;IAE3C,YAAY,EACV,EAAE,EACF,KAAK,EACL,SAAS,EACT,eAAe,EACf,SAAS,GAQV;QACC,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAElB,IAAI,CAAC,eAAe,GAAG,eAAe,IAAI,qBAAqB,CAAA;QAC/D,IAAI,CAAC,SAAS,GAAG,SAAS,IAAK,EAAE,IAAI,EAAE,MAAM,EAAiB,CAAA;QAE9D,MAAM,UAAU,GAAG,GAAG,KAAK,UAAU,CAAA;QAErC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,CAC5C,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,eAAe,EAAE,EAAE,WAAW,EAAE,EAAE,CAClE,UAAU,CAAC,eAAe,CAAC,MAAM,KAAK,EAAE,EAAE,EAAE,EAAE,WAAW,IAAI,eAAe,EAAE,CAAC,IAAI,EAAE,EAAE;YACrF,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,CAAA;YACnE,MAAM,GAAG,GAAG,EAAE,CAAC,iBAAiB,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAA;YAEnD,IAAI,CAAC,GAAG,EAAE,CAAA;YAEV,MAAM,UAAU,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAA;YAE9C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAEpC,YAAY,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,CAAC,CAAA;YAErE,OAAO,GAAG,CAAA;QACZ,CAAC,CAAC,EACJ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,kBAAkB,EAAE,WAAW,EAAE,EAAE,CACjE,CAAA;IACH,CAAC;IAED,qFAAqF;IACrF,2BAA2B;IAC3B,qBAAqB;IACrB,2CAA2C;IAC3C,gCAAgC;IAChC,SAAS;IACT,iCAAiC;IACjC,uCAAuC;IACvC,6CAA6C;IAC7C,OAAO;IAEP,OAAO,GAAG,GAAG,EAAE;QACb,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC/C,IAAI,CAAC,SAAS,EAAE,EAAE,CAAA;IACpB,CAAC,CAAA;CACF"}

package/dist/store/store-context.d.ts

@@ -1,26 +0,0 @@
-import type { IntentionalShutdownCause, UnexpectedError } from '@livestore/common';
-import { Schema } from '@livestore/utils/effect';
-import type { Store } from './store.js';
-export type LiveStoreContext = LiveStoreContextRunning | {
-    stage: 'error';
-    error: UnexpectedError | unknown;
-} | {
-    stage: 'shutdown';
-    cause: IntentionalShutdownCause | StoreAbort;
-};
-declare const StoreAbort_base: Schema.TaggedErrorClass<StoreAbort, "LiveStore.StoreAbort", {
-    readonly _tag: Schema.tag<"LiveStore.StoreAbort">;
-}>;
-export declare class StoreAbort extends StoreAbort_base {
-}
-declare const StoreInterrupted_base: Schema.TaggedErrorClass<StoreInterrupted, "LiveStore.StoreInterrupted", {
-    readonly _tag: Schema.tag<"LiveStore.StoreInterrupted">;
-}>;
-export declare class StoreInterrupted extends StoreInterrupted_base {
-}
-export type LiveStoreContextRunning = {
-    stage: 'running';
-    store: Store;
-};
-export {};
-//# sourceMappingURL=store-context.d.ts.map