@effect/platform-node 4.0.0-beta.5 → 4.0.0-beta.51

package/src/NodeHttpClient.ts

@@ -1,12 +1,15 @@
 /**
  * @since 1.0.0
  */
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { flow } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import { type Pipeable, pipeArguments } from "effect/Pipeable"
+import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
 import * as Cookies from "effect/unstable/http/Cookies"
 import * as Headers from "effect/unstable/http/Headers"
@@ -57,7 +60,7 @@ export {
  * @since 1.0.0
  * @category Dispatcher
  */
-export class Dispatcher extends ServiceMap.Service<Dispatcher, Undici.Dispatcher>()(
+export class Dispatcher extends Context.Service<Dispatcher, Undici.Dispatcher>()(
   "@effect/platform-node/NodeHttpClient/Dispatcher"
 ) {}
 
@@ -86,7 +89,7 @@ export const dispatcherLayerGlobal: Layer.Layer<Dispatcher> = Layer.sync(Dispatc
  * @since 1.0.0
  * @category undici
  */
-export const UndiciOptions = ServiceMap.Reference<Partial<Undici.Dispatcher.RequestOptions>>(
+export const UndiciOptions = Context.Reference<Partial<Undici.Dispatcher.RequestOptions>>(
   "@effect/platform-node/NodeHttpClient/UndiciOptions",
   { defaultValue: () => ({}) }
 )
@@ -150,7 +153,7 @@ function convertBody(
 
 function noopErrorHandler(_: any) {}
 
-class UndiciResponse extends Inspectable.Class implements HttpClientResponse {
+class UndiciResponse extends Inspectable.Class implements HttpClientResponse, Pipeable {
   readonly [IncomingMessage.TypeId]: typeof IncomingMessage.TypeId
   readonly [Response.TypeId]: typeof Response.TypeId
   readonly request: HttpClientRequest
@@ -189,8 +192,8 @@ class UndiciResponse extends Inspectable.Class implements HttpClientResponse {
     return this.cachedCookies = header ? Cookies.fromSetCookie(header) : Cookies.empty
   }
 
-  get remoteAddress(): string | undefined {
-    return undefined
+  get remoteAddress(): Option.Option<string> {
+    return Option.none()
   }
 
   get stream(): Stream.Stream<Uint8Array, Error.HttpClientError> {
@@ -207,10 +210,10 @@ class UndiciResponse extends Inspectable.Class implements HttpClientResponse {
     })
   }
 
-  get json(): Effect.Effect<unknown, Error.HttpClientError> {
+  get json(): Effect.Effect<Schema.Json, Error.HttpClientError> {
     return Effect.flatMap(this.text, (text) =>
       Effect.try({
-        try: () => text === "" ? null : JSON.parse(text) as unknown,
+        try: () => text === "" ? null : JSON.parse(text),
         catch: (cause) =>
           new Error.HttpClientError({
             reason: new Error.DecodeError({
@@ -289,6 +292,10 @@ class UndiciResponse extends Inspectable.Class implements HttpClientResponse {
       status: this.status
     })
   }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 /**
@@ -299,7 +306,7 @@ export const layerUndiciNoDispatcher: Layer.Layer<
   Client.HttpClient,
   never,
   Dispatcher
-> = Client.layerMergedServices(makeUndici)
+> = Client.layerMergedContext(makeUndici)
 
 /**
  * @since 1.0.0
@@ -315,7 +322,7 @@ export const layerUndici: Layer.Layer<Client.HttpClient> = Layer.provide(layerUn
  * @since 1.0.0
  * @category HttpAgent
  */
-export class HttpAgent extends ServiceMap.Service<HttpAgent, {
+export class HttpAgent extends Context.Service<HttpAgent, {
   readonly http: Http.Agent
   readonly https: Https.Agent
 }>()("@effect/platform-node/NodeHttpClient/HttpAgent") {}
@@ -490,7 +497,7 @@ const waitForFinish = (nodeRequest: Http.ClientRequest, request: HttpClientReque
     })
   })
 
-class NodeHttpResponse extends NodeHttpIncomingMessage<Error.HttpClientError> implements HttpClientResponse {
+class NodeHttpResponse extends NodeHttpIncomingMessage<Error.HttpClientError> implements HttpClientResponse, Pipeable {
   readonly [Response.TypeId]: typeof Response.TypeId
   readonly request: HttpClientRequest
 
@@ -555,6 +562,10 @@ class NodeHttpResponse extends NodeHttpIncomingMessage<Error.HttpClientError> im
       status: this.status
     })
   }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }
 
 /**
@@ -565,7 +576,7 @@ export const layerNodeHttpNoAgent: Layer.Layer<
   Client.HttpClient,
   never,
   HttpAgent
-> = Client.layerMergedServices(makeNodeHttp)
+> = Client.layerMergedContext(makeNodeHttp)
 
 /**
  * @since 1.0.0

package/src/NodeHttpIncomingMessage.ts

@@ -3,6 +3,8 @@
  */
 import * as Effect from "effect/Effect"
 import * as Inspectable from "effect/Inspectable"
+import * as Option from "effect/Option"
+import type * as Schema from "effect/Schema"
 import type * as Stream from "effect/Stream"
 import * as Headers from "effect/unstable/http/Headers"
 import * as IncomingMessage from "effect/unstable/http/HttpIncomingMessage"
@@ -23,12 +25,12 @@ export abstract class NodeHttpIncomingMessage<E> extends Inspectable.Class
   readonly [IncomingMessage.TypeId]: typeof IncomingMessage.TypeId
   readonly source: Http.IncomingMessage
   readonly onError: (error: unknown) => E
-  readonly remoteAddressOverride?: string | undefined
+  readonly remoteAddressOverride?: Option.Option<string> | undefined
 
   constructor(
     source: Http.IncomingMessage,
     onError: (error: unknown) => E,
-    remoteAddressOverride?: string
+    remoteAddressOverride?: Option.Option<string>
   ) {
     super()
     this[IncomingMessage.TypeId] = IncomingMessage.TypeId
@@ -42,7 +44,7 @@ export abstract class NodeHttpIncomingMessage<E> extends Inspectable.Class
   }
 
   get remoteAddress() {
-    return this.remoteAddressOverride ?? this.source.socket.remoteAddress
+    return this.remoteAddressOverride ?? Option.fromNullishOr(this.source.socket.remoteAddress)
   }
 
   private textEffect: Effect.Effect<string, E> | undefined
@@ -67,15 +69,15 @@ export abstract class NodeHttpIncomingMessage<E> extends Inspectable.Class
     return Effect.runSync(this.text)
   }
 
-  get json(): Effect.Effect<unknown, E> {
+  get json(): Effect.Effect<Schema.Json, E> {
     return Effect.flatMap(this.text, (text) =>
       Effect.try({
-        try: () => text === "" ? null : JSON.parse(text) as unknown,
+        try: () => text === "" ? null : JSON.parse(text),
         catch: this.onError
       }))
   }
 
-  get jsonUnsafe(): unknown {
+  get jsonUnsafe(): Schema.Json {
     return Effect.runSync(this.json)
   }
 

package/src/NodeHttpPlatform.ts

@@ -18,7 +18,9 @@ import * as NodeFileSystem from "./NodeFileSystem.ts"
  */
 export const make = Platform.make({
   fileResponse(path, status, statusText, headers, start, end, contentLength) {
-    const stream = Fs.createReadStream(path, { start, end })
+    const stream = contentLength === 0
+      ? Readable.from([])
+      : Fs.createReadStream(path, { start, end: end === undefined ? undefined : end - 1 })
     return ServerResponse.raw(stream, {
       headers: {
         ...headers,

package/src/NodeHttpServer.ts

@@ -3,15 +3,18 @@
  */
 import * as Cause from "effect/Cause"
 import * as Config from "effect/Config"
+import * as Context from "effect/Context"
+import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Fiber from "effect/Fiber"
 import type * as FileSystem from "effect/FileSystem"
 import { flow, type LazyArg } from "effect/Function"
+import * as Latch from "effect/Latch"
 import * as Layer from "effect/Layer"
+import type * as Option from "effect/Option"
 import type * as Path from "effect/Path"
 import type * as Record from "effect/Record"
 import * as Scope from "effect/Scope"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
 import * as Cookies from "effect/unstable/http/Cookies"
 import * as Etag from "effect/unstable/http/Etag"
@@ -26,7 +29,7 @@ import type * as HttpPlatform from "effect/unstable/http/HttpPlatform"
 import * as HttpServer from "effect/unstable/http/HttpServer"
 import {
   causeResponse,
-  clientAbortFiberId,
+  ClientAbort,
   HttpServerError,
   RequestParseError,
   ResponseError,
@@ -54,25 +57,35 @@ import { NodeWS } from "./NodeSocket.ts"
  */
 export const make = Effect.fnUntraced(function*(
   evaluate: LazyArg<Http.Server>,
-  options: Net.ListenOptions
+  options: Net.ListenOptions & {
+    readonly disablePreemptiveShutdown?: boolean | undefined
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined
+  }
 ) {
   const scope = yield* Effect.scope
   const server = evaluate()
-  yield* Scope.addFinalizer(
-    scope,
-    Effect.callback<void>((resume) => {
-      if (!server.listening) {
-        return resume(Effect.void)
+
+  const shutdown = yield* Effect.callback<void>((resume) => {
+    if (!server.listening) {
+      return resume(Effect.void)
+    }
+    server.close((error) => {
+      if (error) {
+        resume(Effect.die(error))
+      } else {
+        resume(Effect.void)
       }
-      server.close((error) => {
-        if (error) {
-          resume(Effect.die(error))
-        } else {
-          resume(Effect.void)
-        }
-      })
     })
-  )
+  }).pipe(Effect.cached)
+
+  const preemptiveShutdown = options.disablePreemptiveShutdown ?
+    Effect.void :
+    Effect.timeoutOrElse(shutdown, {
+      duration: options.gracefulShutdownTimeout ?? Duration.seconds(20),
+      orElse: () => Effect.void
+    })
+
+  yield* Scope.addFinalizer(scope, shutdown)
 
   yield* Effect.callback<void, ServeError>((resume) => {
     function onError(cause: Error) {
@@ -110,7 +123,8 @@ export const make = Effect.fnUntraced(function*(
         port: address.port
       },
     serve: Effect.fnUntraced(function*(httpApp, middleware) {
-      const scope = yield* Effect.scope
+      const serveScope = yield* Effect.scope
+      const scope = Scope.forkUnsafe(serveScope, "parallel")
       const handler = yield* (makeHandler(httpApp, {
         middleware: middleware as any,
         scope
@@ -119,12 +133,11 @@ export const make = Effect.fnUntraced(function*(
         middleware: middleware as any,
         scope
       })
-      yield* Effect.addFinalizer(() =>
-        Effect.sync(() => {
-          server.off("request", handler)
-          server.off("upgrade", upgradeHandler)
-        })
-      )
+      yield* Scope.addFinalizerExit(serveScope, () => {
+        server.off("request", handler)
+        server.off("upgrade", upgradeHandler)
+        return preemptiveShutdown
+      })
       server.on("request", handler)
       server.on("upgrade", upgradeHandler)
     })
@@ -151,20 +164,21 @@ export const makeHandler = <
   Exclude<Effect.Services<App>, HttpServerRequest | Scope.Scope>
 > => {
   const handled = HttpEffect.toHandled(httpEffect, handleResponse, options.middleware as any)
-  return Effect.map(Effect.services<any>(), (services) => {
-    return function handler(
+  return Effect.withFiber((parent) => {
+    const services = parent.context
+    return Effect.succeed(function handler(
       nodeRequest: Http.IncomingMessage,
       nodeResponse: Http.ServerResponse
     ) {
       const map = new Map(services.mapUnsafe)
       map.set(HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse))
-      const fiber = Fiber.runIn(Effect.runForkWith(ServiceMap.makeUnsafe<any>(map))(handled), options.scope)
+      const fiber = Fiber.runIn(Effect.runForkWith(Context.makeUnsafe<any>(map))(handled), options.scope)
       nodeResponse.on("close", () => {
         if (!nodeResponse.writableEnded) {
-          fiber.interruptUnsafe(clientAbortFiberId)
+          fiber.interruptUnsafe(parent.id, ClientAbort.annotation)
         }
       })
-    }
+    })
   })
 }
 
@@ -189,8 +203,13 @@ export const makeUpgradeHandler = <
   Exclude<Effect.Services<App>, HttpServerRequest | Scope.Scope>
 > => {
   const handledApp = HttpEffect.toHandled(httpEffect, handleResponse, options.middleware as any)
-  return Effect.map(Effect.services<any>(), (services) =>
-    (function handler(nodeRequest: Http.IncomingMessage, socket: Duplex, head: Buffer) {
+  return Effect.withFiber((parent) => {
+    const services = parent.context
+    return Effect.succeed(function handler(
+      nodeRequest: Http.IncomingMessage,
+      socket: Duplex,
+      head: Buffer
+    ) {
       let nodeResponse_: Http.ServerResponse | undefined = undefined
       const nodeResponse = () => {
         if (nodeResponse_ === undefined) {
@@ -216,13 +235,14 @@ export const makeUpgradeHandler = <
       ))
       const map = new Map(services.mapUnsafe)
       map.set(HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect))
-      const fiber = Fiber.runIn(Effect.runForkWith(ServiceMap.makeUnsafe<any>(map))(handledApp), options.scope)
+      const fiber = Fiber.runIn(Effect.runForkWith(Context.makeUnsafe<any>(map))(handledApp), options.scope)
       socket.on("close", () => {
         if (!socket.writableEnded) {
-          fiber.interruptUnsafe(clientAbortFiberId)
+          fiber.interruptUnsafe(parent.id, ClientAbort.annotation)
         }
       })
-    }));
+    })
+  })
 }
 
 class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> implements HttpServerRequest {
@@ -238,7 +258,7 @@ class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> impleme
     upgradeEffect?: Effect.Effect<Socket.Socket, HttpServerError>,
     url = source.url!,
     headersOverride?: Headers.Headers,
-    remoteAddressOverride?: string
+    remoteAddressOverride?: Option.Option<string>
   ) {
     super(source, (cause) =>
       new HttpServerError({
@@ -270,7 +290,7 @@ class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> impleme
     options: {
       readonly url?: string | undefined
       readonly headers?: Headers.Headers | undefined
-      readonly remoteAddress?: string | undefined
+      readonly remoteAddress?: Option.Option<string> | undefined
     }
   ) {
     return new ServerRequestImpl(
@@ -279,7 +299,7 @@ class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> impleme
       this.upgradeEffect,
       options.url ?? this.url,
       options.headers ?? this.headersOverride,
-      options.remoteAddress ?? this.remoteAddressOverride
+      "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride
     )
   }
 
@@ -351,7 +371,10 @@ class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> impleme
  */
 export const layerServer: (
   evaluate: LazyArg<Http.Server<typeof Http.IncomingMessage, typeof Http.ServerResponse>>,
-  options: Net.ListenOptions
+  options: Net.ListenOptions & {
+    readonly disablePreemptiveShutdown?: boolean | undefined
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined
+  }
 ) => Layer.Layer<HttpServer.HttpServer, ServeError> = flow(make, Layer.effect(HttpServer.HttpServer))
 
 /**
@@ -372,7 +395,10 @@ export const layerHttpServices: Layer.Layer<
  */
 export const layer = (
   evaluate: LazyArg<Http.Server>,
-  options: Net.ListenOptions
+  options: Net.ListenOptions & {
+    readonly disablePreemptiveShutdown?: boolean | undefined
+    readonly gracefulShutdownTimeout?: Duration.Input | undefined
+  }
 ): Layer.Layer<
   HttpServer.HttpServer | NodeServices.NodeServices | HttpPlatform.HttpPlatform | Etag.Generator,
   ServeError
@@ -388,7 +414,12 @@ export const layer = (
  */
 export const layerConfig = (
   evaluate: LazyArg<Http.Server>,
-  options: Config.Wrap<Net.ListenOptions>
+  options: Config.Wrap<
+    Net.ListenOptions & {
+      readonly disablePreemptiveShutdown?: boolean | undefined
+      readonly gracefulShutdownTimeout?: Duration.Input | undefined
+    }
+  >
 ): Layer.Layer<
   HttpServer.HttpServer | FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform | Etag.Generator,
   ServeError | Config.ConfigError
@@ -528,7 +559,7 @@ const handleResponse = (
     }
     case "Stream": {
       nodeResponse.writeHead(response.status, headers)
-      const drainLatch = Effect.makeLatchUnsafe()
+      const drainLatch = Latch.makeUnsafe()
       nodeResponse.on("drain", () => drainLatch.openUnsafe())
       return body.stream.pipe(
         Stream.orDie,

package/src/NodeRedis.ts

@@ -2,11 +2,11 @@
  * @since 1.0.0
  */
 import * as Config from "effect/Config"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Fn from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Scope from "effect/Scope"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Redis from "effect/unstable/persistence/Redis"
 import * as IoRedis from "ioredis"
 
@@ -14,7 +14,7 @@ import * as IoRedis from "ioredis"
  * @since 1.0.0
  * @category Service
  */
-export class NodeRedis extends ServiceMap.Service<NodeRedis, {
+export class NodeRedis extends Context.Service<NodeRedis, {
   readonly client: IoRedis.Redis
   readonly use: <A>(f: (client: IoRedis.Redis) => Promise<A>) => Effect.Effect<A, Redis.RedisError>
 }>()("@effect/platform-node/NodeRedis") {}
@@ -45,8 +45,8 @@ const make = Effect.fnUntraced(function*(
     use
   })
 
-  return ServiceMap.make(NodeRedis, nodeRedis).pipe(
-    ServiceMap.add(Redis.Redis, redis)
+  return Context.make(NodeRedis, nodeRedis).pipe(
+    Context.add(Redis.Redis, redis)
   )
 })
 
@@ -56,7 +56,7 @@ const make = Effect.fnUntraced(function*(
  */
 export const layer = (
   options?: IoRedis.RedisOptions | undefined
-): Layer.Layer<Redis.Redis | NodeRedis> => Layer.effectServices(make(options))
+): Layer.Layer<Redis.Redis | NodeRedis> => Layer.effectContext(make(options))
 
 /**
  * @since 1.0.0
@@ -67,7 +67,7 @@ export const layerConfig: (
 ) => Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> = (
   options: Config.Wrap<IoRedis.RedisOptions>
 ): Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> =>
-  Layer.effectServices(
+  Layer.effectContext(
     Config.unwrap(options).asEffect().pipe(
       Effect.flatMap(make)
     )

package/src/NodeRuntime.ts

@@ -20,7 +20,6 @@ import type * as Runtime from "effect/Runtime"
  *
  * An optional object that can include:
  * - `disableErrorReporting`: Turn off automatic error logging.
- * - `disablePrettyLogger`: Avoid adding the pretty logger.
  * - `teardown`: Provide custom finalization logic.
  *
  * **When to Use**
@@ -48,7 +47,6 @@ export const runMain: {
    *
    * An optional object that can include:
    * - `disableErrorReporting`: Turn off automatic error logging.
-   * - `disablePrettyLogger`: Avoid adding the pretty logger.
    * - `teardown`: Provide custom finalization logic.
    *
    * **When to Use**
@@ -81,7 +79,6 @@ export const runMain: {
    *
    * An optional object that can include:
    * - `disableErrorReporting`: Turn off automatic error logging.
-   * - `disablePrettyLogger`: Avoid adding the pretty logger.
    * - `teardown`: Provide custom finalization logic.
    *
    * **When to Use**

package/src/NodeSocket.ts

@@ -26,6 +26,16 @@ export const layerWebSocketConstructor: Layer.Layer<
   return (url, protocols) => new WS.WebSocket(url, protocols) as unknown as globalThis.WebSocket
 })
 
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWebSocketConstructorWS: Layer.Layer<
+  Socket.WebSocketConstructor
+> = Layer.succeed(Socket.WebSocketConstructor)(
+  (url, protocols) => new WS.WebSocket(url, protocols) as unknown as globalThis.WebSocket
+)
+
 /**
  * @since 1.0.0
  * @category layers
@@ -34,7 +44,7 @@ export const layerWebSocket: (
   url: string | Effect.Effect<string>,
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
-    readonly openTimeout?: Duration.DurationInput | undefined
+    readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
   } | undefined
 ) => Layer.Layer<Socket.Socket, never, never> = flow(

package/src/NodeWorkerRunner.ts

@@ -36,7 +36,7 @@ export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succe
         Effect.scopedWith(Effect.fnUntraced(function*(scope) {
           const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
           const trackFiber = Fiber.runIn(scope)
-          const services = yield* Effect.services<R>()
+          const services = yield* Effect.context<R>()
           const runFork = Effect.runForkWith(services)
           const onExit = (exit: Exit.Exit<any, E>) => {
             if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {