@livestore/livestore 0.0.58-dev.0 → 0.0.58-dev.10

package/src/store.ts

@@ -1,19 +1,27 @@
 import type {
+  Adapter,
   BootDb,
   BootStatus,
+  ClientSession,
+  EventId,
   IntentionalShutdownCause,
   ParamsObject,
   PreparedBindValues,
-  StoreAdapter,
-  StoreAdapterFactory,
   StoreDevtoolsChannel,
 } from '@livestore/common'
 import { getExecArgsFromMutation, prepareBindValues, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
-import { makeMutationEventSchemaMemo, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE } from '@livestore/common/schema'
+import {
+  isPartialMutationEvent,
+  makeMutationEventSchemaMemo,
+  SCHEMA_META_TABLE,
+  SCHEMA_MUTATIONS_META_TABLE,
+  SESSION_CHANGESET_META_TABLE,
+} from '@livestore/common/schema'
 import { assertNever, makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
 import {
   Cause,
+  Data,
   Deferred,
   Duration,
   Effect,
@@ -23,6 +31,7 @@ import {
   Layer,
   Logger,
   LogLevel,
+  MutableHashMap,
   OtelTracer,
   Queue,
   Runtime,
@@ -34,7 +43,6 @@ import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
 import { globalReactivityGraph } from './global-state.js'
-import type { StackInfo } from './react/utils/stack-info.js'
 import type { DebugRefreshReasonBase, Ref } from './reactive.js'
 import type { LiveQuery, QueryContext, ReactivityGraph } from './reactiveQueries/base-class.js'
 import { connectDevtoolsToStore } from './store-devtools.js'
@@ -42,6 +50,7 @@ import { SynchronousDatabaseWrapper } from './SynchronousDatabaseWrapper.js'
 import { ReferenceCountedSet } from './utils/data-structures.js'
 import { downloadBlob } from './utils/dev.js'
 import { getDurationMsFromSpan } from './utils/otel.js'
+import type { StackInfo } from './utils/stack-info.js'
 
 export type BaseGraphQLContext = {
   queriedTables: Set<string>
@@ -51,7 +60,7 @@ export type BaseGraphQLContext = {
 
 export type GraphQLOptions<TContext> = {
   schema: GraphQLSchema
-  makeContext: (db: SynchronousDatabaseWrapper, tracer: otel.Tracer) => TContext
+  makeContext: (db: SynchronousDatabaseWrapper, tracer: otel.Tracer, sessionId: string) => TContext
 }
 
 export type OtelOptions = {
@@ -63,7 +72,7 @@ export type StoreOptions<
   TGraphQLContext extends BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 > = {
-  adapter: StoreAdapter
+  clientSession: ClientSession
   schema: TSchema
   storeId: string
   // TODO remove graphql-related stuff from store and move to GraphQL query directly
@@ -74,8 +83,8 @@ export type StoreOptions<
   fiberSet: FiberSet.FiberSet
   runtime: Runtime.Runtime<Scope.Scope>
   batchUpdates: (runUpdates: () => void) => void
-  // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-  __processedMutationIds: Set<string>
+  currentMutationEventIdRef: { current: EventId }
+  unsyncedMutationEvents: MutableHashMap.MutableHashMap<EventId, MutationEvent.ForSchema<TSchema>>
 }
 
 export type RefreshReason =
@@ -89,6 +98,7 @@ export type RefreshReason =
       writeTables: ReadonlyArray<string>
     }
   | {
+      // TODO rename to a more appropriate name which is framework-agnostic
       _tag: 'react'
       api: string
       label?: string
@@ -109,9 +119,6 @@ export type StoreOtel = {
   queriesSpanContext: otel.Context
 }
 
-let storeCount = 0
-const uniqueStoreId = () => `store-${++storeCount}`
-
 export type StoreMutateOptions = {
   label?: string
   skipRefresh?: boolean
@@ -125,7 +132,9 @@ export type StoreMutateOptions = {
   persisted?: boolean
 }
 
-if (typeof window !== 'undefined') {
+// eslint-disable-next-line unicorn/prefer-global-this
+if (import.meta.env.DEV && typeof window !== 'undefined') {
+  // eslint-disable-next-line unicorn/prefer-global-this
   window.__debugDownloadBlob = downloadBlob
 }
 
@@ -133,10 +142,10 @@ export class Store<
   TGraphQLContext extends BaseGraphQLContext = BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 > extends Inspectable.Class {
-  id = uniqueStoreId()
+  readonly storeId: string
   reactivityGraph: ReactivityGraph
   syncDbWrapper: SynchronousDatabaseWrapper
-  adapter: StoreAdapter
+  clientSession: ClientSession
   schema: LiveStoreSchema
   graphQLSchema?: GraphQLSchema
   graphQLContext?: TGraphQLContext
@@ -150,32 +159,39 @@ export class Store<
   private fiberSet: FiberSet.FiberSet
   private runtime: Runtime.Runtime<Scope.Scope>
 
-  // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-  private __processedMutationIds
-  private __processedMutationWithoutRefreshIds = new Set<string>()
-
   /** RC-based set to see which queries are currently subscribed to */
   activeQueries: ReferenceCountedSet<LiveQuery<any>>
 
+  // NOTE this is currently exposed for the Devtools databrowser to emit mutation events
   readonly __mutationEventSchema
 
+  private currentMutationEventIdRef
+  private unsyncedMutationEvents
+
   // #region constructor
   private constructor({
-    adapter,
+    clientSession,
     schema,
     graphQLOptions,
     reactivityGraph,
     otelOptions,
     disableDevtools,
     batchUpdates,
-    __processedMutationIds,
+    currentMutationEventIdRef,
+    unsyncedMutationEvents,
+    storeId,
     fiberSet,
     runtime,
   }: StoreOptions<TGraphQLContext, TSchema>) {
     super()
 
-    this.syncDbWrapper = new SynchronousDatabaseWrapper({ otel: otelOptions, db: adapter.syncDb })
-    this.adapter = adapter
+    this.storeId = storeId
+
+    this.currentMutationEventIdRef = currentMutationEventIdRef
+    this.unsyncedMutationEvents = unsyncedMutationEvents
+
+    this.syncDbWrapper = new SynchronousDatabaseWrapper({ otel: otelOptions, db: clientSession.syncDb })
+    this.clientSession = clientSession
     this.schema = schema
 
     this.fiberSet = fiberSet
@@ -184,9 +200,6 @@ export class Store<
     // TODO refactor
     this.__mutationEventSchema = makeMutationEventSchemaMemo(schema)
 
-    // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-    this.__processedMutationIds = __processedMutationIds
-
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     this.tableRefs = {}
     this.activeQueries = new ReferenceCountedSet()
@@ -222,7 +235,7 @@ export class Store<
       isRunningInDevtools
         ? this.schema.tables.keys()
         : Array.from(this.schema.tables.keys()).filter(
-            (_) => _ !== SCHEMA_META_TABLE && _ !== SCHEMA_MUTATIONS_META_TABLE,
+            (_) => _ !== SCHEMA_META_TABLE && _ !== SCHEMA_MUTATIONS_META_TABLE && _ !== SESSION_CHANGESET_META_TABLE,
           ),
     )
     const existingTableRefs = new Map(
@@ -236,14 +249,20 @@ export class Store<
 
     if (graphQLOptions) {
       this.graphQLSchema = graphQLOptions.schema
-      this.graphQLContext = graphQLOptions.makeContext(this.syncDbWrapper, this.otel.tracer)
+      this.graphQLContext = graphQLOptions.makeContext(
+        this.syncDbWrapper,
+        this.otel.tracer,
+        clientSession.coordinator.sessionId,
+      )
     }
 
     Effect.gen(this, function* () {
-      yield* this.adapter.coordinator.syncMutations.pipe(
-        Stream.tapSync((mutationEventDecoded) => {
-          this.mutate({ wasSyncMessage: true }, mutationEventDecoded)
-        }),
+      yield* this.clientSession.coordinator.syncMutations.pipe(
+        Stream.tapChunk((mutationsEventsDecodedChunk) =>
+          Effect.sync(() => {
+            this.mutate({ wasSyncMessage: true }, ...mutationsEventsDecodedChunk)
+          }),
+        ),
         Stream.runDrain,
         Effect.interruptible,
         Effect.withSpan('LiveStore:syncMutations'),
@@ -282,6 +301,10 @@ export class Store<
     })
   }
 
+  get sessionId(): string {
+    return this.clientSession.coordinator.sessionId
+  }
+
   /**
    * Subscribe to the results of a query
    * Returns a function to cancel the subscription.
@@ -297,7 +320,7 @@ export class Store<
       { attributes: { label: options?.label, queryLabel: query$.label } },
       options?.otelContext ?? this.otel.queriesSpanContext,
       (span) => {
-        // console.log('store sub', query$.label)
+        // console.debug('store sub', query$.id, query$.label)
         const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
         const label = `subscribe:${options?.label}`
@@ -311,7 +334,7 @@ export class Store<
         }
 
         const unsubscribe = () => {
-          // console.log('store unsub', query$.label)
+          // console.debug('store unsub', query$.id, query$.label)
           try {
             this.reactivityGraph.destroyNode(effect)
             this.activeQueries.remove(query$ as LiveQuery<TResult>)
@@ -327,17 +350,21 @@ export class Store<
 
   // #region mutate
   mutate: {
-    <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(...list: TMutationArg): void
+    <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(...list: TMutationArg): void
     (
-      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(...list: TMutationArg) => void,
+      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(
+        ...list: TMutationArg
+      ) => void,
     ): void
-    <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(
+    <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(
       options: StoreMutateOptions,
       ...list: TMutationArg
     ): void
     (
       options: StoreMutateOptions,
-      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.ForSchema<TSchema>>>(...list: TMutationArg) => void,
+      txn: <const TMutationArg extends ReadonlyArray<MutationEvent.PartialForSchema<TSchema>>>(
+        ...list: TMutationArg
+      ) => void,
     ): void
   } = (firstMutationOrTxnFnOrOptions: any, ...restMutations: any[]) => {
     let mutationsEvents: MutationEvent.ForSchema<TSchema>[]
@@ -361,16 +388,14 @@ export class Store<
       mutationsEvents = [firstMutationOrTxnFnOrOptions, ...restMutations]
     }
 
-    mutationsEvents = mutationsEvents.filter((_) => !this.__processedMutationIds.has(_.id))
+    mutationsEvents = mutationsEvents.filter(
+      (_) => _.id === undefined || !MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(_.id)),
+    )
 
     if (mutationsEvents.length === 0) {
       return
     }
 
-    for (const mutationEvent of mutationsEvents) {
-      this.__processedMutationIds.add(mutationEvent.id)
-    }
-
     const label = options?.label ?? 'mutate'
     const skipRefresh = options?.skipRefresh ?? false
     const wasSyncMessage = options?.wasSyncMessage ?? false
@@ -380,12 +405,12 @@ export class Store<
     mutationsSpan.addEvent('mutate')
 
     // console.group('LiveStore.mutate', { skipRefresh, wasSyncMessage, label })
-    // mutationsEvents.forEach((_) => console.log(_.mutation, _.id, _.args))
+    // mutationsEvents.forEach((_) => console.debug(_.mutation, _.id, _.args))
     // console.groupEnd()
 
     let durationMs: number
 
-    return this.otel.tracer.startActiveSpan(
+    const res = this.otel.tracer.startActiveSpan(
       'LiveStore:mutate',
       { attributes: { 'livestore.mutateLabel': label } },
       this.otel.mutationsSpanContext,
@@ -465,6 +490,16 @@ export class Store<
         return { durationMs }
       },
     )
+
+    // NOTE we need to add the mutation events to the unsynced mutation events map only after running the code above
+    // so the short-circuiting in `mutateWithoutRefresh` doesn't kick in for those events
+    for (const mutationEvent of mutationsEvents) {
+      if (mutationEvent.id !== undefined) {
+        MutableHashMap.set(this.unsyncedMutationEvents, Data.struct(mutationEvent.id), mutationEvent)
+      }
+    }
+
+    return res
   }
 
   /**
@@ -492,19 +527,39 @@ export class Store<
    * the caller must refresh queries after calling this method.
    */
   mutateWithoutRefresh = (
-    mutationEventDecoded: MutationEvent.ForSchema<TSchema>,
+    mutationEventDecoded_: MutationEvent.ForSchema<TSchema> | MutationEvent.PartialForSchema<TSchema>,
     options: {
       otelContext: otel.Context
+      // TODO adjust `skip-persist` with new rebase sync strategy
       coordinatorMode: 'default' | 'skip-coordinator' | 'skip-persist'
     },
   ): { writeTables: ReadonlySet<string>; durationMs: number } => {
+    const mutationDef =
+      this.schema.mutations.get(mutationEventDecoded_.mutation) ??
+      shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
+
+    // Needs to happen only for partial mutation events (thus a function)
+    const nextMutationEventId = () => {
+      const { id, parentId } = this.clientSession.coordinator
+        .nextMutationEventIdPair({ localOnly: mutationDef.options.localOnly })
+        .pipe(Effect.runSync)
+
+      this.currentMutationEventIdRef.current = id
+
+      return { id, parentId }
+    }
+
+    const mutationEventDecoded: MutationEvent.ForSchema<TSchema> = isPartialMutationEvent(mutationEventDecoded_)
+      ? { ...mutationEventDecoded_, ...nextMutationEventId() }
+      : mutationEventDecoded_
+
     // NOTE we also need this temporary workaround here since some code-paths use `mutateWithoutRefresh` directly
     // e.g. the row-query functionality
-    if (this.__processedMutationWithoutRefreshIds.has(mutationEventDecoded.id)) {
+    if (MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(mutationEventDecoded.id))) {
       // NOTE this data should never be used
       return { writeTables: new Set(), durationMs: 0 }
     } else {
-      this.__processedMutationWithoutRefreshIds.add(mutationEventDecoded.id)
+      MutableHashMap.set(this.unsyncedMutationEvents, Data.struct(mutationEventDecoded.id), mutationEventDecoded)
     }
 
     const { otelContext, coordinatorMode = 'default' } = options
@@ -524,10 +579,6 @@ export class Store<
         const allWriteTables = new Set<string>()
         let durationMsTotal = 0
 
-        const mutationDef =
-          this.schema.mutations.get(mutationEventDecoded.mutation) ??
-          shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`)
-
         const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
         for (const {
@@ -547,9 +598,9 @@ export class Store<
 
         if (coordinatorMode !== 'skip-coordinator') {
           // Asynchronously apply mutation to a persistent storage (we're not awaiting this promise here)
-          this.adapter.coordinator
+          this.clientSession.coordinator
             .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: coordinatorMode !== 'skip-persist' })
-            .pipe(Runtime.runFork(this.runtime))
+            .pipe(this.runEffectFork)
         }
 
         // Uncomment to print a list of queries currently registered on the store
@@ -568,7 +619,7 @@ export class Store<
    * This should only be used for framework-internal purposes;
    * all app writes should go through mutate.
    */
-  execute = (
+  __execute = (
     query: string,
     params: ParamsObject = {},
     writeTables?: ReadonlySet<string>,
@@ -576,10 +627,10 @@ export class Store<
   ) => {
     this.syncDbWrapper.execute(query, prepareBindValues(params, query), writeTables, { otelContext })
 
-    this.adapter.coordinator.execute(query, prepareBindValues(params, query)).pipe(this.runEffectFork)
+    this.clientSession.coordinator.execute(query, prepareBindValues(params, query)).pipe(this.runEffectFork)
   }
 
-  select = (query: string, params: ParamsObject = {}) => {
+  __select = (query: string, params: ParamsObject = {}) => {
     return this.syncDbWrapper.select(query, { bindValues: prepareBindValues(params, query) })
   }
 
@@ -597,7 +648,7 @@ export class Store<
 
   __devDownloadMutationLogDb = () =>
     Effect.gen(this, function* () {
-      const data = yield* this.adapter.coordinator.getMutationLogData
+      const data = yield* this.clientSession.coordinator.getMutationLogData
       downloadBlob(data, `livestore-mutationlog-${Date.now()}.db`)
     }).pipe(this.runEffectFork)
 
@@ -615,7 +666,7 @@ export class Store<
 
 export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema> = {
   schema: TSchema
-  adapter: StoreAdapterFactory
+  adapter: Adapter
   storeId: string
   reactivityGraph?: ReactivityGraph
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
@@ -663,7 +714,7 @@ export const createStore = <
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 >({
   schema,
-  adapter: adapterFactory,
+  adapter,
   storeId,
   graphQLOptions,
   otelOptions,
@@ -734,7 +785,7 @@ export const createStore = <
         )
       }).pipe(Effect.withSpan('livestore:shutdown'))
 
-    const adapter: StoreAdapter = yield* adapterFactory({
+    const clientSession: ClientSession = yield* adapter({
       schema,
       storeId,
       devtoolsEnabled: disableDevtools !== true,
@@ -745,7 +796,13 @@ export const createStore = <
 
     const mutationEventSchema = makeMutationEventSchemaMemo(schema)
 
-    const __processedMutationIds = new Set<string>()
+    // TODO get rid of this
+    // const __processedMutationIds = new Set<number>()
+
+    const currentMutationEventIdRef = { current: yield* clientSession.coordinator.getCurrentMutationEventId }
+
+    // TODO fill up with unsynced mutation events from the coordinator
+    const unsyncedMutationEvents = MutableHashMap.empty<EventId, MutationEvent.ForSchema<TSchema>>()
 
     // TODO consider moving booting into the storage backend
     if (boot !== undefined) {
@@ -755,57 +812,67 @@ export const createStore = <
       const bootDbImpl: BootDb = {
         _tag: 'BootDb',
         execute: (queryStr, bindValues) => {
-          const stmt = adapter.syncDb.prepare(queryStr)
+          const stmt = clientSession.syncDb.prepare(queryStr)
           stmt.execute(bindValues)
 
           if (isInTxn === true) {
             txnExecuteStmnts.push([queryStr, bindValues])
           } else {
-            adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
+            clientSession.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
           }
         },
         mutate: (...list) => {
-          for (const mutationEventDecoded of list) {
+          for (const mutationEventDecoded_ of list) {
             const mutationDef =
-              schema.mutations.get(mutationEventDecoded.mutation) ??
-              shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`)
+              schema.mutations.get(mutationEventDecoded_.mutation) ??
+              shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded_.mutation}`)
+
+            const { id, parentId } = clientSession.coordinator
+              .nextMutationEventIdPair({ localOnly: mutationDef.options.localOnly })
+              .pipe(Effect.runSync)
+
+            currentMutationEventIdRef.current = id
+
+            const mutationEventDecoded = { ...mutationEventDecoded_, id, parentId }
+
+            MutableHashMap.set(unsyncedMutationEvents, Data.struct(mutationEventDecoded.id), mutationEventDecoded)
 
-            __processedMutationIds.add(mutationEventDecoded.id)
+            // __processedMutationIds.add(mutationEventDecoded.id.global)
 
             const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
             // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
             for (const { statementSql, bindValues } of execArgsArr) {
-              adapter.syncDb.execute(statementSql, bindValues)
+              clientSession.syncDb.execute(statementSql, bindValues)
             }
 
             const mutationEventEncoded = Schema.encodeUnknownSync(mutationEventSchema)(mutationEventDecoded)
 
-            adapter.coordinator
+            clientSession.coordinator
               .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: true })
               .pipe(runEffectFork)
           }
         },
         select: (queryStr, bindValues) => {
-          const stmt = adapter.syncDb.prepare(queryStr)
+          const stmt = clientSession.syncDb.prepare(queryStr)
           return stmt.select(bindValues)
         },
         txn: (callback) => {
           try {
             isInTxn = true
-            // adapter.syncDb.execute('BEGIN TRANSACTION', undefined)
+            // clientSession.syncDb.execute('BEGIN TRANSACTION', undefined)
 
             callback()
 
-            // adapter.syncDb.execute('COMMIT', undefined)
+            // clientSession.syncDb.execute('COMMIT', undefined)
 
-            // adapter.coordinator.execute('BEGIN', undefined, undefined)
+            // clientSession.coordinator.execute('BEGIN', undefined, undefined)
             for (const [queryStr, bindValues] of txnExecuteStmnts) {
-              adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
+              clientSession.coordinator.execute(queryStr, bindValues).pipe(runEffectFork)
             }
-            // adapter.coordinator.execute('COMMIT', undefined, undefined)
+            // clientSession.coordinator.execute('COMMIT', undefined, undefined)
           } catch (e: any) {
-            // adapter.syncDb.execute('ROLLBACK', undefined)
+            // clientSession.syncDb.execute('ROLLBACK', undefined)
             throw e
           } finally {
             isInTxn = false
@@ -822,13 +889,14 @@ export const createStore = <
 
     const store = Store.createStore<TGraphQLContext, TSchema>(
       {
-        adapter,
+        clientSession,
         schema,
         graphQLOptions,
         otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
         reactivityGraph,
         disableDevtools,
-        __processedMutationIds,
+        currentMutationEventIdRef,
+        unsyncedMutationEvents,
         fiberSet,
         runtime,
         batchUpdates: batchUpdates ?? ((run) => run()),

package/src/utils/dev.ts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/prefer-global-this */
 export const downloadBlob = (
   data: Uint8Array | Blob | string,
   fileName: string,

package/src/{__tests__/react/utils → utils}/stack-info.test.ts

@@ -1,6 +1,6 @@
 import { expect, it } from 'vitest'
 
-import { extractStackInfoFromStackTrace } from '../../../react/utils/stack-info.js'
+import { extractStackInfoFromStackTrace } from './stack-info.js'
 
 it('RouteLink stacktrace', async () => {
   const stackTrace = `\

package/src/{react/utils → utils}/stack-info.ts

@@ -1,7 +1,3 @@
-import React from 'react'
-
-export const originalStackLimit = Error.stackTraceLimit
-
 export type StackInfo = {
   frames: StackFrame[]
 }
@@ -54,11 +50,5 @@ export const extractStackInfoFromStackTrace = (stackTrace: string): StackInfo =>
   return { frames }
 }
 
-export const useStackInfo = (): StackInfo =>
-  React.useMemo(() => {
-    Error.stackTraceLimit = 10
-    // eslint-disable-next-line unicorn/error-message
-    const stack = new Error().stack!
-    Error.stackTraceLimit = originalStackLimit
-    return extractStackInfoFromStackTrace(stack)
-  }, [])
+export const stackInfoToString = (stackInfo: StackInfo): string =>
+  stackInfo.frames.map((f) => `${f.name} (${f.filePath})`).join('\n')

package/src/utils/tests/fixture.ts

@@ -0,0 +1,77 @@
+import type { FromInputSchema } from '@livestore/common/schema'
+import type { Store } from '@livestore/livestore'
+import {
+  createStore,
+  DbSchema,
+  globalReactivityGraph,
+  makeReactivityGraph,
+  makeSchema,
+  sql,
+} from '@livestore/livestore'
+import { Effect, FiberSet } from '@livestore/utils/effect'
+import { makeInMemoryAdapter } from '@livestore/web'
+import type * as otel from '@opentelemetry/api'
+
+export type Todo = {
+  id: string
+  text: string
+  completed: boolean
+}
+
+export type Filter = 'all' | 'active' | 'completed'
+
+export type AppState = {
+  newTodoText: string
+  filter: Filter
+}
+
+export const todos = DbSchema.table(
+  'todos',
+  {
+    id: DbSchema.text({ primaryKey: true }),
+    text: DbSchema.text({ default: '', nullable: false }),
+    completed: DbSchema.boolean({ default: false, nullable: false }),
+  },
+  { deriveMutations: true, isSingleton: false },
+)
+
+export const app = DbSchema.table('app', {
+  id: DbSchema.text({ primaryKey: true }),
+  newTodoText: DbSchema.text({ default: '', nullable: true }),
+  filter: DbSchema.text({ default: 'all', nullable: false }),
+})
+
+export const tables = { todos, app }
+export const schema = makeSchema({ tables })
+
+export interface FixtureSchema extends FromInputSchema.DeriveSchema<{ tables: typeof tables }> {}
+
+export const makeTodoMvc = ({
+  otelTracer,
+  otelContext,
+  useGlobalReactivityGraph = true,
+}: {
+  otelTracer?: otel.Tracer
+  otelContext?: otel.Context
+  useGlobalReactivityGraph?: boolean
+} = {}) =>
+  Effect.gen(function* () {
+    const reactivityGraph = useGlobalReactivityGraph ? globalReactivityGraph : makeReactivityGraph()
+
+    const fiberSet = yield* FiberSet.make()
+
+    const store: Store<any, FixtureSchema> = yield* createStore({
+      schema,
+      storeId: 'default',
+      boot: (db) => db.execute(sql`INSERT OR IGNORE INTO app (id, newTodoText, filter) VALUES ('static', '', 'all');`),
+      adapter: makeInMemoryAdapter(),
+      reactivityGraph,
+      otelOptions: {
+        tracer: otelTracer,
+        rootSpanContext: otelContext,
+      },
+      fiberSet,
+    })
+
+    return { store, reactivityGraph }
+  })

package/src/utils/tests/mod.ts

@@ -0,0 +1,2 @@
+export * from './fixture.js'
+export * from './otel.js'