@livestore/livestore 0.0.54-dev.2 → 0.0.54-dev.22

package/src/store.ts

@@ -1,22 +1,29 @@
-import type { BootDb, PreparedBindValues, ResetMode, StoreAdapter, StoreAdapterFactory } from '@livestore/common'
-import { Devtools, getExecArgsFromMutation } from '@livestore/common'
+import type {
+  BootDb,
+  ParamsObject,
+  PreparedBindValues,
+  ResetMode,
+  StoreAdapter,
+  StoreAdapterFactory,
+  UnexpectedError,
+} from '@livestore/common'
+import { Devtools, getExecArgsFromMutation, prepareBindValues } from '@livestore/common'
 import { version as liveStoreVersion } from '@livestore/common/package.json'
-import type { LiveStoreSchema, MutationEvent, MutationEventSchema } from '@livestore/common/schema'
-import { makeMutationEventSchema } from '@livestore/common/schema'
-import { assertNever, isPromise, makeNoopTracer, ref, shouldNeverHappen } from '@livestore/utils'
-import { Effect, Schema, Stream } from '@livestore/utils/effect'
+import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
+import { makeMutationEventSchemaMemo } from '@livestore/common/schema'
+import { assertNever, isPromise, makeNoopTracer, shouldNeverHappen } from '@livestore/utils'
+import { Effect, Layer, OtelTracer, Schema, Stream } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
-import { globalDbGraph } from './global-state.js'
+import { globalReactivityGraph } from './global-state.js'
 import { MainDatabaseWrapper } from './MainDatabaseWrapper.js'
 import type { StackInfo } from './react/utils/stack-info.js'
-import type { DebugRefreshReasonBase, ReactiveGraph, Ref } from './reactive.js'
-import type { DbContext, DbGraph, LiveQuery } from './reactiveQueries/base-class.js'
+import type { DebugRefreshReasonBase, Ref } from './reactive.js'
+import { NOT_REFRESHED_YET } from './reactive.js'
+import type { LiveQuery, QueryContext, ReactivityGraph } from './reactiveQueries/base-class.js'
 import { downloadBlob } from './utils/dev.js'
 import { getDurationMsFromSpan } from './utils/otel.js'
-import type { ParamsObject } from './utils/util.js'
-import { prepareBindValues } from './utils/util.js'
 
 export type BaseGraphQLContext = {
   queriedTables: Set<string>
@@ -29,17 +36,21 @@ export type GraphQLOptions<TContext> = {
   makeContext: (db: MainDatabaseWrapper, tracer: otel.Tracer) => TContext
 }
 
+export type OtelOptions = {
+  tracer: otel.Tracer
+  rootSpanContext: otel.Context
+}
+
 export type StoreOptions<
   TGraphQLContext extends BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 > = {
   adapter: StoreAdapter
   schema: TSchema
+  // TODO remove graphql-related stuff from store and move to GraphQL query directly
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
-  otelTracer: otel.Tracer
-  otelRootSpanContext: otel.Context
-  dbGraph: DbGraph
-  mutationEventSchema: MutationEventSchema<any>
+  otelOptions: OtelOptions
+  reactivityGraph: ReactivityGraph
   disableDevtools?: boolean
 }
 
@@ -95,11 +106,8 @@ export class Store<
   TSchema extends LiveStoreSchema = LiveStoreSchema,
 > {
   id = uniqueStoreId()
-  graph: ReactiveGraph<RefreshReason, QueryDebugInfo, DbContext>
+  reactivityGraph: ReactivityGraph
   mainDbWrapper: MainDatabaseWrapper
-  // TODO refactor
-  // _proxyDb: InMemoryDatabase
-  // TODO
   adapter: StoreAdapter
   schema: LiveStoreSchema
   graphQLSchema?: GraphQLSchema
@@ -109,7 +117,7 @@ export class Store<
    * Note we're using `Ref<null>` here as we don't care about the value but only about *that* something has changed.
    * This only works in combination with `equal: () => false` which will always trigger a refresh.
    */
-  tableRefs: { [key: string]: Ref<null, DbContext, RefreshReason> }
+  tableRefs: { [key: string]: Ref<null, QueryContext, RefreshReason> }
 
   // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
   __processedMutationIds = new Set<string>()
@@ -124,32 +132,33 @@ export class Store<
     adapter,
     schema,
     graphQLOptions,
-    dbGraph,
-    otelTracer,
-    otelRootSpanContext,
-    mutationEventSchema,
+    reactivityGraph,
+    otelOptions,
     disableDevtools,
   }: StoreOptions<TGraphQLContext, TSchema>) {
-    this.mainDbWrapper = new MainDatabaseWrapper({ otelTracer, otelRootSpanContext, db: adapter.mainDb })
+    this.mainDbWrapper = new MainDatabaseWrapper({ otel: otelOptions, db: adapter.mainDb })
     this.adapter = adapter
     this.schema = schema
 
     // TODO refactor
-    this.__mutationEventSchema = mutationEventSchema
-    // this.mutationEventSchema = makeMutationEventSchema(Object.fromEntries(schema.mutations.entries()) as any)
+    this.__mutationEventSchema = makeMutationEventSchemaMemo(schema)
 
     // TODO generalize the `tableRefs` concept to allow finer-grained refs
     this.tableRefs = {}
     this.activeQueries = new ReferenceCountedSet()
 
-    const mutationsSpan = otelTracer.startSpan('LiveStore:mutations', {}, otelRootSpanContext)
+    const mutationsSpan = otelOptions.tracer.startSpan('LiveStore:mutations', {}, otelOptions.rootSpanContext)
     const otelMuationsSpanContext = otel.trace.setSpan(otel.context.active(), mutationsSpan)
 
-    const queriesSpan = otelTracer.startSpan('LiveStore:queries', {}, otelRootSpanContext)
+    const queriesSpan = otelOptions.tracer.startSpan('LiveStore:queries', {}, otelOptions.rootSpanContext)
     const otelQueriesSpanContext = otel.trace.setSpan(otel.context.active(), queriesSpan)
 
-    this.graph = dbGraph
-    this.graph.context = { store: this as any, otelTracer, rootOtelContext: otelQueriesSpanContext }
+    this.reactivityGraph = reactivityGraph
+    this.reactivityGraph.context = {
+      store: this as unknown as Store<BaseGraphQLContext, LiveStoreSchema>,
+      otelTracer: otelOptions.tracer,
+      rootOtelContext: otelQueriesSpanContext,
+    }
 
     this.adapter.coordinator.syncMutations.pipe(
       Stream.tapSync((mutationEventDecoded) => {
@@ -165,7 +174,7 @@ export class Store<
     }
 
     this.otel = {
-      tracer: otelTracer,
+      tracer: otelOptions.tracer,
       mutationsSpanContext: otelMuationsSpanContext,
       queriesSpanContext: otelQueriesSpanContext,
     }
@@ -177,7 +186,7 @@ export class Store<
       // ...Array.from(dynamicallyRegisteredTables.values()).map((_) => _.sqliteDef.name),
     )
     const existingTableRefs = new Map(
-      Array.from(this.graph.atoms.values())
+      Array.from(this.reactivityGraph.atoms.values())
         .filter((_): _ is Ref<any, any, any> => _._tag === 'ref' && _.label?.startsWith('tableRef:') === true)
         .map((_) => [_.label!.slice('tableRef:'.length), _] as const),
     )
@@ -196,7 +205,7 @@ export class Store<
     parentSpan: otel.Span,
   ): Store<TGraphQLContext, TSchema> => {
     const ctx = otel.trace.setSpan(otel.context.active(), parentSpan)
-    return storeOptions.otelTracer.startActiveSpan('LiveStore:store-constructor', {}, ctx, (span) => {
+    return storeOptions.otelOptions.tracer.startActiveSpan('LiveStore:store-constructor', {}, ctx, (span) => {
       try {
         return new Store(storeOptions)
       } finally {
@@ -224,7 +233,7 @@ export class Store<
         const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
         const label = `subscribe:${options?.label}`
-        const effect = this.graph.makeEffect((get) => onNewValue(get(query$.results$)), { label })
+        const effect = this.reactivityGraph.makeEffect((get) => onNewValue(get(query$.results$)), { label })
 
         this.activeQueries.add(query$ as LiveQuery<TResult>)
 
@@ -236,7 +245,7 @@ export class Store<
         const unsubscribe = () => {
           // console.log('store unsub', query$.label)
           try {
-            this.graph.destroyNode(effect)
+            this.reactivityGraph.destroyNode(effect)
             this.activeQueries.remove(query$ as LiveQuery<TResult>)
             onUnsubsubscribe?.()
           } finally {
@@ -256,14 +265,14 @@ export class Store<
   destroy = async () => {
     for (const tableRef of Object.values(this.tableRefs)) {
       for (const superComp of tableRef.super) {
-        this.graph.removeEdge(superComp, tableRef)
+        this.reactivityGraph.removeEdge(superComp, tableRef)
       }
     }
 
     otel.trace.getSpan(this.otel.mutationsSpanContext)!.end()
     otel.trace.getSpan(this.otel.queriesSpanContext)!.end()
 
-    await this.adapter.coordinator.shutdown()
+    await this.adapter.coordinator.shutdown.pipe(Effect.tapCauseLogPretty, Effect.runPromise)
   }
 
   mutate: {
@@ -374,7 +383,7 @@ export class Store<
             },
           )
 
-          const tablesToUpdate = [] as [Ref<null, DbContext, RefreshReason>, null][]
+          const tablesToUpdate = [] as [Ref<null, QueryContext, RefreshReason>, null][]
           for (const tableName of writeTables) {
             const tableRef = this.tableRefs[tableName]
             assertNever(tableRef !== undefined, `No table ref found for ${tableName}`)
@@ -388,7 +397,7 @@ export class Store<
           }
 
           // Update all table refs together in a batch, to only trigger one reactive update
-          this.graph.setRefs(tablesToUpdate, { debugRefreshReason, otelContext, skipRefresh })
+          this.reactivityGraph.setRefs(tablesToUpdate, { debugRefreshReason, otelContext, skipRefresh })
         } catch (e: any) {
           span.setStatus({ code: otel.SpanStatusCode.ERROR, message: e.toString() })
         } finally {
@@ -412,7 +421,7 @@ export class Store<
       this.otel.mutationsSpanContext,
       (span) => {
         const otelContext = otel.trace.setSpan(otel.context.active(), span)
-        this.graph.runDeferredEffects({ otelContext })
+        this.reactivityGraph.runDeferredEffects({ otelContext })
         span.end()
       },
     )
@@ -480,10 +489,9 @@ export class Store<
 
         if (coordinatorMode !== 'skip-coordinator') {
           // Asynchronously apply mutation to a persistent storage (we're not awaiting this promise here)
-          void this.adapter.coordinator.mutate(mutationEventEncoded, {
-            span,
-            persisted: coordinatorMode !== 'skip-persist',
-          })
+          this.adapter.coordinator
+            .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: coordinatorMode !== 'skip-persist' })
+            .pipe(Effect.tapCauseLogPretty, Effect.runFork)
         }
 
         // Uncomment to print a list of queries currently registered on the store
@@ -509,8 +517,9 @@ export class Store<
   ) => {
     this.mainDbWrapper.execute(query, prepareBindValues(params, query), writeTables, { otelContext })
 
-    const parentSpan = otel.trace.getSpan(otel.context.active())
-    this.adapter.coordinator.execute(query, prepareBindValues(params, query), parentSpan)
+    this.adapter.coordinator
+      .execute(query, prepareBindValues(params, query))
+      .pipe(Effect.tapCauseLogPretty, Effect.runFork)
   }
 
   select = (query: string, params: ParamsObject = {}) => {
@@ -518,7 +527,7 @@ export class Store<
   }
 
   makeTableRef = (tableName: string) =>
-    this.graph.makeRef(null, {
+    this.reactivityGraph.makeRef(null, {
       equal: () => false,
       label: `tableRef:${tableName}`,
       meta: { liveStoreRefType: 'table' },
@@ -527,14 +536,16 @@ export class Store<
   private bootDevtools = () => {
     const devtoolsChannel = Devtools.makeBroadcastChannels()
 
-    const signalsSubcriptionRef = ref<undefined | (() => void)>(undefined)
-    // let alreadySubscribedToLiveQueries = false
-    const liveQueriesSubscriptionRef = ref<undefined | (() => void)>(undefined)
+    type Unsub = () => void
+    type RequestId = string
+
+    const reactivityGraphSubcriptions = new Map<RequestId, Unsub>()
+    const liveQueriesSubscriptions = new Map<RequestId, Unsub>()
     devtoolsChannel.toAppHost.addEventListener('message', async (event) => {
       const decoded = Schema.decodeUnknownOption(Devtools.MessageToAppHost)(event.data)
       if (
         decoded._tag === 'None' ||
-        decoded.value._tag === 'LSD.DevtoolsReadyBroadcast' ||
+        decoded.value._tag === 'LSD.DevtoolsReady' ||
         decoded.value._tag === 'LSD.DevtoolsConnected' ||
         decoded.value.channelId !== this.adapter.coordinator.devtools.channelId
       ) {
@@ -547,12 +558,12 @@ export class Store<
         devtoolsChannel.fromAppHost.postMessage(Schema.encodeSync(Devtools.MessageFromAppHost)(message))
 
       switch (decoded.value._tag) {
-        case 'LSD.SignalsSubscribe': {
+        case 'LSD.ReactivityGraphSubscribe': {
           const includeResults = decoded.value.includeResults
           const send = () =>
             sendToDevtools(
-              Devtools.SignalsRes.make({
-                signals: this.graph.getSnapshot({ includeResults }),
+              Devtools.ReactivityGraphRes.make({
+                reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults }),
                 requestId,
                 liveStoreVersion,
               }),
@@ -560,9 +571,10 @@ export class Store<
 
           send()
 
-          if (signalsSubcriptionRef.current === undefined) {
-            signalsSubcriptionRef.current = this.graph.subscribeToRefresh(() => send())
-          }
+          reactivityGraphSubcriptions.set(
+            requestId,
+            this.reactivityGraph.subscribeToRefresh(() => send()),
+          )
 
           break
         }
@@ -583,9 +595,8 @@ export class Store<
           sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, liveStoreVersion }))
           break
         }
-        case 'LSD.SignalsUnsubscribe': {
-          signalsSubcriptionRef.current!()
-          signalsSubcriptionRef.current = undefined
+        case 'LSD.ReactivityGraphUnsubscribe': {
+          reactivityGraphSubcriptions.get(requestId)!()
           break
         }
         case 'LSD.LiveQueriesSubscribe': {
@@ -598,7 +609,10 @@ export class Store<
                   label: q.label,
                   runs: q.runs,
                   executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
-                  lastestResult: q.results$.previousResult,
+                  lastestResult:
+                    q.results$.previousResult === NOT_REFRESHED_YET
+                      ? 'SYMBOL_NOT_REFRESHED_YET'
+                      : q.results$.previousResult,
                   activeSubscriptions: Array.from(q.activeSubscriptions),
                 })),
                 requestId,
@@ -608,19 +622,22 @@ export class Store<
 
           send()
 
-          if (liveQueriesSubscriptionRef.current === undefined) {
-            liveQueriesSubscriptionRef.current = this.graph.subscribeToRefresh(() => send())
-          }
+          liveQueriesSubscriptions.set(
+            requestId,
+            this.reactivityGraph.subscribeToRefresh(() => send()),
+          )
 
           break
         }
         case 'LSD.LiveQueriesUnsubscribe': {
-          liveQueriesSubscriptionRef.current!()
-          liveQueriesSubscriptionRef.current = undefined
+          liveQueriesSubscriptions.get(requestId)!()
           break
         }
         case 'LSD.ResetAllDataReq': {
-          await this.adapter.coordinator.dangerouslyReset(decoded.value.mode)
+          await this.adapter.coordinator
+            .dangerouslyReset(decoded.value.mode)
+            .pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+
           sendToDevtools(Devtools.ResetAllDataRes.make({ requestId, liveStoreVersion }))
 
           break
@@ -636,144 +653,162 @@ export class Store<
   }
 
   __devDownloadMutationLogDb = async () => {
-    const data = await this.adapter.coordinator.getMutationLogData()
+    const data = await this.adapter.coordinator.getMutationLogData.pipe(Effect.tapCauseLogPretty, Effect.runPromise)
     downloadBlob(data, `livestore-mutationlog-${Date.now()}.db`)
   }
 
   // TODO allow for graceful store reset without requiring a full page reload (which should also call .boot)
-  dangerouslyResetStorage = (mode: ResetMode) => this.adapter.coordinator.dangerouslyReset(mode)
+  dangerouslyResetStorage = (mode: ResetMode) =>
+    this.adapter.coordinator.dangerouslyReset(mode).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+}
+
+export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema> = {
+  schema: TSchema
+  adapter: StoreAdapterFactory
+  reactivityGraph?: ReactivityGraph
+  graphQLOptions?: GraphQLOptions<TGraphQLContext>
+  otelOptions?: Partial<OtelOptions>
+  boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
+  batchUpdates?: (run: () => void) => void
+  disableDevtools?: boolean
 }
 
 /** Create a new LiveStore Store */
 export const createStore = async <
   TGraphQLContext extends BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
+>(
+  options: CreateStoreOptions<TGraphQLContext, TSchema>,
+): Promise<Store<TGraphQLContext, TSchema>> => createStoreEff(options).pipe(Effect.tapCauseLogPretty, Effect.runPromise)
+
+export const createStoreEff = <
+  TGraphQLContext extends BaseGraphQLContext,
+  TSchema extends LiveStoreSchema = LiveStoreSchema,
 >({
   schema,
   graphQLOptions,
-  otelTracer = makeNoopTracer(),
-  otelRootSpanContext = otel.context.active(),
+  otelOptions,
   adapter: adapterFactory,
   boot,
-  dbGraph = globalDbGraph,
+  reactivityGraph = globalReactivityGraph,
   batchUpdates,
   disableDevtools,
-}: {
-  schema: TSchema
-  graphQLOptions?: GraphQLOptions<TGraphQLContext>
-  otelTracer?: otel.Tracer
-  otelRootSpanContext?: otel.Context
-  adapter: StoreAdapterFactory
-  boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
-  dbGraph?: DbGraph
-  batchUpdates?: (run: () => void) => void
-  disableDevtools?: boolean
-}): Promise<Store<TGraphQLContext, TSchema>> => {
-  return otelTracer.startActiveSpan('createStore', {}, otelRootSpanContext, async (span) => {
-    try {
-      performance.mark('livestore:db-creating')
-      const otelContext = otel.trace.setSpan(otel.context.active(), span)
-
-      const adapterPromise = adapterFactory({ otelTracer, otelContext, schema })
-      const adapter = adapterPromise instanceof Promise ? await adapterPromise : adapterPromise
-      performance.mark('livestore:db-created')
-      performance.measure('livestore:db-create', 'livestore:db-creating', 'livestore:db-created')
-
-      if (batchUpdates !== undefined) {
-        dbGraph.effectsWrapper = batchUpdates
-      }
+}: CreateStoreOptions<TGraphQLContext, TSchema>): Effect.Effect<Store<TGraphQLContext, TSchema>, UnexpectedError> => {
+  const otelTracer = otelOptions?.tracer ?? makeNoopTracer()
+  const otelRootSpanContext = otelOptions?.rootSpanContext ?? otel.context.active()
 
-      const mutationEventSchema = makeMutationEventSchema(Object.fromEntries(schema.mutations.entries()) as any)
+  const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
+    Layer.provide(Layer.sync(OtelTracer.Tracer, () => otelTracer)),
+  )
 
-      // TODO consider moving booting into the storage backend
-      if (boot !== undefined) {
-        let isInTxn = false
-        let txnExecuteStmnts: [string, PreparedBindValues | undefined][] = []
+  return Effect.gen(function* () {
+    const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
 
-        const bootDbImpl: BootDb = {
-          _tag: 'BootDb',
-          execute: (queryStr, bindValues) => {
-            const stmt = adapter.mainDb.prepare(queryStr)
-            stmt.execute(bindValues)
+    const adapter = yield* adapterFactory({ schema }).pipe(
+      Effect.withPerformanceMeasure('livestore:makeAdapter'),
+      Effect.withSpan('createStore:makeAdapter'),
+    )
 
-            if (isInTxn === true) {
-              txnExecuteStmnts.push([queryStr, bindValues])
-            } else {
-              void adapter.coordinator.execute(queryStr, bindValues, undefined)
-            }
-          },
-          mutate: (...list) => {
-            for (const mutationEventDecoded of list) {
-              const mutationDef =
-                schema.mutations.get(mutationEventDecoded.mutation) ??
-                shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`)
-
-              const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-              // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-
-              for (const { statementSql, bindValues } of execArgsArr) {
-                adapter.mainDb.execute(statementSql, bindValues)
-              }
+    if (batchUpdates !== undefined) {
+      reactivityGraph.effectsWrapper = batchUpdates
+    }
 
-              const mutationEventEncoded = Schema.encodeUnknownSync(mutationEventSchema)(mutationEventDecoded)
-              void adapter.coordinator.mutate(mutationEventEncoded, { span, persisted: true })
-            }
-          },
-          select: (queryStr, bindValues) => {
-            const stmt = adapter.mainDb.prepare(queryStr)
-            return stmt.select(bindValues)
-          },
-          txn: (callback) => {
-            try {
-              isInTxn = true
-              adapter.mainDb.execute('BEGIN', undefined)
-
-              callback()
-
-              adapter.mainDb.execute('COMMIT', undefined)
-
-              // adapter.coordinator.execute('BEGIN', undefined, undefined)
-              for (const [queryStr, bindValues] of txnExecuteStmnts) {
-                adapter.coordinator.execute(queryStr, bindValues, undefined)
-              }
-              // adapter.coordinator.execute('COMMIT', undefined, undefined)
-            } catch (e: any) {
-              adapter.mainDb.execute('ROLLBACK', undefined)
-              throw e
-            } finally {
-              isInTxn = false
-              txnExecuteStmnts = []
+    const mutationEventSchema = makeMutationEventSchemaMemo(schema)
+
+    // TODO consider moving booting into the storage backend
+    if (boot !== undefined) {
+      let isInTxn = false
+      let txnExecuteStmnts: [string, PreparedBindValues | undefined][] = []
+
+      const bootDbImpl: BootDb = {
+        _tag: 'BootDb',
+        execute: (queryStr, bindValues) => {
+          const stmt = adapter.mainDb.prepare(queryStr)
+          stmt.execute(bindValues)
+
+          if (isInTxn === true) {
+            txnExecuteStmnts.push([queryStr, bindValues])
+          } else {
+            adapter.coordinator.execute(queryStr, bindValues).pipe(Effect.tapCauseLogPretty, Effect.runFork)
+          }
+        },
+        mutate: (...list) => {
+          for (const mutationEventDecoded of list) {
+            const mutationDef =
+              schema.mutations.get(mutationEventDecoded.mutation) ??
+              shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`)
+
+            const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+            // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+
+            for (const { statementSql, bindValues } of execArgsArr) {
+              adapter.mainDb.execute(statementSql, bindValues)
             }
-          },
-        }
 
-        const booting = boot(bootDbImpl, span)
-        // NOTE only awaiting if it's actually a promise to avoid unnecessary async/await
-        if (isPromise(booting)) {
-          await booting
-        }
-      }
+            const mutationEventEncoded = Schema.encodeUnknownSync(mutationEventSchema)(mutationEventDecoded)
+
+            adapter.coordinator
+              .mutate(mutationEventEncoded as MutationEvent.AnyEncoded, { persisted: true })
+              .pipe(Effect.tapCauseLogPretty, Effect.runFork)
+          }
+        },
+        select: (queryStr, bindValues) => {
+          const stmt = adapter.mainDb.prepare(queryStr)
+          return stmt.select(bindValues)
+        },
+        txn: (callback) => {
+          try {
+            isInTxn = true
+            adapter.mainDb.execute('BEGIN', undefined)
+
+            callback()
 
-      // TODO: we can't apply the schema at this point, we've already loaded persisted data!
-      // Think about what to do about this case.
-      // await applySchema(db, schema)
-      return Store.createStore<TGraphQLContext, TSchema>(
-        {
-          adapter: adapter,
-          schema,
-          graphQLOptions,
-          otelTracer,
-          otelRootSpanContext,
-          dbGraph,
-          mutationEventSchema,
-          disableDevtools,
+            adapter.mainDb.execute('COMMIT', undefined)
+
+            // adapter.coordinator.execute('BEGIN', undefined, undefined)
+            for (const [queryStr, bindValues] of txnExecuteStmnts) {
+              adapter.coordinator.execute(queryStr, bindValues).pipe(Effect.tapCauseLogPretty, Effect.runFork)
+            }
+            // adapter.coordinator.execute('COMMIT', undefined, undefined)
+          } catch (e: any) {
+            adapter.mainDb.execute('ROLLBACK', undefined)
+            throw e
+          } finally {
+            isInTxn = false
+            txnExecuteStmnts = []
+          }
         },
-        span,
-      )
-    } finally {
-      span.end()
+      }
+
+      const booting = boot(bootDbImpl, span)
+      // NOTE only awaiting if it's actually a promise to avoid unnecessary async/await
+      if (isPromise(booting)) {
+        yield* Effect.promise(() => booting)
+      }
     }
-  })
+
+    // TODO: we can't apply the schema at this point, we've already loaded persisted data!
+    // Think about what to do about this case.
+    // await applySchema(db, schema)
+    return Store.createStore<TGraphQLContext, TSchema>(
+      {
+        adapter,
+        schema,
+        graphQLOptions,
+        otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
+        reactivityGraph,
+        disableDevtools,
+      },
+      span,
+    )
+  }).pipe(
+    Effect.withSpan('createStore', {
+      parent: otelOptions?.rootSpanContext
+        ? OtelTracer.makeExternalSpan(otel.trace.getSpanContext(otelOptions.rootSpanContext)!)
+        : undefined,
+    }),
+    Effect.provide(TracingLive),
+  )
 }
 
 class ReferenceCountedSet<T> {

package/dist/utils/bounded-collections.d.ts

@@ -1,34 +0,0 @@
-/**
- * Creates a map that has a fixed number of entries.
- * Once hitting the bound, earliest insertions are removed
- */
-export default class BoundMap<K, V> {
-    #private;
-    constructor(sizeLimit: number);
-    onEvict: ((key: K, value: V) => void) | undefined;
-    set: (key: K, value: V) => void;
-    get: (key: K) => V | undefined;
-    delete: (key: K) => void;
-    keys: () => IterableIterator<K>;
-}
-export declare class BoundSet<V> {
-    #private;
-    constructor(sizeLimit: number);
-    onEvict: ((key: V) => void) | undefined;
-    add: (v: V) => void;
-    [Symbol.iterator]: () => IterableIterator<V>;
-}
-export declare class BoundArray<V> {
-    #private;
-    constructor(sizeLimit: number);
-    onEvict: ((key: V) => void) | undefined;
-    push: (v: V) => void;
-    get: (index: number) => V | undefined;
-    delete: (index: number) => void;
-    get length(): number;
-    [Symbol.iterator]: () => IterableIterator<V>;
-    map: <T>(fn: (v: V) => T) => T[];
-    clear: () => void;
-    sort: (fn?: (a: V, b: V) => number) => V[];
-}
-//# sourceMappingURL=bounded-collections.d.ts.map

package/dist/utils/bounded-collections.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bounded-collections.d.ts","sourceRoot":"","sources":["../../src/utils/bounded-collections.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC;;gBAIpB,SAAS,EAAE,MAAM;IAI7B,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAEjD,GAAG,QAAS,CAAC,SAAS,CAAC,UAWtB;IAED,GAAG,QAAS,CAAC,KAAG,CAAC,GAAG,SAAS,CAE5B;IAED,MAAM,QAAS,CAAC,UAEf;IAED,IAAI,4BAEH;CACF;AAED,qBAAa,QAAQ,CAAC,CAAC;;gBAGT,SAAS,EAAE,MAAM;IAW7B,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAEvC,GAAG,MAAO,CAAC,UAET;IAEF,CAAC,MAAM,CAAC,QAAQ,CAAC,4BAEhB;CACF;AAED,qBAAa,UAAU,CAAC,CAAC;;gBAIX,SAAS,EAAE,MAAM;IAI7B,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAEvC,IAAI,MAAO,CAAC,UAQX;IAED,GAAG,UAAW,MAAM,KAAG,CAAC,GAAG,SAAS,CAEnC;IAED,MAAM,UAAW,MAAM,UAEtB;IAED,IAAI,MAAM,WAET;IAED,CAAC,MAAM,CAAC,QAAQ,CAAC,4BAEhB;IAED,GAAG,UAAW,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAG,CAAC,EAAE,CAE9B;IAED,KAAK,aAEJ;IAED,IAAI,QAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,SAElC;CACF"}