the-moby-effect 1.51.7 → 1.54.2

package/src/internal/endpoints/networks.ts

@@ -1,98 +1,138 @@
-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 * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { NetworkConnectOptions, NetworkCreateRequest, NetworkInspect } from "../generated/index.ts";
+import { ContainerIdentifier, NetworkIdentifier } from "../schemas/id.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, Forbidden, InternalServerError, NotFound } from "./httpApiHacks.ts";
+import { BadRequest, Forbidden, InternalServerError, NotFound } from "./errors.ts";
+import { BooleanFilter, StringFilter } from "./filters.ts";
 
 /** @since 1.0.0 */
-export class ListFilters extends Schema.parseJson(
+export const ListFilters = Schema.fromJsonString(
     Schema.Struct({
-        dangling: Schema.optional(Schema.BooleanFromString),
+        dangling: Schema.optional(BooleanFilter("dangling")),
         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")),
+        type: Schema.optional(
+            Schema.Tuple([Schema.Literals(["custom", "builtin"])]).pipe(
+                Schema.decodeTo(Schema.Literals(["custom", "builtin"]), {
+                    decode: SchemaGetter.transform(([value]: readonly ["custom" | "builtin"]) => value),
+                    encode: SchemaGetter.transform((value: "custom" | "builtin") => [value] as const),
+                })
+            )
+        ),
     })
-) {}
+);
 
 /** @since 1.0.0 */
-export class PruneFilters extends Schema.parseJson(
+export const PruneFilters = Schema.fromJsonString(
     Schema.Struct({
         label: Schema.optional(Schema.Array(Schema.String)),
-        until: Schema.optional(Schema.String),
+        until: Schema.optional(StringFilter),
     })
-) {}
+);
 
 /** @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 });
+const listNetworksEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: { filters: Schema.optional(ListFilters) },
+    success: Schema.Array(NetworkInspect), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @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
+const inspectNetworkEndpoint = HttpApiEndpoint.get("inspect", "/:id", {
+    params: { id: Schema.String },
+    query: {
+        verbose: Schema.optional(Schema.Boolean),
+        scope: Schema.optional(Schema.String),
+    },
+    success: NetworkInspect, // 200 OK
+    error: [
+        NotFound, // 404 No such network
+        InternalServerError,
+    ],
+});
 
 /** @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
+const deleteNetworkEndpoint = HttpApiEndpoint.delete("delete", "/:id", {
+    params: { id: Schema.String },
+    success: HttpApiSchema.NoContent, // 204 No Content
+    error: [
+        Forbidden, // 403 Not supported for pre-defined networks
+        NotFound, // 404 No such network
+        InternalServerError,
+    ],
+});
 
 /** @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
+const createNetworkEndpoint = HttpApiEndpoint.post("create", "/create", {
+    payload: NetworkCreateRequest,
+    success: Schema.Struct({ Id: NetworkIdentifier }).pipe(HttpApiSchema.status(201)), // 201 Created
+    error: [
+        BadRequest, // 400 Bad parameter
+        Forbidden, // 403 Forbidden operation
+        NotFound, // 404 Plugin not found
+        InternalServerError,
+    ],
+});
 
 /** @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
+const connectNetworkEndpoint = HttpApiEndpoint.post("connect", "/:id/connect", {
+    params: { id: Schema.String },
+    payload: NetworkConnectOptions,
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        BadRequest, // 400 Bad parameter
+        Forbidden, // 403 Forbidden operation
+        NotFound, // 404 Plugin not found
+        InternalServerError,
+    ],
+});
 
 /** @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
+const disconnectNetworkEndpoint = HttpApiEndpoint.post("disconnect", "/:id/disconnect", {
+    params: { id: Schema.String },
+    payload: Schema.Struct({ Container: ContainerIdentifier, Force: Schema.Boolean }),
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        Forbidden, // 403 Forbidden operation
+        NotFound, // 404 Plugin not found
+        InternalServerError,
+    ],
+});
 
 /** @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 });
+const pruneNetworkEndpoint = HttpApiEndpoint.post("prune", "/prune", {
+    query: { filters: Schema.optional(PruneFilters) },
+    success: Schema.Struct({ NetworksDeleted: Schema.NullishOr(Schema.Array(Schema.String)) }), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @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)
+    .add(
+        listNetworksEndpoint,
+        createNetworkEndpoint,
+        inspectNetworkEndpoint,
+        deleteNetworkEndpoint,
+        connectNetworkEndpoint,
+        disconnectNetworkEndpoint,
+        pruneNetworkEndpoint
+    )
     .prefix("/networks");
 
 /**
@@ -107,55 +147,52 @@ export const NetworksApi = HttpApi.make("NetworksApi").add(NetworksGroup);
  * @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: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
-        type Options<Name extends (typeof NetworksGroup.endpoints)[number]["name"]> =
-            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
-                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof NetworksGroup.endpoints)[number], Name>
-            >;
+export class Networks extends Context.Service<Networks>()("@the-moby-effect/endpoints/Networks", {
+    make: Effect.gen(function* () {
+        type NetworksEndpoints = HttpApiGroup.Endpoints<typeof NetworksGroup>;
+        type Options<Name extends NetworksEndpoints["identifier"]> = HttpApiEndpoint.WithIdentifier<
+            NetworksEndpoints,
+            Name
+        >["~Query"]["Type"];
 
         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 list_ = (filters?: Schema.Schema.Type<typeof ListFilters>) =>
+            client.list({ query: { filters } }).pipe(Effect.mapError(NetworksError("list")));
+        const create_ = (payload: (typeof NetworkCreateRequest)["~type.make.in"]) =>
+            NetworkCreateRequest.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.create({ payload })),
+                Effect.mapError(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")
+            client.inspect({ params: { id }, query: { ...options } }).pipe(Effect.mapError(NetworksError("inspect")));
+        const delete_ = (id: string) =>
+            client.delete({ params: { id } }).pipe(Effect.mapError(NetworksError("delete")));
+        const connect_ = (id: string, payload: (typeof NetworkConnectOptions)["~type.make.in"]) =>
+            NetworkConnectOptions.makeEffect(payload).pipe(
+                Effect.flatMap((payload) =>
+                    client.connect({
+                        params: { id },
+                        payload,
+                    })
+                ),
+                Effect.mapError(NetworksError("connect"))
             );
         const disconnect_ = (
             id: string,
             containerId: ContainerIdentifier,
             options?: { force?: boolean | undefined } | undefined
         ) =>
-            Effect.mapError(
-                client.disconnect({
-                    path: { id },
+            client
+                .disconnect({
+                    params: { 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"));
+                })
+                .pipe(Effect.mapError(NetworksError("disconnect")));
+        const prune_ = (filters?: Schema.Schema.Type<typeof PruneFilters>) =>
+            client.prune({ query: { filters } }).pipe(Effect.mapError(NetworksError("prune")));
 
         return {
             list: list_,
@@ -174,11 +211,19 @@ 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.DefaultWithoutDependencies;
+export const NetworksLayer: Layer.Layer<Networks, never, HttpClient.HttpClient> = Layer.effect(Networks, Networks.make);
 
 /**
  * @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;
+export const NetworksLayerLocalSocket: Layer.Layer<Networks, never, HttpClient.HttpClient> = NetworksLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);

package/src/internal/endpoints/nodes.ts

@@ -1,63 +1,82 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, Schema, type Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
 
-import { MobyConnectionOptions } from "../../MobyConnection.js";
-import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
-import { SwarmNode, SwarmNodeSpec } from "../generated/index.js";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { SwarmNode, SwarmNodeSpec } from "../generated/index.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, InternalServerError, NotFound } from "./httpApiHacks.ts";
-import { NodeNotPartOfSwarm } from "./swarm.js";
+import { BadRequest, InternalServerError, NotFound, ServiceUnavailable } from "./errors.ts";
 
 /** @since 1.0.0 */
-export class ListFilters extends Schema.parseJson(
+export const ListFilters = Schema.fromJsonString(
     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"))),
+        membership: Schema.optional(Schema.Array(Schema.Literals(["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"))),
+        role: Schema.optional(Schema.Array(Schema.Literals(["manager", "worker"]))),
     })
-) {}
+);
 
 /** @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
+const listNodesEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: { filters: Schema.optional(ListFilters) },
+    success: Schema.Array(SwarmNode), // 200 OK
+    error: [
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const inspectNodeEndpoint = HttpApiEndpoint.get("inspect", "/:id", {
+    params: { id: Schema.String },
+    success: SwarmNode, // 200 OK
+    error: [
+        NotFound, // 404 No such node
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const deleteNodeEndpoint = HttpApiEndpoint.delete("delete", "/:id", {
+    params: { id: Schema.String },
+    query: { force: Schema.optional(Schema.Boolean) },
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        NotFound, // 404 No such node
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const updateNodeEndpoint = HttpApiEndpoint.post("update", "/:id/update", {
+    params: { id: Schema.String },
+    query: { version: Schema.Number },
+    payload: SwarmNodeSpec,
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        BadRequest, // 400 Bad parameter
+        NotFound, // 404 No such node
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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)
+    .add(listNodesEndpoint, inspectNodeEndpoint, deleteNodeEndpoint, updateNodeEndpoint)
     .prefix("/nodes");
 
 /**
@@ -72,28 +91,23 @@ export const NodesApi = HttpApi.make("NodesApi").add(NodesGroup);
  * @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: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Nodes extends Context.Service<Nodes>()("@the-moby-effect/endpoints/Nodes", {
+    make: Effect.gen(function* () {
         const httpClient = yield* HttpClient.HttpClient;
         const NodesError = DockerError.WrapForModule("nodes");
         const client = yield* HttpApiClient.group(NodesApi, { group: "nodes", httpClient });
 
-        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 list_ = (filters?: Schema.Schema.Type<typeof ListFilters>) =>
+            client.list({ query: { filters } }).pipe(Effect.mapError(NodesError("list")));
+        const inspect_ = (id: string) =>
+            client.inspect({ params: { id } }).pipe(Effect.mapError(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"));
+            client.delete({ params: { id }, query: { ...options } }).pipe(Effect.mapError(NodesError("delete")));
+        const update_ = (id: string, version: number, payload: (typeof SwarmNodeSpec)["~type.make.in"]) =>
+            SwarmNodeSpec.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.update({ params: { id }, query: { version }, payload })),
+                Effect.mapError(NodesError("update"))
+            );
 
         return {
             list: list_,
@@ -109,11 +123,19 @@ export class Nodes extends Effect.Service<Nodes>()("@the-moby-effect/endpoints/N
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Node
  */
-export const NodesLayer: Layer.Layer<Nodes, never, HttpClient.HttpClient> = Nodes.DefaultWithoutDependencies;
+export const NodesLayer: Layer.Layer<Nodes, never, HttpClient.HttpClient> = Layer.effect(Nodes, Nodes.make);
 
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Node
  */
-export const NodesLayerLocalSocket: Layer.Layer<Nodes, never, HttpClient.HttpClient> = Nodes.Default;
+export const NodesLayerLocalSocket: Layer.Layer<Nodes, never, HttpClient.HttpClient> = NodesLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);