@livestore/livestore 0.3.0-dev.27 → 0.3.0-dev.29

package/src/live-queries/client-document-get-query.ts

@@ -0,0 +1,52 @@
+import type { PreparedBindValues } from '@livestore/common'
+import { SessionIdSymbol } from '@livestore/common'
+import { State } from '@livestore/common/schema'
+import { shouldNeverHappen } from '@livestore/utils'
+import type * as otel from '@opentelemetry/api'
+
+import type { ReactivityGraphContext } from './base-class.js'
+
+export const rowQueryLabel = (
+  table: State.SQLite.ClientDocumentTableDef.Any,
+  id: string | SessionIdSymbol | undefined,
+) => `${table.sqliteDef.name}.get:${id === undefined ? table.default.id : id === SessionIdSymbol ? 'sessionId' : id}`
+
+export const makeExecBeforeFirstRun =
+  ({
+    id,
+    explicitDefaultValues,
+    table,
+    otelContext: otelContext_,
+  }: {
+    id?: string | SessionIdSymbol
+    explicitDefaultValues?: any
+    table: State.SQLite.TableDefBase
+    otelContext: otel.Context | undefined
+  }) =>
+  ({ store }: ReactivityGraphContext) => {
+    if (State.SQLite.tableIsClientDocumentTable(table) === false) {
+      return shouldNeverHappen(
+        `Cannot insert row for table "${table.sqliteDef.name}" which does not have 'deriveEvents: true' set`,
+      )
+    }
+
+    const otelContext = otelContext_ ?? store.otel.queriesSpanContext
+
+    const idVal = id === SessionIdSymbol ? store.sessionId : id!
+    const rowExists =
+      store.sqliteDbWrapper.select(
+        `SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`,
+        [idVal] as any as PreparedBindValues,
+        { otelContext },
+      ).length === 1
+
+    if (rowExists) return
+
+    // It's important that we only commit and don't refresh here, as this function might be called during a render
+    // and otherwise we might end up in a "reactive loop"
+
+    store.commit(
+      { otelContext, skipRefresh: true, label: `${table.sqliteDef.name}.set:${idVal}` },
+      table.set(explicitDefaultValues, idVal as TODO),
+    )
+  }

package/src/live-queries/computed.ts

@@ -1,4 +1,3 @@
-import type { QueryInfo } from '@livestore/common'
 import { getDurationMsFromSpan } from '@livestore/common'
 import * as otel from '@opentelemetry/api'
 
@@ -8,29 +7,25 @@ import { isValidFunctionString } from '../utils/function-string.js'
 import type { DepKey, GetAtomResult, LiveQueryDef, ReactivityGraph, ReactivityGraphContext } from './base-class.js'
 import { depsToString, LiveStoreQueryBase, makeGetAtomResult, withRCMap } from './base-class.js'
 
-export const computed = <TResult, TQueryInfo extends QueryInfo = QueryInfo.None>(
+export const computed = <TResult>(
   fn: (get: GetAtomResult) => TResult,
   options?: {
     label?: string
-    queryInfo?: TQueryInfo
     deps?: DepKey
   },
-): LiveQueryDef<TResult, TQueryInfo> => {
+): LiveQueryDef<TResult> => {
   const hash = options?.deps ? depsToString(options.deps) : fn.toString()
   if (isValidFunctionString(hash)._tag === 'invalid') {
     throw new Error(`On Expo/React Native, computed queries must provide a \`deps\` option`)
   }
 
-  const queryInfo = options?.queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
-
   return {
     _tag: 'def',
     make: withRCMap(hash, (ctx, _otelContext) => {
       // TODO onDestroy
-      return new LiveStoreComputedQuery<TResult, TQueryInfo>({
+      return new LiveStoreComputedQuery<TResult>({
         fn,
         label: options?.label ?? fn.toString(),
-        queryInfo: options?.queryInfo,
         reactivityGraph: ctx.reactivityGraph.deref()!,
       })
     }),
@@ -39,14 +34,10 @@ export const computed = <TResult, TQueryInfo extends QueryInfo = QueryInfo.None>
     // TODO we should figure out whether this could cause some problems and/or if there's a better way to do this
     // NOTE `fn.toString()` doesn't work in Expo as it always produces `[native code]`
     hash,
-    queryInfo,
   }
 }
 
-export class LiveStoreComputedQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo.None> extends LiveStoreQueryBase<
-  TResult,
-  TQueryInfo
-> {
+export class LiveStoreComputedQuery<TResult> extends LiveStoreQueryBase<TResult> {
   _tag: 'computed' = 'computed'
 
   /** A reactive thunk representing the query results */
@@ -56,24 +47,19 @@ export class LiveStoreComputedQuery<TResult, TQueryInfo extends QueryInfo = Quer
 
   reactivityGraph: ReactivityGraph
 
-  queryInfo: TQueryInfo
-
   constructor({
     fn,
     label,
     reactivityGraph,
-    queryInfo,
   }: {
     label: string
     fn: (get: GetAtomResult) => TResult
     reactivityGraph: ReactivityGraph
-    queryInfo?: TQueryInfo
   }) {
     super()
 
     this.label = label
     this.reactivityGraph = reactivityGraph
-    this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
 
     const queryLabel = `${label}:results`
 

package/src/live-queries/db-query.test.ts

@@ -1,5 +1,5 @@
 import { sql } from '@livestore/common'
-import { rawSqlMutation } from '@livestore/common/schema'
+import { rawSqlEvent } from '@livestore/common/schema'
 import { Effect, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 import { Vitest } from '@livestore/utils/node-vitest'
 import * as otel from '@opentelemetry/api'
@@ -20,8 +20,6 @@ TODO write tests for:
 */
 
 Vitest.describe('otel', () => {
-  let cachedProvider: BasicTracerProvider | undefined
-
   const mapAttributes = (attributes: otel.Attributes) => {
     return ReadonlyRecord.map(attributes, (val, key) => {
       if (key === 'code.stacktrace') {
@@ -36,13 +34,11 @@ Vitest.describe('otel', () => {
 
     RG.__resetIds()
 
-    // const provider = cachedProvider ?? new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] })
-    const provider = cachedProvider ?? new BasicTracerProvider()
-    cachedProvider = provider
-    provider.addSpanProcessor(new SimpleSpanProcessor(exporter))
-    provider.register()
+    const provider = new BasicTracerProvider({
+      spanProcessors: [new SimpleSpanProcessor(exporter)],
+    })
 
-    const otelTracer = otel.trace.getTracer('test')
+    const otelTracer = provider.getTracer('test')
 
     const span = otelTracer.startSpan('test-root')
     const otelContext = otel.trace.setSpan(otel.context.active(), span)
@@ -60,16 +56,16 @@ Vitest.describe('otel', () => {
 
   Vitest.scopedLive('otel', () =>
     Effect.gen(function* () {
-      const { store, exporter, span } = yield* makeQuery
+      const { store, exporter, span, provider } = yield* makeQuery
 
       const query$ = queryDb({
         query: `select * from todos`,
-        schema: Schema.Array(tables.todos.schema),
+        schema: Schema.Array(tables.todos.rowSchema),
         queriedTables: new Set(['todos']),
       })
       expect(store.query(query$)).toMatchInlineSnapshot('[]')
 
-      store.commit(rawSqlMutation({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
+      store.commit(rawSqlEvent({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
 
       expect(store.query(query$)).toMatchInlineSnapshot(`
       [
@@ -83,16 +79,22 @@ Vitest.describe('otel', () => {
 
       span.end()
 
-      return { exporter }
+      return { exporter, provider }
     }).pipe(
       Effect.scoped,
-      Effect.tap(({ exporter }) => expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()),
+      Effect.tap(({ exporter, provider }) =>
+        Effect.promise(async () => {
+          await provider.forceFlush()
+          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          await provider.shutdown()
+        }),
+      ),
     ),
   )
 
   Vitest.scopedLive('with thunks', () =>
     Effect.gen(function* () {
-      const { store, exporter, span } = yield* makeQuery
+      const { store, exporter, span, provider } = yield* makeQuery
 
       const defaultTodo = { id: '', text: '', completed: false }
 
@@ -100,7 +102,7 @@ Vitest.describe('otel', () => {
       const query$ = queryDb(
         (get) => ({
           query: `select * from todos ${get(filter)}`,
-          schema: Schema.Array(tables.todos.schema).pipe(Schema.headOrElse(() => defaultTodo)),
+          schema: Schema.Array(tables.todos.rowSchema).pipe(Schema.headOrElse(() => defaultTodo)),
         }),
         { label: 'all todos' },
       )
@@ -117,7 +119,7 @@ Vitest.describe('otel', () => {
 
       expect(store.reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
 
-      store.commit(rawSqlMutation({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
+      store.commit(rawSqlEvent({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
 
       expect(store.reactivityGraph.getSnapshot({ includeResults: true })).toMatchSnapshot()
 
@@ -133,21 +135,27 @@ Vitest.describe('otel', () => {
 
       span.end()
 
-      return { exporter }
+      return { exporter, provider }
     }).pipe(
       Effect.scoped,
-      Effect.tap(({ exporter }) => expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()),
+      Effect.tap(({ exporter, provider }) =>
+        Effect.promise(async () => {
+          await provider.forceFlush()
+          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          await provider.shutdown()
+        }),
+      ),
     ),
   )
 
   Vitest.scopedLive('with thunks with query builder and without labels', () =>
     Effect.gen(function* () {
-      const { store, exporter, span } = yield* makeQuery
+      const { store, exporter, span, provider } = yield* makeQuery
 
       const defaultTodo = { id: '', text: '', completed: false }
 
       const filter = computed(() => ({ completed: false }))
-      const query$ = queryDb((get) => tables.todos.query.where(get(filter)).first({ fallback: () => defaultTodo }))
+      const query$ = queryDb((get) => tables.todos.where(get(filter)).first({ fallback: () => defaultTodo }))
 
       expect(store.query(query$)).toMatchInlineSnapshot(`
       {
@@ -157,7 +165,7 @@ Vitest.describe('otel', () => {
       }
     `)
 
-      store.commit(rawSqlMutation({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
+      store.commit(rawSqlEvent({ sql: sql`INSERT INTO todos (id, text, completed) VALUES ('t1', 'buy milk', 0)` }))
 
       expect(store.query(query$)).toMatchInlineSnapshot(`
       {
@@ -169,10 +177,16 @@ Vitest.describe('otel', () => {
 
       span.end()
 
-      return { exporter }
+      return { exporter, provider }
     }).pipe(
       Effect.scoped,
-      Effect.tap(({ exporter }) => expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()),
+      Effect.tap(({ exporter, provider }) =>
+        Effect.promise(async () => {
+          await provider.forceFlush()
+          expect(getSimplifiedRootSpan(exporter, mapAttributes)).toMatchSnapshot()
+          await provider.shutdown()
+        }),
+      ),
     ),
   )
 })

package/src/live-queries/db-query.ts

@@ -1,4 +1,4 @@
-import type { Bindable, QueryBuilder, QueryInfo } from '@livestore/common'
+import type { Bindable, QueryBuilder } from '@livestore/common'
 import {
   getDurationMsFromSpan,
   getResultSchema,
@@ -6,6 +6,7 @@ import {
   prepareBindValues,
   QueryBuilderAstSymbol,
   replaceSessionIdSymbol,
+  SessionIdSymbol,
   UnexpectedError,
 } from '@livestore/common'
 import { deepEqual, shouldNeverHappen } from '@livestore/utils'
@@ -14,13 +15,13 @@ import * as otel from '@opentelemetry/api'
 
 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 { isValidFunctionString } from '../utils/function-string.js'
 import type { DepKey, GetAtomResult, LiveQueryDef, ReactivityGraph, ReactivityGraphContext } from './base-class.js'
 import { depsToString, LiveStoreQueryBase, makeGetAtomResult, withRCMap } from './base-class.js'
+import { makeExecBeforeFirstRun, rowQueryLabel } from './client-document-get-query.js'
 
-export type QueryInputRaw<TDecoded, TEncoded, TQueryInfo extends QueryInfo> = {
+export type QueryInputRaw<TDecoded, TEncoded> = {
   query: string
   schema: Schema.Schema<TDecoded, TEncoded>
   bindValues?: Bindable
@@ -30,25 +31,20 @@ export type QueryInputRaw<TDecoded, TEncoded, TQueryInfo extends QueryInfo> = {
    * NOTE In the future we want to do this automatically at build time
    */
   queriedTables?: Set<string>
-  queryInfo?: TQueryInfo
   execBeforeFirstRun?: (ctx: ReactivityGraphContext) => void
 }
 
-export const isQueryInputRaw = (value: unknown): value is QueryInputRaw<any, any, any> =>
+export const isQueryInputRaw = (value: unknown): value is QueryInputRaw<any, any> =>
   Predicate.hasProperty(value, 'query') && Predicate.hasProperty(value, 'schema')
 
-export type QueryInput<TDecoded, TEncoded, TQueryInfo extends QueryInfo> =
-  | QueryInputRaw<TDecoded, TEncoded, TQueryInfo>
-  | QueryBuilder<TDecoded, any, any, TQueryInfo>
+export type QueryInput<TDecoded, TEncoded> = QueryInputRaw<TDecoded, TEncoded> | QueryBuilder<TDecoded, any, any>
 
 /**
- * NOTE `query` is only supposed to read data. Don't use it to insert/update/delete data but use mutations instead.
+ * NOTE `queryDb` is only supposed to read data. Don't use it to insert/update/delete data but use events instead.
  */
 export const queryDb: {
-  <TResultSchema, TResult = TResultSchema, TQueryInfo extends QueryInfo = QueryInfo.None>(
-    queryInput:
-      | QueryInputRaw<TResultSchema, ReadonlyArray<any>, TQueryInfo>
-      | QueryBuilder<TResultSchema, any, any, TQueryInfo>,
+  <TResultSchema, TResult = TResultSchema>(
+    queryInput: QueryInputRaw<TResultSchema, ReadonlyArray<any>> | QueryBuilder<TResultSchema, any, any>,
     options?: {
       map?: (rows: TResultSchema) => TResult
       /**
@@ -56,16 +52,15 @@ export const queryDb: {
        */
       label?: string
       deps?: DepKey
-      queryInfo?: TQueryInfo
     },
-  ): LiveQueryDef<TResult, TQueryInfo>
+  ): LiveQueryDef<TResult>
   // 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>(
+  <TResultSchema, TResult = TResultSchema>(
     queryInput:
-      | ((get: GetAtomResult) => QueryInputRaw<TResultSchema, ReadonlyArray<any>, TQueryInfo>)
-      | ((get: GetAtomResult) => QueryBuilder<TResultSchema, any, any, TQueryInfo>),
+      | ((get: GetAtomResult) => QueryInputRaw<TResultSchema, ReadonlyArray<any>>)
+      | ((get: GetAtomResult) => QueryBuilder<TResultSchema, any, any>),
     options?: {
       map?: (rows: TResultSchema) => TResult
       /**
@@ -73,23 +68,21 @@ export const queryDb: {
        */
       label?: string
       deps?: DepKey
-      queryInfo?: TQueryInfo
     },
-  ): LiveQueryDef<TResult, TQueryInfo>
+  ): LiveQueryDef<TResult>
 } = (queryInput, options) => {
-  const queryString = isQueryBuilder(queryInput)
-    ? queryInput.toString()
-    : isQueryInputRaw(queryInput)
-      ? queryInput.query
-      : typeof queryInput === 'function'
-        ? queryInput.toString()
-        : shouldNeverHappen(`Invalid query input: ${queryInput}`)
-
-  const hash = options?.deps ? queryString + '-' + depsToString(options.deps) : queryString
+  const { queryString, extraDeps } = getQueryStringAndExtraDeps(queryInput)
+
+  const hash =
+    (options?.deps ? queryString + '-' + depsToString(options.deps) : queryString) + '-' + depsToString(extraDeps)
   if (isValidFunctionString(hash)._tag === 'invalid') {
     throw new Error(`On Expo/React Native, db queries must provide a \`deps\` option`)
   }
 
+  if (hash.trim() === '') {
+    return shouldNeverHappen(`Invalid query hash for query: ${queryInput}`)
+  }
+
   const label = options?.label ?? queryString
 
   return {
@@ -101,36 +94,55 @@ export const queryDb: {
         queryInput,
         label,
         map: options?.map,
-        // We're not falling back to `None` here as the queryInfo will be set dynamically
-        queryInfo: options?.queryInfo,
         otelContext,
       })
     }),
     label,
     hash,
-    queryInfo:
-      options?.queryInfo ?? (isQueryBuilder(queryInput) ? queryInfoFromQueryBuilder(queryInput) : { _tag: 'None' }),
   }
 }
 
+const bindValuesToDepKey = (bindValues: Bindable | undefined): DepKey => {
+  if (bindValues === undefined) {
+    return []
+  }
+
+  return Object.entries(bindValues)
+    .map(([key, value]: [string, any]) => `${key}:${value === SessionIdSymbol ? 'SessionIdSymbol' : value}`)
+    .join(',')
+}
+
+const getQueryStringAndExtraDeps = (
+  queryInput: QueryInput<any, any> | ((get: GetAtomResult) => QueryInput<any, any>),
+): { queryString: string; extraDeps: DepKey } => {
+  if (isQueryBuilder(queryInput)) {
+    const { query, bindValues } = queryInput.asSql()
+    return { queryString: query, extraDeps: bindValuesToDepKey(bindValues) }
+  }
+
+  if (isQueryInputRaw(queryInput)) {
+    return { queryString: queryInput.query, extraDeps: bindValuesToDepKey(queryInput.bindValues) }
+  }
+
+  if (typeof queryInput === 'function') {
+    return { queryString: queryInput.toString(), extraDeps: [] }
+  }
+
+  return shouldNeverHappen(`Invalid query input: ${queryInput}`)
+}
+
 /* An object encapsulating a reactive SQL query */
-export class LiveStoreDbQuery<
-  TResultSchema,
-  TResult = TResultSchema,
-  TQueryInfo extends QueryInfo = QueryInfo.None,
-> extends LiveStoreQueryBase<TResult, TQueryInfo> {
+export class LiveStoreDbQuery<TResultSchema, TResult = TResultSchema> extends LiveStoreQueryBase<TResult> {
   _tag: 'db' = 'db'
 
   /** A reactive thunk representing the query text */
-  queryInput$: Thunk<QueryInputRaw<any, any, QueryInfo>, ReactivityGraphContext, RefreshReason> | undefined
+  queryInput$: Thunk<QueryInputRaw<any, any>, ReactivityGraphContext, RefreshReason> | undefined
 
   /** A reactive thunk representing the query results */
   results$: Thunk<TResult, ReactivityGraphContext, RefreshReason>
 
   label: string
 
-  queryInfo: TQueryInfo
-
   readonly reactivityGraph
 
   private mapResult: (rows: TResultSchema) => TResult
@@ -140,23 +152,20 @@ export class LiveStoreDbQuery<
     label: inputLabel,
     reactivityGraph,
     map,
-    queryInfo: inputQueryInfo,
     otelContext,
   }: {
     label?: string
     queryInput:
-      | QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>
-      | ((get: GetAtomResult, ctx: ReactivityGraphContext) => QueryInput<TResultSchema, ReadonlyArray<any>, TQueryInfo>)
+      | QueryInput<TResultSchema, ReadonlyArray<any>>
+      | ((get: GetAtomResult, ctx: ReactivityGraphContext) => QueryInput<TResultSchema, ReadonlyArray<any>>)
     reactivityGraph: ReactivityGraph
     map?: (rows: TResultSchema) => TResult
-    queryInfo?: TQueryInfo
     /** Only used for the initial query execution */
     otelContext?: otel.Context
   }) {
     super()
 
     let label = inputLabel ?? 'db(unknown)'
-    let queryInfo = inputQueryInfo ?? ({ _tag: 'None' } as TQueryInfo)
     this.reactivityGraph = reactivityGraph
 
     this.mapResult = map === undefined ? (rows: any) => rows as TResult : map
@@ -172,7 +181,7 @@ export class LiveStoreDbQuery<
       current: undefined,
     }
 
-    type TQueryInputRaw = QueryInputRaw<any, any, QueryInfo>
+    type TQueryInputRaw = QueryInputRaw<any, any>
 
     let queryInputRaw$OrQueryInputRaw: TQueryInputRaw | Thunk<TQueryInputRaw, ReactivityGraphContext, RefreshReason>
 
@@ -188,14 +197,13 @@ export class LiveStoreDbQuery<
             schema,
             bindValues: qbRes.bindValues,
             queriedTables: new Set([ast.tableDef.sqliteDef.name]),
-            queryInfo: queryInfoFromQueryBuilder(qb),
           } satisfies TQueryInputRaw,
           label: ast._tag === 'RowQuery' ? rowQueryLabel(ast.tableDef, ast.id) : qb.toString(),
           execBeforeFirstRun:
             ast._tag === 'RowQuery'
               ? makeExecBeforeFirstRun({
                   table: ast.tableDef,
-                  insertValues: ast.insertValues,
+                  explicitDefaultValues: ast.explicitDefaultValues,
                   id: ast.id,
                   otelContext,
                 })
@@ -232,10 +240,6 @@ export class LiveStoreDbQuery<
 
           schemaRef.current = queryInputRaw.schema
 
-          if (inputQueryInfo === undefined && queryInputRaw.queryInfo !== undefined) {
-            queryInfo = queryInputRaw.queryInfo as TQueryInfo
-          }
-
           return queryInputRaw
         },
         {
@@ -268,10 +272,6 @@ export class LiveStoreDbQuery<
           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 }
@@ -352,9 +352,9 @@ export class LiveStoreDbQuery<
               const expectedSchemaStr = String(schemaRef.current!.ast)
               const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
 
-              console.error(
+              return shouldNeverHappen(
                 `\
-Error parsing SQL query result.
+Error parsing SQL query result (${label}).
 
 Query: ${sqlString}\
 ${bindValuesStr}
@@ -365,8 +365,8 @@ Error: ${parseErrorStr}
 
 Result:`,
                 rawDbResults,
+                '\n',
               )
-              return shouldNeverHappen(`Error parsing SQL query result: ${parsedResult.left}`)
             }
 
             const result = this.mapResult(parsedResult.right)
@@ -388,7 +388,6 @@ Result:`,
     this.results$ = results$
 
     this.label = label
-    this.queryInfo = queryInfo
   }
 
   destroy = () => {
@@ -405,8 +404,3 @@ Result:`,
     }
   }
 }
-
-const queryInfoFromQueryBuilder = (qb: QueryBuilder.Any): QueryInfo.Row | QueryInfo.None => {
-  const ast = qb[QueryBuilderAstSymbol]
-  return ast._tag === 'RowQuery' ? { _tag: 'Row', table: ast.tableDef, id: ast.id } : { _tag: 'None' }
-}

package/src/live-queries/make-ref.ts

@@ -5,6 +5,8 @@ import type { RefreshReason } from '../store/store-types.js'
 import type { ILiveQueryRef, ILiveQueryRefDef, ReactivityGraph, ReactivityGraphContext } from './base-class.js'
 import { withRCMap } from './base-class.js'
 
+// TODO rename to `signal`
+
 export const makeRef = <T>(
   defaultValue: T,
   options?: {

package/src/mod.ts

@@ -13,8 +13,6 @@ export {
 
 export { SqliteDbWrapper, emptyDebugInfo } from './SqliteDbWrapper.js'
 
-export { deriveColQuery } from './row-query-utils.js'
-
 export { queryDb, computed, makeRef, type LiveQuery, type LiveQueryDef } from './live-queries/mod.js'
 
 export * from '@livestore/common/schema'

package/src/reactive.ts

@@ -203,7 +203,7 @@ export class ReactiveGraph<
 
   context: TContext | undefined
 
-  debugRefreshInfos: BoundArray<RefreshDebugInfo<TDebugRefreshReason, TDebugThunkInfo>> = new BoundArray(5000)
+  debugRefreshInfos: BoundArray<RefreshDebugInfo<TDebugRefreshReason, TDebugThunkInfo>> = new BoundArray(200)
 
   private currentDebugRefresh:
     | { refreshedAtoms: AtomDebugInfo<TDebugThunkInfo>[]; startMs: DOMHighResTimeStamp }

package/src/store/create-store.ts

@@ -267,7 +267,7 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, T
         // But for now this is a good enough approximation with little downsides
         __runningInDevtools: getDevtoolsEnabled(disableDevtools) === false,
         confirmUnsavedChanges,
-        // NOTE during boot we're not yet executing mutations in a batched context
+        // NOTE during boot we're not yet executing events in a batched context
         // but only set the provided `batchUpdates` function after boot
         batchUpdates: (run) => run(),
         storeId,
@@ -276,7 +276,7 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, T
         },
       })
 
-      // Starts background fibers (syncing, mutation processing, etc) for store
+      // Starts background fibers (syncing, event processing, etc) for store
       yield* store.boot
 
       if (boot !== undefined) {

package/src/store/store-types.ts

@@ -1,5 +1,5 @@
 import type { ClientSession, IntentionalShutdownCause, StoreInterrupted, UnexpectedError } from '@livestore/common'
-import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
+import type { LiveStoreEvent, LiveStoreSchema } from '@livestore/common/schema'
 import type { Effect, Runtime, Scope } from '@livestore/utils/effect'
 import { Deferred } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
@@ -57,8 +57,8 @@ export type RefreshReason =
   | DebugRefreshReasonBase
   | {
       _tag: 'commit'
-      /** The mutations that were applied */
-      mutations: ReadonlyArray<MutationEvent.AnyDecoded | MutationEvent.PartialAnyDecoded>
+      /** The events that were applied */
+      events: ReadonlyArray<LiveStoreEvent.AnyDecoded | LiveStoreEvent.PartialAnyDecoded>
 
       /** The tables that were written to by the event */
       writeTables: ReadonlyArray<string>
@@ -83,11 +83,11 @@ export type QueryDebugInfo = {
 
 export type StoreOtel = {
   tracer: otel.Tracer
-  mutationsSpanContext: otel.Context
+  commitsSpanContext: otel.Context
   queriesSpanContext: otel.Context
 }
 
-export type StoreMutateOptions = {
+export type StoreCommitOptions = {
   label?: string
   skipRefresh?: boolean
   spanLinks?: otel.Link[]