the-moby-effect 1.48.4 → 1.51.0

package/src/internal/endpoints/secrets.ts

@@ -1,139 +1,117 @@
-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 { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
+import { Effect, Schema, type Layer } from "effect";
 
-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 { MobyConnectionOptions } from "../../MobyConnection.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import { SwarmSecret, SwarmSecretSpec } from "../generated/index.js";
+import { SecretIdentifier } from "../schemas/id.js";
+import { DockerError } from "./circular.ts";
+import { BadRequest, Conflict, InternalServerError, NotFound } from "./httpApiHacks.ts";
+import { NodeNotPartOfSwarm } from "./swarm.js";
 
-import { SwarmSecret, SwarmSecretCreateResponse, SwarmSecretSpec } from "../generated/index.js";
-import { maybeAddQueryParameter } from "./common.js";
+/** @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)),
+        name: Schema.optional(Schema.Array(Schema.String)),
+    })
+) {}
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const SecretsErrorTypeId: unique symbol = Symbol.for(
-    "@the-moby-effect/endpoints/SecretsError"
-) as SecretsErrorTypeId;
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretList */
+const listSecretsEndpoint = HttpApiEndpoint.get("list", "/")
+    .setUrlParams(Schema.Struct({ filters: Schema.optional(ListFilters) }))
+    .addSuccess(Schema.Array(SwarmSecret), { status: 200 }) // 200 OK
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export type SecretsErrorTypeId = typeof SecretsErrorTypeId;
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretCreate */
+const createSecretEndpoint = HttpApiEndpoint.post("create", "/create")
+    .setPayload(SwarmSecretSpec)
+    .addSuccess(Schema.rename(Schema.Struct({ ID: SecretIdentifier }), { ID: "Id" }), { status: 201 }) // 201 Created
+    .addError(Conflict) // 409 name conflicts with an existing object
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const isSecretsError = (u: unknown): u is SecretsError => Predicate.hasProperty(u, SecretsErrorTypeId);
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretInspect */
+const inspectSecretEndpoint = HttpApiEndpoint.get("inspect", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .addSuccess(SwarmSecret, { status: 200 }) // 200 OK
+    .addError(NotFound) // 404 No such secret
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretDelete */
+const deleteSecretEndpoint = HttpApiEndpoint.del("delete", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .addSuccess(HttpApiSchema.NoContent) // 204 No Content
+    .addError(NotFound) // 404 No such secret
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretUpdate */
+const updateSecretEndpoint = HttpApiEndpoint.post("update", "/:id/update")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setUrlParams(Schema.Struct({ version: Schema.BigInt }))
+    .setPayload(SwarmSecretSpec)
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(BadRequest) // 400 Bad request
+    .addError(NotFound) // 404 No such secret
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret */
+const SecretsGroup = HttpApiGroup.make("secrets")
+    .add(listSecretsEndpoint)
+    .add(createSecretEndpoint)
+    .add(inspectSecretEndpoint)
+    .add(deleteSecretEndpoint)
+    .add(updateSecretEndpoint)
+    .addError(InternalServerError)
+    .prefix("/secrets");
 
 /**
+ * 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 Errors
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret
  */
-export class SecretsError extends PlatformError.TypeIdError(SecretsErrorTypeId, "SecretsError")<{
-    method: string;
-    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+export const SecretsApi = HttpApi.make("SecretsApi").add(SecretsGroup);
 
 /**
  * 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
+ * @category Services
  * @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: [],
+    dependencies: [
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        ),
+    ],
 
     effect: Effect.gen(function* () {
-        const defaultClient = yield* HttpClient.HttpClient;
-        const client = defaultClient.pipe(HttpClient.filterStatusOk);
+        const httpClient = yield* HttpClient.HttpClient;
+        const SecretsError = DockerError.WrapForModule("secrets");
+        const client = yield* HttpApiClient.group(SecretsApi, { group: "secrets", httpClient });
 
-        /** @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 }))
-            );
+        const list_ = (filters?: Schema.Schema.Type<ListFilters>) =>
+            Effect.mapError(client.list({ urlParams: { filters } }), SecretsError("list"));
+        const create_ = (payload: SwarmSecretSpec) =>
+            Effect.mapError(client.create({ payload }), SecretsError("create"));
+        const inspect_ = (id: string) => Effect.mapError(client.inspect({ path: { id } }), SecretsError("inspect"));
+        const delete_ = (id: string) => Effect.mapError(client.delete({ path: { id } }), SecretsError("delete"));
+        const update_ = (id: string, version: bigint, payload: SwarmSecretSpec) =>
+            Effect.mapError(client.update({ path: { id }, urlParams: { version }, payload }), SecretsError("update"));
 
         return {
             list: list_,
             create: create_,
-            delete: delete_,
             inspect: inspect_,
+            delete: delete_,
             update: update_,
         };
     }),
@@ -147,4 +125,14 @@ export class Secrets extends Effect.Service<Secrets>()("@the-moby-effect/endpoin
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret
  */
-export const SecretsLayer: Layer.Layer<Secrets, never, HttpClient.HttpClient> = Secrets.Default;
+export const SecretsLayer: Layer.Layer<Secrets, never, HttpClient.HttpClient> = Secrets.DefaultWithoutDependencies;
+
+/**
+ * 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 SecretsLayerLocalSocket: Layer.Layer<Secrets, never, HttpClient.HttpClient> = Secrets.Default;

package/src/internal/endpoints/services.ts

@@ -1,210 +1,187 @@
-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 Stream from "effect/Stream";
-import * as Tuple from "effect/Tuple";
-
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
+import { Effect, Schema, Stream, type Layer } from "effect";
+
+import { MobyConnectionOptions } from "../../MobyConnection.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import { SwarmService, SwarmServiceSpec } from "../generated/index.js";
+import { ServiceIdentifier } from "../schemas/id.js";
+import { DockerError } from "./circular.ts";
 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);
+    BadRequest,
+    Conflict,
+    Forbidden,
+    HttpApiStreamingResponse,
+    InternalServerError,
+    NotFound,
+} from "./httpApiHacks.js";
+import { NodeNotPartOfSwarm } from "./swarm.js";
+
+/** @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)),
+        mode: Schema.optional(Schema.Array(Schema.Literal("replicated", "global"))),
+    })
+) {}
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceList */
+const listServicesEndpoint = HttpApiEndpoint.get("list", "/")
+    .setUrlParams(
+        Schema.Struct({
+            filters: Schema.optional(ListFilters),
+            status: Schema.optional(Schema.BooleanFromString),
+        })
+    )
+    .addSuccess(Schema.Array(SwarmService), { status: 200 }) // 200 OK
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceCreate */
+const createServiceEndpoint = HttpApiEndpoint.post("create", "/create")
+    .setPayload(SwarmServiceSpec)
+    .setHeaders(Schema.Struct({ "X-Registry-Auth": Schema.optional(Schema.String) }))
+    .addSuccess(
+        Schema.Struct({
+            ID: ServiceIdentifier,
+            Warnings: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        { status: 201 }
+    ) // 201 Created
+    .addError(BadRequest) // 400 Bad request
+    .addError(Forbidden) // 403 network is not eligible for services
+    .addError(Conflict) // 409 name conflicts with an existing object
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceDelete */
+const deleteServiceEndpoint = HttpApiEndpoint.del("delete", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(NotFound) // 404 No such service
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceInspect */
+const inspectServiceEndpoint = HttpApiEndpoint.get("inspect", "/:id")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setUrlParams(Schema.Struct({ insertDefaults: Schema.optional(Schema.BooleanFromString) }))
+    .addSuccess(SwarmService, { status: 200 }) // 200 OK
+    .addError(NotFound) // 404 No such service
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceUpdate */
+const updateServiceEndpoint = HttpApiEndpoint.post("update", "/:id/update")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setUrlParams(
+        Schema.Struct({
+            version: Schema.NumberFromString,
+            rollback: Schema.optional(Schema.String),
+            registryAuthFrom: Schema.optional(Schema.String),
+        })
+    )
+    .setHeaders(
+        Schema.Struct({
+            "X-Registry-Auth": Schema.optional(Schema.String),
+        })
+    )
+    .setPayload(SwarmServiceSpec)
+    .addSuccess(Schema.Struct({ Warnings: Schema.optional(Schema.Array(Schema.String)) }), { status: 200 }) // 200 OK
+    .addError(BadRequest) // 400 Bad request
+    .addError(NotFound) // 404 No such service
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service/operation/ServiceLogs */
+const logsServiceEndpoint = HttpApiEndpoint.get("logs", "/:id/logs")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setUrlParams(
+        Schema.Struct({
+            details: Schema.optional(Schema.BooleanFromString),
+            follow: Schema.optional(Schema.BooleanFromString),
+            stdout: Schema.optional(Schema.BooleanFromString),
+            stderr: Schema.optional(Schema.BooleanFromString),
+            since: Schema.optional(Schema.NumberFromString),
+            timestamps: Schema.optional(Schema.BooleanFromString),
+            tail: Schema.optional(Schema.String),
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
+    .addError(NotFound) // 404 No such service
+    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Service */
+const ServicesGroup = HttpApiGroup.make("services")
+    .add(listServicesEndpoint)
+    .add(createServiceEndpoint)
+    .add(deleteServiceEndpoint)
+    .add(inspectServiceEndpoint)
+    .add(updateServiceEndpoint)
+    .add(logsServiceEndpoint)
+    .addError(InternalServerError)
+    .prefix("/services");
 
 /**
+ * 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 Errors
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export class ServicesError extends PlatformError.TypeIdError(ServicesErrorTypeId, "ServicesError")<{
-    method: string;
-    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+export const ServicesApi = HttpApi.make("ServicesApi").add(ServicesGroup);
 
 /**
  * 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
+ * @category Services
  * @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: [],
+    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/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 }))
+        type Options<Name extends (typeof ServicesGroup.endpoints)[number]["name"]> =
+            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
+                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof ServicesGroup.endpoints)[number], Name>
+            >;
+
+        const httpClient = yield* HttpClient.HttpClient;
+        const ServicesError = DockerError.WrapForModule("services");
+        const client = yield* HttpApiClient.group(ServicesApi, { group: "services", httpClient });
+
+        const list_ = (options?: Options<"list">) =>
+            Effect.mapError(client.list({ urlParams: { ...options } }), ServicesError("list"));
+        const create_ = (payload: SwarmServiceSpec) =>
+            Effect.mapError(client.create({ payload, headers: { "X-Registry-Auth": "" } }), ServicesError("create"));
+        const delete_ = (id: string) => Effect.mapError(client.delete({ path: { id } }), ServicesError("delete"));
+        const inspect_ = (id: string, options?: Options<"inspect">) =>
+            Effect.mapError(client.inspect({ path: { id }, urlParams: { ...options } }), ServicesError("inspect"));
+        const update_ = (id: string, payload: SwarmServiceSpec, options: Options<"update">) =>
+            Effect.mapError(
+                client.update({
+                    payload,
+                    path: { id },
+                    urlParams: { ...options },
+                    headers: { "X-Registry-Auth": "" },
+                }),
+                ServicesError("update")
             );
+        const logs_ = (id: string, options?: Options<"logs">) =>
+            HttpApiStreamingResponse(
+                ServicesApi,
+                "services",
+                "logs",
+                httpClient
+            )({ path: { id }, urlParams: { ...options } })
+                .pipe(Stream.decodeText())
+                .pipe(Stream.splitLines)
+                .pipe(Stream.mapError(ServicesError("logs")));
 
         return {
             list: list_,
@@ -225,4 +202,14 @@ export class Services extends Effect.Service<Services>()("@the-moby-effect/endpo
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export const ServicesLayer: Layer.Layer<Services, never, HttpClient.HttpClient> = Services.Default;
+export const ServicesLayerLocalSocket: Layer.Layer<Services, never, HttpClient.HttpClient> = Services.Default;
+
+/**
+ * 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.DefaultWithoutDependencies;