the-moby-effect 1.48.3 → 1.51.0

package/src/internal/endpoints/distribution.ts

@@ -1,76 +1,53 @@
-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 Predicate from "effect/Predicate";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpClient } from "@effect/platform";
+import { Effect, Schema, type Layer } from "effect";
 
+import { MobyConnectionOptions } from "../../MobyConnection.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
 import { RegistryDistributionInspect } from "../generated/index.js";
+import { DockerError } from "./circular.ts";
+import { InternalServerError, NotFound, Unauthorized } from "./httpApiHacks.ts";
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const DistributionsErrorTypeId: unique symbol = Symbol.for(
-    "@the-moby-effect/endpoints/DistributionsError"
-) as DistributionsErrorTypeId;
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution/operation/DistributionInspect */
+const inspectDistributionEndpoint = HttpApiEndpoint.get("inspect", "/:name/json")
+    .setPath(Schema.Struct({ name: Schema.String }))
+    .addSuccess(RegistryDistributionInspect, { status: 200 }) // 200 OK
+    .addError(Unauthorized) // 401 Unauthorized
+    .addError(NotFound); // 404 Name not found
 
-/**
- * @since 1.0.0
- * @category Errors
- */
-export type DistributionsErrorTypeId = typeof DistributionsErrorTypeId;
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const isDistributionsError = (u: unknown): u is DistributionsError =>
-    Predicate.hasProperty(u, DistributionsErrorTypeId);
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution */
+const DistributionsGroup = HttpApiGroup.make("distributions")
+    .add(inspectDistributionEndpoint)
+    .addError(InternalServerError) // 500 Server error
+    .prefix("/distribution");
 
 /**
  * @since 1.0.0
- * @category Errors
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution
  */
-export class DistributionsError extends PlatformError.TypeIdError(DistributionsErrorTypeId, "DistributionsError")<{
-    method: string;
-    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+export const DistributionsApi = HttpApi.make("distributions").add(DistributionsGroup);
 
 /**
  * @since 1.0.0
- * @category Tags
- * @see https://docs.docker.com/engine/api/v1.45/#tag/Distribution
+ * @category Services
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution
  */
 export class Distributions extends Effect.Service<Distributions>()("@the-moby-effect/endpoints/Distributions", {
     accessors: false,
-    dependencies: [],
+    dependencies: [
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        ),
+    ],
 
     effect: Effect.gen(function* () {
-        const contextClient = yield* HttpClient.HttpClient;
-        const client = contextClient.pipe(HttpClient.filterStatusOk);
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution/operation/DistributionInspect */
-        const inspect_ = (
-            name: string
-        ): Effect.Effect<Readonly<RegistryDistributionInspect>, DistributionsError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/distribution/${encodeURIComponent(name)}/json`),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(RegistryDistributionInspect)),
-                Effect.mapError((cause) => new DistributionsError({ method: "inspect", cause }))
-            );
-
+        const httpClient = yield* HttpClient.HttpClient;
+        const DistributionsError = DockerError.WrapForModule("distributions");
+        const client = yield* HttpApiClient.group(DistributionsApi, { group: "distributions", httpClient });
+        const inspect_ = (name: string) =>
+            Effect.mapError(client.inspect({ path: { name } }), DistributionsError("inspect"));
         return { inspect: inspect_ };
     }),
 }) {}
@@ -78,6 +55,15 @@ export class Distributions extends Effect.Service<Distributions>()("@the-moby-ef
 /**
  * @since 1.0.0
  * @category Layers
- * @see https://docs.docker.com/engine/api/v1.45/#tag/Distribution
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution
+ */
+export const DistributionsLayerLocalSocket: Layer.Layer<Distributions, never, HttpClient.HttpClient> =
+    Distributions.Default;
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution
  */
-export const DistributionsLayer: Layer.Layer<Distributions, never, HttpClient.HttpClient> = Distributions.Default;
+export const DistributionsLayer: Layer.Layer<Distributions, never, HttpClient.HttpClient> =
+    Distributions.DefaultWithoutDependencies;

package/src/internal/endpoints/execs.ts

@@ -1,180 +1,122 @@
-import type * as HttpBody from "@effect/platform/HttpBody";
-import type * as HttpClientError from "@effect/platform/HttpClientError";
-import type * as Socket from "@effect/platform/Socket";
-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 * as MobyDemux from "../../MobyDemux.js";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
+import { Effect, Schema, type Layer } from "effect";
 
+import { MobyConnectionOptions } from "../../MobyConnection.js";
+import type { MultiplexedSocket, RawSocket } from "../../MobyDemux.js";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
 import {
-    ContainerExecOptions as ContainerExecStartConfig,
+    ContainerExecStartOptions,
     ContainerExecOptions as ExecConfig,
     ContainerExecInspect as ExecInspectResponse,
-    IDResponse,
 } from "../generated/index.js";
-import { maybeAddQueryParameter } from "./common.js";
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const ExecsErrorTypeId: unique symbol = Symbol.for("@the-moby-effect/endpoints/ExecsError") as ExecsErrorTypeId;
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export type ExecsErrorTypeId = typeof ExecsErrorTypeId;
-
-/**
- * @since 1.0.0
- * @category Errors
- */
-export const isExecsError = (u: unknown): u is ExecsError => Predicate.hasProperty(u, ExecsErrorTypeId);
+import { ExecIdentifier } from "../schemas/id.js";
+import { DockerError } from "./circular.ts";
+import { BadRequest, Conflict, HttpApiSocket, InternalServerError, NotFound } from "./httpApiHacks.js";
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ContainerExec */
+const createExecEndpoint = HttpApiEndpoint.post("container", "/containers/:id/exec")
+    .setPath(Schema.Struct({ id: Schema.String }))
+    .setPayload(ExecConfig)
+    .addSuccess(Schema.Struct({ Id: ExecIdentifier }), { status: 201 })
+    .addError(NotFound) // 404 No such container
+    .addError(Conflict); // 409 Container is not running
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ExecStart */
+const startExecEndpoint = HttpApiEndpoint.post("start", "/exec/:id/start")
+    .setPath(Schema.Struct({ id: ExecIdentifier }))
+    .setHeaders(Schema.Struct({ Upgrade: Schema.Literal("tcp"), Connection: Schema.Literal("Upgrade") }))
+    .setPayload(ContainerExecStartOptions)
+    .addSuccess(HttpApiSchema.Empty(101))
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(NotFound) // 404 No such Exec instance
+    .addError(Conflict); // 409 Container is not running
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ExecResize */
+const resizeExecEndpoint = HttpApiEndpoint.post("resize", "/exec/:id/resize")
+    .setPath(Schema.Struct({ id: ExecIdentifier }))
+    .setUrlParams(
+        Schema.Struct({
+            h: Schema.NumberFromString,
+            w: Schema.NumberFromString,
+        })
+    )
+    .addSuccess(HttpApiSchema.Empty(200))
+    .addError(BadRequest) // 400 Invalid parameters
+    .addError(NotFound); // 404 No such Exec instance
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ExecInspect */
+const inspectExecEndpoint = HttpApiEndpoint.get("inspect", "/exec/:id/json")
+    .setPath(Schema.Struct({ id: ExecIdentifier }))
+    .addSuccess(ExecInspectResponse, { status: 200 })
+    .addError(NotFound);
+
+/** @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec */
+const ExecsGroup = HttpApiGroup.make("exec")
+    .add(createExecEndpoint)
+    .add(startExecEndpoint)
+    .add(resizeExecEndpoint)
+    .add(inspectExecEndpoint)
+    .addError(InternalServerError);
 
 /**
  * @since 1.0.0
- * @category Errors
+ * @category HttpApi
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec
  */
-export class ExecsError extends PlatformError.TypeIdError(ExecsErrorTypeId, "ExecsError")<{
-    method: string;
-    cause:
-        | ParseResult.ParseError
-        | HttpClientError.HttpClientError
-        | HttpBody.HttpBodyError
-        | Socket.SocketError
-        | unknown;
-}> {
-    get message() {
-        return `${this.method}`;
-    }
-}
+export const ExecsApi = HttpApi.make("ExecsApi").add(ExecsGroup);
 
 /**
- * Execs service
- *
  * @since 1.0.0
- * @category Tags
+ * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec
  */
 export class Execs extends Effect.Service<Execs>()("@the-moby-effect/endpoints/Execs", {
     accessors: false,
-    dependencies: [],
+    dependencies: [
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        ),
+    ],
 
     effect: Effect.gen(function* () {
-        const contextClient = yield* HttpClient.HttpClient;
-        const client = contextClient.pipe(HttpClient.filterStatusOk);
-        const maybeUpgradedClient = contextClient.pipe(
-            HttpClient.filterStatus((status) => (status >= 200 && status < 300) || status === 101)
-        );
-
-        /**
-         * Create an exec instance
-         *
-         * @param execConfig - Exec configuration
-         * @param id - ID or name of container
-         * @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ContainerExec
-         */
-        const container_ = (
-            id: string,
-            execConfig: typeof ExecConfig.Encoded
-        ): Effect.Effect<Readonly<IDResponse>, ExecsError, never> =>
-            Function.pipe(
-                Schema.decode(ExecConfig)(execConfig),
-                Effect.map((body) =>
-                    Tuple.make(HttpClientRequest.post(`/containers/${encodeURIComponent(id)}/exec`), body)
-                ),
-                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(ExecConfig))),
-                Effect.flatMap(client.execute),
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(IDResponse)),
-                Effect.mapError((cause) => new ExecsError({ method: "container", cause }))
-            );
-
-        /**
-         * Start an exec instance
-         *
-         * @param execStartConfig -
-         * @param id - Exec instance ID
-         * @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ExecStart
-         */
-        const start_ = <T extends boolean | undefined = undefined>(
-            id: string,
-            execStartConfig: Omit<typeof ContainerExecStartConfig.Encoded, "Detach"> & { Detach?: T }
-        ): Effect.Effect<
-            T extends true ? void : MobyDemux.MultiplexedSocket | MobyDemux.RawSocket,
-            ExecsError,
-            never
-        > => {
-            type U = Effect.Effect<
-                T extends true ? void : MobyDemux.MultiplexedSocket | MobyDemux.RawSocket,
-                ExecsError,
-                never
-            >;
-
-            const response = Function.pipe(
-                Schema.decode(ContainerExecStartConfig)(execStartConfig),
-                Effect.map((body) => Tuple.make(HttpClientRequest.post(`/exec/${encodeURIComponent(id)}/start`), body)),
-                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(ContainerExecStartConfig))),
-                Effect.map(HttpClientRequest.setHeader("Upgrade", "tcp")),
-                Effect.map(HttpClientRequest.setHeader("Connection", "Upgrade")),
-                Effect.flatMap(maybeUpgradedClient.execute),
-                Effect.mapError((cause) => new ExecsError({ method: "start", cause }))
-            );
-
-            const toStreamingSock = Function.compose(
-                MobyDemux.responseToStreamingSocketOrFailUnsafe,
-                Effect.mapError((cause) => new ExecsError({ method: "start", cause }))
-            );
-
-            return execStartConfig.Detach
-                ? (Function.pipe(response, Effect.asVoid) as U)
-                : (Function.pipe(response, Effect.flatMap(toStreamingSock)) as U);
-        };
-
-        /**
-         * Resize an exec instance
-         *
-         * @param id - Exec instance ID
-         * @param h - Height of the TTY session in characters
-         * @param w - Width of the TTY session in characters
-         * @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ExecResize
-         */
-        const resize_ = (
-            id: string,
-            options?:
-                | {
-                      readonly h?: number;
-                      readonly w?: number;
-                  }
-                | undefined
-        ): Effect.Effect<void, ExecsError, never> =>
-            Function.pipe(
-                HttpClientRequest.post(`/exec/${encodeURIComponent(id)}/resize`),
-                maybeAddQueryParameter("h", Option.fromNullable(options?.h)),
-                maybeAddQueryParameter("w", Option.fromNullable(options?.w)),
-                client.execute,
-                Effect.asVoid,
-                Effect.mapError((cause) => new ExecsError({ method: "resize", cause }))
-            );
-
-        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec/operation/ExecInspect */
-        const inspect_ = (id: string): Effect.Effect<ExecInspectResponse, ExecsError, never> =>
-            Function.pipe(
-                HttpClientRequest.get(`/exec/${encodeURIComponent(id)}/json`),
-                client.execute,
-                Effect.flatMap(HttpClientResponse.schemaBodyJson(ExecInspectResponse)),
-                Effect.mapError((cause) => new ExecsError({ method: "inspect", cause }))
+        const httpClient = yield* HttpClient.HttpClient;
+        const ExecsError = DockerError.WrapForModule("execs");
+        const client = yield* HttpApiClient.group(ExecsApi, { group: "exec", httpClient });
+
+        const container_ = (id: string, payload: ConstructorParameters<typeof ExecConfig>[0]) =>
+            Effect.mapError(
+                client.container({ path: { id }, payload: ExecConfig.make(payload) }),
+                ExecsError("container")
             );
+        const start_ = <const T extends boolean = false>(
+            id: ExecIdentifier,
+            payload: Omit<ConstructorParameters<typeof ContainerExecStartOptions>[0], "Detach"> & { Detach: T }
+        ): Effect.Effect<[T] extends [false] ? RawSocket | MultiplexedSocket : void, DockerError, never> =>
+            HttpApiSocket(
+                ExecsApi,
+                "exec",
+                "start",
+                httpClient
+            )({
+                path: { id },
+                payload: ContainerExecStartOptions.make(payload),
+                headers: { Connection: "Upgrade", Upgrade: "tcp" },
+            })
+                .pipe(
+                    Effect.map(
+                        (socket) =>
+                            (payload.Detach === true ? void 0 : socket) as [T] extends [false]
+                                ? RawSocket | MultiplexedSocket
+                                : void
+                    )
+                )
+                .pipe(Effect.mapError(ExecsError("start")));
+        const resize_ = (id: ExecIdentifier, params: { w: number; h: number }) =>
+            Effect.mapError(client.resize({ path: { id }, urlParams: { ...params } }), ExecsError("resize"));
+        const inspect_ = (id: ExecIdentifier) =>
+            Effect.mapError(client.inspect({ path: { id } }), ExecsError("inspect"));
 
         return {
             container: container_,
@@ -190,4 +132,11 @@ export class Execs extends Effect.Service<Execs>()("@the-moby-effect/endpoints/E
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec
  */
-export const ExecsLayer: Layer.Layer<Execs, never, HttpClient.HttpClient> = Execs.Default;
+export const ExecsLayerLocalSocket: Layer.Layer<Execs, never, HttpClient.HttpClient> = Execs.Default;
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Exec
+ */
+export const ExecsLayer: Layer.Layer<Execs, never, HttpClient.HttpClient> = Execs.DefaultWithoutDependencies;