@effect/platform-node 4.0.0-beta.7 → 4.0.0-beta.71

package/src/NodeHttpServer.ts

@@ -1,18 +1,49 @@
 /**
- * @since 1.0.0
+ * Node.js implementation of the Effect `HttpServer`.
+ *
+ * This module adapts a supplied Node `http.Server` into Effect's
+ * platform-independent HTTP server service. It starts the server with Node
+ * `listen` options, converts `request` events into `HttpServerRequest` values,
+ * writes `HttpServerResponse` bodies through Node's `ServerResponse`, and
+ * handles `upgrade` events by exposing the upgraded socket through
+ * `HttpServerRequest.upgrade`.
+ *
+ * Common use cases include serving an Effect HTTP application with {@link layer}
+ * or {@link layerConfig}, embedding request or upgrade handlers into an
+ * existing Node server with {@link makeHandler} and {@link makeUpgradeHandler},
+ * and using {@link layerTest} for integration tests that need an ephemeral
+ * listening port and a client pointed at it.
+ *
+ * Listen options are passed directly to Node, so host, port, backlog, and Unix
+ * socket path behavior follow `node:http`. The server begins listening when the
+ * `HttpServer` is acquired, and handlers are installed when `serve` is run.
+ * Request fibers are interrupted with `ClientAbort` when the client disconnects
+ * before a response finishes. WebSocket support only applies to Node `upgrade`
+ * requests, and ordinary HTTP requests fail if their application attempts to use
+ * `HttpServerRequest.upgrade`.
+ *
+ * Scope ownership is important: the server is closed when the acquiring scope
+ * finalizes, while each `serve` call installs its own request and upgrade
+ * listeners and removes them on finalization. Unless preemptive shutdown is
+ * disabled, finalizing a serve scope also starts a graceful server close, using
+ * the configured timeout or the default timeout.
+ *
+ * @since 4.0.0
  */
 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"
@@ -27,7 +58,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,
@@ -50,30 +81,44 @@ import * as NodeServices from "./NodeServices.ts"
 import { NodeWS } from "./NodeSocket.ts"
 
 /**
- * @since 1.0.0
+ * Creates a scoped `HttpServer` from a Node `http.Server`, starts listening
+ * with the supplied options, registers request and upgrade handling, and closes
+ * the server during scope finalization with optional graceful-shutdown control.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 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) {
@@ -111,7 +156,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
@@ -120,12 +166,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)
     })
@@ -133,8 +178,12 @@ export const make = Effect.fnUntraced(function*(
 })
 
 /**
- * @since 1.0.0
+ * Creates a Node `request` event handler for an Effect HTTP application,
+ * injecting a `HttpServerRequest` and interrupting the request fiber if the
+ * client closes the response before it finishes.
+ *
  * @category Handlers
+ * @since 4.0.0
  */
 export const makeHandler = <
   R,
@@ -152,26 +201,31 @@ 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)
         }
       })
-    }
+    })
   })
 }
 
 /**
- * @since 1.0.0
+ * Creates a Node `upgrade` event handler for an Effect HTTP application,
+ * exposing the upgraded WebSocket as the request's `upgrade` effect and
+ * interrupting the request fiber when the socket closes early.
+ *
  * @category Handlers
+ * @since 4.0.0
  */
 export const makeUpgradeHandler = <
   R,
@@ -190,8 +244,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) {
@@ -217,13 +276,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 {
@@ -239,7 +299,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({
@@ -271,7 +331,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(
@@ -280,7 +340,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
     )
   }
 
@@ -347,17 +407,26 @@ class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> impleme
 }
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Provides an `HttpServer` by creating and managing a scoped Node
+ * `http.Server` with the supplied listen and shutdown options.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 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))
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Provides the Node HTTP support services used by `NodeHttpServer`, including
+ * the HTTP platform, ETag generator, and core Node platform services.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerHttpServices: Layer.Layer<
   NodeServices.NodeServices | HttpPlatform.HttpPlatform | Etag.Generator
@@ -368,12 +437,18 @@ export const layerHttpServices: Layer.Layer<
 )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Provides a Node `HttpServer` together with the Node HTTP platform, ETag, and
+ * core platform services required to serve requests.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 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
@@ -384,26 +459,37 @@ export const layer = (
   )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Provides a Node `HttpServer` and HTTP support services, reading the listen
+ * and shutdown options from a `Config` value.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 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
 > =>
   Layer.mergeAll(
     Layer.effect(HttpServer.HttpServer)(
-      Effect.flatMap(Config.unwrap(options).asEffect(), (options) => make(evaluate, options))
+      Effect.flatMap(Config.unwrap(options), (options) => make(evaluate, options))
     ),
     layerHttpServices
   )
 
 /**
- * @since 1.0.0
+ * Provides a test HTTP server listening on an ephemeral port together with a
+ * Fetch-backed `HttpClient` configured for server integration tests.
+ *
  * @category Testing
+ * @since 4.0.0
  */
 export const layerTest: Layer.Layer<
   | HttpServer.HttpServer

package/src/NodeHttpServerRequest.ts

@@ -1,18 +1,44 @@
 /**
- * @since 1.0.0
+ * Accessors for the Node.js objects backing a platform Node
+ * `HttpServerRequest`.
+ *
+ * Use this module at interop boundaries when an Effect HTTP handler needs the
+ * original `http.IncomingMessage` or `http.ServerResponse` for APIs that are
+ * specific to Node, such as existing middleware, socket inspection, raw stream
+ * piping, or response customization that cannot be expressed with the portable
+ * `HttpServerRequest` and `HttpServerResponse` interfaces.
+ *
+ * The returned request is the original Node request supplied to the server. It
+ * does not reflect Effect request overrides made by middleware, such as a
+ * rewritten URL, adjusted headers, or a substituted remote address. Its body is
+ * also Node's one-shot readable stream, so avoid mixing raw stream consumption
+ * with Effect body, multipart, or stream helpers unless ownership of the body
+ * is clear. The returned response is the Node response owned by the platform
+ * server; writing to it directly bypasses the usual Effect response writer and
+ * must be coordinated carefully to avoid duplicate writes. Upgrade requests may
+ * create that response lazily when it is first requested.
+ *
+ * @since 4.0.0
  */
 import type { HttpServerRequest } from "effect/unstable/http/HttpServerRequest"
 import type * as Http from "node:http"
 
 /**
- * @since 1.0.0
+ * Returns the underlying Node `IncomingMessage` for a platform Node
+ * `HttpServerRequest`.
+ *
  * @category Accessors
+ * @since 4.0.0
  */
 export const toIncomingMessage = (self: HttpServerRequest): Http.IncomingMessage => self.source as any
 
 /**
- * @since 1.0.0
+ * Returns the underlying Node `ServerResponse` for a platform Node
+ * `HttpServerRequest`, evaluating the stored response thunk when the response
+ * was created lazily.
+ *
  * @category Accessors
+ * @since 4.0.0
  */
 export const toServerResponse = (self: HttpServerRequest): Http.ServerResponse => {
   const res = (self as any).response

package/src/NodeMultipart.ts

@@ -1,5 +1,37 @@
 /**
- * @since 1.0.0
+ * Node.js multipart parsing for HTTP `multipart/form-data` request bodies.
+ *
+ * `NodeMultipart` adapts a Node `Readable` plus incoming HTTP headers into
+ * Effect's shared multipart model. It can expose form parts as a stream for
+ * incremental processing, or collect a complete persisted form by writing file
+ * uploads to scoped temporary files through the current `FileSystem` and `Path`
+ * services.
+ *
+ * **Mental model**
+ *
+ * Multipart request bodies are one-shot byte streams. {@link stream} parses the
+ * body as it arrives: fields are decoded to strings and file parts keep their
+ * underlying Node readable stream. {@link persisted} consumes the same kind of
+ * body, builds a `Multipart.Persisted` record, and ties temporary upload files
+ * to the surrounding `Scope`.
+ *
+ * **Common tasks**
+ *
+ * - Use {@link stream} when a route validates fields while piping file uploads
+ *   to storage.
+ * - Use {@link persisted} when a route needs a complete form value with scoped
+ *   temporary files.
+ * - Use {@link fileToReadable} when a downstream Node library expects a
+ *   `Readable`.
+ *
+ * **Gotchas**
+ *
+ * Consume a request body with only one parser. File parts must be drained,
+ * piped, or persisted so the request can finish reading. `contentEffect` loads
+ * an uploaded file into memory, so reserve it for small files. Client-supplied
+ * filenames are metadata, not trusted filesystem paths.
+ *
+ * @since 4.0.0
  */
 import * as Effect from "effect/Effect"
 import type * as FileSystem from "effect/FileSystem"
@@ -16,8 +48,12 @@ import * as NodeStreamP from "node:stream/promises"
 import * as NodeStream from "./NodeStream.ts"
 
 /**
- * @since 1.0.0
+ * Parses multipart data from a Node readable request body and headers into a
+ * stream of `Multipart.Part` values, converting parser failures to
+ * `MultipartError`.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const stream = (
   source: Readable,
@@ -39,8 +75,11 @@ export const stream = (
   )
 
 /**
- * @since 1.0.0
+ * Parses multipart data from a Node readable request body and persists file
+ * parts using the current `FileSystem`, `Path`, and `Scope` services.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const persisted = (
   source: Readable,
@@ -57,7 +96,11 @@ export const persisted = (
     }))
 
 /**
- * @since 1.0.0
+ * Returns the underlying Node readable stream for a multipart file produced by
+ * the Node multipart parser.
+ *
+ * @category converting
+ * @since 4.0.0
  */
 export const fileToReadable = (file: Multipart.File): Readable => (file as FileImpl).file
 

package/src/NodePath.ts

@@ -1,24 +1,60 @@
 /**
- * @since 1.0.0
+ * Node.js layers for Effect's `Path` service.
+ *
+ * This module adapts Node's path and file URL behavior to the
+ * platform-independent `Path` service. Provide one of its layers when a Node
+ * program needs to build, normalize, parse, resolve, or convert paths without
+ * depending directly on `node:path`.
+ *
+ * **Mental model**
+ *
+ * `Path` is a syntactic service: it manipulates strings and `file:` URLs. It
+ * does not read the filesystem, check permissions, or validate that paths
+ * exist. The selected layer decides which separator, drive-letter, UNC, and URL
+ * conversion rules are used.
+ *
+ * **Common tasks**
+ *
+ * Use `layer` for host-platform Node semantics, `layerPosix` for stable POSIX
+ * behavior, and `layerWin32` for stable Windows behavior. `NodeServices.layer`
+ * already includes `layer`, so import this module directly when a program wants
+ * only path support or a platform-specific variant.
+ *
+ * **Gotchas**
+ *
+ * Results that are correct on one platform may not be portable to another.
+ * `fromFileUrl` and `toFileUrl` use Node's `node:url` conversion rules and
+ * report invalid conversions as `BadArgument` failures.
+ *
+ * @since 4.0.0
  */
 import * as NodePath from "@effect/platform-node-shared/NodePath"
 import type * as Layer from "effect/Layer"
 import type { Path } from "effect/Path"
 
 /**
- * @since 1.0.0
- * @category layer
+ * Provides the default Node `Path` service using the platform's `node:path`
+ * implementation.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<Path> = NodePath.layer
 
 /**
- * @since 1.0.0
- * @category layer
+ * Provides the `Path` service using Node's POSIX path implementation,
+ * regardless of the host platform.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerPosix: Layer.Layer<Path> = NodePath.layerPosix
 
 /**
- * @since 1.0.0
- * @category layer
+ * Provides the `Path` service using Node's Windows path implementation,
+ * regardless of the host platform.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerWin32: Layer.Layer<Path> = NodePath.layerWin32

package/src/NodeRedis.ts

@@ -1,20 +1,61 @@
 /**
- * @since 1.0.0
+ * Node.js Redis integration backed by `ioredis`.
+ *
+ * This module creates a scoped `ioredis` client and exposes it in two forms:
+ * the generic `Redis` service consumed by Effect persistence modules, and the
+ * {@link NodeRedis} service for code that needs direct access to the underlying
+ * client.
+ *
+ * **Mental model**
+ *
+ * - {@link layer} creates one `ioredis` client from explicit client options
+ * - {@link layerConfig} reads the same options from `Config`
+ * - Building the layer opens the client, and closing the layer scope calls
+ *   `quit`
+ * - The generic `Redis` service sends command strings through `client.call`
+ * - {@link NodeRedis} exposes the raw client plus `use`, which maps promise
+ *   failures into `RedisError`
+ *
+ * **Common tasks**
+ *
+ * - Provide Redis-backed persistence, persisted queues, or distributed rate
+ *   limiting in Node.js
+ * - Configure connection, TLS, database, retry, and reconnect behavior with
+ *   standard `ioredis` options
+ * - Run custom Redis commands through {@link NodeRedis} when the generic
+ *   `Redis` service does not cover the command shape you need
+ *
+ * **Gotchas**
+ *
+ * - Install the layer at the lifetime you want for the connection; a short
+ *   scope opens and closes a Redis client for that scope
+ * - Persistence and rate limiter stores create their own keys and Lua scripts
+ *   on top of this service, so choose stable prefixes and store ids
+ * - Persisted values may fail to decode after schema changes; plan migrations
+ *   or cleanup for long-lived Redis data
+ * - Avoid unbounded high-cardinality rate-limit keys unless another process or
+ *   key policy bounds their lifetime
+ *
+ * @since 4.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"
 
 /**
- * @since 1.0.0
- * @category Service
+ * Service tag for the Node Redis integration, exposing the underlying
+ * `ioredis` client and a `use` helper that maps client failures to
+ * `RedisError`.
+ *
+ * @category services
+ * @since 4.0.0
  */
-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,30 +86,36 @@ 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)
   )
 })
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Provides `Redis` and `NodeRedis` services backed by an `ioredis` client
+ * created with the supplied options and closed when the layer scope ends.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 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
- * @category Layers
+ * Provides `Redis` and `NodeRedis` services from `Config`-backed ioredis
+ * options, closing the client when the layer scope ends.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerConfig: (
   options: Config.Wrap<IoRedis.RedisOptions>
 ) => Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> = (
   options: Config.Wrap<IoRedis.RedisOptions>
 ): Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> =>
-  Layer.effectServices(
-    Config.unwrap(options).asEffect().pipe(
+  Layer.effectContext(
+    Config.unwrap(options).pipe(
       Effect.flatMap(make)
     )
   )