@livestore/livestore 0.0.0-snapshot-2b8a9de3ec1a701aca891ebc2c98eb328274ae9e → 0.0.0-snapshot-2c861249e50661661613204300b1fc0d902c2e46

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'
@@ -64,12 +64,12 @@ Vitest.describe('otel', () => {
 
       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(`
       [
@@ -100,7 +100,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 +117,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()
 
@@ -147,7 +147,7 @@ Vitest.describe('otel', () => {
       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 +157,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(`
       {

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 './row-query-utils.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 }
@@ -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/live-queries/row-query-utils.ts

@@ -0,0 +1,50 @@
+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.TableDefBase, id: string | SessionIdSymbol | number | undefined) =>
+  `row:${table.sqliteDef.name}${id === undefined ? '' : id === SessionIdSymbol ? `:sessionId` : `:${id}`}`
+
+export const makeExecBeforeFirstRun =
+  ({
+    id,
+    explicitDefaultValues,
+    table,
+    otelContext: otelContext_,
+  }: {
+    id?: string | SessionIdSymbol | number
+    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: `rowQuery:${table.sqliteDef.name}:${idVal}` },
+      table.set(explicitDefaultValues, idVal as TODO),
+    )
+  }

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

@@ -7,8 +7,8 @@ import type {
   MigrationsReport,
 } from '@livestore/common'
 import { provideOtel, UnexpectedError } from '@livestore/common'
-import type { EventId, LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
-import { LS_DEV } from '@livestore/utils'
+import type { LiveStoreSchema } from '@livestore/common/schema'
+import { isDevEnv, LS_DEV } from '@livestore/utils'
 import type { Cause, Schema } from '@livestore/utils/effect'
 import {
   Context,
@@ -19,7 +19,6 @@ import {
   Layer,
   Logger,
   LogLevel,
-  MutableHashMap,
   OtelTracer,
   Queue,
   Runtime,
@@ -74,7 +73,12 @@ export type LiveStoreContextProps<TSchema extends LiveStoreSchema, TContext = {}
     store: Store<TSchema, TContext>,
   ) => Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
   adapter: Adapter
-  disableDevtools?: boolean
+  /**
+   * Whether to disable devtools.
+   *
+   * @default 'auto'
+   */
+  disableDevtools?: boolean | 'auto'
   onBootStatus?: (status: BootStatus) => void
   batchUpdates: (run: () => void) => void
 }
@@ -92,7 +96,12 @@ export interface CreateStoreOptions<TSchema extends LiveStoreSchema, TContext =
     },
   ) => void | Promise<void> | Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
   batchUpdates?: (run: () => void) => void
-  disableDevtools?: boolean
+  /**
+   * Whether to disable devtools.
+   *
+   * @default 'auto'
+   */
+  disableDevtools?: boolean | 'auto'
   onBootStatus?: (status: BootStatus) => void
   shutdownDeferred?: ShutdownDeferred
   /**
@@ -229,7 +238,7 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, T
       const clientSession: ClientSession = yield* adapter({
         schema,
         storeId,
-        devtoolsEnabled: disableDevtools !== true,
+        devtoolsEnabled: getDevtoolsEnabled(disableDevtools),
         bootStatusQueue,
         shutdown,
         connectDevtoolsToStore: connectDevtoolsToStore_,
@@ -248,20 +257,17 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, T
         )
       }
 
-      // TODO fill up with unsynced mutation events from the client session
-      const unsyncedMutationEvents = MutableHashMap.empty<EventId.EventId, MutationEvent.ForSchema<TSchema>>()
-
       const store = new Store<TSchema, TContext>({
         clientSession,
         schema,
         context,
         otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
-        disableDevtools,
-        unsyncedMutationEvents,
-        lifetimeScope,
-        runtime,
+        effectContext: { lifetimeScope, runtime },
+        // TODO find a better way to detect if we're running LiveStore in the LiveStore devtools
+        // 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,
@@ -270,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) {
@@ -314,3 +320,15 @@ const validateStoreId = (storeId: string) =>
       })
     }
   })
+
+const getDevtoolsEnabled = (disableDevtools: boolean | 'auto' | undefined) => {
+  if (disableDevtools === true) {
+    return false
+  }
+
+  if (isDevEnv() === true) {
+    return true
+  }
+
+  return false
+}

package/src/store/store-types.ts

@@ -1,6 +1,6 @@
 import type { ClientSession, IntentionalShutdownCause, StoreInterrupted, UnexpectedError } from '@livestore/common'
-import type { EventId, LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
-import type { Effect, MutableHashMap, Runtime, Scope } from '@livestore/utils/effect'
+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'
 
@@ -41,24 +41,24 @@ export type StoreOptions<TSchema extends LiveStoreSchema = LiveStoreSchema, TCon
   storeId: string
   context: TContext
   otelOptions: OtelOptions
-  disableDevtools?: boolean
-  lifetimeScope: Scope.Scope
-  runtime: Runtime.Runtime<Scope.Scope>
+  effectContext: {
+    runtime: Runtime.Runtime<Scope.Scope>
+    lifetimeScope: Scope.Scope
+  }
   confirmUnsavedChanges: boolean
   batchUpdates: (runUpdates: () => void) => void
-  // TODO validate whether we still need this
-  unsyncedMutationEvents: MutableHashMap.MutableHashMap<EventId.EventId, MutationEvent.ForSchema<TSchema>>
   params: {
     leaderPushBatchSize: number
   }
+  __runningInDevtools: boolean
 }
 
 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[]