@effect/platform 0.57.8 → 0.58.1

package/src/internal/{http/multiplex.ts → httpMultiplex.ts}

@@ -3,25 +3,26 @@ import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
-import type * as App from "../../Http/App.js"
-import type * as Multiplex from "../../Http/Multiplex.js"
-import * as Error from "../../Http/ServerError.js"
-import * as ServerRequest from "../../Http/ServerRequest.js"
-import type * as ServerResponse from "../../Http/ServerResponse.js"
+import type * as App from "../HttpApp.js"
+import type * as Multiplex from "../HttpMultiplex.js"
+import * as Error from "../HttpServerError.js"
+import * as ServerRequest from "../HttpServerRequest.js"
+import type * as ServerResponse from "../HttpServerResponse.js"
 
 /** @internal */
-export const TypeId: Multiplex.TypeId = Symbol.for("@effect/platform/Http/Multiplex") as Multiplex.TypeId
+export const TypeId: Multiplex.TypeId = Symbol.for("@effect/platform/HttpMultiplex") as Multiplex.TypeId
 
-class MultiplexImpl<E = never, R = never>
-  extends Effectable.Class<ServerResponse.ServerResponse, E | Error.RouteNotFound, R | ServerRequest.ServerRequest>
-  implements Multiplex.Multiplex<E, R>
-{
+class MultiplexImpl<E = never, R = never> extends Effectable.Class<
+  ServerResponse.HttpServerResponse,
+  E | Error.RouteNotFound,
+  R | ServerRequest.HttpServerRequest
+> implements Multiplex.HttpMultiplex<E, R> {
   readonly [TypeId]: Multiplex.TypeId
 
   constructor(
     readonly apps: ReadonlyArray<
       readonly [
-        predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>,
+        predicate: (request: ServerRequest.HttpServerRequest) => Effect.Effect<boolean, E, R>,
         app: App.Default<E, R>
       ]
     >
@@ -29,7 +30,7 @@ class MultiplexImpl<E = never, R = never>
     super()
     this[TypeId] = TypeId
 
-    let execute: (request: ServerRequest.ServerRequest) => App.Default<E | Error.RouteNotFound, R> = (request) =>
+    let execute: (request: ServerRequest.HttpServerRequest) => App.Default<E | Error.RouteNotFound, R> = (request) =>
       Effect.fail(new Error.RouteNotFound({ request }))
 
     for (let i = apps.length - 1; i >= 0; i--) {
@@ -42,7 +43,7 @@ class MultiplexImpl<E = never, R = never>
         )
     }
 
-    this.execute = Effect.flatMap(ServerRequest.ServerRequest, execute)
+    this.execute = Effect.flatMap(ServerRequest.HttpServerRequest, execute)
   }
 
   execute: App.Default<E | Error.RouteNotFound, R>
@@ -59,32 +60,35 @@ class MultiplexImpl<E = never, R = never>
   }
   toJSON(): unknown {
     return {
-      _id: "@effect/platform/Http/Multiplex"
+      _id: "@effect/platform/HttpMultiplex"
     }
   }
 }
 
 /** @internal */
-export const empty: Multiplex.Multiplex<never> = new MultiplexImpl([])
+export const empty: Multiplex.HttpMultiplex<never> = new MultiplexImpl([])
 
 /** @internal */
 export const make = <E, R>(
   apps: Iterable<
-    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<E, R>]
+    readonly [
+      predicate: (request: ServerRequest.HttpServerRequest) => Effect.Effect<boolean, E, R>,
+      app: App.Default<E, R>
+    ]
   >
-): Multiplex.Multiplex<E, R> => new MultiplexImpl(Arr.fromIterable(apps))
+): Multiplex.HttpMultiplex<E, R> => new MultiplexImpl(Arr.fromIterable(apps))
 
 /** @internal */
 export const add = dual<
   <E2, R2, E3, R3>(
-    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
+    predicate: (request: ServerRequest.HttpServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<E3, R3>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2 | E3, R | R2 | R3>,
   <E, R, E2, R2, E3, R3>(
-    self: Multiplex.Multiplex<E, R>,
-    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
+    self: Multiplex.HttpMultiplex<E, R>,
+    predicate: (request: ServerRequest.HttpServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<E3, R3>
-  ) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>
+  ) => Multiplex.HttpMultiplex<E | E2 | E3, R | R2 | R3>
 >(
   3,
   (self, predicate, app) =>
@@ -100,13 +104,13 @@ export const headerExact = dual<
     header: string,
     value: string,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     header: string,
     value: string,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(
   4,
   (self, header, value, app) =>
@@ -122,13 +126,13 @@ export const headerRegex = dual<
     header: string,
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     header: string,
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(
   4,
   (self, header, regex, app) =>
@@ -144,13 +148,13 @@ export const headerStartsWith = dual<
     header: string,
     prefix: string,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     header: string,
     prefix: string,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(
   4,
   (self, header, prefix, app) =>
@@ -166,13 +170,13 @@ export const headerEndsWith = dual<
     header: string,
     suffix: string,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     header: string,
     suffix: string,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(
   4,
   (self, header, suffix, app) =>
@@ -187,12 +191,12 @@ export const hostRegex = dual<
   <E2, R2>(
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(3, (self, regex, app) => headerRegex(self, "host", regex, app))
 
 /** @internal */
@@ -200,12 +204,12 @@ export const hostStartsWith = dual<
   <E2, R2>(
     prefix: string,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     prefix: string,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(3, (self, prefix, app) => headerStartsWith(self, "host", prefix, app))
 
 /** @internal */
@@ -213,12 +217,12 @@ export const hostEndsWith = dual<
   <E2, R2>(
     suffix: string,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     suffix: string,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(3, (self, suffix, app) => headerEndsWith(self, "host", suffix, app))
 
 /** @internal */
@@ -226,10 +230,10 @@ export const hostExact = dual<
   <E2, R2>(
     host: string,
     app: App.Default<E2, R2>
-  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  ) => <E, R>(self: Multiplex.HttpMultiplex<E, R>) => Multiplex.HttpMultiplex<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Multiplex.Multiplex<E, R>,
+    self: Multiplex.HttpMultiplex<E, R>,
     host: string,
     app: App.Default<E2, R2>
-  ) => Multiplex.Multiplex<E | E2, R | R2>
+  ) => Multiplex.HttpMultiplex<E | E2, R | R2>
 >(3, (self, host, app) => headerExact(self, "host", host, app))

package/src/internal/{http/platform.ts → httpPlatform.ts}

@@ -1,18 +1,18 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
-import * as FileSystem from "../../FileSystem.js"
-import type * as Body from "../../Http/Body.js"
-import * as Etag from "../../Http/Etag.js"
-import * as Headers from "../../Http/Headers.js"
-import type * as Platform from "../../Http/Platform.js"
-import type * as ServerResponse from "../../Http/ServerResponse.js"
+import * as Etag from "../Etag.js"
+import * as FileSystem from "../FileSystem.js"
+import * as Headers from "../Headers.js"
+import type * as Body from "../HttpBody.js"
+import type * as Platform from "../HttpPlatform.js"
+import type * as ServerResponse from "../HttpServerResponse.js"
 
 /** @internal */
-export const TypeId: Platform.TypeId = Symbol.for("@effect/platform/Http/Platform") as Platform.TypeId
+export const TypeId: Platform.TypeId = Symbol.for("@effect/platform/HttpPlatform") as Platform.TypeId
 
 /** @internal */
-export const tag = Context.GenericTag<Platform.Platform>("@effect/platform/Http/Platform")
+export const tag = Context.GenericTag<Platform.HttpPlatform>("@effect/platform/HttpPlatform")
 
 /** @internal */
 export const make = (impl: {
@@ -24,15 +24,15 @@ export const make = (impl: {
     start: number,
     end: number | undefined,
     contentLength: number
-  ) => ServerResponse.ServerResponse
+  ) => ServerResponse.HttpServerResponse
   readonly fileWebResponse: (
-    file: Body.Body.FileLike,
+    file: Body.HttpBody.FileLike,
     status: number,
     statusText: string | undefined,
     headers: Headers.Headers,
     options?: FileSystem.StreamOptions
-  ) => ServerResponse.ServerResponse
-}): Effect.Effect<Platform.Platform, never, FileSystem.FileSystem | Etag.Generator> =>
+  ) => ServerResponse.HttpServerResponse
+}): Effect.Effect<Platform.HttpPlatform, never, FileSystem.FileSystem | Etag.Generator> =>
   Effect.gen(function*(_) {
     const fs = yield* _(FileSystem.FileSystem)
     const etagGen = yield* _(Etag.Generator)