the-moby-effect 1.45.0-alpha.8 → 1.48.0

package/src/internal/endpoints/secrets.ts

@@ -0,0 +1,149 @@
+import * as PlatformError from "@effect/platform/Error";
+import * as HttpBody from "@effect/platform/HttpBody";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+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 Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Tuple from "effect/Tuple";
+
+import { SwarmSecret, SwarmSecretCreateResponse, SwarmSecretSpec } from "../generated/index.js";
+import { maybeAddQueryParameter } from "./common.js";
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const SecretsErrorTypeId: unique symbol = Symbol.for(
+    "@the-moby-effect/endpoints/SecretsError"
+) as SecretsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export type SecretsErrorTypeId = typeof SecretsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const isSecretsError = (u: unknown): u is SecretsError => Predicate.hasProperty(u, SecretsErrorTypeId);
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class SecretsError extends PlatformError.TypeIdError(SecretsErrorTypeId, "SecretsError")<{
+    method: string;
+    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
+}> {
+    get message() {
+        return `${this.method}`;
+    }
+}
+
+/**
+ * Secrets are sensitive data that can be used by services. Swarm mode must be
+ * enabled for these endpoints to work.
+ *
+ * @since 1.0.0
+ * @category Tags
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret
+ */
+export class Secrets extends Effect.Service<Secrets>()("@the-moby-effect/endpoints/Secrets", {
+    accessors: false,
+    dependencies: [],
+
+    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/Secret/operation/SecretList */
+        const list_ = (
+            options?: { readonly filters?: Record<string, string | Array<string>> } | undefined
+        ): Effect.Effect<Readonly<Array<SwarmSecret>>, SecretsError, never> =>
+            Function.pipe(
+                HttpClientRequest.get("/secrets"),
+                maybeAddQueryParameter(
+                    "filters",
+                    Function.pipe(options?.filters, Option.fromNullable, Option.map(JSON.stringify))
+                ),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(SwarmSecret))),
+                Effect.mapError((cause) => new SecretsError({ method: "list", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretCreate */
+        const create_ = (
+            data: typeof SwarmSecretSpec.Encoded
+        ): Effect.Effect<Readonly<SwarmSecretCreateResponse>, SecretsError, never> =>
+            Function.pipe(
+                Schema.decode(SwarmSecretSpec)(data),
+                Effect.map((body) => Tuple.make(HttpClientRequest.post("/secrets/create"), body)),
+                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(SwarmSecretSpec))),
+                Effect.flatMap(client.execute),
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmSecretCreateResponse)),
+                Effect.mapError((cause) => new SecretsError({ method: "create", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretDelete */
+        const delete_ = (id: string): Effect.Effect<void, SecretsError, never> =>
+            Function.pipe(
+                HttpClientRequest.del(`/secrets/${encodeURIComponent(id)}`),
+                client.execute,
+                Effect.asVoid,
+                Effect.mapError((cause) => new SecretsError({ method: "delete", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretInspect */
+        const inspect_ = (id: string): Effect.Effect<Readonly<SwarmSecret>, SecretsError, never> =>
+            Function.pipe(
+                HttpClientRequest.get(`/secrets/${encodeURIComponent(id)}`),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmSecret)),
+                Effect.mapError((cause) => new SecretsError({ method: "inspect", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretUpdate */
+        const update_ = (
+            id: string,
+            options: {
+                readonly spec: SwarmSecretSpec;
+                readonly version: number;
+            }
+        ): Effect.Effect<void, SecretsError, never> =>
+            Function.pipe(
+                HttpClientRequest.post(`/secrets/${encodeURIComponent(id)}/update`),
+                maybeAddQueryParameter("version", Option.some(options.version)),
+                HttpClientRequest.schemaBodyJson(SwarmSecretSpec)(options.spec),
+                Effect.flatMap(client.execute),
+                Effect.asVoid,
+                Effect.mapError((cause) => new SecretsError({ method: "update", cause }))
+            );
+
+        return {
+            list: list_,
+            create: create_,
+            delete: delete_,
+            inspect: inspect_,
+            update: update_,
+        };
+    }),
+}) {}
+
+/**
+ * Secrets are sensitive data that can be used by services. Swarm mode must be
+ * enabled for these endpoints to work.
+ *
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret
+ */
+export const SecretsLayer: Layer.Layer<Secrets, never, HttpClient.HttpClient> = Secrets.Default;

package/src/internal/endpoints/services.ts

@@ -0,0 +1,227 @@
+import * as PlatformError from "@effect/platform/Error";
+import * as HttpBody from "@effect/platform/HttpBody";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+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 Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as Tuple from "effect/Tuple";
+
+import {
+    SwarmService,
+    SwarmServiceCreateResponse,
+    SwarmServiceSpec,
+    SwarmServiceUpdateResponse,
+} from "../generated/index.js";
+import { maybeAddQueryParameter } from "./common.js";
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const ServicesErrorTypeId: unique symbol = Symbol.for(
+    "@the-moby-effect/endpoints/ServicesError"
+) as ServicesErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export type ServicesErrorTypeId = typeof ServicesErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const isServicesError = (u: unknown): u is ServicesError => Predicate.hasProperty(u, ServicesErrorTypeId);
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class ServicesError extends PlatformError.TypeIdError(ServicesErrorTypeId, "ServicesError")<{
+    method: string;
+    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
+}> {
+    get message() {
+        return `${this.method}`;
+    }
+}
+
+/**
+ * Services are the definitions of tasks to run on a swarm. Swarm mode must be
+ * enabled for these endpoints to work.
+ *
+ * @since 1.0.0
+ * @category Tags
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
+ */
+export class Services extends Effect.Service<Services>()("@the-moby-effect/endpoints/Services", {
+    accessors: false,
+    dependencies: [],
+
+    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/Service/operation/ServiceList */
+        const list_ = (
+            options?: { readonly filters?: string; readonly status?: boolean } | undefined
+        ): Effect.Effect<Readonly<Array<SwarmService>>, ServicesError, never> =>
+            Function.pipe(
+                HttpClientRequest.get("/services"),
+                maybeAddQueryParameter(
+                    "filters",
+                    Function.pipe(options?.filters, Option.fromNullable, Option.map(JSON.stringify))
+                ),
+                maybeAddQueryParameter("status", Option.fromNullable(options?.status)),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(SwarmService))),
+                Effect.mapError((cause) => new ServicesError({ method: "list", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceCreate */
+        const create_ = (options: {
+            readonly body: typeof SwarmServiceSpec.Encoded;
+            readonly "X-Registry-Auth"?: string;
+        }): Effect.Effect<Readonly<SwarmServiceCreateResponse>, ServicesError, never> =>
+            Function.pipe(
+                Schema.decode(SwarmServiceSpec)(options.body),
+                Effect.map((body) => Tuple.make(HttpClientRequest.post("/services/create"), body)),
+                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(SwarmServiceSpec))),
+                Effect.map(HttpClientRequest.setHeader("X-Registry-Auth", "")),
+                Effect.flatMap(client.execute),
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmServiceCreateResponse)),
+                Effect.mapError((cause) => new ServicesError({ method: "create", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceDelete */
+        const delete_ = (id: string): Effect.Effect<void, ServicesError, never> =>
+            Function.pipe(
+                HttpClientRequest.del(`/services/${encodeURIComponent(id)}`),
+                client.execute,
+                Effect.asVoid,
+                Effect.mapError((cause) => new ServicesError({ method: "delete", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceInspect */
+        const inspect_ = (
+            id: string,
+            options?:
+                | {
+                      readonly insertDefaults?: boolean;
+                  }
+                | undefined
+        ): Effect.Effect<Readonly<SwarmService>, ServicesError, never> =>
+            Function.pipe(
+                HttpClientRequest.get(`/services/${encodeURIComponent(id)}`),
+                maybeAddQueryParameter("insertDefaults", Option.fromNullable(options?.insertDefaults)),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmService)),
+                Effect.mapError((cause) => new ServicesError({ method: "inspect", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceUpdate */
+        const update_ = (
+            id: string,
+            options: {
+                readonly body: SwarmServiceSpec;
+                /**
+                 * The version number of the service object being updated. This
+                 * is required to avoid conflicting writes. This version number
+                 * should be the value as currently set on the service _before_
+                 * the update. You can find the current version by calling `GET
+                 * /services/{id}`
+                 */
+                readonly version: number;
+                /**
+                 * If the `X-Registry-Auth` header is not specified, this
+                 * parameter indicates where to find registry authorization
+                 * credentials.
+                 */
+                readonly registryAuthFrom?: string;
+                /**
+                 * Set to this parameter to `previous` to cause a server-side
+                 * rollback to the previous service spec. The supplied spec will
+                 * be ignored in this case.
+                 */
+                readonly rollback?: string;
+                /**
+                 * A base64url-encoded auth configuration for pulling from
+                 * private registries.
+                 *
+                 * Refer to the [authentication
+                 * section](#section/Authentication) for details.
+                 */
+                readonly "X-Registry-Auth"?: string;
+            }
+        ): Effect.Effect<Readonly<SwarmServiceUpdateResponse>, ServicesError, never> =>
+            Function.pipe(
+                HttpClientRequest.post(`/services/${encodeURIComponent(id)}/update`),
+                HttpClientRequest.setHeader("X-Registry-Auth", ""),
+                maybeAddQueryParameter("version", Option.some(options.version)),
+                maybeAddQueryParameter("registryAuthFrom", Option.fromNullable(options.registryAuthFrom)),
+                maybeAddQueryParameter("rollback", Option.fromNullable(options.rollback)),
+                HttpClientRequest.schemaBodyJson(SwarmServiceSpec)(options.body),
+                Effect.flatMap(client.execute),
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmServiceUpdateResponse)),
+                Effect.mapError((cause) => new ServicesError({ method: "update", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceLogs */
+        const logs_ = (
+            id: string,
+            options?:
+                | {
+                      readonly details?: boolean;
+                      readonly follow?: boolean;
+                      readonly stdout?: boolean;
+                      readonly stderr?: boolean;
+                      readonly since?: number;
+                      readonly timestamps?: boolean;
+                      readonly tail?: string;
+                  }
+                | undefined
+        ): Stream.Stream<string, ServicesError, never> =>
+            Function.pipe(
+                HttpClientRequest.get(`/services/${encodeURIComponent(id)}/logs`),
+                maybeAddQueryParameter("details", Option.fromNullable(options?.details)),
+                maybeAddQueryParameter("follow", Option.fromNullable(options?.follow)),
+                maybeAddQueryParameter("stdout", Option.fromNullable(options?.stdout)),
+                maybeAddQueryParameter("stderr", Option.fromNullable(options?.stderr)),
+                maybeAddQueryParameter("since", Option.fromNullable(options?.since)),
+                maybeAddQueryParameter("timestamps", Option.fromNullable(options?.timestamps)),
+                maybeAddQueryParameter("tail", Option.fromNullable(options?.tail)),
+                client.execute,
+                HttpClientResponse.stream,
+                Stream.decodeText(),
+                Stream.mapError((cause) => new ServicesError({ method: "logs", cause }))
+            );
+
+        return {
+            list: list_,
+            create: create_,
+            delete: delete_,
+            inspect: inspect_,
+            update: update_,
+            logs: logs_,
+        };
+    }),
+}) {}
+
+/**
+ * Services are the definitions of tasks to run on a swarm. Swarm mode must be
+ * enabled for these endpoints to work.
+ *
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
+ */
+export const ServicesLayer: Layer.Layer<Services, never, HttpClient.HttpClient> = Services.Default;

package/src/internal/endpoints/session.ts

@@ -0,0 +1,90 @@
+import * as PlatformError from "@effect/platform/Error";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Socket from "@effect/platform/Socket";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+
+import { hijackResponseUnsafe } from "../demux/hijack.js";
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const SessionsErrorTypeId: unique symbol = Symbol.for(
+    "@the-moby-effect/endpoints/SessionsError"
+) as SessionsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export type SessionsErrorTypeId = typeof SessionsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const isSessionsError = (u: unknown): u is SessionsError => Predicate.hasProperty(u, SessionsErrorTypeId);
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class SessionsError extends PlatformError.TypeIdError(SessionsErrorTypeId, "SessionsError")<{
+    method: string;
+    cause: HttpClientError.HttpClientError | Socket.SocketError | unknown;
+}> {
+    get message() {
+        return `${this.method}`;
+    }
+}
+
+/**
+ * @since 1.0.0
+ * @category Tags
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Session
+ */
+export class Sessions extends Effect.Service<Sessions>()("@the-moby-effect/endpoints/Session", {
+    accessors: false,
+    dependencies: [],
+
+    effect: Effect.gen(function* () {
+        const defaultClient = yield* HttpClient.HttpClient;
+        const client = defaultClient.pipe(HttpClient.filterStatus((status) => status === 101));
+
+        /**
+         * Start a new interactive session with a server. Session allows server
+         * to call back to the client for advanced capabilities. This endpoint
+         * hijacks the HTTP connection to HTTP2 transport that allows the client
+         * to expose gPRC services on that connection. For example, the client
+         * sends this request to upgrade the connection: `POST /session HTTP/1.1
+         * Upgrade: h2c Connection: Upgrade` The Docker daemon responds with a
+         * `101 UPGRADED` response follow with the raw stream: `HTTP/1.1 101
+         * UPGRADED Connection: Upgrade Upgrade: h2c`
+         *
+         * @see https://docs.docker.com/reference/api/engine/latest/#tag/Session/operation/Session
+         */
+        const session_ = (): Effect.Effect<Socket.Socket, SessionsError, never> =>
+            Function.pipe(
+                HttpClientRequest.post("/session"),
+                HttpClientRequest.setHeader("Upgrade", "h2c"),
+                HttpClientRequest.setHeader("Connection", "Upgrade"),
+                client.execute,
+                Effect.flatMap(hijackResponseUnsafe),
+                Effect.mapError((cause) => new SessionsError({ method: "session", cause }))
+            );
+
+        return { session: session_ };
+    }),
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Session
+ */
+export const SessionsLayer: Layer.Layer<Sessions, never, HttpClient.HttpClient> = Sessions.Default;

package/src/internal/endpoints/swarm.ts

@@ -0,0 +1,182 @@
+import * as PlatformError from "@effect/platform/Error";
+import * as HttpBody from "@effect/platform/HttpBody";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+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 Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Tuple from "effect/Tuple";
+
+import {
+    Swarm as SwarmData,
+    SwarmInitRequest,
+    SwarmJoinRequest,
+    SwarmSpec,
+    SwarmUnlockKeyResponse,
+    SwarmUnlockRequest,
+} from "../generated/index.js";
+import { maybeAddQueryParameter } from "./common.js";
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const SwarmsErrorTypeId: unique symbol = Symbol.for(
+    "@the-moby-effect/endpoints/SwarmsError"
+) as SwarmsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export type SwarmsErrorTypeId = typeof SwarmsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const isSwarmsError = (u: unknown): u is SwarmsError => Predicate.hasProperty(u, SwarmsErrorTypeId);
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class SwarmsError extends PlatformError.TypeIdError(SwarmsErrorTypeId, "SwarmsError")<{
+    method: string;
+    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
+}> {
+    get message() {
+        return `${this.method}`;
+    }
+}
+
+/**
+ * Engines can be clustered together in a swarm. Refer to the swarm mode
+ * documentation for more information.
+ *
+ * @since 1.0.0
+ * @category Tags
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm
+ */
+export class Swarm extends Effect.Service<Swarm>()("@the-moby-effect/endpoints/Swarm", {
+    accessors: false,
+    dependencies: [],
+
+    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/Swarm/operation/SwarmInspect */
+        const inspect_ = (): Effect.Effect<Readonly<SwarmData>, SwarmsError, never> =>
+            Function.pipe(
+                HttpClientRequest.get("/swarm"),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmData)),
+                Effect.mapError((cause) => new SwarmsError({ method: "inspect", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmInit */
+        const init_ = (options: typeof SwarmInitRequest.Encoded): Effect.Effect<Readonly<string>, SwarmsError, never> =>
+            Function.pipe(
+                Schema.decode(SwarmInitRequest)(options),
+                Effect.map((body) => Tuple.make(HttpClientRequest.post("/swarm/init"), body)),
+                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(SwarmInitRequest))),
+                Effect.flatMap(client.execute),
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.String)),
+                Effect.mapError((cause) => new SwarmsError({ method: "init", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmJoin */
+        const join_ = (options: typeof SwarmJoinRequest.Encoded): Effect.Effect<void, SwarmsError, never> =>
+            Function.pipe(
+                Schema.decode(SwarmJoinRequest)(options),
+                Effect.map((body) => Tuple.make(HttpClientRequest.post("/swarm/join"), body)),
+                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(SwarmJoinRequest))),
+                Effect.flatMap(client.execute),
+                Effect.asVoid,
+                Effect.mapError((cause) => new SwarmsError({ method: "join", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmLeave */
+        const leave_ = (options: {
+            /**
+             * Force leave swarm, even if this is the last manager or that it
+             * will break the cluster.
+             */
+            readonly force?: boolean;
+        }): Effect.Effect<void, SwarmsError, never> =>
+            Function.pipe(
+                HttpClientRequest.post("/swarm/leave"),
+                maybeAddQueryParameter("force", Option.fromNullable(options.force)),
+                client.execute,
+                Effect.asVoid,
+                Effect.mapError((cause) => new SwarmsError({ method: "leave", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmUpdate */
+        const update_ = (options: {
+            readonly spec: SwarmSpec;
+            readonly version: number;
+            readonly rotateWorkerToken?: boolean;
+            readonly rotateManagerToken?: boolean;
+            readonly rotateManagerUnlockKey?: boolean;
+        }): Effect.Effect<void, SwarmsError, never> =>
+            Function.pipe(
+                HttpClientRequest.post("/swarm/update"),
+                maybeAddQueryParameter("version", Option.some(options.version)),
+                maybeAddQueryParameter("rotateWorkerToken", Option.fromNullable(options.rotateWorkerToken)),
+                maybeAddQueryParameter("rotateManagerToken", Option.fromNullable(options.rotateManagerToken)),
+                maybeAddQueryParameter("rotateManagerUnlockKey", Option.fromNullable(options.rotateManagerUnlockKey)),
+                HttpClientRequest.schemaBodyJson(SwarmSpec)(options.spec),
+                Effect.flatMap(client.execute),
+                Effect.asVoid,
+                Effect.mapError((cause) => new SwarmsError({ method: "update", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmUnlockkey */
+        const unlockkey_ = (): Effect.Effect<SwarmUnlockKeyResponse, SwarmsError, never> =>
+            Function.pipe(
+                HttpClientRequest.get("/swarm/unlockkey"),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmUnlockKeyResponse)),
+                Effect.mapError((cause) => new SwarmsError({ method: "unlockkey", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmUnlock */
+        const unlock_ = (options: typeof SwarmUnlockRequest.Encoded): Effect.Effect<void, SwarmsError, never> =>
+            Function.pipe(
+                Schema.decode(SwarmUnlockRequest)(options),
+                Effect.map((body) => Tuple.make(HttpClientRequest.post("/swarm/unlock"), body)),
+                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(SwarmUnlockRequest))),
+                Effect.flatMap(client.execute),
+                Effect.asVoid,
+                Effect.mapError((cause) => new SwarmsError({ method: "unlock", cause }))
+            );
+
+        return {
+            inspect: inspect_,
+            init: init_,
+            join: join_,
+            leave: leave_,
+            update: update_,
+            unlockkey: unlockkey_,
+            unlock: unlock_,
+        };
+    }),
+}) {}
+
+/**
+ * Engines can be clustered together in a swarm. Refer to the swarm mode
+ * documentation for more information.
+ *
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm
+ */
+export const SwarmLayer: Layer.Layer<Swarm, never, HttpClient.HttpClient> = Swarm.Default;