the-moby-effect 1.48.4 → 1.51.1

package/src/internal/endpoints/networks.ts

@@ -1,185 +1,167 @@
-import type * as HttpBody from "@effect/platform/HttpBody";
-import type * as HttpClientError from "@effect/platform/HttpClientError";
-import type * as Layer from "effect/Layer";
-import type * as ParseResult from "effect/ParseResult";
-
-import * as PlatformError from "@effect/platform/Error";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import * as Tuple from "effect/Tuple";
-
-import {
-    NetworkConnectOptions as NetworkConnectRequest,
-    NetworkCreateRequest,
-    NetworkCreateResponse,
-    NetworkDisconnectOptions as NetworkDisconnectRequest,
-    NetworkPruneResponse,
-    NetworkSummary,
-} from "../generated/index.js";
-import { maybeAddQueryParameter } from "./common.js";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
+import { Effect, Schema, type Layer } from "effect";
+
+import { MobyConnectionOptions } from "../../MobyConnection.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import { NetworkConnectOptions, NetworkCreateRequest, NetworkInspect } from "../generated/index.js";
+import { ContainerIdentifier, NetworkIdentifier } from "../schemas/id.js";
+import { DockerError } from "./circular.ts";
+import { BadRequest, Forbidden, InternalServerError, NotFound } from "./httpApiHacks.ts";
+
+/** @since 1.0.0 */
+export class ListFilters extends Schema.parseJson(
+    Schema.Struct({
+        dangling: Schema.optional(Schema.BooleanFromString),
+        driver: Schema.optional(Schema.Array(Schema.String)),
+        id: Schema.optional(Schema.Array(Schema.String)),
+        label: Schema.optional(Schema.Array(Schema.String)),
+        name: Schema.optional(Schema.Array(Schema.String)),
+        scope: Schema.optional(Schema.Array(Schema.String)),
+        type: Schema.optional(Schema.Literal("custom", "builtin")),
+    })
+) {}
+
+/** @since 1.0.0 */
+export class PruneFilters extends Schema.parseJson(
+    Schema.Struct({
+        label: Schema.optional(Schema.Array(Schema.String)),
+        until: Schema.optional(Schema.String),
+    })
+) {}
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkList */
+const listNetworksEndpoint = HttpApiEndpoint.get("list", "/")
+    .setUrlParams(Schema.Struct({ filters: Schema.optional(ListFilters) }))
+    .addSuccess(Schema.Array(NetworkInspect), { status: 200 });
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkInspect */
+const inspectNetworkEndpoint = HttpApiEndpoint.get("inspect", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setUrlParams(
+        Schema.Struct({
+            verbose: Schema.optional(Schema.BooleanFromString),
+            scope: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(NetworkInspect, { status: 200 })
+    .addError(NotFound); // 404 No such network
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkDelete */
+const deleteNetworkEndpoint = HttpApiEndpoint.del("delete", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .addSuccess(HttpApiSchema.NoContent) // 204 No Content
+    .addError(Forbidden) // 403 Not supported for pre-defined networks
+    .addError(NotFound); // 404 No such network
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkCreate */
+const createNetworkEndpoint = HttpApiEndpoint.post("create", "/create")
+    .setPayload(NetworkCreateRequest)
+    .addSuccess(Schema.Struct({ Id: NetworkIdentifier }), { status: 201 })
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(Forbidden) // 403 Forbidden operation
+    .addError(NotFound); // 404 Plugin not found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkConnect */
+const connectNetworkEndpoint = HttpApiEndpoint.post("connect", "/:id/connect")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setPayload(NetworkConnectOptions)
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(Forbidden) // 403 Forbidden operation
+    .addError(NotFound); // 404 Plugin not found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkDisconnect */
+const disconnectNetworkEndpoint = HttpApiEndpoint.post("disconnect", "/:id/disconnect")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setPayload(Schema.Struct({ Container: ContainerIdentifier, Force: Schema.Boolean }))
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(Forbidden) // 403 Forbidden operation
+    .addError(NotFound); // 404 Plugin not found
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkPrune */
+const pruneNetworkEndpoint = HttpApiEndpoint.post("prune", "/prune")
+    .setUrlParams(Schema.Struct({ filters: Schema.optional(PruneFilters) }))
+    .addSuccess(Schema.Struct({ NetworksDeleted: Schema.NullishOr(Schema.Array(Schema.String)) }), { status: 200 });
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network */
+const NetworksGroup = HttpApiGroup.make("networks")
+    .add(listNetworksEndpoint)
+    .add(createNetworkEndpoint)
+    .add(inspectNetworkEndpoint)
+    .add(deleteNetworkEndpoint)
+    .add(connectNetworkEndpoint)
+    .add(disconnectNetworkEndpoint)
+    .add(pruneNetworkEndpoint)
+    .addError(InternalServerError)
+    .prefix("/networks");
 
 /**
  * @since 1.0.0
- * @category Errors
- */
-export const NetworksErrorTypeId: unique symbol = Symbol.for(
-    "@the-moby-effect/endpoints/NetworksError"
-) as NetworksErrorTypeId;
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export type NetworksErrorTypeId = typeof NetworksErrorTypeId;
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const isNetworksError = (u: unknown): u is NetworksError => Predicate.hasProperty(u, NetworksErrorTypeId);
-
-/**
- * @since 1.0.0
- * @category Errors
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Network
  */
-export class NetworksError extends PlatformError.TypeIdError(NetworksErrorTypeId, "NetworksError")<{
-    method: string;
-    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+export const NetworksApi = HttpApi.make("NetworksApi").add(NetworksGroup);
 
 /**
- * Networks service
- *
  * @since 1.0.0
- * @category Tags
+ * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Network
  */
 export class Networks extends Effect.Service<Networks>()("@the-moby-effect/endpoints/Networks", {
     accessors: false,
-    dependencies: [],
+    dependencies: [
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        ),
+    ],
 
     effect: Effect.gen(function* () {
-        const defaultClient = yield* HttpClient.HttpClient;
-        const client = defaultClient.pipe(HttpClient.filterStatusOk);
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkList */
-        const list_ = (
-            options?: { readonly filters?: Record<string, string | Array<string>> } | undefined
-        ): Effect.Effect<Readonly<Array<NetworkSummary>>, NetworksError> =>
-            Function.pipe(
-                HttpClientRequest.get("/networks"),
-                maybeAddQueryParameter(
-                    "filters",
-                    Function.pipe(options?.filters, Option.fromNullable, Option.map(JSON.stringify))
-                ),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(NetworkSummary))),
-                Effect.mapError((cause) => new NetworksError({ method: "list", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkDelete */
-        const delete_ = (id: string): Effect.Effect<void, NetworksError> =>
-            Function.pipe(
-                HttpClientRequest.del(`/networks/${encodeURIComponent(id)}`),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new NetworksError({ method: "delete", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkInspect */
-        const inspect_ = (
-            id: string,
-            options?:
-                | {
-                      readonly verbose?: boolean;
-                      readonly scope?: string;
-                  }
-                | undefined
-        ): Effect.Effect<Readonly<NetworkSummary>, NetworksError> =>
-            Function.pipe(
-                HttpClientRequest.get(`/networks/${encodeURIComponent(id)}`),
-                maybeAddQueryParameter("verbose", Option.fromNullable(options?.verbose)),
-                maybeAddQueryParameter("scope", Option.fromNullable(options?.scope)),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(NetworkSummary)),
-                Effect.mapError((cause) => new NetworksError({ method: "inspect", cause }))
+        type Options<Name extends (typeof NetworksGroup.endpoints)[number]["name"]> =
+            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
+                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof NetworksGroup.endpoints)[number], Name>
+            >;
+
+        const httpClient = yield* HttpClient.HttpClient;
+        const NetworksError = DockerError.WrapForModule("networks");
+        const client = yield* HttpApiClient.group(NetworksApi, { group: "networks", httpClient });
+
+        const list_ = (filters?: Schema.Schema.Type<ListFilters>) =>
+            Effect.mapError(client.list({ urlParams: { filters } }), NetworksError("list"));
+        const create_ = (...payload: ConstructorParameters<typeof NetworkCreateRequest>) =>
+            Effect.mapError(client.create({ payload: NetworkCreateRequest.make(...payload) }), NetworksError("create"));
+        const inspect_ = (id: string, options?: Options<"inspect">) =>
+            Effect.mapError(client.inspect({ path: { id }, urlParams: { ...options } }), NetworksError("inspect"));
+        const delete_ = (id: string) => Effect.mapError(client.delete({ path: { id } }), NetworksError("delete"));
+        const connect_ = (id: string, ...payload: ConstructorParameters<typeof NetworkConnectOptions>) =>
+            Effect.mapError(
+                client.connect({
+                    path: { id },
+                    payload: NetworkConnectOptions.make(...payload),
+                }),
+                NetworksError("connect")
             );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkCreate */
-        const create_ = (
-            createRequest: typeof NetworkCreateRequest.Encoded
-        ): Effect.Effect<NetworkCreateResponse, NetworksError> =>
-            Function.pipe(
-                Schema.decode(NetworkCreateRequest)(createRequest),
-                Effect.map((body) => Tuple.make(HttpClientRequest.post("/networks/create"), body)),
-                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(NetworkCreateRequest))),
-                Effect.flatMap(client.execute),
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(NetworkCreateResponse)),
-                Effect.mapError((cause) => new NetworksError({ method: "create", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkConnect */
-        const connect_ = (
-            id: string,
-            connectRequest: typeof NetworkConnectRequest.Encoded
-        ): Effect.Effect<void, NetworksError> =>
-            Function.pipe(
-                Schema.decode(NetworkConnectRequest)(connectRequest),
-                Effect.map((body) =>
-                    Tuple.make(HttpClientRequest.post(`/networks/${encodeURIComponent(id)}/connect`), body)
-                ),
-                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(NetworkConnectRequest))),
-                Effect.flatMap(client.execute),
-                Effect.asVoid,
-                Effect.mapError((cause) => new NetworksError({ method: "connect", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkDisconnect */
         const disconnect_ = (
             id: string,
-            disconnectRequest: typeof NetworkDisconnectRequest.Encoded
-        ): Effect.Effect<void, NetworksError> =>
-            Function.pipe(
-                Schema.decode(NetworkDisconnectRequest)(disconnectRequest),
-                Effect.map((body) =>
-                    Tuple.make(HttpClientRequest.post(`/networks/${encodeURIComponent(id)}/disconnect`), body)
-                ),
-                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(NetworkDisconnectRequest))),
-                Effect.flatMap(client.execute),
-                Effect.asVoid,
-                Effect.mapError((cause) => new NetworksError({ method: "disconnect", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Network/operation/NetworkPrune */
-        const prune_ = (
-            options: { readonly filters?: Record<string, string | Array<string>> } | undefined
-        ): Effect.Effect<NetworkPruneResponse, NetworksError, never> =>
-            Function.pipe(
-                HttpClientRequest.post("/networks/prune"),
-                maybeAddQueryParameter(
-                    "filters",
-                    Function.pipe(options?.filters, Option.fromNullable, Option.map(JSON.stringify))
-                ),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(NetworkPruneResponse)),
-                Effect.mapError((cause) => new NetworksError({ method: "prune", cause }))
+            containerId: ContainerIdentifier,
+            options?: { force?: boolean | undefined } | undefined
+        ) =>
+            Effect.mapError(
+                client.disconnect({
+                    path: { id },
+                    payload: { Container: containerId, Force: options?.force ?? false },
+                }),
+                NetworksError("disconnect")
             );
+        const prune_ = (filters?: Schema.Schema.Type<PruneFilters>) =>
+            Effect.mapError(client.prune({ urlParams: { filters } }), NetworksError("prune"));
 
         return {
             list: list_,
-            delete: delete_,
-            inspect: inspect_,
             create: create_,
+            inspect: inspect_,
+            delete: delete_,
             connect: connect_,
             disconnect: disconnect_,
             prune: prune_,
@@ -192,4 +174,11 @@ export class Networks extends Effect.Service<Networks>()("@the-moby-effect/endpo
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Network
  */
-export const NetworksLayer: Layer.Layer<Networks, never, HttpClient.HttpClient> = Networks.Default;
+export const NetworksLayer: Layer.Layer<Networks, never, HttpClient.HttpClient> = Networks.DefaultWithoutDependencies;
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Network
+ */
+export const NetworksLayerLocalSocket: Layer.Layer<Networks, never, HttpClient.HttpClient> = Networks.Default;

package/src/internal/endpoints/nodes.ts

@@ -1,140 +1,104 @@
-import type * as HttpBody from "@effect/platform/HttpBody";
-import type * as HttpClientError from "@effect/platform/HttpClientError";
-import type * as Layer from "effect/Layer";
-import type * as ParseResult from "effect/ParseResult";
-
-import * as PlatformError from "@effect/platform/Error";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
+import { Effect, Schema, type Layer } from "effect";
 
+import { MobyConnectionOptions } from "../../MobyConnection.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
 import { SwarmNode, SwarmNodeSpec } from "../generated/index.js";
-import { maybeAddQueryParameter } from "./common.js";
+import { DockerError } from "./circular.ts";
+import { BadRequest, InternalServerError, NotFound } from "./httpApiHacks.ts";
+import { NodeNotPartOfSwarm } from "./swarm.js";
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const NodesErrorTypeId: unique symbol = Symbol.for("@the-moby-effect/endpoints/NodesError") as NodesErrorTypeId;
+/** @since 1.0.0 */
+export class ListFilters extends Schema.parseJson(
+    Schema.Struct({
+        id: Schema.optional(Schema.Array(Schema.String)),
+        label: Schema.optional(Schema.Array(Schema.String)),
+        membership: Schema.optional(Schema.Array(Schema.Literal("accepted", "pending"))),
+        name: Schema.optional(Schema.Array(Schema.String)),
+        "node.label": Schema.optional(Schema.Array(Schema.String)),
+        role: Schema.optional(Schema.Array(Schema.Literal("manager", "worker"))),
+    })
+) {}
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export type NodesErrorTypeId = typeof NodesErrorTypeId;
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeList */
+const listNodesEndpoint = HttpApiEndpoint.get("list", "/")
+    .setUrlParams(Schema.Struct({ filters: Schema.optional(ListFilters) }))
+    .addSuccess(Schema.Array(SwarmNode), { status: 200 })
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const isNodesError = (u: unknown): u is NodesError => Predicate.hasProperty(u, NodesErrorTypeId);
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeInspect */
+const inspectNodeEndpoint = HttpApiEndpoint.get("inspect", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .addSuccess(SwarmNode, { status: 200 })
+    .addError(NotFound) // 404 No such node
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeDelete */
+const deleteNodeEndpoint = HttpApiEndpoint.del("delete", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setUrlParams(Schema.Struct({ force: Schema.optional(Schema.BooleanFromString) }))
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(NotFound) // 404 No such node
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeUpdate */
+const updateNodeEndpoint = HttpApiEndpoint.post("update", "/:id/update")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setUrlParams(Schema.Struct({ version: Schema.NumberFromString }))
+    .setPayload(SwarmNodeSpec)
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(BadRequest) // 400 Bad parameter
+    .addError(NotFound) // 404 No such node
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node */
+const NodesGroup = HttpApiGroup.make("nodes")
+    .add(listNodesEndpoint)
+    .add(inspectNodeEndpoint)
+    .add(deleteNodeEndpoint)
+    .add(updateNodeEndpoint)
+    .addError(InternalServerError)
+    .prefix("/nodes");
 
 /**
  * @since 1.0.0
- * @category Errors
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Node
  */
-export class NodesError extends PlatformError.TypeIdError(NodesErrorTypeId, "NodesError")<{
-    method: string;
-    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+export const NodesApi = HttpApi.make("NodesApi").add(NodesGroup);
 
 /**
- * Nodes service
- *
  * @since 1.0.0
- * @category Tags
- * @see https://docs.docker.com/engine/api/v1.45/#tag/Node
+ * @category Services
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Node
  */
 export class Nodes extends Effect.Service<Nodes>()("@the-moby-effect/endpoints/Nodes", {
     accessors: false,
-    dependencies: [],
+    dependencies: [
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        ),
+    ],
 
     effect: Effect.gen(function* () {
-        const defaultClient = yield* HttpClient.HttpClient;
-        const client = defaultClient.pipe(HttpClient.filterStatusOk);
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeList */
-        const list_ = (
-            options?:
-                | {
-                      readonly filters?: {
-                          id?: [string] | undefined;
-                          label?: [string] | undefined;
-                          membership?: ["accepted" | "pending"] | undefined;
-                          name?: [string] | undefined;
-                          "node.label"?: [string] | undefined;
-                          role?: ["manager" | "worker"] | undefined;
-                      };
-                  }
-                | undefined
-        ): Effect.Effect<Readonly<Array<SwarmNode>>, NodesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get("/nodes"),
-                maybeAddQueryParameter(
-                    "filters",
-                    Function.pipe(options?.filters, Option.fromNullable, Option.map(JSON.stringify))
-                ),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(SwarmNode))),
-                Effect.mapError((cause) => new NodesError({ method: "list", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeDelete */
-        const delete_ = (
-            id: string,
-            options?:
-                | {
-                      readonly force?: boolean | undefined;
-                  }
-                | undefined
-        ): Effect.Effect<void, NodesError, never> =>
-            Function.pipe(
-                HttpClientRequest.del(`/nodes/${encodeURIComponent(id)}`),
-                maybeAddQueryParameter("force", Option.fromNullable(options?.force)),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(SwarmNode))),
-                Effect.mapError((cause) => new NodesError({ method: "delete", cause }))
-            );
+        const httpClient = yield* HttpClient.HttpClient;
+        const NodesError = DockerError.WrapForModule("nodes");
+        const client = yield* HttpApiClient.group(NodesApi, { group: "nodes", httpClient });
 
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeInspect */
-        const inspect_ = (id: string): Effect.Effect<Readonly<SwarmNode>, NodesError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/nodes/${encodeURIComponent(id)}`),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmNode)),
-                Effect.mapError((cause) => new NodesError({ method: "inspect", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Node/operation/NodeUpdate */
-        const update_ = (
-            id: string,
-            options: {
-                readonly body: SwarmNodeSpec;
-                readonly version: number;
-            }
-        ): Effect.Effect<void, NodesError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/nodes/${encodeURIComponent(id)}/update`),
-                maybeAddQueryParameter("version", Option.some(options.version)),
-                HttpClientRequest.schemaBodyJson(SwarmNodeSpec)(options.body),
-                Effect.flatMap(client.execute),
-                Effect.asVoid,
-                Effect.mapError((cause) => new NodesError({ method: "update", cause }))
-            );
+        const list_ = (filters?: Schema.Schema.Type<ListFilters>) =>
+            Effect.mapError(client.list({ urlParams: { filters } }), NodesError("list"));
+        const inspect_ = (id: string) => Effect.mapError(client.inspect({ path: { id } }), NodesError("inspect"));
+        const delete_ = (id: string, options?: { force?: boolean | undefined } | undefined) =>
+            Effect.mapError(client.delete({ path: { id }, urlParams: { ...options } }), NodesError("delete"));
+        const update_ = (id: string, version: number, payload: SwarmNodeSpec) =>
+            Effect.mapError(client.update({ path: { id }, urlParams: { version }, payload }), NodesError("update"));
 
         return {
             list: list_,
-            delete: delete_,
             inspect: inspect_,
+            delete: delete_,
             update: update_,
         };
     }),
@@ -143,6 +107,13 @@ export class Nodes extends Effect.Service<Nodes>()("@the-moby-effect/endpoints/N
 /**
  * @since 1.0.0
  * @category Layers
- * @see https://docs.docker.com/engine/api/v1.45/#tag/Node
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Node
+ */
+export const NodesLayer: Layer.Layer<Nodes, never, HttpClient.HttpClient> = Nodes.DefaultWithoutDependencies;
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Node
  */
-export const NodesLayer: Layer.Layer<Nodes, never, HttpClient.HttpClient> = Nodes.Default;
+export const NodesLayerLocalSocket: Layer.Layer<Nodes, never, HttpClient.HttpClient> = Nodes.Default;