@livestore/livestore 0.4.0-dev.1 → 0.4.0-dev.10

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

@@ -9,7 +9,7 @@ import {
   SessionIdSymbol,
   UnexpectedError,
 } from '@livestore/common'
-import { deepEqual, shouldNeverHappen } from '@livestore/utils'
+import { deepEqual, omitUndefineds, shouldNeverHappen } from '@livestore/utils'
 import { Equal, Hash, Predicate, Schema, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
@@ -124,9 +124,8 @@ export const queryDb: {
         reactivityGraph: ctx.reactivityGraph.deref()!,
         queryInput,
         label,
-        map: options?.map,
-        otelContext,
         def,
+        ...omitUndefineds({ map: options?.map, otelContext }),
       })
     }),
     label,
@@ -429,7 +428,11 @@ Result:`,
             return result
           },
         ),
-      { label: `${label}:results`, meta: { liveStoreThunkType: 'db.result' }, equal: resultsEqual },
+      {
+        label: `${label}:results`,
+        meta: { liveStoreThunkType: 'db.result' },
+        ...omitUndefineds({ equal: resultsEqual }),
+      },
     )
 
     this.results$ = results$

package/src/mod.ts

@@ -4,6 +4,7 @@ export {
   type BootStatus,
   type DebugInfo,
   IntentionalShutdownCause,
+  liveStoreVersion,
   type MutableDebugInfo,
   type PreparedBindValues,
   prepareBindValues,
@@ -14,6 +15,7 @@ export {
   SessionIdSymbol,
   type SqliteDb,
   StoreInterrupted,
+  type SyncState,
   sql,
 } from '@livestore/common'
 export * from '@livestore/common/schema'

package/src/reactive.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-
+import type { DebugRefreshReasonBase, DebugThunkInfo } from './reactive.ts'
 import { ReactiveGraph } from './reactive.ts'
 
 describe('a trivial graph', () => {
@@ -424,3 +424,152 @@ describe('error handling', () => {
     )
   })
 })
+
+// Bug: When an effect calls setRef during execution, it triggers nested runEffects calls.
+// The nested call would overwrite and clear the shared currentDebugRefresh state,
+// causing a TypeError when the outer runEffects tried to access currentDebugRefresh.refreshedAtoms.
+// Fix: Use local variables to capture debug state instead of relying on shared mutable state.
+describe('bug fix: currentDebugRefresh race condition', () => {
+  it('keeps the debug refresh context when nested effect runs are triggered', () => {
+    type TestRefreshReason = DebugRefreshReasonBase | { _tag: 'outer' } | { _tag: 'nested' }
+
+    const graph = new ReactiveGraph<TestRefreshReason, DebugThunkInfo>()
+    graph.context = {}
+
+    const triggerRef = graph.makeRef(0, { label: 'trigger' })
+    const responseRef = graph.makeRef(0, { label: 'response' })
+
+    const triggerThunk = graph.makeThunk((get) => get(triggerRef), { label: 'triggerThunk' })
+    const laterThunk = graph.makeThunk((get) => get(triggerRef) + 1, { label: 'laterThunk' })
+    const responseThunk = graph.makeThunk((get) => get(responseRef), { label: 'responseThunk' })
+
+    const nestedEffect = graph.makeEffect((get) => {
+      get(responseThunk)
+    })
+
+    let observedLater: number | undefined
+    const outerEffect = graph.makeEffect((get) => {
+      const current = get(triggerThunk)
+
+      if (current !== 0) {
+        graph.setRef(responseRef, current, {
+          debugRefreshReason: { _tag: 'nested' },
+        })
+      }
+
+      observedLater = get(laterThunk)
+    })
+
+    nestedEffect.doEffect()
+    outerEffect.doEffect()
+    graph.debugRefreshInfos.clear()
+
+    graph.setRef(triggerRef, 1, { debugRefreshReason: { _tag: 'outer' } })
+
+    expect(observedLater).toBe(2)
+
+    const refreshInfos = Array.from(graph.debugRefreshInfos)
+    const outerRefresh = refreshInfos.find((info) => info.reason._tag === 'outer')
+    expect(outerRefresh).toBeDefined()
+    const refreshedLabels = outerRefresh!.refreshedAtoms.map((atomInfo) => atomInfo.atom.label)
+    expect(refreshedLabels).toContain('triggerThunk')
+    expect(refreshedLabels).toContain('laterThunk')
+
+    const makeThunkRefreshes = refreshInfos.filter((info) => info.reason._tag === 'makeThunk')
+    expect(makeThunkRefreshes).toHaveLength(0)
+  })
+
+  it('handles nested runEffects from effect calling setRef', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+    const b = graph.makeRef(2)
+
+    // Effect that calls setRef, triggering nested runEffects
+    graph
+      .makeEffect((get) => {
+        get(a)
+        graph.setRef(b, 3)
+      })
+      .doEffect()
+
+    // Effect observing b
+    graph.makeEffect((get) => get(b)).doEffect()
+
+    // Previously crashed with: Cannot read properties of undefined (reading 'refreshedAtoms')
+    // Now handles nested runEffects correctly
+    expect(() => graph.setRef(a, 2)).not.toThrow()
+  })
+
+  it('handles thunk calling setRef directly', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+    const b = graph.makeRef(2)
+
+    // Effect observing b so setRef(b) triggers runEffects
+    graph.makeEffect((get) => get(b)).doEffect()
+
+    // Thunk that calls setRef during its computation
+    const thunk = graph.makeThunk((get) => {
+      const val = get(a)
+      graph.setRef(b, val * 2) // This triggers nested runEffects
+      return val + get(b)
+    })
+
+    // With our fix, this handles nested currentDebugRefresh correctly
+    expect(() => thunk.computeResult()).not.toThrow()
+    expect(thunk.computeResult()).toBe(3) // 1 + 2 (b was already set to 2)
+  })
+
+  it('handles nested thunk computations', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+
+    // Outer thunk that creates and computes inner thunk
+    const outerThunk = graph.makeThunk((get) => {
+      const val = get(a)
+
+      // Create and compute inner thunk during outer computation
+      const innerThunk = graph.makeThunk((innerGet) => innerGet(a) * 2)
+
+      // Nested thunk computation - previously could corrupt currentDebugRefresh
+      return val + innerThunk.computeResult()
+    })
+
+    // With our fix, nested thunk computations work correctly
+    expect(() => outerThunk.computeResult()).not.toThrow()
+    expect(outerThunk.computeResult()).toBe(3) // 1 + (1 * 2)
+  })
+})
+
+// Bug: Nodes could have undefined or deleted super/sub properties in certain edge cases,
+// causing crashes with "Cannot read properties of undefined" errors.
+// Fix: Added validation checks in destroyNode to handle corrupted nodes gracefully.
+// Note: Full addEdge protection was removed, so some scenarios still crash with native errors.
+describe('bug fix: node corruption protection', () => {
+  it('handles node destruction during effect execution', () => {
+    const graph = new ReactiveGraph()
+    graph.context = {}
+
+    const a = graph.makeRef(1)
+    const thunk1 = graph.makeThunk((get) => get(a) * 2)
+    const thunk2 = graph.makeThunk((get) => get(thunk1))
+
+    let firstRun = true
+    const effect = graph.makeEffect((get) => {
+      if (firstRun) {
+        firstRun = false
+        graph.destroyNode(thunk1) // Destroy dependency mid-execution
+      }
+      get(thunk2)
+    })
+
+    // Should detect the destroyed node
+    expect(() => effect.doEffect()).toThrow('LiveStore Error: Attempted to compute destroyed')
+  })
+})

package/src/reactive.ts

@@ -22,7 +22,7 @@
 // - At every thunk we check value equality with the previous value and cutoff propagation if possible.
 
 import { BoundArray } from '@livestore/common'
-import { deepEqual, shouldNeverHappen } from '@livestore/utils'
+import { deepEqual, omitUndefineds, shouldNeverHappen } from '@livestore/utils'
 import type { Types } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 // import { getDurationMsFromSpan } from './otel.ts'
@@ -45,9 +45,9 @@ export type Ref<T, TContext, TDebugRefreshReason extends DebugRefreshReason> = {
   computeResult: () => T
   sub: Set<Atom<any, TContext, TDebugRefreshReason>> // always empty
   super: Set<Thunk<any, TContext, TDebugRefreshReason> | Effect<TDebugRefreshReason>>
-  label?: string
+  label?: string | undefined
   /** Container for meta information (e.g. the LiveStore Store) */
-  meta?: any
+  meta?: any | undefined
   equal: (a: T, b: T) => boolean
   refreshes: number
 }
@@ -61,9 +61,9 @@ export type Thunk<TResult, TContext, TDebugRefreshReason extends DebugRefreshRea
   previousResult: TResult | NOT_REFRESHED_YET
   sub: Set<Atom<any, TContext, TDebugRefreshReason>>
   super: Set<Thunk<any, TContext, TDebugRefreshReason> | Effect<TDebugRefreshReason>>
-  label?: string
+  label?: string | undefined
   /** Container for meta information (e.g. the LiveStore Store) */
-  meta?: any
+  meta?: any | undefined
   equal: (a: TResult, b: TResult) => boolean
   recomputations: number
 
@@ -80,7 +80,7 @@ export type Effect<TDebugRefreshReason extends DebugRefreshReason> = {
   isDestroyed: boolean
   doEffect: (otelContext?: otel.Context | undefined, debugRefreshReason?: TDebugRefreshReason | undefined) => void
   sub: Set<Atom<any, TODO, TODO>>
-  label?: string
+  label?: string | undefined
   invocations: number
 }
 
@@ -103,10 +103,10 @@ export type DebugRefreshReasonBase =
   /** Usually in response to some `commit` calls with `skipRefresh: true` */
   | {
       _tag: 'runDeferredEffects'
-      originalRefreshReasons?: ReadonlyArray<DebugRefreshReasonBase>
-      manualRefreshReason?: DebugRefreshReasonBase
+      originalRefreshReasons?: ReadonlyArray<DebugRefreshReasonBase> | undefined
+      manualRefreshReason?: DebugRefreshReasonBase | undefined
     }
-  | { _tag: 'makeThunk'; label?: string }
+  | { _tag: 'makeThunk'; label?: string | undefined }
   | { _tag: 'unknown' }
 
 export type DebugRefreshReason<T extends string = string> = DebugRefreshReasonBase | { _tag: T }
@@ -135,7 +135,7 @@ const unknownRefreshReason = () => {
   return { _tag: 'unknown' as const }
 }
 
-export type EncodedOption<A> = { _tag: 'Some'; value?: A } | { _tag: 'None' }
+export type EncodedOption<A> = { _tag: 'Some'; value?: A | undefined } | { _tag: 'None' }
 const encodedOptionSome = <A>(value: A): EncodedOption<A> => ({ _tag: 'Some', value })
 const encodedOptionNone = <A>(): EncodedOption<A> => ({ _tag: 'None' })
 
@@ -192,7 +192,7 @@ export const __resetIds = () => {
 export class ReactiveGraph<
   TDebugRefreshReason extends DebugRefreshReason,
   TDebugThunkInfo extends DebugThunkInfo,
-  TContext extends { effectsWrapper?: (runEffects: () => void) => void } = {},
+  TContext extends { effectsWrapper?: ((runEffects: () => void) => void) | undefined } = {},
 > {
   id = uniqueGraphId()
 
@@ -211,10 +211,8 @@ export class ReactiveGraph<
 
   private refreshCallbacks: Set<() => void> = new Set()
 
-  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: for debugging
   private nodeIdCounter = 0
   private uniqueNodeId = () => `node-${++this.nodeIdCounter}`
-  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: for debugging
   private refreshInfoIdCounter = 0
   private uniqueRefreshInfoId = () => `refresh-info-${++this.refreshInfoIdCounter}`
 
@@ -231,8 +229,7 @@ export class ReactiveGraph<
       computeResult: () => ref.previousResult,
       sub: new Set(),
       super: new Set(),
-      label: options?.label,
-      meta: options?.meta,
+      ...omitUndefineds({ label: options?.label, meta: options?.meta }),
       equal: options?.equal ?? deepEqual,
       refreshes: 0,
     }
@@ -267,8 +264,11 @@ export class ReactiveGraph<
       computeResult: (otelContext, debugRefreshReason) => {
         if (thunk.isDirty) {
           const neededCurrentRefresh = this.currentDebugRefresh === undefined
+          let localDebugRefresh: { refreshedAtoms: any[]; startMs: number } | undefined
           if (neededCurrentRefresh) {
-            this.currentDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
+            // Use local variable to prevent corruption from nested computations
+            localDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
+            this.currentDebugRefresh = localDebugRefresh
           }
 
           // Reset previous subcomputations as we're about to re-add them as part of the `doEffect` call below
@@ -300,15 +300,20 @@ export class ReactiveGraph<
             debugInfo: debugInfo ?? (unknownRefreshReason() as TDebugThunkInfo),
           } satisfies AtomDebugInfo<TDebugThunkInfo>
 
-          this.currentDebugRefresh!.refreshedAtoms.push(debugInfoForAtom)
+          // Use currentDebugRefresh if available (could be from parent or local)
+          const debugRefresh = localDebugRefresh ?? this.currentDebugRefresh
+          if (debugRefresh) {
+            debugRefresh.refreshedAtoms.push(debugInfoForAtom)
+          }
 
           thunk.isDirty = false
           thunk.previousResult = result
           thunk.recomputations++
 
-          if (neededCurrentRefresh) {
-            const refreshedAtoms = this.currentDebugRefresh!.refreshedAtoms
-            const durationMs = performance.now() - this.currentDebugRefresh!.startMs
+          if (neededCurrentRefresh && localDebugRefresh) {
+            // Use local reference which can't be corrupted by nested calls
+            const refreshedAtoms = localDebugRefresh.refreshedAtoms
+            const durationMs = performance.now() - localDebugRefresh.startMs
             this.currentDebugRefresh = undefined
 
             this.debugRefreshInfos.push({
@@ -330,8 +335,7 @@ export class ReactiveGraph<
       sub: new Set(),
       super: new Set(),
       recomputations: 0,
-      label: options?.label,
-      meta: options?.meta,
+      ...omitUndefineds({ label: options?.label, meta: options?.meta }),
       equal: options?.equal ?? deepEqual,
       __getResult: getResult,
     }
@@ -407,7 +411,7 @@ export class ReactiveGraph<
         doEffect(getAtom as GetAtom, otelContext, debugRefreshReason)
       },
       sub: new Set(),
-      label: options?.label,
+      ...omitUndefineds({ label: options?.label }),
       invocations: 0,
     }
 
@@ -461,7 +465,7 @@ export class ReactiveGraph<
     } else {
       this.runEffects(effectsToRefresh, {
         debugRefreshReason: options?.debugRefreshReason ?? (unknownRefreshReason() as TDebugRefreshReason),
-        otelContext: options?.otelContext,
+        ...omitUndefineds({ otelContext: options?.otelContext }),
       })
     }
   }
@@ -475,15 +479,21 @@ export class ReactiveGraph<
   ) => {
     const effectsWrapper = this.context?.effectsWrapper ?? ((runEffects: () => void) => runEffects())
     effectsWrapper(() => {
-      this.currentDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
-
-      for (const effect of effectsToRefresh) {
-        effect.doEffect(options?.otelContext, options.debugRefreshReason)
+      // Capture debug state in local variable to prevent corruption from nested runEffects
+      const previousDebugRefresh = this.currentDebugRefresh
+      const localDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
+      this.currentDebugRefresh = localDebugRefresh
+
+      try {
+        for (const effect of effectsToRefresh) {
+          effect.doEffect(options?.otelContext, options.debugRefreshReason)
+        }
+      } finally {
+        this.currentDebugRefresh = previousDebugRefresh
       }
 
-      const refreshedAtoms = this.currentDebugRefresh.refreshedAtoms
-      const durationMs = performance.now() - this.currentDebugRefresh.startMs
-      this.currentDebugRefresh = undefined
+      const refreshedAtoms = localDebugRefresh.refreshedAtoms
+      const durationMs = performance.now() - localDebugRefresh.startMs
 
       const refreshDebugInfo: RefreshDebugInfo<TDebugRefreshReason, TDebugThunkInfo> = {
         id: this.uniqueRefreshInfoId(),
@@ -509,9 +519,9 @@ export class ReactiveGraph<
         debugRefreshReason: {
           _tag: 'runDeferredEffects',
           originalRefreshReasons: Array.from(debugRefreshReasons) as ReadonlyArray<DebugRefreshReasonBase>,
-          manualRefreshReason: options?.debugRefreshReason,
-        } as TDebugRefreshReason,
-        otelContext: options?.otelContext,
+          ...omitUndefineds({ manualRefreshReason: options?.debugRefreshReason }),
+        } as unknown as TDebugRefreshReason,
+        ...omitUndefineds({ otelContext: options?.otelContext }),
       })
     }
   }
@@ -641,8 +651,7 @@ const serializeAtom = (atom: Atom<any, unknown, any>, includeResult: boolean): S
     return {
       _tag: atom._tag,
       id: atom.id,
-      label: atom.label,
-      meta: atom.meta,
+      ...omitUndefineds({ label: atom.label, meta: atom.meta }),
       isDirty: atom.isDirty,
       sub,
       super: super_,
@@ -655,8 +664,7 @@ const serializeAtom = (atom: Atom<any, unknown, any>, includeResult: boolean): S
   return {
     _tag: 'thunk',
     id: atom.id,
-    label: atom.label,
-    meta: atom.meta,
+    ...omitUndefineds({ label: atom.label, meta: atom.meta }),
     isDirty: atom.isDirty,
     sub,
     super: super_,
@@ -676,7 +684,7 @@ const serializeEffect = (effect: Effect<any>): SerializedEffect => {
   return {
     _tag: effect._tag,
     id: effect.id,
-    label: effect.label,
+    ...omitUndefineds({ label: effect.label }),
     sub,
     invocations: effect.invocations,
     isDestroyed: effect.isDestroyed,

package/src/store/create-store.ts

@@ -5,13 +5,16 @@ import {
   type ClientSessionDevtoolsChannel,
   type ClientSessionSyncProcessorSimulationParams,
   type IntentionalShutdownCause,
+  type InvalidPullError,
+  type IsOfflineError,
+  type MaterializeError,
   type MigrationsReport,
   provideOtel,
   type SyncError,
   UnexpectedError,
 } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
-import { isDevEnv, LS_DEV } from '@livestore/utils'
+import { isDevEnv, LS_DEV, omitUndefineds } from '@livestore/utils'
 import {
   Context,
   Deferred,
@@ -156,7 +159,7 @@ export const createStorePromise = async <TSchema extends LiveStoreSchema = LiveS
     Effect.withSpan('createStore', {
       attributes: { storeId: options.storeId, disableDevtools: options.disableDevtools },
     }),
-    provideOtel({ parentSpanContext: otelOptions?.rootSpanContext, otelTracer: otelOptions?.tracer }),
+    provideOtel(omitUndefineds({ parentSpanContext: otelOptions?.rootSpanContext, otelTracer: otelOptions?.tracer })),
     Effect.tapCauseLogPretty,
     Effect.annotateLogs({ thread: 'window' }),
     Effect.provide(Logger.prettyWithThread('window')),
@@ -217,7 +220,12 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema.An
 
       const runtime = yield* Effect.runtime<Scope.Scope>()
 
-      const shutdown = (exit: Exit.Exit<IntentionalShutdownCause, UnexpectedError | SyncError>) =>
+      const shutdown = (
+        exit: Exit.Exit<
+          IntentionalShutdownCause,
+          UnexpectedError | MaterializeError | SyncError | InvalidPullError | IsOfflineError
+        >,
+      ) =>
         Effect.gen(function* () {
           yield* Scope.close(lifetimeScope, exit).pipe(
             Effect.logWarnIfTakesLongerThan({ label: '@livestore/livestore:shutdown', duration: 500 }),
@@ -280,7 +288,7 @@ export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema.An
         storeId,
         params: {
           leaderPushBatchSize: params?.leaderPushBatchSize ?? DEFAULT_PARAMS.leaderPushBatchSize,
-          simulation: params?.simulation,
+          ...omitUndefineds({ simulation: params?.simulation }),
         },
       })
 

package/src/store/store-types.ts

@@ -2,6 +2,9 @@ import type {
   ClientSession,
   ClientSessionSyncProcessorSimulationParams,
   IntentionalShutdownCause,
+  InvalidPullError,
+  IsOfflineError,
+  MaterializeError,
   StoreInterrupted,
   SyncError,
   UnexpectedError,
@@ -28,11 +31,11 @@ export type LiveStoreContext =
 
 export type ShutdownDeferred = Deferred.Deferred<
   IntentionalShutdownCause,
-  UnexpectedError | SyncError | StoreInterrupted
+  UnexpectedError | SyncError | StoreInterrupted | MaterializeError | InvalidPullError | IsOfflineError
 >
 export const makeShutdownDeferred: Effect.Effect<ShutdownDeferred> = Deferred.make<
   IntentionalShutdownCause,
-  UnexpectedError | SyncError | StoreInterrupted
+  UnexpectedError | SyncError | StoreInterrupted | MaterializeError | InvalidPullError | IsOfflineError
 >()
 
 export type LiveStoreContextRunning = {