@effect/platform 0.13.9 → 0.13.11

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/router.ts

@@ -12,6 +12,7 @@ import type * as Method from "@effect/platform/Http/Method"
 import type * as Router from "@effect/platform/Http/Router"
 import * 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 Schema from "@effect/schema/Schema"
 import * as Channel from "@effect/stream/Channel"
 import * as Sink from "@effect/stream/Sink"
@@ -133,7 +134,7 @@ const toHttpApp = <R, E>(
         request = sliceRequestUrl(request, route.prefix.value)
       }
       return Effect.mapInputContext(
-        route.handler,
+        route.handler as Effect.Effect<Exclude<R, Router.RouteContext>, E, ServerResponse.ServerResponse>,
         (context) =>
           Context.add(
             Context.add(context, ServerRequest.ServerRequest, request),
@@ -241,15 +242,18 @@ export const mountApp = dual<
   <R1, E1>(
     path: string,
     that: App.Default<R1, E1>
-  ) => <R, E>(self: Router.Router<R, E>) => Router.Router<R | R1, E | E1>,
+  ) => <R, E>(
+    self: Router.Router<R, E>
+  ) => Router.Router<Exclude<R | R1, Router.RouteContext | ServerRequest.ServerRequest>, E | E1>,
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
     path: string,
     that: App.Default<R1, E1>
-  ) => Router.Router<R | R1, E | E1>
+  ) => Router.Router<Exclude<R | R1, Router.RouteContext | ServerRequest.ServerRequest>, E | E1>
 >(
   3,
-  (self, path, that) => new RouterImpl(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that]) as any)
+  (self, path, that) =>
+    new RouterImpl<any, any>(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that]))
 )
 
 /** @internal */
@@ -257,23 +261,27 @@ export const route = (method: Method.Method | "*"): {
   <R1, E1>(
     path: string,
     handler: Router.Route.Handler<R1, E1>
-  ): <R, E>(self: Router.Router<R, E>) => Router.Router<R | Exclude<R1, Router.RouteContext>, E1 | E>
+  ): <R, E>(
+    self: Router.Router<R, E>
+  ) => Router.Router<R | Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>, E1 | E>
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
     path: string,
     handler: Router.Route.Handler<R1, E1>
-  ): Router.Router<R | Exclude<R1, Router.RouteContext>, E | E1>
+  ): Router.Router<R | Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>, E | E1>
 } =>
   dual<
     <R1, E1>(
       path: string,
       handler: Router.Route.Handler<R1, E1>
-    ) => <R, E>(self: Router.Router<R, E>) => Router.Router<R | Exclude<R1, Router.RouteContext>, E | E1>,
+    ) => <R, E>(
+      self: Router.Router<R, E>
+    ) => Router.Router<R | Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>, E | E1>,
     <R, E, R1, E1>(
       self: Router.Router<R, E>,
       path: string,
       handler: Router.Route.Handler<R1, E1>
-    ) => Router.Router<R | Exclude<R1, Router.RouteContext>, E | E1>
+    ) => Router.Router<R | Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>, E | E1>
   >(3, (self, path, handler) =>
     new RouterImpl(
       Chunk.append(self.routes, new RouteImpl(method, path, handler)) as any,
@@ -307,17 +315,17 @@ export const options = route("OPTIONS")
 /** @internal */
 export const use = dual<
   <R, E, R1, E1>(
-    f: (self: Router.Route.Handler<R, E>) => Router.Route.Handler<R1, E1>
-  ) => (self: Router.Router<R, E>) => Router.Router<R1, E1>,
+    f: (self: Router.Route.Handler<R, E>) => App.Default<R1, E1>
+  ) => (self: Router.Router<R, E>) => Router.Router<Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>, E1>,
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
-    f: (self: Router.Route.Handler<R, E>) => Router.Route.Handler<R1, E1>
-  ) => Router.Router<R1, E1>
+    f: (self: Router.Route.Handler<R, E>) => App.Default<R1, E1>
+  ) => Router.Router<Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest>, E1>
 >(2, (self, f) =>
-  new RouterImpl(
+  new RouterImpl<any, any>(
     Chunk.map(
       self.routes,
-      (route) => new RouteImpl(route.method, route.path, f(route.handler), route.prefix)
+      (route) => new RouteImpl(route.method, route.path, f(route.handler) as any, route.prefix)
     ),
     Chunk.map(
       self.mounts,
@@ -412,19 +420,31 @@ export const provideService = dual<
     tag: T,
     service: Context.Tag.Service<T>
   ) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>
->(3, (self, tag, service) => use(self, Effect.provideService(tag, service)))
+>(3, <R, E, T extends Context.Tag<any, any>>(
+  self: Router.Router<R, E>,
+  tag: T,
+  service: Context.Tag.Service<T>
+): Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E> => use(self, Effect.provideService(tag, service)))
 
 /* @internal */
 export const provideServiceEffect = dual<
   <T extends Context.Tag<any, any>, R1, E1>(
     tag: T,
     effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
-  ) => <R, E>(self: Router.Router<R, E>) => Router.Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1>,
+  ) => <R, E>(
+    self: Router.Router<R, E>
+  ) => Router.Router<
+    Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest> | Exclude<R, Context.Tag.Identifier<T>>,
+    E | E1
+  >,
   <R, E, T extends Context.Tag<any, any>, R1, E1>(
     self: Router.Router<R, E>,
     tag: T,
     effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
-  ) => Router.Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1>
+  ) => Router.Router<
+    Exclude<R1, Router.RouteContext | ServerRequest.ServerRequest> | Exclude<R, Context.Tag.Identifier<T>>,
+    E | E1
+  >
 >(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
   self: Router.Router<R, E>,
   tag: T,

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(