@livestore/livestore 0.3.0-dev.11 → 0.3.0-dev.5

package/src/row-query-utils.ts

@@ -4,33 +4,28 @@ import { DbSchema } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 
-import type { GetResult, LiveQueryDef, ReactivityGraphContext } from './live-queries/base-class.js'
+import type { LiveQuery, LiveQueryAny, QueryContext } from './live-queries/base-class.js'
 import { computed } from './live-queries/computed.js'
 
 export const rowQueryLabel = (table: DbSchema.TableDefBase, id: string | SessionIdSymbol | undefined) =>
   `row:${table.sqliteDef.name}${id === undefined ? '' : id === SessionIdSymbol ? `:sessionId` : `:${id}`}`
 
 export const deriveColQuery: {
-  <TQueryDef extends LiveQueryDef<any, QueryInfo.None>, TCol extends keyof GetResult<TQueryDef> & string>(
-    queryDef: TQueryDef,
+  <TQuery extends LiveQuery<any, QueryInfo.None>, TCol extends keyof TQuery['__result!'] & string>(
+    query$: TQuery,
     colName: TCol,
-  ): LiveQueryDef<GetResult<TQueryDef>[TCol], QueryInfo.None>
-  <TQueryDef extends LiveQueryDef<any, QueryInfo.Row>, TCol extends keyof GetResult<TQueryDef> & string>(
-    queryDef: TQueryDef,
+  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.None>
+  <TQuery extends LiveQuery<any, QueryInfo.Row>, TCol extends keyof TQuery['__result!'] & string>(
+    query$: TQuery,
     colName: TCol,
-  ): LiveQueryDef<GetResult<TQueryDef>[TCol], QueryInfo.Col>
-} = (queryDef: LiveQueryDef<any, QueryInfo.Row | QueryInfo.Col>, colName: string) => {
-  return computed((get) => get(queryDef)[colName], {
-    label: `deriveColQuery:${queryDef.label}:${colName}`,
+  ): LiveQuery<TQuery['__result!'][TCol], QueryInfo.Col>
+} = (query$: LiveQueryAny, colName: string) => {
+  return computed((get) => get(query$)[colName], {
+    label: `deriveColQuery:${query$.label}:${colName}`,
     queryInfo:
-      queryDef.queryInfo._tag === 'Row'
-        ? { _tag: 'Col', table: queryDef.queryInfo.table, column: colName, id: queryDef.queryInfo.id }
+      query$.queryInfo._tag === 'Row'
+        ? { _tag: 'Col', table: query$.queryInfo.table, column: colName, id: query$.queryInfo.id }
         : undefined,
-    deps: [
-      queryDef.queryInfo.table.sqliteDef.name,
-      queryDef.queryInfo.id === SessionIdSymbol ? 'sessionId' : queryDef.queryInfo.id,
-      queryDef.queryInfo._tag === 'Col' ? queryDef.queryInfo.column : undefined,
-    ],
   }) as any
 }
 
@@ -46,17 +41,15 @@ export const makeExecBeforeFirstRun =
     table: DbSchema.TableDefBase
     otelContext: otel.Context | undefined
   }) =>
-  ({ store }: ReactivityGraphContext) => {
+  ({ store }: QueryContext) => {
     const otelContext = otelContext_ ?? store.otel.queriesSpanContext
 
     if (table.options.isSingleton === false) {
       const idStr = id === SessionIdSymbol ? store.sessionId : id!
       const rowExists =
-        store.sqliteDbWrapper.select(
-          `SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`,
-          [idStr] as any as PreparedBindValues,
-          { otelContext },
-        ).length === 1
+        store.syncDbWrapper.select(`SELECT 1 FROM '${table.sqliteDef.name}' WHERE id = ?`, {
+          bindValues: [idStr] as any as PreparedBindValues,
+        }).length === 1
 
       if (rowExists) return
 
@@ -66,11 +59,7 @@ export const makeExecBeforeFirstRun =
         )
       }
 
-      // It's important that we only mutate and don't refresh here, as this function might be called during a render
-      // and otherwise we might end up in a "reactive loop"
-      store.mutate(
-        { otelContext, skipRefresh: true, label: `rowQuery:${table.sqliteDef.name}:${idStr}` },
-        table.insert({ id, ...insertValues }),
-      )
+      // NOTE It's important that we only mutate and don't refresh here, as this function is called during a render
+      store.mutate({ otelContext, skipRefresh: true }, table.insert({ id, ...insertValues }))
     }
   }

package/src/store/create-store.ts

@@ -14,7 +14,6 @@ import {
   Effect,
   Exit,
   identity,
-  Layer,
   Logger,
   LogLevel,
   MutableHashMap,
@@ -27,7 +26,8 @@ import {
 import { nanoid } from '@livestore/utils/nanoid'
 import * as otel from '@opentelemetry/api'
 
-import { LiveStoreContextRunning } from '../effect/index.js'
+import { globalReactivityGraph } from '../global-state.js'
+import type { ReactivityGraph } from '../live-queries/base-class.js'
 import { connectDevtoolsToStore } from './devtools.js'
 import { Store } from './store.js'
 import type { BaseGraphQLContext, GraphQLOptions, OtelOptions, ShutdownDeferred } from './store-types.js'
@@ -36,11 +36,12 @@ export interface CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext,
   schema: TSchema
   adapter: Adapter
   storeId: string
+  reactivityGraph?: ReactivityGraph
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   boot?: (
     store: Store<TGraphQLContext, TSchema>,
     parentSpan: otel.Span,
-  ) => void | Promise<void> | Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
+  ) => void | Promise<void> | Effect.Effect<void, unknown, OtelTracer.OtelTracer>
   batchUpdates?: (run: () => void) => void
   disableDevtools?: boolean
   onBootStatus?: (status: BootStatus) => void
@@ -94,6 +95,7 @@ export const createStore = <
   storeId,
   graphQLOptions,
   boot,
+  reactivityGraph = globalReactivityGraph,
   batchUpdates,
   disableDevtools,
   onBootStatus,
@@ -161,28 +163,29 @@ 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>({
-        clientSession,
-        schema,
-        graphQLOptions,
-        otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
-        disableDevtools,
-        unsyncedMutationEvents,
-        lifetimeScope,
-        runtime,
-        // NOTE during boot we're not yet executing mutations in a batched context
-        // but only set the provided `batchUpdates` function after boot
-        batchUpdates: (run) => run(),
-        storeId,
-      })
-
-      yield* store.boot
+      const store = Store.createStore<TGraphQLContext, TSchema>(
+        {
+          clientSession,
+          schema,
+          graphQLOptions,
+          otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
+          reactivityGraph,
+          disableDevtools,
+          unsyncedMutationEvents,
+          lifetimeScope,
+          runtime,
+          // NOTE during boot we're not yet executing mutations in a batched context
+          // but only set the provided `batchUpdates` function after boot
+          batchUpdates: (run) => run(),
+          storeId,
+        },
+        span,
+      )
 
       if (boot !== undefined) {
         // TODO also incorporate `boot` function progress into `bootStatusQueue`
         yield* Effect.tryAll(() => boot(store, span)).pipe(
           UnexpectedError.mapToUnexpectedError,
-          Effect.provide(Layer.succeed(LiveStoreContextRunning, { stage: 'running', store: store as any as Store })),
           Effect.withSpan('createStore:boot'),
         )
       }

package/src/store/devtools.ts

@@ -6,14 +6,14 @@ import { Effect, Stream } from '@livestore/utils/effect'
 
 import type { LiveQuery, ReactivityGraph } from '../live-queries/base-class.js'
 import { NOT_REFRESHED_YET } from '../reactive.js'
-import type { SqliteDbWrapper } from '../SqliteDbWrapper.js'
-import { emptyDebugInfo as makeEmptyDebugInfo } from '../SqliteDbWrapper.js'
+import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
+import { emptyDebugInfo as makeEmptyDebugInfo } from '../SynchronousDatabaseWrapper.js'
 import type { ReferenceCountedSet } from '../utils/data-structures.js'
 
 type IStore = {
   clientSession: ClientSession
   reactivityGraph: ReactivityGraph
-  sqliteDbWrapper: SqliteDbWrapper
+  syncDbWrapper: SynchronousDatabaseWrapper
   activeQueries: ReferenceCountedSet<LiveQuery<any>>
 }
 
@@ -73,7 +73,7 @@ export const connectDevtoolsToStore = ({
       const requestIdleCallback = globalThis.requestIdleCallback ?? ((cb: () => void) => cb())
 
       switch (decodedMessage._tag) {
-        case 'LSD.ClientSession.ReactivityGraphSubscribe': {
+        case 'LSD.ReactivityGraphSubscribe': {
           const includeResults = decodedMessage.includeResults
 
           const send = () =>
@@ -104,10 +104,10 @@ export const connectDevtoolsToStore = ({
 
           break
         }
-        case 'LSD.ClientSession.DebugInfoReq': {
+        case 'LSD.DebugInfoReq': {
           sendToDevtools(
             Devtools.DebugInfoRes.make({
-              debugInfo: store.sqliteDbWrapper.debugInfo,
+              debugInfo: store.syncDbWrapper.debugInfo,
               requestId,
               clientId,
               sessionId,
@@ -116,19 +116,19 @@ export const connectDevtoolsToStore = ({
           )
           break
         }
-        case 'LSD.ClientSession.DebugInfoHistorySubscribe': {
+        case 'LSD.DebugInfoHistorySubscribe': {
           const buffer: DebugInfo[] = []
           let hasStopped = false
           let tickHandle: number | undefined
 
           const tick = () => {
-            buffer.push(store.sqliteDbWrapper.debugInfo)
+            buffer.push(store.syncDbWrapper.debugInfo)
 
             // NOTE this resets the debug info, so all other "readers" e.g. in other `requestAnimationFrame` loops,
             // will get the empty debug info
             // TODO We need to come up with a more graceful way to do store. Probably via a single global
             // `requestAnimationFrame` loop that is passed in somehow.
-            store.sqliteDbWrapper.debugInfo = makeEmptyDebugInfo()
+            store.syncDbWrapper.debugInfo = makeEmptyDebugInfo()
 
             if (buffer.length > 10) {
               sendToDevtools(
@@ -162,31 +162,31 @@ export const connectDevtoolsToStore = ({
 
           break
         }
-        case 'LSD.ClientSession.DebugInfoHistoryUnsubscribe': {
+        case 'LSD.DebugInfoHistoryUnsubscribe': {
           // NOTE given WebMesh channels have persistent retry behaviour, it can happen that a previous
           // WebMesh channel will send a unsubscribe message for an old requestId. Thus the `?.()` handling.
           debugInfoHistorySubscriptions.get(requestId)?.()
           debugInfoHistorySubscriptions.delete(requestId)
           break
         }
-        case 'LSD.ClientSession.DebugInfoResetReq': {
-          store.sqliteDbWrapper.debugInfo.slowQueries.clear()
+        case 'LSD.DebugInfoResetReq': {
+          store.syncDbWrapper.debugInfo.slowQueries.clear()
           sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, clientId, sessionId, liveStoreVersion }))
           break
         }
-        case 'LSD.ClientSession.DebugInfoRerunQueryReq': {
+        case 'LSD.DebugInfoRerunQueryReq': {
           const { queryStr, bindValues, queriedTables } = decodedMessage
-          store.sqliteDbWrapper.select(queryStr, bindValues, { queriedTables, skipCache: true })
+          store.syncDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true })
           sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, clientId, sessionId, liveStoreVersion }))
           break
         }
-        case 'LSD.ClientSession.ReactivityGraphUnsubscribe': {
+        case 'LSD.ReactivityGraphUnsubscribe': {
           // NOTE given WebMesh channels have persistent retry behaviour, it can happen that a previous
           // WebMesh channel will send a unsubscribe message for an old requestId. Thus the `?.()` handling.
           reactivityGraphSubcriptions.get(requestId)?.()
           break
         }
-        case 'LSD.ClientSession.LiveQueriesSubscribe': {
+        case 'LSD.LiveQueriesSubscribe': {
           const send = () =>
             requestIdleCallback(
               () =>
@@ -222,7 +222,7 @@ export const connectDevtoolsToStore = ({
 
           break
         }
-        case 'LSD.ClientSession.LiveQueriesUnsubscribe': {
+        case 'LSD.LiveQueriesUnsubscribe': {
           // NOTE given WebMesh channels have persistent retry behaviour, it can happen that a previous
           // WebMesh channel will send a unsubscribe message for an old requestId. Thus the `?.()` handling.
           liveQueriesSubscriptions.get(requestId)?.()

package/src/store/store-types.ts

@@ -5,8 +5,9 @@ import { Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
+import type { ReactivityGraph } from '../live-queries/base-class.js'
 import type { DebugRefreshReasonBase } from '../reactive.js'
-import type { SqliteDbWrapper } from '../SqliteDbWrapper.js'
+import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
 import type { StackInfo } from '../utils/stack-info.js'
 import type { Store } from './store.js'
 
@@ -42,7 +43,7 @@ export type BaseGraphQLContext = {
 
 export type GraphQLOptions<TContext> = {
   schema: GraphQLSchema
-  makeContext: (db: SqliteDbWrapper, tracer: otel.Tracer, sessionId: string) => TContext
+  makeContext: (db: SynchronousDatabaseWrapper, tracer: otel.Tracer, sessionId: string) => TContext
 }
 
 export type OtelOptions = {
@@ -60,6 +61,7 @@ export type StoreOptions<
   // TODO remove graphql-related stuff from store and move to GraphQL query directly
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   otelOptions: OtelOptions
+  reactivityGraph: ReactivityGraph
   disableDevtools?: boolean
   lifetimeScope: Scope.Scope
   runtime: Runtime.Runtime<Scope.Scope>
@@ -73,7 +75,7 @@ export type RefreshReason =
   | {
       _tag: 'mutate'
       /** The mutations that were applied */
-      mutations: ReadonlyArray<MutationEvent.AnyDecoded | MutationEvent.PartialAnyDecoded>
+      mutations: ReadonlyArray<MutationEvent.AnyDecoded | MutationEvent.PartialAny>
 
       /** The tables that were written to by the event */
       writeTables: ReadonlyArray<string>
@@ -85,8 +87,6 @@ export type RefreshReason =
       label?: string
       stackInfo?: StackInfo
     }
-  | { _tag: 'subscribe.initial'; label?: string }
-  | { _tag: 'subscribe.update'; label?: string }
   | { _tag: 'manual'; label?: string }
 
 export type QueryDebugInfo = {
@@ -108,5 +108,3 @@ export type StoreMutateOptions = {
   spanLinks?: otel.Link[]
   otelContext?: otel.Context
 }
-
-export type Unsubscribe = () => void