@livestore/livestore 0.4.0 → 0.5.0-dev.0

package/src/effect/LiveStore.ts

@@ -1,15 +1,29 @@
 import type { UnknownError } from '@livestore/common'
 import type { LiveStoreEvent, LiveStoreSchema } from '@livestore/common/schema'
 import { omitUndefineds } from '@livestore/utils'
-import type { Cause, OtelTracer, Scope } from '@livestore/utils/effect'
-import { Context, Deferred, Duration, Effect, Layer, pipe } from '@livestore/utils/effect'
+import type { Schema } from '@livestore/utils/effect'
+import {
+  type Cause,
+  type OtelTracer,
+  type Scope,
+  Context,
+  Deferred,
+  Duration,
+  Effect,
+  Layer,
+  pipe,
+} from '@livestore/utils/effect'
 
 import type { LiveStoreContextProps } from '../store/create-store.ts'
 import { createStore, DeferredStoreContext, LiveStoreContextRunning } from '../store/create-store.ts'
 import type { LiveStoreContextRunning as LiveStoreContextRunningType, Queryable } from '../store/store-types.ts'
 import type { Store as StoreClass } from '../store/store.ts'
 
-export const makeLiveStoreContext = <TSchema extends LiveStoreSchema, TContext = {}>({
+export const makeLiveStoreContext = <
+  TSchema extends LiveStoreSchema,
+  TContext = {},
+  TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
+>({
   schema,
   storeId = 'default',
   context,
@@ -20,9 +34,9 @@ export const makeLiveStoreContext = <TSchema extends LiveStoreSchema, TContext =
   batchUpdates,
   syncPayload,
   syncPayloadSchema,
-}: LiveStoreContextProps<TSchema, TContext>): Effect.Effect<
-  LiveStoreContextRunning['Type'],
-  UnknownError | Cause.TimeoutException,
+}: LiveStoreContextProps<TSchema, TContext, TSyncPayloadSchema>): Effect.Effect<
+  LiveStoreContextRunning['Service'],
+  UnknownError | Cause.TimeoutError,
   DeferredStoreContext | Scope.Scope | OtelTracer.OtelTracer
 > =>
   pipe(
@@ -35,9 +49,9 @@ export const makeLiveStoreContext = <TSchema extends LiveStoreSchema, TContext =
         ...omitUndefineds({ context, boot, disableDevtools, onBootStatus, syncPayload, syncPayloadSchema }),
       })
 
-      return { stage: 'running', store } as any as LiveStoreContextRunning['Type']
+      return LiveStoreContextRunning.of({ stage: 'running', store } as any as LiveStoreContextRunning['Service'])
     }),
-    Effect.tapErrorCause((cause) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.failCause(def, cause))),
+    Effect.tapCause((cause) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.failCause(def, cause))),
     Effect.tap((storeCtx) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.succeed(def, storeCtx))),
     // This can take quite a while.
     // TODO make this configurable
@@ -58,10 +72,14 @@ export const makeLiveStoreContext = <TSchema extends LiveStoreSchema, TContext =
  * const layer = MainStore.layer({ adapter, ... })
  * ```
  */
-export const LiveStoreContextLayer = <TSchema extends LiveStoreSchema, TContext = {}>(
-  props: LiveStoreContextProps<TSchema, TContext>,
-): Layer.Layer<LiveStoreContextRunning, UnknownError | Cause.TimeoutException, OtelTracer.OtelTracer> =>
-  Layer.scoped(LiveStoreContextRunning, makeLiveStoreContext(props)).pipe(
+export const LiveStoreContextLayer = <
+  TSchema extends LiveStoreSchema,
+  TContext = {},
+  TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
+>(
+  props: LiveStoreContextProps<TSchema, TContext, TSyncPayloadSchema>,
+): Layer.Layer<LiveStoreContextRunning, UnknownError | Cause.TimeoutError, OtelTracer.OtelTracer> =>
+  Layer.effect(LiveStoreContextRunning, makeLiveStoreContext(props)).pipe(
     Layer.withSpan('LiveStore'),
     Layer.provide(LiveStoreContextDeferred),
   )
@@ -71,7 +89,7 @@ export const LiveStoreContextLayer = <TSchema extends LiveStoreSchema, TContext
  */
 export const LiveStoreContextDeferred = Layer.effect(
   DeferredStoreContext,
-  Deferred.make<LiveStoreContextRunning['Type'], UnknownError>(),
+  Deferred.make<LiveStoreContextRunning['Service'], UnknownError>(),
 )
 
 // =============================================================================
@@ -99,10 +117,11 @@ export interface DeferredContextId<TStoreId extends string> {
 }
 
 /** Props for creating a store layer (schema and storeId are already provided) */
-export type StoreLayerProps<TSchema extends LiveStoreSchema, TContext = {}> = Omit<
-  LiveStoreContextProps<TSchema, TContext>,
-  'storeId' | 'schema'
->
+export type StoreLayerProps<
+  TSchema extends LiveStoreSchema,
+  TContext = {},
+  TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
+> = Omit<LiveStoreContextProps<TSchema, TContext, TSyncPayloadSchema>, 'storeId' | 'schema'>
 
 /**
  * Type for a Store.Tag class. This is the return type of `Store.Tag(schema, storeId)`.
@@ -117,16 +136,18 @@ export type StoreLayerProps<TSchema extends LiveStoreSchema, TContext = {}> = Om
  * Uses `interface` (not `type`) to allow the self-referential identifier without
  * triggering TS2456 (circular type alias).
  */
-export interface StoreTagClass<TSchema extends LiveStoreSchema, TStoreId extends string>
-  extends Context.Tag<StoreTagClass<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>> {
+export interface StoreTagClass<TSchema extends LiveStoreSchema, TStoreId extends string> extends Context.Key<
+  StoreTagClass<TSchema, TStoreId>,
+  LiveStoreContextRunningType<TSchema>
+> {
   /** Constructor signature (makes the type extendable as a class) */
-  new (): Context.Tag<StoreTagClass<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>>
+  new (): Context.Key<StoreTagClass<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>>
 
-  /** Tag identity type (from Context.Tag) */
+  /** Key identity type (from Context.Key) */
   readonly Id: StoreTagClass<TSchema, TStoreId>
 
-  /** Service type (from Context.Tag) */
-  readonly Type: LiveStoreContextRunningType<TSchema>
+  /** Service type (from Context.Key) */
+  readonly Service: LiveStoreContextRunningType<TSchema>
 
   /** The LiveStore schema for this store */
   readonly schema: TSchema
@@ -135,12 +156,12 @@ export interface StoreTagClass<TSchema extends LiveStoreSchema, TStoreId extends
   readonly storeId: TStoreId
 
   /** Creates a layer that initializes the store */
-  layer<TContext>(
-    props: StoreLayerProps<TSchema, TContext>,
-  ): Layer.Layer<StoreTagClass<TSchema, TStoreId>, UnknownError | Cause.TimeoutException, OtelTracer.OtelTracer>
+  layer<TContext, TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json>(
+    props: StoreLayerProps<TSchema, TContext, TSyncPayloadSchema>,
+  ): Layer.Layer<StoreTagClass<TSchema, TStoreId>, UnknownError | Cause.TimeoutError, OtelTracer.OtelTracer>
 
   /** Deferred store tag for async initialization patterns */
-  readonly Deferred: Context.Tag<
+  readonly Deferred: Context.Key<
     DeferredContextId<TStoreId>,
     Deferred.Deferred<LiveStoreContextRunningType<TSchema>, UnknownError>
   >
@@ -168,7 +189,7 @@ export interface StoreTagClass<TSchema extends LiveStoreSchema, TStoreId extends
 /**
  * Create a typed store context class for use with Effect.
  *
- * Returns a class that extends `Context.Tag`, making it directly yieldable in Effect code.
+ * Returns a class that extends `Context.Service`, making it directly yieldable in Effect code.
  * The class includes static methods for creating layers and accessors for common operations.
  *
  * @param schema - The LiveStore schema (used for type inference and runtime)
@@ -224,17 +245,19 @@ const makeStoreTag = <TSchema extends LiveStoreSchema, TStoreId extends string>(
   type DeferredType = Deferred.Deferred<RunningType, UnknownError>
 
   // Create the deferred tag and layers upfront
-  const _DeferredTag = Context.GenericTag<DeferredContextId<TStoreId>, DeferredType>(
+  const _DeferredTag = Context.Service<DeferredContextId<TStoreId>, DeferredType>(
     `@livestore/store-deferred/${storeId}`,
   )
 
   const _DeferredLayer = Layer.effect(_DeferredTag, Deferred.make<RunningType, UnknownError>())
 
-  class Tag extends Context.Tag(`@livestore/store/${storeId}`)<Tag, RunningType>() {
+  class Tag extends Context.Service<Tag, RunningType>()(`@livestore/store/${storeId}`) {
     static readonly schema: TSchema = schema
     static readonly storeId: TStoreId = storeId
 
-    static layer<TContext = {}>(props: StoreLayerProps<TSchema, TContext>) {
+    static layer<TContext = {}, TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json>(
+      props: StoreLayerProps<TSchema, TContext, TSyncPayloadSchema>,
+    ) {
       return pipe(
         Effect.gen(function* () {
           const store = yield* createStore({
@@ -259,11 +282,11 @@ const makeStoreTag = <TSchema extends LiveStoreSchema, TStoreId extends string>(
             optDeferred._tag === 'Some' ? Deferred.succeed(optDeferred.value, ctx) : Effect.void,
           )
 
-          return ctx
+          return Tag.of(ctx)
         }),
         Effect.timeout(Duration.minutes(5)),
         Effect.withSpan(`@livestore/effect:Store.Tag:${storeId}`),
-        Layer.scoped(Tag),
+        Layer.effect(Tag),
         Layer.withSpan(`LiveStore:${storeId}`),
         Layer.provide(_DeferredLayer),
       )
@@ -275,10 +298,10 @@ const makeStoreTag = <TSchema extends LiveStoreSchema, TStoreId extends string>(
     static readonly fromDeferred = pipe(
       Effect.gen(function* () {
         const deferred = yield* _DeferredTag
-        const ctx = yield* deferred
-        return Layer.succeed(Tag, ctx)
+        const ctx = yield* Deferred.await(deferred)
+        return Layer.succeed(Tag, Tag.of(ctx))
       }),
-      Layer.unwrapScoped,
+      Layer.unwrap,
     )
 
     static query<TResult>(query: Queryable<TResult>) {
@@ -291,7 +314,7 @@ const makeStoreTag = <TSchema extends LiveStoreSchema, TStoreId extends string>(
       })
     }
 
-    static use<A, E, R>(f: (ctx: RunningType) => Effect.Effect<A, E, R>) {
+    static override use<A, E, R>(f: (ctx: RunningType) => Effect.Effect<A, E, R>) {
       return Effect.flatMap(Tag, f)
     }
   }
@@ -338,14 +361,17 @@ export const Store = {
  */
 export interface StoreContext<TSchema extends LiveStoreSchema, TStoreId extends string> {
   readonly storeId: TStoreId
-  readonly Tag: Context.Tag<StoreContextId<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>>
-  readonly DeferredTag: Context.Tag<
+  readonly Tag: Context.Key<StoreContextId<TSchema, TStoreId>, LiveStoreContextRunningType<TSchema>>
+  readonly DeferredTag: Context.Key<
     DeferredContextId<TStoreId>,
     Deferred.Deferred<LiveStoreContextRunningType<TSchema>, UnknownError>
   >
-  readonly Layer: <TContext = {}>(
-    props: Omit<LiveStoreContextProps<TSchema, TContext>, 'storeId'>,
-  ) => Layer.Layer<StoreContextId<TSchema, TStoreId>, UnknownError | Cause.TimeoutException, OtelTracer.OtelTracer>
+  readonly Layer: <
+    TContext = {},
+    TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
+  >(
+    props: Omit<LiveStoreContextProps<TSchema, TContext, TSyncPayloadSchema>, 'storeId'>,
+  ) => Layer.Layer<StoreContextId<TSchema, TStoreId>, UnknownError | Cause.TimeoutError, OtelTracer.OtelTracer>
   readonly DeferredLayer: Layer.Layer<DeferredContextId<TStoreId>>
   readonly fromDeferred: Layer.Layer<StoreContextId<TSchema, TStoreId>, UnknownError, DeferredContextId<TStoreId>>
 }
@@ -368,17 +394,20 @@ export const makeStoreContext =
     type RunningType = LiveStoreContextRunningType<TSchema>
     type DeferredType = Deferred.Deferred<RunningType, UnknownError>
 
-    const Tag = Context.GenericTag<StoreContextId<TSchema, TStoreId>, RunningType>(`@livestore/store/${storeId}`)
+    const Tag = Context.Service<StoreContextId<TSchema, TStoreId>, RunningType>(`@livestore/store/${storeId}`)
 
-    const DeferredTag = Context.GenericTag<DeferredContextId<TStoreId>, DeferredType>(
+    const DeferredTag = Context.Service<DeferredContextId<TStoreId>, DeferredType>(
       `@livestore/store-deferred/${storeId}`,
     )
 
     const DeferredLayer = Layer.effect(DeferredTag, Deferred.make<RunningType, UnknownError>())
 
-    const makeLayer = <TContext = {}>(
-      props: Omit<LiveStoreContextProps<TSchema, TContext>, 'storeId'>,
-    ): Layer.Layer<StoreContextId<TSchema, TStoreId>, UnknownError | Cause.TimeoutException, OtelTracer.OtelTracer> =>
+    const makeLayer = <
+      TContext = {},
+      TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
+    >(
+      props: Omit<LiveStoreContextProps<TSchema, TContext, TSyncPayloadSchema>, 'storeId'>,
+    ): Layer.Layer<StoreContextId<TSchema, TStoreId>, UnknownError | Cause.TimeoutError, OtelTracer.OtelTracer> =>
       pipe(
         Effect.gen(function* () {
           const store = yield* createStore({
@@ -407,7 +436,7 @@ export const makeStoreContext =
         }),
         Effect.timeout(Duration.minutes(5)),
         Effect.withSpan(`@livestore/effect:makeStoreContext:${storeId}`),
-        Layer.scoped(Tag),
+        Layer.effect(Tag),
         Layer.withSpan(`LiveStore:${storeId}`),
         Layer.provide(DeferredLayer),
       )
@@ -419,10 +448,10 @@ export const makeStoreContext =
     > = pipe(
       Effect.gen(function* () {
         const deferred = yield* DeferredTag
-        const ctx = yield* deferred
+        const ctx = yield* Deferred.await(deferred)
         return Layer.succeed(Tag, ctx)
       }),
-      Layer.unwrapScoped,
+      Layer.unwrap,
     )
 
     return {