@livestore/livestore 0.0.0-snapshot-a39a3b63b870a2878f22f82ce2979a6989076053 → 0.0.0-snapshot-97ca7eac46b6a583b22d40189126d06a377ec1b0

package/package.json

@@ -1,54 +1,52 @@
 {
   "name": "@livestore/livestore",
-  "version": "0.0.0-snapshot-a39a3b63b870a2878f22f82ce2979a6989076053",
+  "version": "0.0.0-snapshot-97ca7eac46b6a583b22d40189126d06a377ec1b0",
   "type": "module",
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    },
+    "./internal": {
+      "types": "./dist/internal/mod.d.ts",
+      "default": "./dist/internal/mod.js"
     },
     "./internal/testing-utils": {
       "types": "./dist/utils/tests/mod.d.ts",
       "default": "./dist/utils/tests/mod.js"
     },
     "./effect": {
-      "types": "./dist/effect/index.d.ts",
-      "default": "./dist/effect/index.js"
+      "types": "./dist/effect/mod.d.ts",
+      "default": "./dist/effect/mod.js"
     }
   },
-  "types": "./dist/index.d.ts",
+  "types": "./dist/mod.d.ts",
   "typesVersions": {
     "*": {
+      "internal": [
+        "./dist/internal/mod.d.ts"
+      ],
       "testing-utils": [
         "./dist/utils/tests/mod.d.ts"
       ],
       "effect": [
-        "./dist/effect/index.d.ts"
+        "./dist/effect/mod.d.ts"
       ]
     }
   },
   "dependencies": {
-    "@graphql-typed-document-node/core": "3.2.0",
     "@opentelemetry/api": "1.9.0",
-    "@livestore/common": "0.0.0-snapshot-a39a3b63b870a2878f22f82ce2979a6989076053",
-    "@livestore/utils": "0.0.0-snapshot-a39a3b63b870a2878f22f82ce2979a6989076053"
+    "@livestore/common": "0.0.0-snapshot-97ca7eac46b6a583b22d40189126d06a377ec1b0",
+    "@livestore/utils": "0.0.0-snapshot-97ca7eac46b6a583b22d40189126d06a377ec1b0"
   },
   "devDependencies": {
     "@opentelemetry/sdk-trace-base": "^1.30.1",
     "jsdom": "^26.0.0",
-    "typescript": "^5.7.3",
-    "vite": "^6.1.0",
-    "vitest": "^2.1.4",
-    "@livestore/adapter-web": "0.0.0-snapshot-a39a3b63b870a2878f22f82ce2979a6989076053"
-  },
-  "peerDependencies": {
-    "graphql": "~16.0"
-  },
-  "peerDependenciesMeta": {
-    "graphql": {
-      "optional": true
-    }
+    "typescript": "^5.8.2",
+    "vite": "^6.2.1",
+    "vitest": "^3.0.8",
+    "@livestore/adapter-web": "0.0.0-snapshot-97ca7eac46b6a583b22d40189126d06a377ec1b0"
   },
   "publishConfig": {
     "access": "public"

package/src/SqliteDbWrapper.ts

@@ -9,12 +9,18 @@ import type {
   SqliteDbChangeset,
   SqliteDbSession,
 } from '@livestore/common'
-import { BoundArray, BoundMap, sql, SqliteError } from '@livestore/common'
+import {
+  BoundArray,
+  BoundMap,
+  getDurationMsFromSpan,
+  getStartTimeHighResFromSpan,
+  sql,
+  SqliteError,
+} from '@livestore/common'
 import { isDevEnv } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 
 import QueryCache from './QueryCache.js'
-import { getDurationMsFromSpan, getStartTimeHighResFromSpan } from './utils/otel.js'
 
 export const emptyDebugInfo = (): DebugInfo => ({
   slowQueries: new BoundArray(200),

package/src/effect/LiveStore.ts

@@ -1,92 +1,31 @@
-import type { Adapter, BootStatus, UnexpectedError } from '@livestore/common'
+import type { UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import type { Cause, OtelTracer, Scope } from '@livestore/utils/effect'
-import { Context, Deferred, Duration, Effect, Layer, pipe } from '@livestore/utils/effect'
-import type * as otel from '@opentelemetry/api'
-import type { GraphQLSchema } from 'graphql'
+import { Deferred, Duration, Effect, Layer, pipe } from '@livestore/utils/effect'
 
-import type { SqliteDbWrapper } from '../SqliteDbWrapper.js'
-import { createStore } from '../store/create-store.js'
-import type { Store } from '../store/store.js'
-import type { BaseGraphQLContext, LiveStoreContextRunning as LiveStoreContextRunning_ } from '../store/store-types.js'
+import type { LiveStoreContextProps } from '../store/create-store.js'
+import { createStore, DeferredStoreContext, LiveStoreContextRunning } from '../store/create-store.js'
 
-export class LiveStoreContextRunning extends Context.Tag('@livestore/livestore/effect/LiveStoreContextRunning')<
-  LiveStoreContextRunning,
-  LiveStoreContextRunning_
->() {
-  static fromDeferred = Effect.gen(function* () {
-    const deferred = yield* DeferredStoreContext
-    const ctx = yield* deferred
-    return Layer.succeed(LiveStoreContextRunning, ctx)
-  }).pipe(Layer.unwrapScoped)
-}
-
-export class DeferredStoreContext extends Context.Tag('@livestore/livestore/effect/DeferredStoreContext')<
-  DeferredStoreContext,
-  Deferred.Deferred<LiveStoreContextRunning['Type'], UnexpectedError>
->() {}
-
-export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
-  schema: LiveStoreSchema
-  /**
-   * The `storeId` can be used to isolate multiple stores from each other.
-   * So it can be useful for multi-tenancy scenarios.
-   *
-   * The `storeId` is also used for persistence.
-   *
-   * @default 'default'
-   */
-  storeId?: string
-  graphQLOptions?: {
-    schema: Effect.Effect<GraphQLSchema, never, OtelTracer.OtelTracer>
-    makeContext: (db: SqliteDbWrapper, tracer: otel.Tracer, sessionId: string) => GraphQLContext
-  }
-  boot?: (
-    store: Store<GraphQLContext, LiveStoreSchema>,
-  ) => Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
-  adapter: Adapter
-  disableDevtools?: boolean
-  onBootStatus?: (status: BootStatus) => void
-  batchUpdates: (run: () => void) => void
-}
-
-export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>(
-  props: LiveStoreContextProps<GraphQLContext>,
-): Layer.Layer<LiveStoreContextRunning, UnexpectedError | Cause.TimeoutException, OtelTracer.OtelTracer> =>
-  Layer.scoped(LiveStoreContextRunning, makeLiveStoreContext(props)).pipe(
-    Layer.withSpan('LiveStore'),
-    Layer.provide(LiveStoreContextDeferred),
-  )
-
-export const LiveStoreContextDeferred = Layer.effect(
-  DeferredStoreContext,
-  Deferred.make<LiveStoreContextRunning['Type'], UnexpectedError>(),
-)
-
-export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>({
+export const makeLiveStoreContext = <TSchema extends LiveStoreSchema, TContext = {}>({
   schema,
   storeId = 'default',
-  graphQLOptions: graphQLOptions_,
+  context,
   boot,
   adapter,
   disableDevtools,
   onBootStatus,
   batchUpdates,
-}: LiveStoreContextProps<GraphQLContext>): Effect.Effect<
+}: LiveStoreContextProps<TSchema, TContext>): Effect.Effect<
   LiveStoreContextRunning['Type'],
   UnexpectedError | Cause.TimeoutException,
   DeferredStoreContext | Scope.Scope | OtelTracer.OtelTracer
 > =>
   pipe(
     Effect.gen(function* () {
-      const graphQLOptions = yield* graphQLOptions_
-        ? Effect.all({ schema: graphQLOptions_.schema, makeContext: Effect.succeed(graphQLOptions_.makeContext) })
-        : Effect.succeed(undefined)
-
       const store = yield* createStore({
         schema,
         storeId,
-        graphQLOptions,
+        context,
         boot,
         adapter,
         disableDevtools,
@@ -100,7 +39,7 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
       }
       globalThis.__debugLiveStore[storeId] = store
 
-      return { stage: 'running', store } satisfies LiveStoreContextRunning['Type']
+      return { stage: 'running', store } as any as LiveStoreContextRunning['Type']
     }),
     Effect.tapErrorCause((cause) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.failCause(def, cause))),
     Effect.tap((storeCtx) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.succeed(def, storeCtx))),
@@ -109,3 +48,16 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
     Effect.timeout(Duration.minutes(5)),
     Effect.withSpan('@livestore/livestore/effect:makeLiveStoreContext'),
   )
+
+export const LiveStoreContextLayer = <TSchema extends LiveStoreSchema, TContext = {}>(
+  props: LiveStoreContextProps<TSchema, TContext>,
+): Layer.Layer<LiveStoreContextRunning, UnexpectedError | Cause.TimeoutException, OtelTracer.OtelTracer> =>
+  Layer.scoped(LiveStoreContextRunning, makeLiveStoreContext(props)).pipe(
+    Layer.withSpan('LiveStore'),
+    Layer.provide(LiveStoreContextDeferred),
+  )
+
+export const LiveStoreContextDeferred = Layer.effect(
+  DeferredStoreContext,
+  Deferred.make<LiveStoreContextRunning['Type'], UnexpectedError>(),
+)

package/src/effect/{index.ts → mod.ts}

@@ -1,8 +1,7 @@
+export { LiveStoreContextLayer, LiveStoreContextDeferred } from './LiveStore.js'
 export {
-  LiveStoreContextLayer,
   LiveStoreContextRunning as LiveStoreContext,
   LiveStoreContextRunning,
-  LiveStoreContextDeferred,
   DeferredStoreContext,
   type LiveStoreContextProps,
-} from './LiveStore.js'
+} from '../store/create-store.js'

package/src/internal/mod.ts

@@ -0,0 +1,2 @@
+export * as LiveQueries from '../live-queries/mod.js'
+export * as ReactiveGraph from '../reactive.js'

package/src/live-queries/base-class.ts

@@ -15,7 +15,7 @@ export const makeReactivityGraph = (): ReactivityGraph =>
 export type ReactivityGraphContext = {
   store: Store
   /** Maps from the hash of the query definition to the RcRef of the query */
-  defRcMap: Map<string, RcRef<LiveQueryAny | ILiveQueryRef<any>>>
+  defRcMap: Map<string, RcRef<LiveQuery.Any | ILiveQueryRef<any>>>
   /** Back-reference to the reactivity graph for convenience */
   reactivityGraph: WeakRef<ReactivityGraph>
   otelTracer: otel.Tracer
@@ -23,7 +23,7 @@ export type ReactivityGraphContext = {
   effectsWrapper: (run: () => void) => void
 }
 
-export type GetResult<TQuery extends LiveQueryDefAny | LiveQueryAny> =
+export type GetResult<TQuery extends LiveQueryDef.Any | LiveQuery.Any> =
   TQuery extends LiveQuery<infer TResult, infer _1>
     ? TResult
     : TQuery extends LiveQueryDef<infer TResult, infer _1>
@@ -32,9 +32,6 @@ export type GetResult<TQuery extends LiveQueryDefAny | LiveQueryAny> =
 
 let queryIdCounter = 0
 
-export type LiveQueryAny = LiveQuery<any, QueryInfo>
-export type LiveQueryDefAny = LiveQueryDef<any, any>
-
 export interface ILiveQueryRefDef<T> {
   _tag: 'live-ref-def'
   defaultValue: T
@@ -77,6 +74,10 @@ export interface LiveQueryDef<TResult, TQueryInfo extends QueryInfo = QueryInfo.
   queryInfo: TQueryInfo
 }
 
+export namespace LiveQueryDef {
+  export type Any = LiveQueryDef<any, any>
+}
+
 /**
  * A LiveQuery is stateful
  */
@@ -115,6 +116,10 @@ export interface LiveQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo.Non
   executionTimes: number[]
 }
 
+export namespace LiveQuery {
+  export type Any = LiveQuery<any, any>
+}
+
 export abstract class LiveStoreQueryBase<TResult, TQueryInfo extends QueryInfo>
   implements LiveQuery<TResult, TQueryInfo>
 {
@@ -170,7 +175,7 @@ export type GetAtomResult = <T>(
   debugRefreshReason?: RefreshReason | undefined,
 ) => T
 
-export type DependencyQueriesRef = Set<RcRef<LiveQueryAny | ILiveQueryRef<any>>>
+export type DependencyQueriesRef = Set<RcRef<LiveQuery.Any | ILiveQueryRef<any>>>
 
 export const makeGetAtomResult = (
   get: RG.GetAtom,
@@ -201,7 +206,7 @@ export const makeGetAtomResult = (
   return getAtom
 }
 
-export const withRCMap = <T extends LiveQueryAny | ILiveQueryRef<any>>(
+export const withRCMap = <T extends LiveQuery.Any | ILiveQueryRef<any>>(
   id: string,
   make: (ctx: ReactivityGraphContext, otelContext?: otel.Context) => T,
 ): ((ctx: ReactivityGraphContext, otelContext?: otel.Context) => RcRef<T>) => {

package/src/live-queries/computed.ts

@@ -1,10 +1,10 @@
 import type { QueryInfo } from '@livestore/common'
+import { getDurationMsFromSpan } from '@livestore/common'
 import * as otel from '@opentelemetry/api'
 
 import type { Thunk } from '../reactive.js'
 import type { RefreshReason } from '../store/store-types.js'
 import { isValidFunctionString } from '../utils/function-string.js'
-import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { DepKey, GetAtomResult, LiveQueryDef, ReactivityGraph, ReactivityGraphContext } from './base-class.js'
 import { depsToString, LiveStoreQueryBase, makeGetAtomResult, withRCMap } from './base-class.js'
 

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

@@ -1,13 +1,16 @@
+import { sql } from '@livestore/common'
+import { rawSqlMutation } from '@livestore/common/schema'
 import { Effect, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 import { Vitest } from '@livestore/utils/node-vitest'
 import * as otel from '@opentelemetry/api'
 import { BasicTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
 import { expect } from 'vitest'
 
-import { computed, queryDb, rawSqlMutation, sql } from '../index.js'
 import * as RG from '../reactive.js'
 import { makeTodoMvc, tables } from '../utils/tests/fixture.js'
 import { getSimplifiedRootSpan } from '../utils/tests/otel.js'
+import { computed } from './computed.js'
+import { queryDb } from './db-query.js'
 
 /*
 TODO write tests for:

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

@@ -1,5 +1,6 @@
 import type { Bindable, QueryBuilder, QueryInfo } from '@livestore/common'
 import {
+  getDurationMsFromSpan,
   getResultSchema,
   isQueryBuilder,
   prepareBindValues,
@@ -16,7 +17,6 @@ import { isThunk, NOT_REFRESHED_YET } from '../reactive.js'
 import { makeExecBeforeFirstRun, rowQueryLabel } from '../row-query-utils.js'
 import type { RefreshReason } from '../store/store-types.js'
 import { isValidFunctionString } from '../utils/function-string.js'
-import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { DepKey, GetAtomResult, LiveQueryDef, ReactivityGraph, ReactivityGraphContext } from './base-class.js'
 import { depsToString, LiveStoreQueryBase, makeGetAtomResult, withRCMap } from './base-class.js'
 

package/src/live-queries/mod.ts

@@ -0,0 +1,4 @@
+export * from './base-class.js'
+export * from './computed.js'
+export * from './db-query.js'
+export * from './make-ref.js'

package/src/mod.ts

@@ -0,0 +1,37 @@
+export { Store } from './store/store.js'
+export { createStore, createStorePromise, type CreateStoreOptions } from './store/create-store.js'
+export type { QueryDebugInfo, RefreshReason, OtelOptions } from './store/store-types.js'
+
+export { type LiveStoreContext, type ShutdownDeferred, type LiveStoreContextRunning } from './store/store-types.js'
+
+export { SqliteDbWrapper, emptyDebugInfo } from './SqliteDbWrapper.js'
+
+export { deriveColQuery } from './row-query-utils.js'
+
+export { queryDb, computed, makeRef, type LiveQuery, type LiveQueryDef } from './live-queries/mod.js'
+
+export * from '@livestore/common/schema'
+export {
+  sql,
+  SessionIdSymbol,
+  type BootStatus,
+  type SqliteDb,
+  type DebugInfo,
+  type MutableDebugInfo,
+  prepareBindValues,
+  type Bindable,
+  type PreparedBindValues,
+  type QueryBuilderAst,
+  type QueryBuilder,
+  type RowQuery,
+  StoreInterrupted,
+  IntentionalShutdownCause,
+  provideOtel,
+} from '@livestore/common'
+
+export { deepEqual } from '@livestore/utils'
+export { nanoid } from '@livestore/utils/nanoid'
+
+export * from './utils/stack-info.js'
+
+export type { ClientSession, Adapter, PreparedStatement } from '@livestore/common'

package/src/store/create-store.ts

@@ -11,6 +11,7 @@ import type { EventId, LiveStoreSchema, MutationEvent } from '@livestore/common/
 import { LS_DEV } from '@livestore/utils'
 import type { Cause } from '@livestore/utils/effect'
 import {
+  Context,
   Deferred,
   Effect,
   Exit,
@@ -28,22 +29,63 @@ import {
 import { nanoid } from '@livestore/utils/nanoid'
 import * as otel from '@opentelemetry/api'
 
-import { LiveStoreContextRunning } from '../effect/index.js'
 import { connectDevtoolsToStore } from './devtools.js'
 import { Store } from './store.js'
-import type { BaseGraphQLContext, GraphQLOptions, OtelOptions, ShutdownDeferred } from './store-types.js'
+import type {
+  LiveStoreContextRunning as LiveStoreContextRunning_,
+  OtelOptions,
+  ShutdownDeferred,
+} from './store-types.js'
 
 export const DEFAULT_PARAMS = {
   leaderPushBatchSize: 1,
 }
 
-export interface CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema> {
+export class LiveStoreContextRunning extends Context.Tag('@livestore/livestore/effect/LiveStoreContextRunning')<
+  LiveStoreContextRunning,
+  LiveStoreContextRunning_
+>() {
+  static fromDeferred = Effect.gen(function* () {
+    const deferred = yield* DeferredStoreContext
+    const ctx = yield* deferred
+    return Layer.succeed(LiveStoreContextRunning, ctx)
+  }).pipe(Layer.unwrapScoped)
+}
+
+export class DeferredStoreContext extends Context.Tag('@livestore/livestore/effect/DeferredStoreContext')<
+  DeferredStoreContext,
+  Deferred.Deferred<LiveStoreContextRunning['Type'], UnexpectedError>
+>() {}
+
+export type LiveStoreContextProps<TSchema extends LiveStoreSchema, TContext = {}> = {
+  schema: TSchema
+  /**
+   * The `storeId` can be used to isolate multiple stores from each other.
+   * So it can be useful for multi-tenancy scenarios.
+   *
+   * The `storeId` is also used for persistence.
+   *
+   * @default 'default'
+   */
+  storeId?: string
+  /** Can be useful for custom live query implementations (e.g. see `@livestore/graphql`) */
+  context?: TContext
+  boot?: (
+    store: Store<TSchema, TContext>,
+  ) => Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
+  adapter: Adapter
+  disableDevtools?: boolean
+  onBootStatus?: (status: BootStatus) => void
+  batchUpdates: (run: () => void) => void
+}
+
+export interface CreateStoreOptions<TSchema extends LiveStoreSchema, TContext = {}> {
   schema: TSchema
   adapter: Adapter
   storeId: string
-  graphQLOptions?: GraphQLOptions<TGraphQLContext>
+  context?: TContext
   boot?: (
-    store: Store<TGraphQLContext, TSchema>,
+    store: Store<TSchema, TContext>,
     ctx: {
       migrationsReport: MigrationsReport
       parentSpan: otel.Span
@@ -62,17 +104,14 @@ export interface CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext,
 }
 
 /** Create a new LiveStore Store */
-export const createStorePromise = async <
-  TGraphQLContext extends BaseGraphQLContext,
-  TSchema extends LiveStoreSchema = LiveStoreSchema,
->({
+export const createStorePromise = async <TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}>({
   signal,
   otelOptions,
   ...options
-}: CreateStoreOptions<TGraphQLContext, TSchema> & {
+}: CreateStoreOptions<TSchema, TContext> & {
   signal?: AbortSignal
   otelOptions?: Partial<OtelOptions>
-}): Promise<Store<TGraphQLContext, TSchema>> =>
+}): Promise<Store<TSchema, TContext>> =>
   Effect.gen(function* () {
     const scope = yield* Scope.make()
     const runtime = yield* Effect.runtime()
@@ -96,14 +135,11 @@ export const createStorePromise = async <
     Effect.runPromise,
   )
 
-export const createStore = <
-  TGraphQLContext extends BaseGraphQLContext,
-  TSchema extends LiveStoreSchema = LiveStoreSchema,
->({
+export const createStore = <TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}>({
   schema,
   adapter,
   storeId,
-  graphQLOptions,
+  context = {} as TContext,
   boot,
   batchUpdates,
   disableDevtools,
@@ -111,8 +147,8 @@ export const createStore = <
   shutdownDeferred,
   params,
   debug,
-}: CreateStoreOptions<TGraphQLContext, TSchema>): Effect.Effect<
-  Store<TGraphQLContext, TSchema>,
+}: CreateStoreOptions<TSchema, TContext>): Effect.Effect<
+  Store<TSchema, TContext>,
   UnexpectedError,
   Scope.Scope | OtelTracer.OtelTracer
 > =>
@@ -199,10 +235,10 @@ export const createStore = <
       // TODO fill up with unsynced mutation events from the client session
       const unsyncedMutationEvents = MutableHashMap.empty<EventId.EventId, MutationEvent.ForSchema<TSchema>>()
 
-      const store = new Store<TGraphQLContext, TSchema>({
+      const store = new Store<TSchema, TContext>({
         clientSession,
         schema,
-        graphQLOptions,
+        context,
         otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
         disableDevtools,
         unsyncedMutationEvents,

package/src/store/store-types.ts

@@ -1,12 +1,9 @@
-import type { ClientSession, IntentionalShutdownCause, UnexpectedError } from '@livestore/common'
+import type { ClientSession, IntentionalShutdownCause, StoreInterrupted, UnexpectedError } from '@livestore/common'
 import type { EventId, LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
 import type { Deferred, MutableHashMap, Runtime, Scope } from '@livestore/utils/effect'
-import { Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
-import type { GraphQLSchema } from 'graphql'
 
 import type { DebugRefreshReasonBase } from '../reactive.js'
-import type { SqliteDbWrapper } from '../SqliteDbWrapper.js'
 import type { StackInfo } from '../utils/stack-info.js'
 import type { Store } from './store.js'
 
@@ -18,47 +15,26 @@ export type LiveStoreContext =
     }
   | {
       stage: 'shutdown'
-      cause: IntentionalShutdownCause | StoreAbort
+      cause: IntentionalShutdownCause | StoreInterrupted
     }
 
-export class StoreAbort extends Schema.TaggedError<StoreAbort>()('LiveStore.StoreAbort', {}) {}
-export class StoreInterrupted extends Schema.TaggedError<StoreInterrupted>()('LiveStore.StoreInterrupted', {}) {}
-
-export type ShutdownDeferred = Deferred.Deferred<
-  void,
-  UnexpectedError | IntentionalShutdownCause | StoreInterrupted | StoreAbort
->
+export type ShutdownDeferred = Deferred.Deferred<void, UnexpectedError | IntentionalShutdownCause | StoreInterrupted>
 
 export type LiveStoreContextRunning = {
   stage: 'running'
   store: Store
 }
 
-export type BaseGraphQLContext = {
-  queriedTables: Set<string>
-  /** Needed by Pothos Otel plugin for resolver tracing to work */
-  otelContext?: otel.Context
-}
-
-export type GraphQLOptions<TContext> = {
-  schema: GraphQLSchema
-  makeContext: (db: SqliteDbWrapper, tracer: otel.Tracer, sessionId: string) => TContext
-}
-
 export type OtelOptions = {
   tracer: otel.Tracer
   rootSpanContext: otel.Context
 }
 
-export type StoreOptions<
-  TGraphQLContext extends BaseGraphQLContext,
-  TSchema extends LiveStoreSchema = LiveStoreSchema,
-> = {
+export type StoreOptions<TSchema extends LiveStoreSchema = LiveStoreSchema, TContext = {}> = {
   clientSession: ClientSession
   schema: TSchema
   storeId: string
-  // TODO remove graphql-related stuff from store and move to GraphQL query directly
-  graphQLOptions?: GraphQLOptions<TGraphQLContext>
+  context: TContext
   otelOptions: OtelOptions
   disableDevtools?: boolean
   lifetimeScope: Scope.Scope
@@ -93,7 +69,7 @@ export type RefreshReason =
   | { _tag: 'manual'; label?: string }
 
 export type QueryDebugInfo = {
-  _tag: 'graphql' | 'db' | 'computed' | 'unknown'
+  _tag: string
   label: string
   query: string
   durationMs: number