effect 4.0.0-beta.43 → 4.0.0-beta.45

package/src/unstable/rpc/RpcClient.ts

@@ -3,6 +3,7 @@
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -17,7 +18,6 @@ import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Struct from "../../Struct.ts"
 import type { Span } from "../../Tracer.ts"
@@ -39,7 +39,7 @@ import type * as RpcMiddleware from "./RpcMiddleware.ts"
 import * as RpcSchema from "./RpcSchema.ts"
 import * as RpcSerialization from "./RpcSerialization.ts"
 import * as RpcWorker from "./RpcWorker.ts"
-import { withRun } from "./Utils.ts"
+import { withRunClient } from "./Utils.ts"
 
 /**
  * @since 4.0.0
@@ -66,11 +66,11 @@ export declare namespace RpcClient {
           readonly asQueue?: AsQueue | undefined
           readonly streamBufferSize?: number | undefined
           readonly headers?: Headers.Input | undefined
-          readonly context?: ServiceMap.ServiceMap<never> | undefined
+          readonly context?: Context.Context<never> | undefined
         } :
         {
           readonly headers?: Headers.Input | undefined
-          readonly context?: ServiceMap.ServiceMap<never> | undefined
+          readonly context?: Context.Context<never> | undefined
           readonly discard?: Discard | undefined
         }
     ) => Current extends Rpc.Rpc<
@@ -129,11 +129,11 @@ export declare namespace RpcClient {
         readonly asQueue?: AsQueue | undefined
         readonly streamBufferSize?: number | undefined
         readonly headers?: Headers.Input | undefined
-        readonly context?: ServiceMap.ServiceMap<never> | undefined
+        readonly context?: Context.Context<never> | undefined
       } :
       {
         readonly headers?: Headers.Input | undefined
-        readonly context?: ServiceMap.ServiceMap<never> | undefined
+        readonly context?: Context.Context<never> | undefined
         readonly discard?: Discard | undefined
       }
   ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
@@ -192,7 +192,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     readonly onFromClient: (
       options: {
         readonly message: FromClient<Rpcs>
-        readonly context: ServiceMap.ServiceMap<never>
+        readonly context: Context.Context<never>
         readonly discard: boolean
       }
     ) => Effect.Effect<void, E>
@@ -216,7 +216,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     readonly onFromClient: (
       options: {
         readonly message: FromClient<Rpcs>
-        readonly context: ServiceMap.ServiceMap<never>
+        readonly context: Context.Context<never>
         readonly discard: boolean
       }
     ) => Effect.Effect<void, E>
@@ -233,20 +233,20 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
   const disableTracing = options?.disableTracing ?? false
   const generateRequestId = options?.generateRequestId ?? (() => requestIdCounter++ as RequestId)
 
-  const services = yield* Effect.services<Rpc.MiddlewareClient<Rpcs> | Scope.Scope>()
-  const scope = ServiceMap.get(services, Scope.Scope)
+  const services = yield* Effect.context<Rpc.MiddlewareClient<Rpcs> | Scope.Scope>()
+  const scope = Context.get(services, Scope.Scope)
 
   type ClientEntry = {
     readonly _tag: "Effect"
     readonly rpc: Rpc.AnyWithProps
-    readonly context: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     resume: (_: Exit.Exit<any, any>) => void
   } | {
     readonly _tag: "Queue"
     readonly rpc: Rpc.AnyWithProps
     readonly queue: Queue.Queue<any, any>
     readonly scope: Scope.Scope
-    readonly context: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
   }
   const entries = new Map<RequestId, ClientEntry>()
 
@@ -279,18 +279,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       readonly asQueue?: boolean | undefined
       readonly streamBufferSize?: number | undefined
       readonly headers?: Headers.Input | undefined
-      readonly context?: ServiceMap.ServiceMap<never> | undefined
+      readonly context?: Context.Context<never> | undefined
       readonly discard?: boolean | undefined
     }) => {
       const headers = opts?.headers ? Headers.fromInput(opts.headers) : Headers.empty
-      const context = opts?.context ?? ServiceMap.empty()
+      const context = opts?.context ?? Context.empty()
       if (!isStream) {
         const onRequest = (span: Span | undefined) =>
           onEffectRequest(
             rpc,
             middleware,
             span,
-            rpc.payloadSchema.makeUnsafe(payload),
+            rpc.payloadSchema.make(payload),
             headers,
             context,
             opts?.discard ?? false
@@ -304,7 +304,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       const queue = onStreamRequest(
         rpc,
         middleware,
-        rpc.payloadSchema.makeUnsafe(payload),
+        rpc.payloadSchema.make(payload),
         headers,
         opts?.streamBufferSize ?? 16,
         context
@@ -323,7 +323,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     span: Span | undefined,
     payload: any,
     headers: Headers.Headers,
-    context: ServiceMap.ServiceMap<never>,
+    context: Context.Context<never>,
     discard: boolean
   ) =>
     Effect.withFiber<any, any, any>((parentFiber) => {
@@ -375,7 +375,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
           entries.set(id, entry)
           fiber = send.pipe(
             span ? Effect.withParentSpan(span, { captureStackTrace: false }) : identity,
-            Effect.runForkWith(parentFiber.services)
+            Effect.runForkWith(parentFiber.context)
           )
           fiber.addObserver((exit) => {
             if (exit._tag === "Failure") {
@@ -402,7 +402,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     payload: any,
     headers: Headers.Headers,
     streamBufferSize: number,
-    context: ServiceMap.ServiceMap<never>
+    context: Context.Context<never>
   ) {
     if (isShutdown) {
       return yield* Effect.interrupt
@@ -414,7 +414,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     const fiber = Fiber.getCurrent()!
     const id = generateRequestId()
 
-    const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope)
     yield* Scope.addFinalizerExit(
       scope,
       (exit) => {
@@ -508,7 +508,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
   const sendInterrupt = (
     requestId: RequestId,
     interruptors: ReadonlyArray<number>,
-    context: ServiceMap.ServiceMap<never>
+    context: Context.Context<never>
   ): Effect.Effect<void> =>
     Effect.callback<void>((resume) => {
       const parentFiber = Fiber.getCurrent()!
@@ -518,7 +518,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
         discard: false
       }).pipe(
         Effect.timeout(1000),
-        Effect.runForkWith(parentFiber.services)
+        Effect.runForkWith(parentFiber.context)
       )
       fiber.addObserver(() => {
         resume(Effect.void)
@@ -587,6 +587,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
   return { client, write } as const
 })
 
+let clientIdCounter = 0
+
 /**
  * @since 4.0.0
  * @category client
@@ -614,11 +616,12 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
     readonly flatten?: Flatten | undefined
   } | undefined
 ) {
+  const clientId = clientIdCounter++
   const { run, send, supportsAck, supportsTransferables } = yield* Protocol
 
   type ClientEntry = {
     readonly rpc: Rpc.AnyWithProps
-    readonly context: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     readonly schemas: RpcSchemas
   }
   const entries = new Map<RequestId, ClientEntry>()
@@ -636,16 +639,16 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
 
           const entry: ClientEntry = {
             rpc,
-            context: collector ? ServiceMap.add(fiber.services, Transferable.Collector, collector) : fiber.services,
+            context: collector ? Context.add(fiber.context, Transferable.Collector, collector) : fiber.context,
             schemas: rpcSchemas(rpc)
           }
           entries.set(message.id, entry)
 
           return entry.schemas.encodePayload(message.payload).pipe(
-            Effect.provideServices(entry.context),
+            Effect.provideContext(entry.context),
             Effect.orDie,
             Effect.flatMap((payload) =>
-              send({
+              send(clientId, {
                 ...message,
                 id: String(message.id),
                 payload,
@@ -657,7 +660,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
         case "Ack": {
           const entry = entries.get(message.requestId)
           if (!entry) return Effect.void
-          return send({
+          return send(clientId, {
             _tag: "Ack",
             requestId: String(message.requestId)
           }) as Effect.Effect<void, RpcClientError>
@@ -666,7 +669,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           const entry = entries.get(message.requestId)
           if (!entry) return Effect.void
           entries.delete(message.requestId)
-          return send({
+          return send(clientId, {
             _tag: "Interrupt",
             requestId: String(message.requestId)
           }) as Effect.Effect<void, RpcClientError>
@@ -678,14 +681,14 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
     }
   })
 
-  yield* run((message) => {
+  yield* run(clientId, (message) => {
     switch (message._tag) {
       case "Chunk": {
         const requestId = RequestId(message.requestId)
         const entry = entries.get(requestId)
         if (!entry || Option.isNone(entry.schemas.decodeChunk)) return Effect.void
         return entry.schemas.decodeChunk.value(message.values).pipe(
-          Effect.provideServices(entry.context),
+          Effect.provideContext(entry.context),
           Effect.orDie,
           Effect.flatMap((chunk) =>
             write({ _tag: "Chunk", clientId: 0, requestId: RequestId(message.requestId), values: chunk })
@@ -706,7 +709,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
         if (!entry) return Effect.void
         entries.delete(requestId)
         return entry.schemas.decodeExit(message.exit).pipe(
-          Effect.provideServices(entry.context),
+          Effect.provideContext(entry.context),
           Effect.orDie,
           Effect.matchCauseEffect({
             onSuccess: (exit) => write({ _tag: "Exit", clientId: 0, requestId, exit }),
@@ -767,7 +770,7 @@ const rpcSchemas = (rpc: Rpc.AnyWithProps) => {
  * @since 4.0.0
  * @category headers
  */
-export const CurrentHeaders = ServiceMap.Reference<Headers.Headers>("effect/rpc/RpcClient/CurrentHeaders", {
+export const CurrentHeaders = Context.Reference<Headers.Headers>("effect/rpc/RpcClient/CurrentHeaders", {
   defaultValue: () => Headers.empty
 })
 
@@ -796,11 +799,13 @@ export const withHeaders: {
  * @since 4.0.0
  * @category protocol
  */
-export class Protocol extends ServiceMap.Service<Protocol, {
+export class Protocol extends Context.Service<Protocol, {
   readonly run: (
+    clientId: number,
     f: (data: FromServerEncoded) => Effect.Effect<void>
   ) => Effect.Effect<never>
   readonly send: (
+    clientId: number,
     request: FromClientEncoded,
     transferables?: ReadonlyArray<globalThis.Transferable>
   ) => Effect.Effect<void, RpcClientError>
@@ -810,7 +815,7 @@ export class Protocol extends ServiceMap.Service<Protocol, {
   /**
    * @since 4.0.0
    */
-  static make = withRun<Protocol["Service"]>()
+  static make = withRunClient
 }
 
 /**
@@ -836,7 +841,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
     const emptyResponseError = (request: FromClientEncoded) =>
       protocolDefect("Received empty HTTP response from RPC server", request)
 
-    const send = Effect.fnUntraced(function*(request: FromClientEncoded) {
+    const send = Effect.fnUntraced(function*(clientId: number, request: FromClientEncoded) {
       if (request._tag !== "Request") {
         return
       }
@@ -857,15 +862,15 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
           catch: (cause) => protocolDefect("Error decoding HTTP response", cause)
         })
         if (!Array.isArray(responses)) {
-          return yield* Effect.fail(protocolDefect("Expected an array of responses", responses))
+          return yield* protocolDefect("Expected an array of responses", responses)
         }
         if (responses.length === 0) {
-          return yield* Effect.fail(emptyResponseError(request))
+          return yield* emptyResponseError(request)
         }
         let i = 0
         return yield* Effect.whileLoop({
           while: () => i < responses.length,
-          body: () => writeResponse(responses[i++]),
+          body: () => writeResponse(clientId, responses[i++]),
           step: constVoid
         })
       }
@@ -882,7 +887,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
             let i = 0
             return Effect.whileLoop({
               while: () => i < responses.length,
-              body: () => writeResponse(responses[i++]),
+              body: () => writeResponse(clientId, responses[i++]),
               step: constVoid
             })
           })
@@ -890,7 +895,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
           Effect.mapError((cause) => cause instanceof RpcClientError ? cause : httpClientError(cause))
         )
       if (!hasResponse) {
-        return yield* Effect.fail(emptyResponseError(request))
+        return yield* emptyResponseError(request)
       }
     })
 
@@ -931,9 +936,11 @@ export const makeProtocolSocket = (options?: {
   never,
   Scope.Scope | RpcSerialization.RpcSerialization | Socket.Socket
 > =>
-  Protocol.make(Effect.fnUntraced(function*(writeResponse) {
+  Protocol.make(Effect.fnUntraced(function*(writeResponse, clientIds) {
     const socket = yield* Socket.Socket
     const serialization = yield* RpcSerialization.RpcSerialization
+    const hooks = yield* Effect.serviceOption(ConnectionHooks)
+    const requestClientMap = new Map<string, number>()
 
     const write = yield* socket.writer
 
@@ -941,10 +948,14 @@ export const makeProtocolSocket = (options?: {
 
     const pinger = yield* makePinger(write(parser.encode(constPing)!))
     let currentError: RpcClientError | undefined
-    const clearCurrentError = Effect.sync(() => {
+    const onOpen = Effect.suspend(() => {
       currentError = undefined
+      return Option.isSome(hooks) ? hooks.value.onConnect : Effect.void
     })
 
+    const broadcast = (response: FromServerEncoded) =>
+      Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response))
+
     yield* Effect.suspend(() => {
       parser = serialization.makeUnsafe()
       pinger.reset()
@@ -959,13 +970,23 @@ export const makeProtocolSocket = (options?: {
               const response = responses[i++]
               if (response._tag === "Pong") {
                 pinger.onPong()
+                return Effect.void
+              }
+              if ("requestId" in response) {
+                const clientId = requestClientMap.get(response.requestId)
+                if (clientId !== undefined) {
+                  if (response._tag === "Exit") {
+                    requestClientMap.delete(response.requestId)
+                  }
+                  return writeResponse(clientId, response)
+                }
               }
-              return writeResponse(response)
+              return broadcast(response)
             },
             step: constVoid
           })
         } catch (defect) {
-          return writeResponse({
+          return broadcast({
             _tag: "ClientProtocolError",
             error: new RpcClientError({
               reason: new RpcClientDefect({
@@ -975,7 +996,7 @@ export const makeProtocolSocket = (options?: {
             })
           })
         }
-      }, { onOpen: clearCurrentError }).pipe(
+      }, { onOpen }).pipe(
         Effect.raceFirst(Effect.flatMap(
           pinger.timeout,
           () =>
@@ -993,6 +1014,7 @@ export const makeProtocolSocket = (options?: {
       Effect.flatMap(() =>
         Effect.fail(new Socket.SocketError({ reason: new Socket.SocketCloseError({ code: 1000 }) }))
       ),
+      Option.isSome(hooks) ? Effect.ensuring(hooks.value.onDisconnect) : identity,
       Effect.tapCause((cause) => {
         const error = Cause.findError(cause)
         const hasError = Result.isSuccess(error)
@@ -1008,7 +1030,7 @@ export const makeProtocolSocket = (options?: {
             cause: Cause.squash(cause)
           })
         })
-        return writeResponse({
+        return broadcast({
           _tag: "ClientProtocolError",
           error: currentError
         })
@@ -1022,10 +1044,13 @@ export const makeProtocolSocket = (options?: {
     )
 
     return {
-      send(request) {
+      send(clientId, request) {
         if (currentError) {
           return Effect.fail(currentError)
         }
+        if (request._tag === "Request") {
+          requestClientMap.set(request.id, clientId)
+        }
         const encoded = parser.encode(request)
         if (encoded === undefined) return Effect.void
         return Effect.orDie(write(encoded))
@@ -1096,17 +1121,22 @@ export const makeProtocolWorker = (
   WorkerError,
   Scope.Scope | Worker.WorkerPlatform | Worker.Spawner
 > =>
-  Protocol.make(Effect.fnUntraced(function*(writeResponse) {
+  Protocol.make(Effect.fnUntraced(function*(writeResponse, clientIds) {
     const worker = yield* Worker.WorkerPlatform
     const scope = yield* Effect.scope
     let workerId = 0
     const initialMessage = yield* Effect.serviceOption(RpcWorker.InitialMessage)
+    const hooks = yield* Effect.serviceOption(ConnectionHooks)
 
     const entries = new Map<string, {
+      readonly clientId: number
       readonly worker: Worker.Worker<FromServerEncoded, FromClientEncoded | RpcWorker.InitialMessage.Encoded>
       readonly latch: Latch.Latch
     }>()
 
+    const broadcast = (response: FromServerEncoded) =>
+      Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response))
+
     const acquire = Effect.gen(function*() {
       const id = workerId++
       const backing = yield* worker.spawn<FromServerEncoded, FromClientEncoded | RpcWorker.InitialMessage.Encoded>(id)
@@ -1117,16 +1147,21 @@ export const makeProtocolWorker = (
           if (entry) {
             entries.delete(response.requestId)
             entry.latch.openUnsafe()
-            return writeResponse(response)
+            return writeResponse(entry.clientId, response)
           }
         } else if (response._tag === "Defect") {
           for (const [requestId, entry] of entries) {
             entries.delete(requestId)
             entry.latch.openUnsafe()
           }
-          return writeResponse(response)
+          return broadcast(response)
+        } else if ("requestId" in response) {
+          const entry = entries.get(response.requestId)
+          if (entry) {
+            return writeResponse(entry.clientId, response)
+          }
         }
-        return writeResponse(response)
+        return broadcast(response)
       }, {
         onSpawn: Option.isSome(initialMessage) ?
           Effect.flatMap(
@@ -1137,7 +1172,7 @@ export const makeProtocolWorker = (
       }).pipe(
         Effect.tapCause((cause) => {
           const error = Cause.findError(cause)
-          return writeResponse({
+          return broadcast({
             _tag: "ClientProtocolError",
             error: new RpcClientError({
               reason: Result.isSuccess(error) ? error.success.reason : new RpcClientDefect({
@@ -1185,13 +1220,17 @@ export const makeProtocolWorker = (
       })
     )
 
-    const send = (request: FromClientEncoded, transferables?: ReadonlyArray<globalThis.Transferable>) => {
+    const send = (
+      clientId: number,
+      request: FromClientEncoded,
+      transferables?: ReadonlyArray<globalThis.Transferable>
+    ) => {
       switch (request._tag) {
         case "Request": {
           return Pool.get(pool).pipe(
             Effect.flatMap((worker) => {
               const latch = Latch.makeUnsafe(false)
-              entries.set(request.id, { worker, latch })
+              entries.set(request.id, { clientId, worker, latch })
               return Effect.flatMap(worker.send(request, transferables), () => latch.await)
             }),
             Effect.scoped,
@@ -1215,6 +1254,7 @@ export const makeProtocolWorker = (
     }
 
     yield* Effect.scoped(Pool.get(pool))
+    if (Option.isSome(hooks)) yield* hooks.value.onConnect
 
     return {
       send,
@@ -1245,6 +1285,15 @@ export const layerProtocolWorker: (
   Worker.WorkerPlatform | Worker.Spawner
 > = flow(makeProtocolWorker, Layer.effect(Protocol))
 
+/**
+ * @since 4.0.0
+ * @category ConnectionHooks
+ */
+export class ConnectionHooks extends Context.Service<ConnectionHooks, {
+  readonly onConnect: Effect.Effect<void>
+  readonly onDisconnect: Effect.Effect<void>
+}>()("effect/rpc/RpcClient/ConnectionHooks") {}
+
 // internal
 
 const decodeDefect = Schema.decodeSync(Schema.Defect)