@effect/platform 0.13.8 → 0.13.10

package/src/Http/ServerResponse.ts

@@ -8,8 +8,6 @@ import type * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import type * as Etag from "@effect/platform/Http/Etag"
 import type * as Headers from "@effect/platform/Http/Headers"
-import type * as Error from "@effect/platform/Http/ServerError"
-import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
 import type * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internal from "@effect/platform/internal/http/serverResponse"
 import type * as Schema from "@effect/schema/Schema"
@@ -39,19 +37,6 @@ export interface ServerResponse extends Pipeable {
   readonly body: Body.Body
 }
 
-/**
- * @since 1.0.0
- */
-export namespace ServerResponse {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface NonEffectBody extends ServerResponse {
-    readonly body: Body.NonEffect
-  }
-}
-
 /**
  * @since 1.0.0
  * @category models
@@ -86,14 +71,6 @@ export namespace Options {
  */
 export const isServerResponse: (u: unknown) => u is ServerResponse = internal.isServerResponse
 
-/**
- * @since 1.0.0
- */
-export const toNonEffectBody: (
-  self: ServerResponse
-) => Effect.Effect<ServerRequest.ServerRequest, Error.ResponseError, ServerResponse.NonEffectBody> =
-  internal.toNonEffectBody
-
 /**
  * @since 1.0.0
  * @category constructors
@@ -116,7 +93,10 @@ export const text: (body: string, options?: Options.WithContentType) => ServerRe
  * @since 1.0.0
  * @category constructors
  */
-export const json: (body: unknown, options?: Options.WithContent) => ServerResponse = internal.json
+export const json: (
+  body: unknown,
+  options?: Options.WithContent
+) => Effect.Effect<never, Body.BodyError, ServerResponse> = internal.json
 
 /**
  * @since 1.0.0
@@ -124,7 +104,8 @@ export const json: (body: unknown, options?: Options.WithContent) => ServerRespo
  */
 export const schemaJson: <I, A>(
   schema: Schema.Schema<I, A>
-) => (body: A, options?: Options.WithContent) => ServerResponse = internal.schemaJson
+) => (body: A, options?: Options.WithContent) => Effect.Effect<never, Body.BodyError, ServerResponse> =
+  internal.schemaJson
 
 /**
  * @since 1.0.0
@@ -138,15 +119,6 @@ export const unsafeJson: (body: unknown, options?: Options.WithContent) => Serve
  */
 export const urlParams: (body: UrlParams.Input, options?: Options.WithContent) => ServerResponse = internal.urlParams
 
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const effect: (
-  body: Effect.Effect<never, unknown, Body.NonEffect>,
-  options?: Options.WithContent
-) => ServerResponse = internal.effect
-
 /**
  * @since 1.0.0
  * @category constructors

package/src/internal/http/body.ts

@@ -1,3 +1,4 @@
+import * as Data from "@effect/data/Data"
 import * as Effect from "@effect/io/Effect"
 import type * as PlatformError from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
@@ -10,6 +11,17 @@ export const TypeId: Body.TypeId = Symbol.for(
   "@effect/platform/Http/Body"
 ) as Body.TypeId
 
+/** @internal */
+export const ErrorTypeId: Body.ErrorTypeId = Symbol.for(
+  "@effect/platform/Http/Body/BodyError"
+) as Body.ErrorTypeId
+
+const bodyError = Data.tagged<Body.BodyError>("BodyError")
+
+/** @internal */
+export const BodyError = (reason: Body.BodyErrorReason): Body.BodyError =>
+  bodyError({ [ErrorTypeId]: ErrorTypeId, reason })
+
 class EmptyImpl implements Body.Empty {
   readonly [TypeId]: Body.TypeId
   readonly _tag = "Empty"
@@ -59,37 +71,25 @@ export const uint8Array = (body: Uint8Array, contentType?: string): Body.Uint8Ar
 export const text = (body: string, contentType?: string): Body.Uint8Array =>
   uint8Array(new TextEncoder().encode(body), contentType ?? "text/plain")
 
-class EffectBodyImpl implements Body.EffectBody {
-  readonly [TypeId]: Body.TypeId
-  readonly _tag = "Effect"
-  constructor(
-    readonly effect: Effect.Effect<never, unknown, Body.NonEffect>,
-    readonly contentType?: string
-  ) {
-    this[TypeId] = TypeId
-  }
-}
-
-/** @internal */
-export const effect = (
-  body: Effect.Effect<never, unknown, Body.NonEffect>
-): Body.EffectBody => new EffectBodyImpl(body)
-
 /** @internal */
 export const unsafeJson = (body: unknown): Body.Uint8Array =>
   uint8Array(new TextEncoder().encode(JSON.stringify(body)), "application/json")
 
 /** @internal */
-export const json = (body: unknown): Body.EffectBody => effect(Effect.try(() => unsafeJson(body)))
+export const json = (body: unknown): Effect.Effect<never, Body.BodyError, Body.Uint8Array> =>
+  Effect.try({
+    try: () => unsafeJson(body),
+    catch: (error) => BodyError({ _tag: "JsonError", error })
+  })
 
 /** @internal */
 export const jsonSchema = <I, A>(schema: Schema.Schema<I, A>) => {
   const encode = Schema.encode(schema)
-  return (body: A): Body.EffectBody =>
-    effect(Effect.flatMap(
-      encode(body),
-      (json) => Effect.try(() => unsafeJson(json))
-    ))
+  return (body: A): Effect.Effect<never, Body.BodyError, Body.Uint8Array> =>
+    Effect.flatMap(
+      Effect.mapError(encode(body), (error) => BodyError({ _tag: "SchemaError", error })),
+      json
+    )
 }
 
 /** @internal */

package/src/internal/http/client.ts

@@ -43,17 +43,9 @@ const setProto = <R, E, A>(
 /** @internal */
 export const make = (
   f: (
-    request: ClientRequest.ClientRequest.NonEffectBody
+    request: ClientRequest.ClientRequest
   ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
-): Client.Client.Default => {
-  function client(request: ClientRequest.ClientRequest) {
-    return Effect.flatMap(
-      internalRequest.resolveBody(request),
-      (request) => f(request)
-    )
-  }
-  return setProto(client)
-}
+): Client.Client.Default => setProto(f)
 
 /** @internal */
 export const fetch = (
@@ -98,7 +90,7 @@ export const fetch = (
     )
   )
 
-const convertBody = (body: Body.NonEffect): BodyInit | undefined => {
+const convertBody = (body: Body.Body): BodyInit | undefined => {
   switch (body._tag) {
     case "Empty":
       return undefined

package/src/internal/http/clientRequest.ts

@@ -10,7 +10,6 @@ import * as Headers from "@effect/platform/Http/Headers"
 import type { Method } from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
-import * as internalError from "@effect/platform/internal/http/clientError"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
 
@@ -313,20 +312,6 @@ export const uint8ArrayBody = dual<
   (self, body, contentType = "application/octet-stream") => setBody(self, internalBody.uint8Array(body, contentType))
 )
 
-/** @internal */
-export const effectBody = dual<
-  (
-    body: Effect.Effect<never, unknown, Body.NonEffect>
-  ) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (
-    self: ClientRequest.ClientRequest,
-    body: Effect.Effect<never, unknown, Body.NonEffect>
-  ) => ClientRequest.ClientRequest
->(
-  2,
-  (self, body) => setBody(self, internalBody.effect(body))
-)
-
 /** @internal */
 export const textBody = dual<
   (body: string, contentType?: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
@@ -338,9 +323,14 @@ export const textBody = dual<
 
 /** @internal */
 export const jsonBody = dual<
-  (body: unknown) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, body: unknown) => ClientRequest.ClientRequest
->(2, (self, body) => setBody(self, internalBody.json(body)))
+  (
+    body: unknown
+  ) => (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>,
+  (
+    self: ClientRequest.ClientRequest,
+    body: unknown
+  ) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+>(2, (self, body) => Effect.map(internalBody.json(body), (body) => setBody(self, body)))
 
 /** @internal */
 export const unsafeJsonBody = dual<
@@ -368,14 +358,16 @@ export const fileBody = dual<
 
 /** @internal */
 export const schemaBody = <I, A>(schema: Schema.Schema<I, A>): {
-  (body: A): (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  (self: ClientRequest.ClientRequest, body: A): ClientRequest.ClientRequest
+  (body: A): (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+  (self: ClientRequest.ClientRequest, body: A): Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
 } => {
   const encode = internalBody.jsonSchema(schema)
   return dual<
-    (body: A) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-    (self: ClientRequest.ClientRequest, body: A) => ClientRequest.ClientRequest
-  >(2, (self, body) => setBody(self, encode(body)))
+    (
+      body: A
+    ) => (self: ClientRequest.ClientRequest) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>,
+    (self: ClientRequest.ClientRequest, body: A) => Effect.Effect<never, Body.BodyError, ClientRequest.ClientRequest>
+  >(2, (self, body) => Effect.map(encode(body), (body) => setBody(self, body)))
 }
 
 /** @internal */
@@ -419,19 +411,3 @@ export const streamBody = dual<
   (self, body, { contentLength, contentType = "application/octet-stream" } = {}) =>
     setBody(self, internalBody.stream(body, contentType, contentLength))
 )
-
-/** @internal */
-export const resolveBody = (
-  self: ClientRequest.ClientRequest
-): Effect.Effect<never, Error.RequestError, ClientRequest.ClientRequest.NonEffectBody> =>
-  self.body._tag === "Effect"
-    ? Effect.map(
-      Effect.mapError(self.body.effect, (error) =>
-        internalError.requestError({
-          reason: "Encode",
-          request: self,
-          error
-        })),
-      (body) => setBody(self, body) as ClientRequest.ClientRequest.NonEffectBody
-    )
-    : Effect.succeed(self as ClientRequest.ClientRequest.NonEffectBody)

package/src/internal/http/middleware.ts

@@ -8,11 +8,12 @@ import * as ServerRequest from "@effect/platform/Http/ServerRequest"
 export const make = <M extends Middleware.Middleware>(middleware: M): M => middleware
 
 /** @internal */
-export const logger = make((httpApp) =>
-  Effect.withLogSpan(
-    Effect.flatMap(
-      ServerRequest.ServerRequest,
-      (request) =>
+export const logger = make((httpApp) => {
+  let counter = 0
+  return Effect.flatMap(
+    ServerRequest.ServerRequest,
+    (request) =>
+      Effect.withLogSpan(
         Effect.tap(
           Effect.tapErrorCause(httpApp, (cause) =>
             Effect.annotateLogs(Effect.log(cause), {
@@ -26,11 +27,11 @@ export const logger = make((httpApp) =>
               "http.url": request.url,
               "http.status": response.status
             })
-        )
-    ),
-    "http.span"
+        ),
+        `http.span.${++counter}`
+      )
   )
-)
+})
 
 /** @internal */
 export const tracer = make((httpApp) =>

package/src/internal/http/serverResponse.ts

@@ -6,12 +6,9 @@ import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import * as Etag from "@effect/platform/Http/Etag"
 import * as Headers from "@effect/platform/Http/Headers"
-import type * as Error from "@effect/platform/Http/ServerError"
-import * as ServerRequest from "@effect/platform/Http/ServerRequest"
 import type * as ServerResponse from "@effect/platform/Http/ServerResponse"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
-import * as internalError from "@effect/platform/internal/http/serverError"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
 import * as Mime from "mime"
@@ -51,29 +48,6 @@ class ServerResponseImpl implements ServerResponse.ServerResponse {
 export const isServerResponse = (u: unknown): u is ServerResponse.ServerResponse =>
   typeof u === "object" && u !== null && TypeId in u
 
-/** @internal */
-export const toNonEffectBody = (
-  self: ServerResponse.ServerResponse
-): Effect.Effect<ServerRequest.ServerRequest, Error.ResponseError, ServerResponse.ServerResponse.NonEffectBody> =>
-  self.body._tag === "Effect" ?
-    Effect.map(
-      Effect.catchAll(self.body.effect, (error) =>
-        Effect.flatMap(
-          ServerRequest.ServerRequest,
-          (request) =>
-            Effect.fail(
-              internalError.responseError({
-                reason: "Decode",
-                request,
-                response: self,
-                error
-              })
-            )
-        )),
-      (body) => setBody(self, body) as ServerResponse.ServerResponse.NonEffectBody
-    ) :
-    Effect.succeed(self as ServerResponse.ServerResponse.NonEffectBody)
-
 /** @internal */
 export const empty = (options?: ServerResponse.Options.WithContent): ServerResponse.ServerResponse =>
   new ServerResponseImpl(
@@ -105,13 +79,17 @@ export const text = (body: string, options?: ServerResponse.Options.WithContentT
   )
 
 /** @internal */
-export const json = (body: unknown, options?: ServerResponse.Options.WithContent): ServerResponse.ServerResponse =>
-  new ServerResponseImpl(
-    options?.status ?? 200,
-    options?.statusText,
-    options?.headers ?? Headers.empty,
-    internalBody.json(body)
-  )
+export const json = (
+  body: unknown,
+  options?: ServerResponse.Options.WithContent
+): Effect.Effect<never, Body.BodyError, ServerResponse.ServerResponse> =>
+  Effect.map(internalBody.json(body), (body) =>
+    new ServerResponseImpl(
+      options?.status ?? 200,
+      options?.statusText,
+      options?.headers ?? Headers.empty,
+      body
+    ))
 
 /** @internal */
 export const unsafeJson = (
@@ -130,13 +108,17 @@ export const schemaJson = <I, A>(
   schema: Schema.Schema<I, A>
 ) => {
   const encode = internalBody.jsonSchema(schema)
-  return (body: A, options?: ServerResponse.Options.WithContent): ServerResponse.ServerResponse =>
-    new ServerResponseImpl(
-      options?.status ?? 200,
-      options?.statusText,
-      options?.headers ?? Headers.empty,
-      encode(body)
-    )
+  return (
+    body: A,
+    options?: ServerResponse.Options.WithContent
+  ): Effect.Effect<never, Body.BodyError, ServerResponse.ServerResponse> =>
+    Effect.map(encode(body), (body) =>
+      new ServerResponseImpl(
+        options?.status ?? 200,
+        options?.statusText,
+        options?.headers ?? Headers.empty,
+        body
+      ))
 }
 
 /** @internal */
@@ -189,18 +171,6 @@ export const urlParams = (
     internalBody.text(UrlParams.toString(UrlParams.fromInput(body)), "application/x-www-form-urlencoded")
   )
 
-/** @internal */
-export const effect = (
-  body: Effect.Effect<never, unknown, Body.NonEffect>,
-  options?: ServerResponse.Options.WithContent
-): ServerResponse.ServerResponse =>
-  new ServerResponseImpl(
-    options?.status ?? 200,
-    options?.statusText,
-    options?.headers ?? Headers.empty,
-    internalBody.effect(body)
-  )
-
 /** @internal */
 export const raw = (body: unknown, options?: ServerResponse.Options): ServerResponse.ServerResponse =>
   new ServerResponseImpl(