@livestore/livestore 0.0.0-snapshot-b2abb1712675b77ec94147aeb6c4ffa858b97daa → 0.0.0-snapshot-d494b38b4c747ce88538b162d3be1e7a74efe171

package/src/store/store.ts

@@ -8,7 +8,6 @@ import {
 } from '@livestore/common'
 import {
   Devtools,
-  getDurationMsFromSpan,
   getExecStatementsFromMaterializer,
   getResultSchema,
   hashMaterializerResults,
@@ -115,70 +114,71 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
       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({
+      materializeEvent: Effect.fn('client-session-sync-processor:materialize-event')(
+        (eventDecoded, { withChangeset, materializerHashLeader }) =>
+          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()
+
+            if (
+              materializerHashLeader._tag === 'Some' &&
+              materializerHash._tag === 'Some' &&
+              materializerHashLeader.value !== materializerHash.value
+            ) {
+              const error = 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)}`,
               })
-            }
 
-            // durationMsTotal += durationMs
-            for (const table of writeTables) {
-              writeTablesForEvent.add(table)
+              // Fork the shutdown effect to run in the background as a daemon,
+              // ensuring it's not interrupted.
+              yield* Effect.forkDaemon(this.clientSession.shutdown(Cause.fail(error)))
+
+              // TODO: we should probably handle this more gracefully using Effect’s error channel
             }
-          }
-        }
 
-        let sessionChangeset:
-          | { _tag: 'sessionChangeset'; data: Uint8Array; debug: any }
-          | { _tag: 'no-op' }
-          | { _tag: 'unset' } = { _tag: 'unset' }
+            const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
+            const otelContext = otel.trace.setSpan(otel.context.active(), span)
+            return yield* Effect.sync(() => {
+              const writeTablesForEvent = new Set<string>()
+
+              const exec = () => {
+                for (const {
+                  statementSql,
+                  bindValues,
+                  writeTables = this.sqliteDbWrapper.getTablesUsed(statementSql),
+                } of execArgsArr) {
+                  this.sqliteDbWrapper.cachedExecute(statementSql, bindValues, { otelContext, writeTables })
+
+                  // durationMsTotal += durationMs
+                  for (const table of writeTables) {
+                    writeTablesForEvent.add(table)
+                  }
+                }
+              }
 
-        if (withChangeset === true) {
-          sessionChangeset = this.sqliteDbWrapper.withChangeset(exec).changeset
-        } else {
-          exec()
-        }
+              let sessionChangeset:
+                | { _tag: 'sessionChangeset'; data: Uint8Array; 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 }
+            })
+          }),
+      ),
       rollback: (changeset) => {
         this.sqliteDbWrapper.rollback(changeset)
       },
@@ -552,89 +552,80 @@ export class Store<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext =
   } = (firstEventOrTxnFnOrOptions: any, ...restEvents: any[]) => {
     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')
-
-    // console.group('LiveStore.commit', { skipRefresh })
-    // events.forEach((_) => console.debug(_.name, _.args))
-    // console.groupEnd()
+    Runtime.runSync(
+      this.effectContext.runtime,
+      Effect.gen(this, function* () {
+        yield* Effect.sync(() => {
+          for (const event of events) {
+            replaceSessionIdSymbol(event.args, this.clientSession.sessionId)
+          }
+        })
 
-    let durationMs: number
+        if (events.length === 0) return
 
-    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)
+        const localRuntime = yield* Effect.runtime()
 
-        try {
-          // Materialize events to state
-          const { writeTables } = (() => {
-            try {
-              const materializeEvents = () => {
-                return Runtime.runSync(this.effectContext.runtime, this.syncProcessor.push(events, { otelContext }))
-              }
+        const materializeEventsTx = Effect.try({
+          try: () => {
+            const materializeEvents = this.syncProcessor.push(events)
 
-              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 runMaterializeEvents = () => {
+              return Runtime.runSync(localRuntime, materializeEvents)
             }
-          })()
 
-          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 debugRefreshReason = {
-            _tag: 'commit' as const,
-            events,
-            writeTables: Array.from(writeTables),
-          }
+            if (events.length > 1) {
+              // TODO: what to do about leader transaction here?
+              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()
+        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 span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
+        const otelContext = otel.trace.setSpan(otel.context.active(), span)
+        const skipRefresh = options?.skipRefresh ?? false
+
+        // Update all table refs together in a batch, to only trigger one reactive update
+        yield* Effect.sync(() => {
+          this.reactivityGraph.setRefs(tablesToUpdate, {
+            debugRefreshReason,
+            otelContext,
+            skipRefresh,
+          })
+        })
+      }).pipe(
+        Effect.withSpan('LiveStore:commit', {
+          root: true,
+          attributes: {
+            'livestore.eventsCount': events.length,
+            'livestore.eventTags': events.map((_) => _.name),
+            'livestore.commitLabel': options?.label,
+          },
+          links: options?.spanLinks?.map((link) => ({
+            _tag: 'SpanLink',
+            span: OtelTracer.makeExternalSpan(link.context),
+            attributes: link.attributes ?? {},
+          })),
+        }),
+      ),
     )
   }
-  // #endregion commit
 
   /**
    * Returns an async iterable of events.