@effect/platform 0.44.6 → 0.45.0

package/src/Http/ClientResponse.ts

@@ -4,10 +4,13 @@
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
+import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
 import * as internal from "../internal/http/clientResponse.js"
 import type * as Error from "./ClientError.js"
 import type * as ClientRequest from "./ClientRequest.js"
 import type * as IncomingMessage from "./IncomingMessage.js"
+import type * as UrlParams from "./UrlParams.js"
 
 export {
   /**
@@ -15,6 +18,11 @@ export {
    * @category schema
    */
   schemaBodyJson,
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  schemaBodyJsonEffect,
   /**
    * @since 1.0.0
    * @category schema
@@ -24,7 +32,17 @@ export {
    * @since 1.0.0
    * @category schema
    */
-  schemaHeaders
+  schemaBodyUrlParamsEffect,
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  schemaHeaders,
+  /**
+   * @since 1.0.0
+   * @category schema
+   */
+  schemaHeadersEffect
 } from "./IncomingMessage.js"
 
 /**
@@ -84,3 +102,88 @@ export const schemaNoBody: <
   A
 >(schema: Schema.Schema<A, I, R>) => (self: ClientResponse) => Effect.Effect<A, ParseResult.ParseError, R> =
   internal.schemaNoBody
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const arrayBuffer: <E, R>(
+  effect: Effect.Effect<ClientResponse, E, R>
+) => Effect.Effect<ArrayBuffer, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.arrayBuffer
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const formData: <E, R>(
+  effect: Effect.Effect<ClientResponse, E, R>
+) => Effect.Effect<FormData, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.formData
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const json: <E, R>(
+  effect: Effect.Effect<ClientResponse, E, R>
+) => Effect.Effect<unknown, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.json
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const stream: <E, R>(
+  effect: Effect.Effect<ClientResponse, E, R>
+) => Stream.Stream<Uint8Array, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.stream
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const text: <E, R>(
+  effect: Effect.Effect<ClientResponse, E, R>
+) => Effect.Effect<string, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.text
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const urlParamsBody: <E, R>(
+  effect: Effect.Effect<ClientResponse, E, R>
+) => Effect.Effect<UrlParams.UrlParams, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.urlParamsBody
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaJsonEffect: <
+  R,
+  I extends {
+    readonly status?: number | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+    readonly body?: unknown
+  },
+  A
+>(
+  schema: Schema.Schema<A, I, R>
+) => <E, R2>(
+  effect: Effect.Effect<ClientResponse, E, R2>
+) => Effect.Effect<
+  A,
+  Error.ResponseError | E | ParseResult.ParseError,
+  Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>
+> = internal.schemaJsonEffect
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaNoBodyEffect: <
+  R,
+  I extends { readonly status?: number | undefined; readonly headers?: Readonly<Record<string, string>> | undefined },
+  A
+>(
+  schema: Schema.Schema<A, I, R>
+) => <E, R2>(
+  effect: Effect.Effect<ClientResponse, E, R2>
+) => Effect.Effect<A, E | ParseResult.ParseError, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =
+  internal.schemaNoBodyEffect

package/src/Http/IncomingMessage.ts

@@ -52,6 +52,15 @@ export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
     Effect.flatMap(self.json, parse)
 }
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyJsonEffect = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
+  const decode = schemaBodyJson(schema)
+  return <E, E2, R2>(effect: Effect.Effect<IncomingMessage<E>, E2, R2>) => Effect.scoped(Effect.flatMap(effect, decode))
+}
+
 /**
  * @since 1.0.0
  * @category schema
@@ -64,6 +73,17 @@ export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>
     Effect.flatMap(self.urlParamsBody, (_) => parse(Object.fromEntries(_)))
 }
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyUrlParamsEffect = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<A, I, R>
+) => {
+  const decode = schemaBodyUrlParams(schema)
+  return <E, E2, R2>(effect: Effect.Effect<IncomingMessage<E>, E2, R2>) => Effect.scoped(Effect.flatMap(effect, decode))
+}
+
 /**
  * @since 1.0.0
  * @category schema
@@ -73,6 +93,17 @@ export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(
   return <E>(self: IncomingMessage<E>): Effect.Effect<A, ParseResult.ParseError, R> => parse(self.headers)
 }
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaHeadersEffect = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<A, I, R>
+) => {
+  const decode = schemaHeaders(schema)
+  return <E, E2, R2>(effect: Effect.Effect<IncomingMessage<E>, E2, R2>) => Effect.scoped(Effect.flatMap(effect, decode))
+}
+
 const SpanSchema = Schema.struct({
   traceId: Schema.string,
   spanId: Schema.string,

package/src/internal/http/client.ts

@@ -2,11 +2,12 @@ import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import { dual } from "effect/Function"
+import { dual, pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import { pipeArguments } from "effect/Pipeable"
 import type * as Predicate from "effect/Predicate"
 import type * as Schedule from "effect/Schedule"
+import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type * as Body from "../../Http/Body.js"
 import type * as Client from "../../Http/Client.js"
@@ -68,7 +69,7 @@ const addB3Headers = (req: ClientRequest.ClientRequest) =>
 export const makeDefault = (
   f: (
     request: ClientRequest.ClientRequest
-  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError>
+  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError, Scope.Scope>
 ): Client.Client.Default => make(Effect.flatMap(f), addB3Headers)
 
 /** @internal */
@@ -91,25 +92,31 @@ export const fetch = (options?: RequestInit): Client.Client.Default =>
           const fetch = fetch_._tag === "Some" ? fetch_.value : globalThis.fetch
           const headers = new Headers(request.headers)
           const send = (body: BodyInit | undefined) =>
-            Effect.map(
-              Effect.tryPromise({
-                try: (signal) =>
-                  fetch(url, {
-                    ...options,
-                    method: request.method,
-                    headers,
-                    body,
-                    duplex: request.body._tag === "Stream" ? "half" : undefined,
-                    signal
-                  } as any),
-                catch: (_) =>
-                  internalError.requestError({
-                    request,
-                    reason: "Transport",
-                    error: _
-                  })
-              }),
-              (_) => internalResponse.fromWeb(request, _)
+            pipe(
+              Effect.acquireRelease(
+                Effect.sync(() => new AbortController()),
+                (controller) => Effect.sync(() => controller.abort())
+              ),
+              Effect.flatMap((controller) =>
+                Effect.tryPromise({
+                  try: () =>
+                    fetch(url, {
+                      ...options,
+                      method: request.method,
+                      headers,
+                      body,
+                      duplex: request.body._tag === "Stream" ? "half" : undefined,
+                      signal: controller.signal
+                    } as any),
+                  catch: (_) =>
+                    internalError.requestError({
+                      request,
+                      reason: "Transport",
+                      error: _
+                    })
+                })
+              ),
+              Effect.map((_) => internalResponse.fromWeb(request, _))
             )
           if (Method.hasBody(request.method)) {
             return send(convertBody(request.body))
@@ -449,6 +456,22 @@ export const mapEffect = dual<
   ) => Client.Client<R | R2, E | E2, B>
 >(2, (self, f) => transformResponse(self, Effect.flatMap(f)))
 
+/** @internal */
+export const scoped = <R, E, A>(
+  self: Client.Client<R, E, A>
+): Client.Client<Exclude<R, Scope.Scope>, E, A> => transformResponse(self, Effect.scoped)
+
+/** @internal */
+export const mapEffectScoped = dual<
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<Exclude<R | R2, Scope.Scope>, E | E2, B>,
+  <R, E, A, R2, E2, B>(
+    self: Client.Client<R, E, A>,
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ) => Client.Client<Exclude<R | R2, Scope.Scope>, E | E2, B>
+>(2, (self, f) => scoped(mapEffect(self, f)))
+
 /** @internal */
 export const mapRequest = dual<
   (
@@ -532,7 +555,7 @@ export const schemaFunction = dual<
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, Exclude<SR | R, Scope.Scope>>,
   <R, E, A, SA, SI, SR>(
     self: Client.Client<R, E, A>,
     schema: Schema.Schema<SA, SI, SR>
@@ -540,27 +563,29 @@ export const schemaFunction = dual<
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, Exclude<SR | R, Scope.Scope>>
 >(2, (self, schema) => {
   const encode = Schema.encode(schema)
   return (request) => (a) =>
-    Effect.flatMap(
-      Effect.tryMap(encode(a), {
-        try: (body) => new TextEncoder().encode(JSON.stringify(body)),
-        catch: (error) =>
-          internalError.requestError({
-            request,
-            reason: "Encode",
-            error
-          })
-      }),
-      (body) =>
-        self(
-          internalRequest.setBody(
-            request,
-            internalBody.uint8Array(body, "application/json")
+    Effect.scoped(
+      Effect.flatMap(
+        Effect.tryMap(encode(a), {
+          try: (body) => new TextEncoder().encode(JSON.stringify(body)),
+          catch: (error) =>
+            internalError.requestError({
+              request,
+              reason: "Encode",
+              error
+            })
+        }),
+        (body) =>
+          self(
+            internalRequest.setBody(
+              request,
+              internalBody.uint8Array(body, "application/json")
+            )
           )
-        )
+      )
     )
 })
 

package/src/internal/http/clientResponse.ts

@@ -170,3 +170,56 @@ export const schemaNoBody = <
       headers: self.headers
     })
 }
+
+/** @internal */
+export const arrayBuffer = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.arrayBuffer))
+
+/** @internal */
+export const text = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.text))
+
+/** @internal */
+export const json = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.json))
+
+/** @internal */
+export const urlParamsBody = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.urlParamsBody))
+
+/** @internal */
+export const formData = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.formData))
+
+/** @internal */
+export const stream = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Stream.unwrapScoped(Effect.map(effect, (_) => _.stream))
+
+/** @internal */
+export const schemaJsonEffect = <
+  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>) => {
+  const decode = schemaJson(schema)
+  return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
+    Effect.scoped(Effect.flatMap(effect, decode))
+}
+
+/** @internal */
+export const schemaNoBodyEffect = <
+  R,
+  I extends {
+    readonly status?: number | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+  },
+  A
+>(schema: Schema.Schema<A, I, R>) => {
+  const decode = schemaNoBody(schema)
+  return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
+    Effect.scoped(Effect.flatMap(effect, decode))
+}