@livestore/livestore 0.4.0-dev.2 → 0.4.0-dev.5

package/src/reactive.ts

@@ -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}`
 
@@ -267,8 +265,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 +301,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({
@@ -475,14 +481,17 @@ export class ReactiveGraph<
   ) => {
     const effectsWrapper = this.context?.effectsWrapper ?? ((runEffects: () => void) => runEffects())
     effectsWrapper(() => {
-      this.currentDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
+      // Capture debug state in local variable to prevent corruption from nested runEffects
+      const localDebugRefresh = { refreshedAtoms: [], startMs: performance.now() }
+      this.currentDebugRefresh = localDebugRefresh
 
       for (const effect of effectsToRefresh) {
         effect.doEffect(options?.otelContext, options.debugRefreshReason)
       }
 
-      const refreshedAtoms = this.currentDebugRefresh.refreshedAtoms
-      const durationMs = performance.now() - this.currentDebugRefresh.startMs
+      // Use local reference which can't be corrupted by nested calls
+      const refreshedAtoms = localDebugRefresh.refreshedAtoms
+      const durationMs = performance.now() - localDebugRefresh.startMs
       this.currentDebugRefresh = undefined
 
       const refreshDebugInfo: RefreshDebugInfo<TDebugRefreshReason, TDebugThunkInfo> = {

package/src/store/create-store.ts

@@ -5,6 +5,9 @@ import {
   type ClientSessionDevtoolsChannel,
   type ClientSessionSyncProcessorSimulationParams,
   type IntentionalShutdownCause,
+  type InvalidPullError,
+  type IsOfflineError,
+  type MaterializeError,
   type MigrationsReport,
   provideOtel,
   type SyncError,
@@ -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 }),

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 = {

package/src/store/store.ts

@@ -3,13 +3,14 @@ import {
   type ClientSession,
   type ClientSessionSyncProcessor,
   Devtools,
-  getDurationMsFromSpan,
   getExecStatementsFromMaterializer,
   getResultSchema,
   hashMaterializerResults,
   IntentionalShutdownCause,
   isQueryBuilder,
   liveStoreVersion,
+  MaterializeError,
+  MaterializerHashMismatchError,
   makeClientSessionSyncProcessor,
   type PreparedBindValues,
   prepareBindValues,
@@ -20,7 +21,7 @@ import {
 } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { getEventDef, LiveStoreEvent, SystemTables } from '@livestore/common/schema'
-import { assertNever, isDevEnv, notYetImplemented } from '@livestore/utils'
+import { assertNever, isDevEnv, notYetImplemented, shouldNeverHappen } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
 import {
   Cause,
@@ -128,72 +129,76 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       schema,
       clientSession,
       runtime: effectContext.runtime,
-      materializeEvent: (eventDecoded, { otelContext, withChangeset, materializerHashLeader }) => {
-        const { eventDef, materializer } = getEventDef(schema, eventDecoded.name)
-
-        const execArgsArr = getExecStatementsFromMaterializer({
-          eventDef,
-          materializer,
-          dbState: this.sqliteDbWrapper,
-          event: { decoded: eventDecoded, encoded: undefined },
-        })
-
-        const materializerHash = isDevEnv() ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
-
-        if (
-          materializerHashLeader._tag === 'Some' &&
-          materializerHash._tag === 'Some' &&
-          materializerHashLeader.value !== materializerHash.value
-        ) {
-          void this.shutdown(
-            Cause.fail(
-              UnexpectedError.make({
-                cause: `Materializer hash mismatch detected for event "${eventDecoded.name}".`,
-                note: `Please make sure your event materializer is a pure function without side effects.`,
-              }),
-            ),
-          )
-        }
-
-        const writeTablesForEvent = new Set<string>()
-
-        const exec = () => {
-          for (const {
-            statementSql,
-            bindValues,
-            writeTables = this.sqliteDbWrapper.getTablesUsed(statementSql),
-          } of execArgsArr) {
-            try {
-              this.sqliteDbWrapper.cachedExecute(statementSql, bindValues, { otelContext, writeTables })
-            } catch (cause) {
-              throw UnexpectedError.make({
-                cause,
-                note: `Error executing materializer for event "${eventDecoded.name}".\nStatement: ${statementSql}\nBind values: ${JSON.stringify(bindValues)}`,
-              })
+      materializeEvent: Effect.fn('client-session-sync-processor:materialize-event')(
+        (eventDecoded, { withChangeset, materializerHashLeader }) =>
+          // We need to use `Effect.gen` (even though we're using `Effect.fn`) so that we can pass `this` to the function
+          Effect.gen(this, function* () {
+            const { eventDef, materializer } = getEventDef(schema, eventDecoded.name)
+
+            const execArgsArr = getExecStatementsFromMaterializer({
+              eventDef,
+              materializer,
+              dbState: this.sqliteDbWrapper,
+              event: { decoded: eventDecoded, encoded: undefined },
+            })
+
+            const materializerHash = isDevEnv() ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
+
+            // Hash mismatch detection only occurs during the pull path (when receiving events from the leader).
+            // During push path (local commits), materializerHashLeader is always Option.none(), so this condition
+            // will never be met. The check happens when the same event comes back from the leader during sync,
+            // allowing us to compare the leader's computed hash with our local re-materialization hash.
+            if (
+              materializerHashLeader._tag === 'Some' &&
+              materializerHash._tag === 'Some' &&
+              materializerHashLeader.value !== materializerHash.value
+            ) {
+              return yield* MaterializerHashMismatchError.make({ eventName: eventDecoded.name })
             }
 
-            // durationMsTotal += durationMs
-            for (const table of writeTables) {
-              writeTablesForEvent.add(table)
+            const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
+            const otelContext = otel.trace.setSpan(otel.context.active(), span)
+
+            const writeTablesForEvent = new Set<string>()
+
+            const exec = () => {
+              for (const {
+                statementSql,
+                bindValues,
+                writeTables = this.sqliteDbWrapper.getTablesUsed(statementSql),
+              } of execArgsArr) {
+                try {
+                  this.sqliteDbWrapper.cachedExecute(statementSql, bindValues, { otelContext, writeTables })
+                } catch (cause) {
+                  // TOOD refactor with `SqliteError`
+                  throw UnexpectedError.make({
+                    cause,
+                    note: `Error executing materializer for event "${eventDecoded.name}".\nStatement: ${statementSql}\nBind values: ${JSON.stringify(bindValues)}`,
+                  })
+                }
+
+                // durationMsTotal += durationMs
+                for (const table of writeTables) {
+                  writeTablesForEvent.add(table)
+                }
+
+                this.sqliteDbWrapper.debug.head = eventDecoded.seqNum
+              }
             }
 
-            this.sqliteDbWrapper.debug.head = eventDecoded.seqNum
-          }
-        }
-
-        let sessionChangeset:
-          | { _tag: 'sessionChangeset'; data: Uint8Array<ArrayBuffer>; debug: any }
-          | { _tag: 'no-op' }
-          | { _tag: 'unset' } = { _tag: 'unset' }
-
-        if (withChangeset === true) {
-          sessionChangeset = this.sqliteDbWrapper.withChangeset(exec).changeset
-        } else {
-          exec()
-        }
+            let sessionChangeset:
+              | { _tag: 'sessionChangeset'; data: Uint8Array<ArrayBuffer>; debug: any }
+              | { _tag: 'no-op' }
+              | { _tag: 'unset' } = { _tag: 'unset' }
+            if (withChangeset === true) {
+              sessionChangeset = this.sqliteDbWrapper.withChangeset(exec).changeset
+            } else {
+              exec()
+            }
 
-        return { writeTables: writeTablesForEvent, sessionChangeset, materializerHash }
-      },
+            return { writeTables: writeTablesForEvent, sessionChangeset, materializerHash }
+          }).pipe(Effect.mapError((cause) => MaterializeError.make({ cause }))),
+      ),
       rollback: (changeset) => {
         this.sqliteDbWrapper.rollback(changeset)
       },
@@ -477,7 +482,19 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         queriedTables: new Set([query[QueryBuilderAstSymbol].tableDef.sqliteDef.name]),
       })
 
-      return Schema.decodeSync(schema)(rawRes)
+      const decodeResult = Schema.decodeEither(schema)(rawRes)
+      if (decodeResult._tag === 'Right') {
+        return decodeResult.right
+      } else {
+        return shouldNeverHappen(
+          `Failed to decode query result with for schema:`,
+          schema.toString(),
+          'raw result:',
+          rawRes,
+          'decode error:',
+          decodeResult.left,
+        )
+      }
     } else if (query._tag === 'def') {
       const query$ = query.make(this.reactivityGraph.context!)
       const result = this.query(query$.value, options)
@@ -597,84 +614,76 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
 
     const { events, options } = this.getCommitArgs(firstEventOrTxnFnOrOptions, restEvents)
 
-    for (const event of events) {
-      replaceSessionIdSymbol(event.args, this.clientSession.sessionId)
-    }
-
-    if (events.length === 0) return
-
-    const skipRefresh = options?.skipRefresh ?? false
-
-    const commitsSpan = otel.trace.getSpan(this.otel.commitsSpanContext)!
-    commitsSpan.addEvent('commit')
+    Effect.gen(this, function* () {
+      const commitsSpan = otel.trace.getSpan(this.otel.commitsSpanContext)
+      commitsSpan?.addEvent('commit')
+      const currentSpan = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
+      commitsSpan?.addLink({ context: currentSpan.spanContext() })
 
-    // console.group('LiveStore.commit', { skipRefresh })
-    // events.forEach((_) => console.debug(_.name, _.args))
-    // console.groupEnd()
-
-    let durationMs: number
-
-    return this.otel.tracer.startActiveSpan(
-      'LiveStore:commit',
-      {
-        attributes: {
-          'livestore.eventsCount': events.length,
-          'livestore.eventTags': events.map((_) => _.name),
-          'livestore.commitLabel': options?.label,
-        },
-        links: options?.spanLinks,
-      },
-      options?.otelContext ?? this.otel.commitsSpanContext,
-      (span) => {
-        const otelContext = otel.trace.setSpan(otel.context.active(), span)
+      for (const event of events) {
+        replaceSessionIdSymbol(event.args, this.clientSession.sessionId)
+      }
 
-        try {
-          // Materialize events to state
-          const { writeTables } = (() => {
-            try {
-              const materializeEvents = () => this.syncProcessor.push(events, { otelContext })
+      if (events.length === 0) return
 
-              if (events.length > 1) {
-                return this.sqliteDbWrapper.txn(materializeEvents)
-              } else {
-                return materializeEvents()
-              }
-            } catch (e: any) {
-              console.error(e)
-              span.setStatus({ code: otel.SpanStatusCode.ERROR, message: e.toString() })
-              throw e
-            } finally {
-              span.end()
-            }
-          })()
+      const localRuntime = yield* Effect.runtime()
 
-          const tablesToUpdate = [] as [Ref<null, ReactivityGraphContext, RefreshReason>, null][]
-          for (const tableName of writeTables) {
-            const tableRef = this.tableRefs[tableName]
-            assertNever(tableRef !== undefined, `No table ref found for ${tableName}`)
-            tablesToUpdate.push([tableRef!, null])
+      const materializeEventsTx = Effect.try({
+        try: () => {
+          const runMaterializeEvents = () => {
+            return this.syncProcessor.push(events).pipe(Runtime.runSync(localRuntime))
           }
 
-          const debugRefreshReason = {
-            _tag: 'commit' as const,
-            events,
-            writeTables: Array.from(writeTables),
+          if (events.length > 1) {
+            return this.sqliteDbWrapper.txn(runMaterializeEvents)
+          } else {
+            return runMaterializeEvents()
           }
+        },
+        catch: (cause) => UnexpectedError.make({ cause }),
+      })
 
-          // Update all table refs together in a batch, to only trigger one reactive update
-          this.reactivityGraph.setRefs(tablesToUpdate, { debugRefreshReason, otelContext, skipRefresh })
-        } catch (e: any) {
-          console.error(e)
-          span.setStatus({ code: otel.SpanStatusCode.ERROR, message: e.toString() })
-          throw e
-        } finally {
-          span.end()
+      // Materialize events to state
+      const { writeTables } = yield* materializeEventsTx
 
-          durationMs = getDurationMsFromSpan(span)
-        }
+      const tablesToUpdate: [Ref<null, ReactivityGraphContext, RefreshReason>, null][] = []
+      for (const tableName of writeTables) {
+        const tableRef = this.tableRefs[tableName]
+        assertNever(tableRef !== undefined, `No table ref found for ${tableName}`)
+        tablesToUpdate.push([tableRef!, null])
+      }
 
-        return { durationMs }
-      },
+      const debugRefreshReason: RefreshReason = {
+        _tag: 'commit',
+        events,
+        writeTables: Array.from(writeTables),
+      }
+      const skipRefresh = options?.skipRefresh ?? false
+
+      // Update all table refs together in a batch, to only trigger one reactive update
+      this.reactivityGraph.setRefs(tablesToUpdate, {
+        debugRefreshReason,
+        skipRefresh,
+        otelContext: otel.trace.setSpan(otel.context.active(), currentSpan),
+      })
+    }).pipe(
+      Effect.withSpan('LiveStore:commit', {
+        root: true,
+        attributes: {
+          'livestore.eventsCount': events.length,
+          'livestore.eventTags': events.map((_) => _.name),
+          ...(options?.label && { 'livestore.commitLabel': options.label }),
+        },
+        links: [
+          // Span link to LiveStore:commits
+          OtelTracer.makeSpanLink({ context: otel.trace.getSpanContext(this.otel.commitsSpanContext)! }),
+          // User-provided span links
+          ...(options?.spanLinks?.map(OtelTracer.makeSpanLink) ?? []),
+        ],
+      }),
+      Effect.tapErrorCause(Effect.logError),
+      Effect.catchAllCause((cause) => Effect.fork(this.shutdown(cause))),
+      Runtime.runSync(this.effectContext.runtime),
     )
   }
   // #endregion commit
@@ -746,9 +755,7 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
    *
    * This is called automatically when the store was created using the React or Effect API.
    */
-  shutdown = (cause?: Cause.Cause<UnexpectedError>): Effect.Effect<void> => {
-    this.checkShutdown('shutdown')
-
+  shutdown = (cause?: Cause.Cause<UnexpectedError | MaterializeError>): Effect.Effect<void> => {
     this.isShutdown = true
     return this.clientSession.shutdown(
       cause ? Exit.failCause(cause) : Exit.succeed(IntentionalShutdownCause.make({ reason: 'manual' })),
@@ -798,14 +805,12 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
         .pipe(this.runEffectFork)
     },
 
-    syncStates: () => {
+    syncStates: () =>
       Effect.gen(this, function* () {
         const session = yield* this.syncProcessor.syncState
-        console.log('Session sync state:', session.toJSON())
         const leader = yield* this.clientSession.leaderThread.getSyncState
-        console.log('Leader sync state:', leader.toJSON())
-      }).pipe(this.runEffectFork)
-    },
+        return { session, leader }
+      }).pipe(this.runEffectPromise),
 
     version: liveStoreVersion,
 
@@ -827,6 +832,9 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema.Any, TConte
       Runtime.runFork(this.effectContext.runtime),
     )
 
+  private runEffectPromise = <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) =>
+    effect.pipe(Effect.tapCauseLogPretty, Runtime.runPromise(this.effectContext.runtime))
+
   private getCommitArgs = (
     firstEventOrTxnFnOrOptions: any,
     restEvents: any[],

package/src/utils/tests/otel.ts

@@ -4,10 +4,13 @@ import type { InMemorySpanExporter, ReadableSpan } from '@opentelemetry/sdk-trac
 
 type SimplifiedNestedSpan = { _name: string; attributes: any; children: SimplifiedNestedSpan[] }
 
-export const getSimplifiedRootSpan = (
+type NestedSpan = { span: ReadableSpan; children: NestedSpan[] }
+
+const buildSimplifiedRootSpans = (
   exporter: InMemorySpanExporter,
+  rootSpanName: string,
   mapAttributes?: (attributes: Attributes) => Attributes,
-): SimplifiedNestedSpan => {
+): SimplifiedNestedSpan[] => {
   const spans = exporter.getFinishedSpans()
   const spansMap = new Map<string, NestedSpan>(spans.map((span) => [span.spanContext().spanId, { span, children: [] }]))
 
@@ -21,14 +24,12 @@ export const getSimplifiedRootSpan = (
     }
   })
 
-  type NestedSpan = { span: ReadableSpan; children: NestedSpan[] }
-  const createStoreSpanData = spans.find((_) => _.name === 'createStore')
-  if (createStoreSpanData === undefined) {
+  const rootSpanDataList = spans.filter((_) => _.name === rootSpanName)
+  if (rootSpanDataList.length === 0) {
     throw new Error(
-      `Could not find the root span named 'createStore'. Available spans: ${spans.map((s) => s.name).join(', ')}`,
+      `Could not find any root spans named '${rootSpanName}'. Available spans: ${spans.map((s) => s.name).join(', ')}`,
     )
   }
-  const rootSpan = spansMap.get(createStoreSpanData.spanContext().spanId)!
 
   const simplifySpanRec = (span: NestedSpan): SimplifiedNestedSpan =>
     omitEmpty({
@@ -40,20 +41,29 @@ export const getSimplifiedRootSpan = (
         .map(simplifySpanRec),
     })
 
-  // console.log('rootSpan', rootSpan.span)
-
-  // console.dir(
-  //   spans.map((_) => [_.spanContext().spanId, _.name, _.attributes, _.parentSpanId]),
-  //   { depth: 10 },
-  // )
-
-  const simplifiedRootSpan = simplifySpanRec(rootSpan)
-
-  // console.log('simplifiedRootSpan', simplifiedRootSpan)
+  return rootSpanDataList.map((rootSpanData) => {
+    const rootSpan = spansMap.get(rootSpanData.spanContext().spanId)!
+    return simplifySpanRec(rootSpan)
+  })
+}
 
-  // writeFileSync('tmp/trace.json', JSON.stringify(toTraceFile(spans), null, 2))
+export const getSimplifiedRootSpan = (
+  exporter: InMemorySpanExporter,
+  rootSpanName: string,
+  mapAttributes?: (attributes: Attributes) => Attributes,
+): SimplifiedNestedSpan => {
+  const results = buildSimplifiedRootSpans(exporter, rootSpanName, mapAttributes)
+  const firstResult = results[0]
+  if (!firstResult) throw new Error(`Could not find the root span named '${rootSpanName}'.`)
+  return firstResult
+}
 
-  return simplifiedRootSpan
+export const getAllSimplifiedRootSpans = (
+  exporter: InMemorySpanExporter,
+  rootSpanName: string,
+  mapAttributes?: (attributes: Attributes) => Attributes,
+): SimplifiedNestedSpan[] => {
+  return buildSimplifiedRootSpans(exporter, rootSpanName, mapAttributes)
 }
 
 // const compareHrTime = (a: [number, numndber], b: [number, number]) => {