@livestore/livestore 0.0.54 → 0.0.55-dev.0

package/src/effect/LiveStore.ts

@@ -1,7 +1,7 @@
-import type { BootDb, StoreAdapterFactory, UnexpectedError } from '@livestore/common'
+import type { BootDb, BootStatus, StoreAdapterFactory, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
-import type { Cause } from '@livestore/utils/effect'
-import { Context, Deferred, Duration, Effect, Layer, OtelTracer, pipe, Runtime, Scope } from '@livestore/utils/effect'
+import type { Cause, Scope } from '@livestore/utils/effect'
+import { Context, Deferred, Duration, Effect, FiberSet, Layer, OtelTracer, pipe } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
@@ -32,7 +32,7 @@ export type LiveStoreCreateStoreOptions<GraphQLContext extends BaseGraphQLContex
   schema: LiveStoreSchema
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelOptions?: OtelOptions
-  boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
+  boot?: (db: BootDb, parentSpan: otel.Span) => void | Promise<void> | Effect.Effect<void, unknown, otel.Tracer>
   adapter: StoreAdapterFactory
   batchUpdates?: (run: () => void) => void
   disableDevtools?: boolean
@@ -43,7 +43,7 @@ export const LiveStoreContextRunning = Context.GenericTag<LiveStoreContextRunnin
   '@livestore/livestore/effect/LiveStoreContextRunning',
 )
 
-export type DeferredStoreContext = Deferred.Deferred<LiveStoreContextRunning>
+export type DeferredStoreContext = Deferred.Deferred<LiveStoreContextRunning, UnexpectedError>
 export const DeferredStoreContext = Context.GenericTag<DeferredStoreContext>(
   '@livestore/livestore/effect/DeferredStoreContext',
 )
@@ -56,9 +56,10 @@ export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
     schema: Effect.Effect<GraphQLSchema, never, otel.Tracer>
     makeContext: (db: MainDatabaseWrapper) => GraphQLContext
   }
-  boot?: (db: BootDb) => Effect.Effect<void>
+  boot?: (db: BootDb) => Effect.Effect<void, unknown, otel.Tracer>
   adapter: StoreAdapterFactory
   disableDevtools?: boolean
+  onBootStatus?: (status: BootStatus) => void
 }
 
 export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>(
@@ -69,14 +70,18 @@ export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>
     Layer.provide(LiveStoreContextDeferred),
   )
 
-export const LiveStoreContextDeferred = Layer.effect(DeferredStoreContext, Deferred.make<LiveStoreContextRunning>())
+export const LiveStoreContextDeferred = Layer.effect(
+  DeferredStoreContext,
+  Deferred.make<LiveStoreContextRunning, UnexpectedError>(),
+)
 
 export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>({
   schema,
   graphQLOptions: graphQLOptions_,
-  boot: boot_,
+  boot,
   adapter,
   disableDevtools,
+  onBootStatus,
 }: LiveStoreContextProps<GraphQLContext>): Effect.Effect<
   LiveStoreContextRunning,
   UnexpectedError | Cause.TimeoutException,
@@ -84,23 +89,16 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
 > =>
   pipe(
     Effect.gen(function* () {
-      const runtime = yield* Effect.runtime<never>()
-
       const otelRootSpanContext = otel.context.active()
 
-      const storeScope = yield* Scope.make()
-
-      yield* Effect.addFinalizer((ex) => Scope.close(storeScope, ex))
-
       const otelTracer = yield* OtelTracer.Tracer
 
       const graphQLOptions = yield* graphQLOptions_
         ? Effect.all({ schema: graphQLOptions_.schema, makeContext: Effect.succeed(graphQLOptions_.makeContext) })
         : Effect.succeed(undefined)
 
-      const boot = boot_
-        ? (db: BootDb) => boot_(db).pipe(Effect.withSpan('boot'), Effect.tapCauseLogPretty, Runtime.runPromise(runtime))
-        : undefined
+      // TODO join fiber set and close tear down parent scope in case of error (Needs refactor with Mike A)
+      const fiberSet = yield* FiberSet.make()
 
       const store = yield* createStore({
         schema,
@@ -112,14 +110,18 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
         boot,
         adapter,
         disableDevtools,
-        storeScope,
+        fiberSet,
+        onBootStatus,
       })
 
       window.__debugLiveStore = store
 
       return { stage: 'running', store } satisfies LiveStoreContextRunning
     }),
+    Effect.tapErrorCause((cause) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.failCause(def, cause))),
     Effect.tap((storeCtx) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.succeed(def, storeCtx))),
-    Effect.timeout(Duration.seconds(60)),
+    // This can take quite a while.
+    // TODO make this configurable
+    Effect.timeout(Duration.minutes(5)),
     Effect.withSpan('@livestore/livestore/effect:makeLiveStoreContext'),
   )

package/src/react/LiveStoreProvider.tsx

@@ -1,7 +1,7 @@
 import { type BootDb, type BootStatus, type StoreAdapterFactory, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
 import { errorToString } from '@livestore/utils'
-import { Effect, Exit, Logger, LogLevel, Schema, Scope } from '@livestore/utils/effect'
+import { Effect, Exit, FiberSet, Logger, LogLevel, Schema, Scope } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type { ReactElement, ReactNode } from 'react'
 import React from 'react'
@@ -14,7 +14,7 @@ import { LiveStoreContext } from './LiveStoreContext.js'
 
 interface LiveStoreProviderProps<GraphQLContext> {
   schema: LiveStoreSchema
-  boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
+  boot?: (db: BootDb, parentSpan: otel.Span) => void | Promise<void> | Effect.Effect<void, unknown, otel.Tracer>
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelOptions?: OtelOptions
   renderLoading: (status: BootStatus) => ReactElement
@@ -153,20 +153,23 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
       }
     })
 
-    createStore({
-      storeScope,
-      schema,
-      graphQLOptions,
-      otelOptions,
-      boot,
-      adapter,
-      batchUpdates,
-      disableDevtools,
-      onBootStatus: (status) => {
-        if (ctxValueRef.current.value.stage === 'running' || ctxValueRef.current.value.stage === 'error') return
-        setContextValue(status)
-      },
-    }).pipe(
+    FiberSet.make().pipe(
+      Effect.andThen((fiberSet) =>
+        createStore({
+          fiberSet,
+          schema,
+          graphQLOptions,
+          otelOptions,
+          boot,
+          adapter,
+          batchUpdates,
+          disableDevtools,
+          onBootStatus: (status) => {
+            if (ctxValueRef.current.value.stage === 'running' || ctxValueRef.current.value.stage === 'error') return
+            setContextValue(status)
+          },
+        }),
+      ),
       Effect.tapSync((store) => setContextValue({ stage: 'running', store })),
       Effect.tapError((error) => Effect.sync(() => setContextValue({ stage: 'error', error }))),
       Effect.tapDefect((defect) => Effect.sync(() => setContextValue({ stage: 'error', error: defect }))),

package/src/store.ts

@@ -17,11 +17,13 @@ import {
 } from '@livestore/common'
 import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
 import { makeMutationEventSchemaMemo } from '@livestore/common/schema'
-import { assertNever, isPromise, makeNoopTracer, shouldNeverHappen, throttle } from '@livestore/utils'
+import { assertNever, makeNoopTracer, shouldNeverHappen, throttle } from '@livestore/utils'
 import { cuid } from '@livestore/utils/cuid'
 import {
   Effect,
   Exit,
+  FiberSet,
+  Inspectable,
   Layer,
   Logger,
   LogLevel,
@@ -71,7 +73,7 @@ export type StoreOptions<
   otelOptions: OtelOptions
   reactivityGraph: ReactivityGraph
   disableDevtools?: boolean
-  storeScope: Scope.CloseableScope
+  fiberSet: FiberSet.FiberSet
   // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
   __processedMutationIds: Set<string>
 }
@@ -126,10 +128,10 @@ export type StoreMutateOptions = {
 export class Store<
   TGraphQLContext extends BaseGraphQLContext = BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
-> {
+> extends Inspectable.Class {
   id = uniqueStoreId()
   readonly devtoolsConnectionId = cuid()
-  private storeScope: Scope.CloseableScope
+  private fiberSet: FiberSet.FiberSet
   reactivityGraph: ReactivityGraph
   mainDbWrapper: MainDatabaseWrapper
   adapter: StoreAdapter
@@ -160,13 +162,15 @@ export class Store<
     otelOptions,
     disableDevtools,
     __processedMutationIds,
-    storeScope,
+    fiberSet,
   }: StoreOptions<TGraphQLContext, TSchema>) {
+    super()
+
     this.mainDbWrapper = new MainDatabaseWrapper({ otel: otelOptions, db: adapter.mainDb })
     this.adapter = adapter
     this.schema = schema
 
-    this.storeScope = storeScope
+    this.fiberSet = fiberSet
 
     // TODO refactor
     this.__mutationEventSchema = makeMutationEventSchemaMemo(schema)
@@ -239,7 +243,9 @@ export class Store<
           otel.trace.getSpan(this.otel.queriesSpanContext)!.end()
         }),
       )
-    }).pipe(Scope.extend(storeScope), Effect.forkIn(storeScope), Effect.scoped, runEffectFork)
+
+      yield* Effect.never
+    }).pipe(Effect.scoped, Effect.withSpan('LiveStore:store-constructor'), FiberSet.run(fiberSet), runEffectFork)
   }
 
   static createStore = <TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema = LiveStoreSchema>(
@@ -305,7 +311,7 @@ export class Store<
    * Currently only used when shutting down the app for debugging purposes (e.g. to close Otel spans).
    */
   destroy = async () => {
-    await Scope.close(this.storeScope, Exit.void).pipe(Effect.withSpan('Store:destroy'), runEffectPromise)
+    await FiberSet.clear(this.fiberSet).pipe(Effect.withSpan('Store:destroy'), runEffectPromise)
   }
 
   mutate: {
@@ -571,6 +577,7 @@ export class Store<
       meta: { liveStoreRefType: 'table' },
     })
 
+  // #region devtools
   // TODO shutdown behaviour
   private bootDevtools = () =>
     Effect.gen(this, function* () {
@@ -584,6 +591,8 @@ export class Store<
 
       const channelId = this.adapter.coordinator.devtools.channelId
 
+      const runtime = yield* Effect.runtime()
+
       window.addEventListener('message', (event) => {
         const decodedMessageRes = Schema.decodeOption(Devtools.DevtoolsWindowMessage.MessageForStore)(event.data)
         if (decodedMessageRes._tag === 'None') return
@@ -773,7 +782,7 @@ export class Store<
 
                 storeMessagePort.start()
               }),
-              runEffectFork,
+              Runtime.runFork(runtime),
             )
 
           return
@@ -782,6 +791,7 @@ export class Store<
 
       sendToDevtoolsContentscript(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }))
     })
+  // #endregion devtools
 
   __devDownloadDb = () => {
     const data = this.mainDbWrapper.export()
@@ -795,6 +805,13 @@ export class Store<
 
   // 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).pipe(runEffectPromise)
+
+  toJSON = () => {
+    return {
+      _tag: 'Store',
+      reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults: true }),
+    }
+  }
 }
 
 export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSchema extends LiveStoreSchema> = {
@@ -803,7 +820,7 @@ export type CreateStoreOptions<TGraphQLContext extends BaseGraphQLContext, TSche
   reactivityGraph?: ReactivityGraph
   graphQLOptions?: GraphQLOptions<TGraphQLContext>
   otelOptions?: Partial<OtelOptions>
-  boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
+  boot?: (db: BootDb, parentSpan: otel.Span) => void | Promise<void> | Effect.Effect<void, unknown, otel.Tracer>
   batchUpdates?: (run: () => void) => void
   disableDevtools?: boolean
   onBootStatus?: (status: BootStatus) => void
@@ -827,9 +844,13 @@ export const createStorePromise = async <
       })
     }
 
-    return yield* createStore({ ...options, storeScope: scope }).pipe(Scope.extend(scope))
+    return yield* FiberSet.make().pipe(
+      Effect.andThen((fiberSet) => createStore({ ...options, fiberSet })),
+      Scope.extend(scope),
+    )
   }).pipe(Effect.withSpan('createStore'), runEffectPromise)
 
+// #region createStore
 export const createStore = <
   TGraphQLContext extends BaseGraphQLContext,
   TSchema extends LiveStoreSchema = LiveStoreSchema,
@@ -843,8 +864,8 @@ export const createStore = <
   batchUpdates,
   disableDevtools,
   onBootStatus,
-  storeScope,
-}: CreateStoreOptions<TGraphQLContext, TSchema> & { storeScope: Scope.CloseableScope }): Effect.Effect<
+  fiberSet,
+}: CreateStoreOptions<TGraphQLContext, TSchema> & { fiberSet: FiberSet.FiberSet }): Effect.Effect<
   Store<TGraphQLContext, TSchema>,
   UnexpectedError,
   Scope.Scope
@@ -859,7 +880,7 @@ export const createStore = <
   return Effect.gen(function* () {
     const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie)
 
-    const bootStatusQueue = yield* Queue.unbounded<BootStatus>()
+    const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
 
     yield* Queue.take(bootStatusQueue).pipe(
       Effect.tapSync((status) => onBootStatus?.(status)),
@@ -872,7 +893,12 @@ export const createStore = <
       schema,
       devtoolsEnabled: disableDevtools !== true,
       bootStatusQueue,
-      shutdown: (cause) => Scope.close(storeScope, Exit.failCause(cause)),
+      shutdown: (cause) =>
+        Effect.gen(function* () {
+          yield* Effect.logWarning(`Shutting down LiveStore`, cause)
+          // TODO close parent scope? (Needs refactor with Mike A)
+          yield* FiberSet.clear(fiberSet)
+        }).pipe(Effect.withSpan('livestore:shutdown')),
     }).pipe(Effect.withPerformanceMeasure('livestore:makeAdapter'), Effect.withSpan('createStore:makeAdapter'))
 
     if (batchUpdates !== undefined) {
@@ -950,19 +976,12 @@ export const createStore = <
         },
       }
 
-      const booting = yield* Effect.try({
-        try: () => boot(bootDbImpl, span),
-        catch: (cause) => new UnexpectedError({ cause }),
-      })
-      // NOTE only awaiting if it's actually a promise to avoid unnecessary async/await
-      if (isPromise(booting)) {
-        yield* Effect.tryPromise({ try: () => booting, catch: (cause) => new UnexpectedError({ cause }) })
-      }
+      yield* Effect.tryAll(() => boot(bootDbImpl, span)).pipe(
+        UnexpectedError.mapToUnexpectedError,
+        Effect.withSpan('createStore:boot'),
+      )
     }
 
-    // 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,
@@ -972,12 +991,11 @@ export const createStore = <
         reactivityGraph,
         disableDevtools,
         __processedMutationIds,
-        storeScope,
+        fiberSet,
       },
       span,
     )
   }).pipe(
-    // Effect.scoped,
     Effect.withSpan('createStore', {
       parent: otelOptions?.rootSpanContext
         ? OtelTracer.makeExternalSpan(otel.trace.getSpanContext(otelOptions.rootSpanContext)!)
@@ -986,6 +1004,7 @@ export const createStore = <
     Effect.provide(TracingLive),
   )
 }
+// #endregion createStore
 
 // TODO consider replacing with Effect's RC data structures
 class ReferenceCountedSet<T> {