@effect/platform 0.64.1 → 0.65.0

package/src/internal/httpClientResponse.ts

@@ -5,8 +5,8 @@ import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
-import type { Scope } from "effect/Scope"
 import * as Stream from "effect/Stream"
+import type { Unify } from "effect/Unify"
 import * as Cookies from "../Cookies.js"
 import * as Headers from "../Headers.js"
 import * as Error from "../HttpClientError.js"
@@ -194,63 +194,10 @@ export const schemaNoBody = <
     })
 }
 
-/** @internal */
-export const arrayBuffer = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
-  Effect.scoped(Effect.flatMap(effect, (_) => _.arrayBuffer))
-
-/** @internal */
-export const text = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
-  Effect.scoped(Effect.flatMap(effect, (_) => _.text))
-
-/** @internal */
-export const json = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
-  Effect.scoped(Effect.flatMap(effect, (_) => _.json))
-
-/** @internal */
-export const urlParamsBody = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
-  Effect.scoped(Effect.flatMap(effect, (_) => _.urlParamsBody))
-
-/** @internal */
-export const formData = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
-  Effect.scoped(Effect.flatMap(effect, (_) => _.formData))
-
-/** @internal */
-export const void_ = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
-  Effect.scoped(Effect.asVoid(effect))
-
 /** @internal */
 export const stream = <E, R>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) =>
   Stream.unwrapScoped(Effect.map(effect, (_) => _.stream))
 
-/** @internal */
-export const schemaJsonScoped = <
-  R,
-  I extends {
-    readonly status?: number | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-    readonly body?: unknown | undefined
-  },
-  A
->(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
-  const decode = schemaJson(schema, options)
-  return <E, R2>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R2>) =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
-/** @internal */
-export const schemaNoBodyScoped = <
-  R,
-  I extends {
-    readonly status?: number | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-  },
-  A
->(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
-  const decode = schemaNoBody(schema, options)
-  return <E, R2>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R2>) =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
 /** @internal */
 export const matchStatus = dual<
   <
@@ -264,7 +211,7 @@ export const matchStatus = dual<
     }
   >(
     cases: Cases
-  ) => (self: ClientResponse.HttpClientResponse) => Cases[keyof Cases] extends (_: any) => infer R ? R : never,
+  ) => (self: ClientResponse.HttpClientResponse) => Cases[keyof Cases] extends (_: any) => infer R ? Unify<R> : never,
   <
     const Cases extends {
       readonly [status: number]: (_: ClientResponse.HttpClientResponse) => any
@@ -274,7 +221,10 @@ export const matchStatus = dual<
       readonly "5xx"?: (_: ClientResponse.HttpClientResponse) => any
       readonly orElse: (_: ClientResponse.HttpClientResponse) => any
     }
-  >(self: ClientResponse.HttpClientResponse, cases: Cases) => Cases[keyof Cases] extends (_: any) => infer R ? R : never
+  >(
+    self: ClientResponse.HttpClientResponse,
+    cases: Cases
+  ) => Cases[keyof Cases] extends (_: any) => infer R ? Unify<R> : never
 >(2, (self, cases) => {
   const status = self.status
   if (cases[status]) {
@@ -290,43 +240,3 @@ export const matchStatus = dual<
   }
   return cases.orElse(self)
 })
-
-/** @internal */
-export const matchStatusScoped = dual<
-  <
-    const Cases extends {
-      readonly [status: number]: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "2xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "3xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "4xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "5xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly orElse: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-    }
-  >(cases: Cases) => <E, R>(self: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) => Effect.Effect<
-    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
-    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
-    Exclude<
-      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
-      Scope
-    >
-  >,
-  <
-    E,
-    R,
-    const Cases extends {
-      readonly [status: number]: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "2xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "3xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "4xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "5xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly orElse: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
-    }
-  >(self: Effect.Effect<ClientResponse.HttpClientResponse, E, R>, cases: Cases) => Effect.Effect<
-    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
-    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
-    Exclude<
-      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
-      Scope
-    >
-  >
->(2, (self, cases) => Effect.scoped(Effect.flatMap(self, matchStatus(cases) as any)))

package/src/internal/worker.ts

@@ -1,8 +1,6 @@
 import * as Schema from "@effect/schema/Schema"
 import * as Serializable from "@effect/schema/Serializable"
-import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
-import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
@@ -11,9 +9,9 @@ import * as FiberRef from "effect/FiberRef"
 import * as FiberSet from "effect/FiberSet"
 import { identity, pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as Mailbox from "effect/Mailbox"
 import * as Option from "effect/Option"
 import * as Pool from "effect/Pool"
-import * as Queue from "effect/Queue"
 import * as Schedule from "effect/Schedule"
 import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
@@ -62,7 +60,7 @@ export const makeManager = Effect.gen(function*() {
         let requestIdCounter = 0
         const requestMap = new Map<
           number,
-          Queue.Queue<Exit.Exit<ReadonlyArray<O>, E | WorkerError>> | Deferred.Deferred<O, E | WorkerError>
+          Mailbox.Mailbox<O, E | WorkerError> | Deferred.Deferred<O, E | WorkerError>
         >()
 
         const collector = Transferable.unsafeMakeCollector()
@@ -84,10 +82,10 @@ export const makeManager = Effect.gen(function*() {
           return handleMessage(message[1])
         }).pipe(
           Effect.onError((cause) =>
-            Effect.forEach(requestMap.values(), (queue) =>
-              Deferred.DeferredTypeId in queue
-                ? Deferred.failCause(queue, cause)
-                : Queue.offer(queue, Exit.failCause(cause)))
+            Effect.forEach(requestMap.values(), (mailbox) =>
+              Deferred.DeferredTypeId in mailbox
+                ? Deferred.failCause(mailbox, cause)
+                : mailbox.failCause(cause))
           ),
           Effect.retry(Schedule.spaced(1000)),
           Effect.annotateLogs({
@@ -100,10 +98,10 @@ export const makeManager = Effect.gen(function*() {
 
         yield* Effect.addFinalizer(() =>
           Effect.zipRight(
-            Effect.forEach(requestMap.values(), (queue) =>
-              Deferred.DeferredTypeId in queue
-                ? Deferred.interrupt(queue)
-                : Queue.offer(queue, Exit.failCause(Cause.empty)), {
+            Effect.forEach(requestMap.values(), (mailbox) =>
+              Deferred.DeferredTypeId in mailbox
+                ? Deferred.interrupt(mailbox)
+                : mailbox.end, {
               discard: true
             }),
             Effect.sync(() => requestMap.clear())
@@ -112,61 +110,58 @@ export const makeManager = Effect.gen(function*() {
 
         const handleMessage = (response: Worker.Worker.Response<E, O>) =>
           Effect.suspend(() => {
-            const queue = requestMap.get(response[0])
-            if (!queue) return Effect.void
+            const mailbox = requestMap.get(response[0])
+            if (!mailbox) return Effect.void
 
             switch (response[1]) {
               // data
               case 0: {
-                return Deferred.DeferredTypeId in queue
-                  ? Deferred.succeed(queue, response[2][0])
-                  : Queue.offer(queue, Exit.succeed(response[2]))
+                return Deferred.DeferredTypeId in mailbox
+                  ? Deferred.succeed(mailbox, response[2][0])
+                  : mailbox.offerAll(response[2])
               }
               // end
               case 1: {
                 if (response.length === 2) {
-                  return Deferred.DeferredTypeId in queue
-                    ? Deferred.interrupt(queue)
-                    : Queue.offer(queue, Exit.failCause(Cause.empty))
+                  return Deferred.DeferredTypeId in mailbox
+                    ? Deferred.interrupt(mailbox)
+                    : mailbox.end
                 }
-                return Deferred.DeferredTypeId in queue
-                  ? Deferred.succeed(queue, response[2][0])
-                  : Effect.zipRight(
-                    Queue.offer(queue, Exit.succeed(response[2])),
-                    Queue.offer(queue, Exit.failCause(Cause.empty))
-                  )
+                return Deferred.DeferredTypeId in mailbox
+                  ? Deferred.succeed(mailbox, response[2][0])
+                  : Effect.zipRight(mailbox.offerAll(response[2]), mailbox.end)
               }
               // error / defect
               case 2:
               case 3: {
                 if (response[1] === 2) {
-                  return Deferred.DeferredTypeId in queue
-                    ? Deferred.fail(queue, response[2])
-                    : Queue.offer(queue, Exit.fail(response[2]))
+                  return Deferred.DeferredTypeId in mailbox
+                    ? Deferred.fail(mailbox, response[2])
+                    : mailbox.fail(response[2])
                 }
                 const cause = WorkerError.decodeCause(response[2])
-                return Deferred.DeferredTypeId in queue
-                  ? Deferred.failCause(queue, cause)
-                  : Queue.offer(queue, Exit.failCause(cause))
+                return Deferred.DeferredTypeId in mailbox
+                  ? Deferred.failCause(mailbox, cause)
+                  : mailbox.failCause(cause)
               }
             }
           })
 
         const executeAcquire = <
-          Q extends Queue.Queue<Exit.Exit<ReadonlyArray<O>, E | WorkerError>> | Deferred.Deferred<O, E | WorkerError>
-        >(request: I, makeQueue: Effect.Effect<Q>) =>
+          Q extends Mailbox.Mailbox<O, E | WorkerError> | Deferred.Deferred<O, E | WorkerError>
+        >(request: I, makeMailbox: Effect.Effect<Q>) =>
           Effect.withFiberRuntime<{
             readonly id: number
-            readonly queue: Q
+            readonly mailbox: Q
           }>((fiber) => {
             const context = fiber.getFiberRef(FiberRef.currentContext)
             const span = Context.getOption(context, Tracer.ParentSpan).pipe(
               Option.filter((span): span is Tracer.Span => span._tag === "Span")
             )
             const id = requestIdCounter++
-            return makeQueue.pipe(
-              Effect.tap((queue) => {
-                requestMap.set(id, queue)
+            return makeMailbox.pipe(
+              Effect.tap((mailbox) => {
+                requestMap.set(id, mailbox)
                 return wrappedEncode(request).pipe(
                   Effect.tap((payload) =>
                     backing.send([
@@ -177,13 +172,13 @@ export const makeManager = Effect.gen(function*() {
                     ], collector.unsafeRead())
                   ),
                   Effect.catchAllCause((cause) =>
-                    Deferred.DeferredTypeId in queue ?
-                      Deferred.failCause(queue, cause) :
-                      Queue.offer(queue, Exit.failCause(cause))
+                    Mailbox.isMailbox<O, E | WorkerError>(mailbox)
+                      ? mailbox.failCause(cause)
+                      : Deferred.failCause(mailbox, cause)
                   )
                 )
               }),
-              Effect.map((queue) => ({ id, queue }))
+              Effect.map((mailbox) => ({ id, mailbox }))
             )
           })
 
@@ -197,18 +192,8 @@ export const makeManager = Effect.gen(function*() {
         const execute = (request: I) =>
           Stream.fromChannel(
             Channel.acquireUseRelease(
-              executeAcquire(request, Queue.unbounded<Exit.Exit<ReadonlyArray<O>, E | WorkerError>>()),
-              ({ queue }) => {
-                const loop: Channel.Channel<Chunk.Chunk<O>, unknown, E | WorkerError, unknown, void, unknown> = Channel
-                  .flatMap(
-                    Queue.take(queue),
-                    Exit.match({
-                      onFailure: (cause) => Cause.isEmpty(cause) ? Channel.void : Channel.failCause(cause),
-                      onSuccess: (value) => Channel.flatMap(Channel.write(Chunk.unsafeFromArray(value)), () => loop)
-                    })
-                  )
-                return loop
-              },
+              executeAcquire(request, Mailbox.make<O, E | WorkerError>()),
+              ({ mailbox }) => Mailbox.toChannel(mailbox),
               executeRelease
             )
           )
@@ -216,7 +201,7 @@ export const makeManager = Effect.gen(function*() {
         const executeEffect = (request: I) =>
           Effect.acquireUseRelease(
             executeAcquire(request, Deferred.make<O, WorkerError | E>()),
-            ({ queue }) => Deferred.await(queue),
+            ({ mailbox }) => Deferred.await(mailbox),
             executeRelease
           )