liminal 0.17.13 → 0.17.15

package/Client.ts

@@ -15,23 +15,27 @@ import {
   Take,
   Schema as S,
   Array,
-  Struct,
   Fiber,
   Exit,
   Cause,
   Result,
   flow,
+  Tracer,
+  identity,
+  Semaphore,
 } from "effect"
 import { Socket } from "effect/unstable/socket"
 import { Worker } from "effect/unstable/workers"
+import * as Spanner from "liminal-util/Spanner"
 
-import { diagnostic } from "./_diagnostic.ts"
 import { decodeJsonString, encodeJsonString } from "./_util/schema.ts"
-import { type ClientError, AuditionError, ConnectionError, type FError, UnresolvedError } from "./errors.ts"
-import { type F } from "./F.ts"
+import { type ClientError, AuditionError, ConnectionError, UnresolvedError } from "./errors.ts"
+import type { Fn, FnError } from "./Fn.ts"
 import { Protocol, type ProtocolDefinition } from "./Protocol.ts"
+import * as Reducer from "./Reducer.ts"
+import * as Tracing from "./Tracing.ts"
 
-const { debug, span } = diagnostic("Client")
+const span = Spanner.make(import.meta.url)
 
 export const TypeId = "~liminal/Client" as const
 
@@ -47,15 +51,21 @@ interface EventTake<A, E> {
   readonly take: Take.Take<A, E>
 }
 
-export interface Session<Self, D extends ProtocolDefinition> {
-  readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError>
+export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<
+  {
+    readonly state: Stream.Stream<S.Struct<D["state"]>["Type"], ClientError | S.SchemaError>
 
-  readonly f: F<Self, D>
+    readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError>
 
-  readonly end: Effect.Effect<void>
-}
+    readonly fnRaw: <K extends keyof D["external"], M extends D["external"][K]>(
+      tag: K,
+      payload: M["payload"]["Type"],
+    ) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], ClientSelf>
 
-export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<Session<ClientSelf, D>, ClientError>
+    readonly end: Effect.Effect<void>
+  },
+  ClientError
+>
 
 export interface Client<Self, ClientId extends string, D extends ProtocolDefinition> extends Context.Service<
   Self,
@@ -69,15 +79,23 @@ export interface Client<Self, ClientId extends string, D extends ProtocolDefinit
 
   readonly protocol: Protocol<D>
 
+  readonly state: Stream.Stream<
+    S.Struct<D["state"]>["Type"],
+    ClientError | S.SchemaError,
+    Self | S.Struct<D["state"]>["DecodingServices"]
+  >
+
   readonly events: Stream.Stream<
     ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"],
     ClientError | S.SchemaError,
     Self
   >
 
-  readonly f: F<Self, D>
+  readonly fn: Fn<Self, D["external"]>
 
   readonly invalidate: Effect.Effect<void, never, Self>
+
+  readonly reducer: <K extends keyof D["events"], R extends Reducer.Reducer<D, K>>(_tag: K, f: R) => R
 }
 
 export const Service =
@@ -87,13 +105,27 @@ export const Service =
 
     const protocol = Protocol(definition)
 
-    const events = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(Struct.get("events")), Stream.unwrap)
+    const state = tag.asEffect().pipe(
+      Effect.flatMap(RcRef.get),
+      Effect.map(({ state }) => state),
+      Stream.unwrap,
+    )
+
+    const events = tag.asEffect().pipe(
+      Effect.flatMap(RcRef.get),
+      Effect.map(({ events }) => events),
+      Stream.unwrap,
+    )
 
-    const f: F<Self, D> = (_tag) =>
-      Effect.fnUntraced(function* (value) {
-        const { f } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get))
-        return yield* f(_tag)(value)
-      }, Effect.scoped)
+    const fn = ((_tag: keyof D["external"], ...f: Array<any>) =>
+      Effect.fnUntraced(
+        function* (payload: any) {
+          const { fnRaw: fn } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get))
+          return yield* fn(_tag, payload)
+        },
+        Effect.scoped,
+        ...(f as [any]),
+      )) as Fn<Self, D["external"]>
 
     const invalidate = tag.asEffect().pipe(
       Effect.flatMap((rc) =>
@@ -106,47 +138,69 @@ export const Service =
       Effect.ignore,
     )
 
+    const reducer = <K extends keyof D["events"], R extends Reducer.Reducer<D, K>>(_event: K, f: R) => f
+
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
       protocol,
+      state,
       events,
-      f,
+      fn,
       invalidate,
+      reducer,
     })
   }
 
-export interface ClientTransport<D extends ProtocolDefinition> {
+export interface ClientTransport<D extends ProtocolDefinition, R> {
   readonly listen: (
-    publish: (message: Protocol<D>["Actor"]["Type"]) => Effect.Effect<void, ClientError>,
-  ) => Effect.Effect<void, ClientError | S.SchemaError, Scope.Scope | Protocol<D>["Actor"]["DecodingServices"]>
+    publish: (message: Protocol<D>["Actor"]["Type"]) => Effect.Effect<void, ClientError, R>,
+  ) => Effect.Effect<void, ClientError | S.SchemaError, Scope.Scope | Protocol<D>["Actor"]["DecodingServices"] | R>
 
   readonly send: (
     message: Protocol<D>["F"]["Payload"]["Type"],
   ) => Effect.Effect<void, ClientError | S.SchemaError, Protocol<D>["F"]["Payload"]["EncodingServices"]>
 }
 
-const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
-  client: Client<Self, Id, D>,
-  build: Effect.Effect<ClientTransport<D>, ClientError, R | Scope.Scope>,
-  replay?: ReplayConfig | undefined,
-) =>
+const make = <Self, Id extends string, D extends ProtocolDefinition, Reducers extends Reducer.Reducers<D>, R, CR>({
+  build,
+  client,
+  reducers,
+  onConnect,
+  replay,
+}: {
+  readonly client: Client<Self, Id, D>
+  readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>)
+  readonly reducers: Reducers
+  readonly build: Effect.Effect<
+    ClientTransport<D, Reducer.Reducers.Services<Self, Reducers> | CR>,
+    ClientError,
+    R | Scope.Scope
+  >
+  readonly replay?: ReplayConfig | undefined
+}) =>
   Effect.gen(function* () {
-    const rcr: RcRef.RcRef<Session<Self, D>, ClientError> = yield* RcRef.make({
+    const rcr: Service<Self, D> = yield* RcRef.make({
       acquire: Effect.gen(function* () {
         type _ = typeof client.protocol
         type Event = ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"]
 
-        yield* debug("AcquisitionStarted")
-
         const { listen, send } = yield* build
 
         const audition = yield* Deferred.make<void>()
+        const stateDeferred = yield* Deferred.make<Ref.Ref<S.Struct<D["state"]>["Type"]>>()
 
-        const inflights: Record<string, Deferred.Deferred<_["F"]["Success"]["Type"], FError<D>>> = {}
+        const inflights: Record<
+          string,
+          {
+            readonly deferred: Deferred.Deferred<_["F"]["Success"]["Type"], FnError<D["external"], keyof D["external"]>>
+            readonly span?: Tracer.AnySpan | undefined
+          }
+        > = {}
         let callId = 0
         let takeCount = 0
-        const pubsub = yield* PubSub.unbounded<EventTake<Event, ClientError>>()
+        const eventsPubsub = yield* PubSub.unbounded<EventTake<Event, ClientError>>()
+        const statePubsub = yield* PubSub.unbounded<S.Struct<D["state"]>["Type"]>({ replay: 1 })
 
         const replayState = yield* Ref.make<{
           readonly startupOpen: boolean
@@ -175,57 +229,85 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
                 return { startupOpen, buffer }
               })
             }
-            yield* PubSub.publish(pubsub, eventTake)
+            yield* PubSub.publish(eventsPubsub, eventTake)
           })
 
         const outer = yield* Scope.Scope
         const scope = yield* Scope.fork(outer, "sequential")
         const end = Scope.close(scope, Exit.void)
+        const reduceMutex = yield* Semaphore.make(1)
+        const reduceTask = Semaphore.withPermits(reduceMutex, 1)
 
         const fiber = yield* listen(
           Effect.fnUntraced(function* (message) {
             switch (message._tag) {
               case "Audition.Success": {
-                yield* debug("Audition.Succeeded")
+                const { initial } = message
+                yield* PubSub.publish(statePubsub, initial)
+                const state = yield* Ref.make(initial)
+                yield* Deferred.succeed(stateDeferred, state)
                 yield* Deferred.succeed(audition, void 0)
+                yield* onConnect?.(initial) ?? Effect.void
                 return
               }
               case "Audition.Failure": {
                 const { expected, actual } = message
-                yield* debug("Audition.Failed", { expected, actual })
                 return yield* new AuditionError({ value: { expected, actual } })
               }
               case "Event": {
                 const { event } = message
-                yield* debug("Event.Emitted", { event })
-                yield* publishTake([event as never], true)
+                const { _tag } = event as never
+                const reducer = reducers[_tag]!
+                const state = yield* Deferred.await(stateDeferred)
+                yield* Effect.gen(function* () {
+                  const current = yield* Ref.get(state)
+                  const reduced = yield* reducer(event as never)(current).pipe(
+                    Effect.provideService(client, rcr),
+                  ) as Effect.Effect<
+                    S.Struct<D["state"]>["Type"] | undefined,
+                    never,
+                    Reducer.Reducers.Services<Self, Reducers>
+                  >
+                  if (reduced) {
+                    yield* PubSub.publish(statePubsub, reduced)
+                    yield* Ref.set(state, reduced)
+                  }
+                }).pipe(reduceTask)
+                const parent = message.trace ? Tracer.externalSpan(message.trace) : undefined
+                yield* publishTake([event], true).pipe(
+                  span("enqueue-event", {
+                    attributes: { _tag },
+                    kind: "consumer",
+                    parent,
+                  }),
+                )
                 return
               }
               case "F.Success":
               case "F.Failure": {
                 const { id } = message
-                const deferred = inflights[id]
-                if (deferred) {
+                const inflight = inflights[id]
+                if (inflight) {
                   delete inflights[id]
-                  switch (message._tag) {
-                    case "F.Success": {
-                      const { _tag, value } = message.success as never
-                      yield* debug("Call.Succeeded", { id, _tag, value })
-                      yield* Deferred.succeed(deferred, value)
-                      return
+                  return yield* Effect.gen(function* () {
+                    switch (message._tag) {
+                      case "F.Success": {
+                        const { value } = message.success as never
+                        yield* Deferred.succeed(inflight.deferred, value)
+                        return
+                      }
+                      case "F.Failure": {
+                        const { _tag, value } = message.failure as never
+                        yield* Effect.annotateLogs(Effect.logDebug("Call.Failed"), { id, _tag })
+                        yield* Deferred.fail(inflight.deferred, value)
+                        return
+                      }
                     }
-                    case "F.Failure": {
-                      const { _tag, value } = message.failure as never
-                      yield* debug("Call.Failed", { id, _tag, value })
-                      yield* Deferred.fail(deferred, value)
-                      return
-                    }
-                  }
+                  }).pipe(inflight.span ? Effect.withParentSpan(inflight.span, { captureStackTrace: false }) : identity)
                 }
                 return
               }
               case "Disconnect": {
-                yield* debug("Disconnected")
                 return
               }
             }
@@ -234,7 +316,13 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
           Effect.ensuring(
             Effect.all(
               [
-                debug("Client.Closed", { unresolved: Record.keys(inflights).length }),
+                Effect.sync(() => Record.keys(inflights).length).pipe(
+                  Effect.flatMap((unresolved) =>
+                    unresolved === 0
+                      ? Effect.void
+                      : Effect.annotateLogs(Effect.logDebug("Client.Closed"), { unresolved }),
+                  ),
+                ),
                 Deferred.succeed(audition, void 0),
                 RcRef.invalidate(rcr),
               ],
@@ -245,8 +333,25 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
           Effect.provideService(Scope.Scope, scope),
         )
 
+        const interrupt = Stream.interruptWhen(
+          Fiber.await(fiber).pipe(
+            Effect.flatMap(
+              Exit.match({
+                onSuccess: () => Effect.void,
+                onFailure: flow(
+                  Cause.findError,
+                  Result.match({
+                    onSuccess: Effect.fail,
+                    onFailure: () => Effect.void,
+                  }),
+                ),
+              }),
+            ),
+          ),
+        )
+
         const events = Effect.gen(function* () {
-          const queue = yield* PubSub.subscribe(pubsub)
+          const queue = yield* PubSub.subscribe(eventsPubsub)
           const live = (replayCount: number) =>
             Stream.fromSubscription(queue).pipe(
               Stream.filter((entry) => entry.seq > replayCount),
@@ -283,109 +388,115 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
                 ),
                 live(replayCount),
               )
-        }).pipe(
-          Stream.unwrap,
-          Stream.interruptWhen(
-            Fiber.await(fiber).pipe(
-              Effect.flatMap(
-                Exit.match({
-                  onSuccess: () => Effect.void,
-                  onFailure: flow(
-                    Cause.findError,
-                    Result.match({
-                      onSuccess: Effect.fail,
-                      onFailure: () => Effect.void,
-                    }),
-                  ),
-                }),
-              ),
-            ),
-          ),
-        )
+        }).pipe(Stream.unwrap, interrupt)
 
-        yield* Deferred.await(audition)
+        const state = Stream.fromPubSub(statePubsub).pipe(interrupt)
 
         const encodingServices = yield* Effect.context<_["F"]["Payload"]["EncodingServices"]>()
 
-        const f: F<Self, D> = (_tag) =>
-          Effect.fnUntraced(
-            function* (value) {
-              const exit = fiber.pollUnsafe()
-              if (exit) {
-                return yield* Exit.match(exit, {
-                  onSuccess: () => new UnresolvedError(),
-                  onFailure: flow(
-                    Cause.findError,
-                    Result.match({
-                      onSuccess: Effect.fail,
-                      onFailure: () => new UnresolvedError(),
-                    }),
-                  ),
-                })
-              }
-              const id = callId++
-              const inflight = yield* Deferred.make<_["F"]["Success"]["Type"], FError<D>>()
-              inflights[id] = inflight
-              yield* send({
-                _tag: "F.Payload",
-                id,
-                payload: { _tag, value } as never,
+        yield* Deferred.await(audition)
+
+        const fnRaw = <K extends keyof D["external"]>(_tag: K, value: D["external"][K]["payload"]["Type"]) =>
+          Effect.gen(function* () {
+            const exit = fiber.pollUnsafe()
+            if (exit) {
+              return yield* Exit.match(exit, {
+                onSuccess: () => new UnresolvedError(),
+                onFailure: flow(
+                  Cause.findError,
+                  Result.match({
+                    onSuccess: Effect.fail,
+                    onFailure: () => new UnresolvedError(),
+                  }),
+                ),
               })
-              return yield* Effect.raceFirst(
-                Deferred.await(inflight),
-                Fiber.await(fiber).pipe(
-                  Effect.flatMap(
-                    (exit): Effect.Effect<never, ClientError | UnresolvedError | S.SchemaError> =>
-                      Exit.match(exit, {
-                        onSuccess: () => new UnresolvedError().asEffect(),
-                        onFailure: flow(
-                          Cause.findError,
-                          Result.match({
-                            onSuccess: Effect.fail,
-                            onFailure: () => new UnresolvedError().asEffect(),
-                          }),
-                        ),
-                      }),
-                  ),
+            }
+            const id = callId++
+            const deferred = yield* Deferred.make<
+              _["F"]["Success"]["Type"],
+              FnError<D["external"], keyof D["external"]>
+            >()
+            const span = yield* Tracing.current
+            const trace = span ? Tracing.toTraceEnvelope(span) : undefined
+            inflights[id] = { deferred, span }
+            yield* send({
+              _tag: "F.Payload",
+              id,
+              payload: { _tag, value } as never,
+              ...(trace && { trace }),
+            })
+            return yield* Effect.raceFirst(
+              Deferred.await(deferred),
+              Fiber.await(fiber).pipe(
+                Effect.flatMap(
+                  (exit): Effect.Effect<never, ClientError | UnresolvedError | S.SchemaError> =>
+                    Exit.match(exit, {
+                      onSuccess: () => new UnresolvedError().asEffect(),
+                      onFailure: flow(
+                        Cause.findError,
+                        Result.match({
+                          onSuccess: Effect.fail,
+                          onFailure: () => new UnresolvedError().asEffect(),
+                        }),
+                      ),
+                    }),
                 ),
-              )
-            },
-            span("f"),
-            Effect.scoped,
+              ),
+            )
+          }).pipe(
+            span("fn", {
+              kind: "client",
+              attributes: { _tag },
+            }),
             Effect.provide(encodingServices),
           )
 
-        return { events, f, end }
+        return { state, events, fnRaw, end }
       }).pipe(span("acquire", { attributes: { client: client.key } }), Effect.annotateLogs("client", client.key)),
     })
 
     return rcr
   }).pipe(Layer.effect(client))
 
-export const layerSocket = <Self, Id extends string, D extends ProtocolDefinition>({
+export const layerSocket = <
+  Self,
+  Id extends string,
+  D extends ProtocolDefinition,
+  Reducers extends Reducer.Reducers<D>,
+  CR = never,
+>({
   client,
+  reducers,
   url,
   protocols,
   replay,
+  onConnect,
 }: {
   readonly client: Client<Self, Id, D>
-  readonly url?: string | undefined
-  readonly protocols?: string | Array<string> | undefined
+  readonly reducers: Reducers
   readonly replay?: ReplayConfig | undefined
+  readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>)
+  readonly protocols?: string | Array<string> | undefined
+  readonly url?: string | undefined
 }): Layer.Layer<
   Self,
   never,
   | Socket.WebSocketConstructor
   | Protocol<D>["Actor"]["DecodingServices"]
   | Protocol<D>["F"]["Payload"]["EncodingServices"]
+  | Reducer.Reducers.Services<Self, Reducers>
+  | CR
 > => {
   const { F, Actor } = client.protocol
   const encodeFPayload = encodeJsonString(F.Payload)
   const decodeActor = decodeJsonString(Actor)
 
-  return make<Self, Id, D, Socket.WebSocketConstructor>(
+  return make<Self, Id, D, Reducers, Socket.WebSocketConstructor, CR>({
     client,
-    Effect.gen(function* () {
+    reducers,
+    onConnect,
+    replay,
+    build: Effect.gen(function* () {
       const socket = yield* Socket.makeWebSocket(url ?? "/", {
         protocols: ["liminal", Encoding.encodeBase64Url(client.key), ...(protocols ? Array.ensure(protocols) : [])],
       })
@@ -405,10 +516,9 @@ export const layerSocket = <Self, Id extends string, D extends ProtocolDefinitio
                 Effect.fnUntraced(function* (cause) {
                   const { reason } = cause
                   if (reason._tag === "SocketCloseError" && reason.code === 1000) {
-                    yield* debug("Socket.Disconnected")
                     return yield* publish({ _tag: "Disconnect" })
                   }
-                  yield* debug(`SocketErrored.${reason._tag}`, { cause })
+                  yield* Effect.annotateLogs(Effect.logDebug(`SocketErrored.${reason._tag}`), { cause })
                   return yield* new ConnectionError({ cause })
                 }),
               ),
@@ -427,24 +537,41 @@ export const layerSocket = <Self, Id extends string, D extends ProtocolDefinitio
         ),
       }
     }),
-    replay,
-  )
+  })
 }
 
-export const layerWorker = <Self, Id extends string, D extends ProtocolDefinition, T extends Protocol<D>>({
+export const layerWorker = <
+  Self,
+  Id extends string,
+  D extends ProtocolDefinition,
+  Reducers extends Reducer.Reducers<D>,
+  T extends Protocol<D>,
+  CR = never,
+>({
   client,
+  reducers,
   replay,
+  onConnect,
 }: {
   readonly client: Client<Self, Id, D>
+  readonly reducers: Reducers
   readonly replay?: ReplayConfig | undefined
+  readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>)
 }): Layer.Layer<
   Self,
   never,
-  Worker.WorkerPlatform | Worker.Spawner | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"]
+  | Worker.WorkerPlatform
+  | Worker.Spawner
+  | T["Actor"]["DecodingServices"]
+  | T["F"]["Payload"]["EncodingServices"]
+  | Reducer.Reducers.Services<Self, Reducers>
 > =>
-  make<Self, Id, D, Worker.WorkerPlatform | Worker.Spawner>(
+  make<Self, Id, D, Reducers, Worker.WorkerPlatform | Worker.Spawner, CR>({
     client,
-    Effect.gen(function* () {
+    reducers,
+    onConnect,
+    replay,
+    build: Effect.gen(function* () {
       const platform = yield* Worker.WorkerPlatform
       const backing = yield* platform
         .spawn<T["Actor"]["Type"], T["Client"]["Type"]>(0)
@@ -484,5 +611,4 @@ export const layerWorker = <Self, Id extends string, D extends ProtocolDefinitio
         send,
       }
     }),
-    replay,
-  )
+  })