@effect/platform-node 0.27.2 → 0.27.4

package/dist/{Server-7a3dbcbe.cjs.dev.js → server-b13861a8.cjs.dev.js}

@@ -4,7 +4,7 @@ var FileSystem = require('@effect/platform/FileSystem');
 var App = require('@effect/platform/Http/App');
 var IncomingMessage = require('@effect/platform/Http/IncomingMessage');
 var Middleware = require('@effect/platform/Http/Middleware');
-var Server$1 = require('@effect/platform/Http/Server');
+var Server = require('@effect/platform/Http/Server');
 var Error = require('@effect/platform/Http/ServerError');
 var ServerRequest = require('@effect/platform/Http/ServerRequest');
 var Config = require('effect/Config');
@@ -39,26 +39,11 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-function _mergeNamespaces(n, m) {
-  m.forEach(function (e) {
-    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-      if (k !== 'default' && !(k in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  });
-  return Object.freeze(n);
-}
-
 var FileSystem__namespace = /*#__PURE__*/_interopNamespace(FileSystem);
 var App__namespace = /*#__PURE__*/_interopNamespace(App);
 var IncomingMessage__namespace = /*#__PURE__*/_interopNamespace(IncomingMessage);
 var Middleware__namespace = /*#__PURE__*/_interopNamespace(Middleware);
-var Server__namespace = /*#__PURE__*/_interopNamespace(Server$1);
+var Server__namespace = /*#__PURE__*/_interopNamespace(Server);
 var Error__namespace = /*#__PURE__*/_interopNamespace(Error);
 var ServerRequest__namespace = /*#__PURE__*/_interopNamespace(ServerRequest);
 var Config__namespace = /*#__PURE__*/_interopNamespace(Config);
@@ -70,7 +55,7 @@ var Runtime__namespace = /*#__PURE__*/_interopNamespace(Runtime);
 var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
 
 /** @internal */
-const make$1 = (evaluate, options) => Effect__namespace.gen(function* (_) {
+const make = (evaluate, options) => Effect__namespace.gen(function* (_) {
   const server = evaluate();
   const serverFiber = yield* _(Effect__namespace.addFinalizer(() => Effect__namespace.async(resume => {
     server.close(error => {
@@ -102,24 +87,10 @@ const make$1 = (evaluate, options) => Effect__namespace.gen(function* (_) {
       hostname: address.address,
       port: address.port
     },
-    serve: (httpApp, middleware) => {
-      const handledApp = middleware ? middleware(App__namespace.withDefaultMiddleware(respond(httpApp))) : App__namespace.withDefaultMiddleware(respond(httpApp));
-      return Effect__namespace.flatMap(Effect__namespace.all([Effect__namespace.runtime(), Effect__namespace.fiberId]), ([runtime, fiberId]) => {
-        const runFork = Runtime__namespace.runFork(runtime);
-        function handler(nodeRequest, nodeResponse) {
-          const fiber = runFork(Effect__namespace.provideService(handledApp, ServerRequest__namespace.ServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse)));
-          nodeResponse.on("close", () => {
-            if (!nodeResponse.writableEnded) {
-              runFork(fiber.interruptAsFork(fiberId));
-            }
-          });
-        }
-        return Effect__namespace.all([Effect__namespace.acquireRelease(Effect__namespace.sync(() => server.on("request", handler)), () => Effect__namespace.sync(() => server.off("request", handler))), Fiber__namespace.join(serverFiber)], {
-          discard: true,
-          concurrency: "unbounded"
-        });
-      });
-    }
+    serve: (httpApp, middleware) => Effect__namespace.flatMap(makeHandler(httpApp, middleware), handler => Effect__namespace.all([Effect__namespace.acquireRelease(Effect__namespace.sync(() => server.on("request", handler)), () => Effect__namespace.sync(() => server.off("request", handler))), Fiber__namespace.join(serverFiber)], {
+      discard: true,
+      concurrency: "unbounded"
+    }))
   });
 }).pipe(Effect__namespace.locally(IncomingMessage__namespace.maxBodySize, Option__namespace.some(FileSystem__namespace.Size(1024 * 1024 * 10))));
 const respond = /*#__PURE__*/Middleware__namespace.make(httpApp => Effect__namespace.flatMap(ServerRequest__namespace.ServerRequest, request => Effect__namespace.tapErrorCause(Effect__namespace.tap(Effect__namespace.flatMap(httpApp, response => Effect__namespace.flatMap(App__namespace.preResponseHandler, f => f(request, response))), response => handleResponse(request, response)), _cause => Effect__namespace.sync(() => {
@@ -131,6 +102,22 @@ const respond = /*#__PURE__*/Middleware__namespace.make(httpApp => Effect__names
     nodeResponse.end();
   }
 }))));
+
+/** @internal */
+const makeHandler = (httpApp, middleware) => {
+  const handledApp = middleware ? middleware(App__namespace.withDefaultMiddleware(respond(httpApp))) : App__namespace.withDefaultMiddleware(respond(httpApp));
+  return Effect__namespace.map(Effect__namespace.zip(Effect__namespace.runtime(), Effect__namespace.fiberId), ([runtime, fiberId]) => {
+    const runFork = Runtime__namespace.runFork(runtime);
+    return function handler(nodeRequest, nodeResponse) {
+      const fiber = runFork(Effect__namespace.provideService(handledApp, ServerRequest__namespace.ServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse)));
+      nodeResponse.on("close", () => {
+        if (!nodeResponse.writableEnded) {
+          runFork(fiber.interruptAsFork(fiberId));
+        }
+      });
+    };
+  });
+};
 class ServerRequestImpl extends incomingMessage.IncomingMessageImpl {
   constructor(source, response, url = source.url, headersOverride, remoteAddressOverride) {
     super(source, _ => Error__namespace.RequestError({
@@ -182,10 +169,10 @@ class ServerRequestImpl extends incomingMessage.IncomingMessageImpl {
 }
 
 /** @internal */
-const layer$1 = (evaluate, options) => Layer__namespace.merge(Layer__namespace.scoped(Server__namespace.Server, make$1(evaluate, options)), platform.layer);
+const layer = (evaluate, options) => Layer__namespace.merge(Layer__namespace.scoped(Server__namespace.Server, make(evaluate, options)), platform.layer);
 
 /** @internal */
-const layerConfig$1 = (evaluate, options) => Layer__namespace.merge(Layer__namespace.scoped(Server__namespace.Server, Effect__namespace.flatMap(Effect__namespace.config(Config__namespace.unwrap(options)), options => make$1(evaluate, options))), platform.layer);
+const layerConfig = (evaluate, options) => Layer__namespace.merge(Layer__namespace.scoped(Server__namespace.Server, Effect__namespace.flatMap(Effect__namespace.config(Config__namespace.unwrap(options)), options => make(evaluate, options))), platform.layer);
 const handleResponse = (request, response) => Effect__namespace.suspend(() => {
   const nodeResponse = request.response;
   if (request.method === "HEAD") {
@@ -266,38 +253,11 @@ const handleResponse = (request, response) => Effect__namespace.suspend(() => {
   }
 });
 
-/**
- * @since 1.0.0
- *
- * Also includes exports from [`@effect/platform/Http/Server`](https://effect-ts.github.io/platform/platform/Http/Server.ts.html).
- */
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const make = make$1;
-
-/**
- * @since 1.0.0
- * @category layers
- */
-const layer = layer$1;
-
-/**
- * @since 1.0.0
- * @category layers
- */
-const layerConfig = layerConfig$1;
-
-var Server = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  make: make,
-  layer: layer,
-  layerConfig: layerConfig
-}, [Server__namespace]);
+/** @internal */
+const requestSource = self => self.source;
 
-exports.Server = Server;
 exports.layer = layer;
 exports.layerConfig = layerConfig;
 exports.make = make;
+exports.makeHandler = makeHandler;
+exports.requestSource = requestSource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform-node",
-  "version": "0.27.2",
+  "version": "0.27.4",
   "description": "Unified interfaces for common platform-specific services",
   "main": "dist/effect-platform-node.cjs.js",
   "module": "dist/effect-platform-node.esm.js",
@@ -136,6 +136,12 @@
       "import": "./Http/Server/dist/effect-platform-node-Http-Server.cjs.mjs",
       "default": "./Http/Server/dist/effect-platform-node-Http-Server.cjs.js"
     },
+    "./Http/ServerRequest": {
+      "types": "./dist/declarations/src/Http/ServerRequest.d.ts",
+      "module": "./Http/ServerRequest/dist/effect-platform-node-Http-ServerRequest.esm.js",
+      "import": "./Http/ServerRequest/dist/effect-platform-node-Http-ServerRequest.cjs.mjs",
+      "default": "./Http/ServerRequest/dist/effect-platform-node-Http-ServerRequest.cjs.js"
+    },
     "./HttpClient": {
       "types": "./dist/declarations/src/HttpClient.d.ts",
       "module": "./HttpClient/dist/effect-platform-node-HttpClient.esm.js",

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

@@ -6,6 +6,7 @@
 import type { WorkerError } from "@effect/platform/WorkerError"
 import type * as Runner from "@effect/platform/WorkerRunner"
 import type { Effect } from "effect"
+import type * as Layer from "effect/Layer"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import * as internal from "./internal/workerRunner"
@@ -23,3 +24,9 @@ export const make: <I, R, E, O>(
   process: (request: I) => Stream.Stream<R, E, O>,
   options?: Runner.Runner.Options<O> | undefined
 ) => Effect.Effect<R | Scope.Scope, WorkerError, void> = internal.make
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: Layer.Layer<never, never, Runner.PlatformRunner> = internal.layer

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