@effect/platform-node 0.27.3 → 0.27.5

package/src/Http/Server.ts

@@ -3,8 +3,11 @@
  *
  * Also includes exports from [`@effect/platform/Http/Server`](https://effect-ts.github.io/platform/platform/Http/Server.ts.html).
  */
+import type * as App from "@effect/platform/Http/App"
+import type * as Middleware from "@effect/platform/Http/Middleware"
 import type * as Platform from "@effect/platform/Http/Platform"
 import type * as Server from "@effect/platform/Http/Server"
+import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
 import type * as Config from "effect/Config"
 import type * as ConfigError from "effect/ConfigError"
 import type * as Effect from "effect/Effect"
@@ -29,6 +32,28 @@ export const make: (
   options: Net.ListenOptions
 ) => Effect.Effect<Scope.Scope, never, Server.Server> = internal.make
 
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeHandler: {
+  <R, E>(
+    httpApp: App.Default<R, E>
+  ): Effect.Effect<
+    Exclude<R, ServerRequest.ServerRequest>,
+    never,
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse<Http.IncomingMessage>) => void
+  >
+  <R, E, App extends App.Default<any, any>>(
+    httpApp: App.Default<R, E>,
+    middleware: Middleware.Middleware.Applied<R, E, App>
+  ): Effect.Effect<
+    Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    never,
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse<Http.IncomingMessage>) => void
+  >
+} = internal.makeHandler
+
 /**
  * @since 1.0.0
  * @category layers

package/src/Http/ServerRequest.ts

@@ -0,0 +1,19 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Http/ServerRequest`](https://effect-ts.github.io/platform/platform/Http/ServerRequest.ts.html).
+ */
+import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import type * as Http from "node:http"
+import * as internal from "../internal/http/server"
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform/Http/ServerRequest"
+
+/**
+ * @category conversions
+ * @since 1.0.0
+ */
+export const toIncomingMessage: (self: ServerRequest.ServerRequest) => Http.IncomingMessage = internal.requestSource

package/src/HttpServer.ts

@@ -1,13 +1,13 @@
 /**
  * @since 1.0.0
  */
+import * as request from "@effect/platform-node/Http/ServerRequest"
 import * as app from "@effect/platform/Http/App"
 import * as body from "@effect/platform/Http/Body"
 import * as headers from "@effect/platform/Http/Headers"
 import * as middleware from "@effect/platform/Http/Middleware"
 import * as router from "@effect/platform/Http/Router"
 import * as error from "@effect/platform/Http/ServerError"
-import * as request from "@effect/platform/Http/ServerRequest"
 import * as response from "@effect/platform/Http/ServerResponse"
 import * as urlParams from "@effect/platform/Http/UrlParams"
 import * as etag from "./Http/Etag"
@@ -67,8 +67,8 @@ export {
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/ServerRequest](https://effect-ts.github.io/platform/platform/Http/ServerRequest.ts.html)
-   * - Module: `@effect/platform/Http/ServerRequest`
+   * - Docs: [Http/ServerRequest](https://effect-ts.github.io/platform/platform-node/Http/ServerRequest.ts.html)
+   * - Module: `@effect/platform-node/Http/ServerRequest`
    */
   request,
   /**

package/src/internal/http/server.ts

@@ -78,35 +78,15 @@ export const make = (
           hostname: address.address,
           port: address.port
         },
-      serve: (httpApp, middleware) => {
-        const handledApp = middleware
-          ? middleware(App.withDefaultMiddleware(respond(httpApp)))
-          : App.withDefaultMiddleware(respond(httpApp))
-        return Effect.flatMap(Effect.all([Effect.runtime(), Effect.fiberId]), ([runtime, fiberId]) => {
-          const runFork = Runtime.runFork(runtime)
-          function handler(nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) {
-            const fiber = runFork(
-              Effect.provideService(
-                handledApp,
-                ServerRequest.ServerRequest,
-                new ServerRequestImpl(nodeRequest, nodeResponse)
-              )
-            )
-            nodeResponse.on("close", () => {
-              if (!nodeResponse.writableEnded) {
-                runFork(fiber.interruptAsFork(fiberId))
-              }
-            })
-          }
-          return Effect.all([
+      serve: (httpApp, middleware) =>
+        Effect.flatMap(makeHandler(httpApp, middleware!), (handler) =>
+          Effect.all([
             Effect.acquireRelease(
               Effect.sync(() => server.on("request", handler)),
               () => Effect.sync(() => server.off("request", handler))
             ),
             Fiber.join(serverFiber)
-          ], { discard: true, concurrency: "unbounded" }) as Effect.Effect<never, Error.ServeError, never>
-        })
-      }
+          ], { discard: true, concurrency: "unbounded" }) as Effect.Effect<never, Error.ServeError, never>)
     })
   }).pipe(
     Effect.locally(
@@ -138,6 +118,47 @@ const respond = Middleware.make((httpApp) =>
     ))
 )
 
+/** @internal */
+export const makeHandler: {
+  <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
+    Exclude<R, ServerRequest.ServerRequest>,
+    never,
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+  >
+  <R, E, App extends App.Default<any, any>>(
+    httpApp: App.Default<R, E>,
+    middleware: Middleware.Middleware.Applied<R, E, App>
+  ): Effect.Effect<
+    Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    never,
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+  >
+} = <R, E>(httpApp: App.Default<R, E>, middleware?: Middleware.Middleware) => {
+  const handledApp = middleware
+    ? middleware(App.withDefaultMiddleware(respond(httpApp)))
+    : App.withDefaultMiddleware(respond(httpApp))
+  return Effect.map(
+    Effect.zip(Effect.runtime<R>(), Effect.fiberId),
+    ([runtime, fiberId]) => {
+      const runFork = Runtime.runFork(runtime)
+      return function handler(nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) {
+        const fiber = runFork(
+          Effect.provideService(
+            handledApp,
+            ServerRequest.ServerRequest,
+            new ServerRequestImpl(nodeRequest, nodeResponse)
+          )
+        )
+        nodeResponse.on("close", () => {
+          if (!nodeResponse.writableEnded) {
+            runFork(fiber.interruptAsFork(fiberId))
+          }
+        })
+      }
+    }
+  )
+}
+
 class ServerRequestImpl extends IncomingMessageImpl<Error.RequestError> implements ServerRequest.ServerRequest {
   readonly [ServerRequest.TypeId]: ServerRequest.TypeId
 
@@ -339,3 +360,7 @@ const handleResponse = (request: ServerRequest.ServerRequest, response: ServerRe
       }
     }
   })
+
+/** @internal */
+export const requestSource = (self: ServerRequest.ServerRequest): Http.IncomingMessage =>
+  (self as ServerRequestImpl).source