the-moby-effect 1.51.6 → 1.54.1

package/src/internal/endpoints/distribution.ts

@@ -1,24 +1,32 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, 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 { MobyConnectionOptions } from "../../MobyConnection.js";
-import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
-import { RegistryDistributionInspect } from "../generated/index.js";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { RegistryDistributionInspect } from "../generated/index.ts";
 import { DockerError } from "./circular.ts";
-import { InternalServerError, NotFound, Unauthorized } from "./httpApiHacks.ts";
+import { InternalServerError, NotFound, Unauthorized } from "./errors.ts";
 
 /** @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
+const inspectDistributionEndpoint = HttpApiEndpoint.get("inspect", "/:name/json", {
+    params: { name: Schema.String },
+    success: RegistryDistributionInspect, // 200 OK
+    error: [
+        Unauthorized, // 401 Unauthorized
+        NotFound, // 404 Name not found
+        InternalServerError, // 500 Server error
+    ],
+});
 
 /** @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");
+const DistributionsGroup = HttpApiGroup.make("distributions").add(inspectDistributionEndpoint).prefix("/distribution");
 
 /**
  * @since 1.0.0
@@ -32,22 +40,13 @@ export const DistributionsApi = HttpApi.make("distributions").add(DistributionsG
  * @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: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Distributions extends Context.Service<Distributions>()("@the-moby-effect/endpoints/Distributions", {
+    make: Effect.gen(function* () {
         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"));
+            client.inspect({ params: { name } }).pipe(Effect.mapError(DistributionsError("inspect")));
         return { inspect: inspect_ };
     }),
 }) {}
@@ -57,13 +56,23 @@ export class Distributions extends Effect.Service<Distributions>()("@the-moby-ef
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Distribution
  */
-export const DistributionsLayerLocalSocket: Layer.Layer<Distributions, never, HttpClient.HttpClient> =
-    Distributions.Default;
+export const DistributionsLayer: Layer.Layer<Distributions, never, HttpClient.HttpClient> = Layer.effect(
+    Distributions,
+    Distributions.make
+);
 
 /**
  * @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.DefaultWithoutDependencies;
+export const DistributionsLayerLocalSocket: Layer.Layer<Distributions, never, HttpClient.HttpClient> =
+    DistributionsLayer.pipe(
+        Layer.provide(
+            makeAgnosticHttpClientLayer(
+                MobyConnectionOptions.socket({
+                    socketPath: "/var/run/docker.sock",
+                })
+            )
+        )
+    );

package/src/internal/endpoints/errors.ts

@@ -0,0 +1,170 @@
+import * as Schema from "effect/Schema";
+
+/** @since 1.0.0 */
+export class BadRequest extends Schema.ErrorClass<BadRequest>("BadRequest")(
+    {
+        _tag: Schema.tagDefaultOmit("BadRequest"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "BadRequest",
+        description: "BadRequest",
+        httpApiStatus: 400,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class Unauthorized extends Schema.ErrorClass<Unauthorized>("Unauthorized")(
+    {
+        _tag: Schema.tagDefaultOmit("Unauthorized"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "Unauthorized",
+        description: "Unauthorized",
+        httpApiStatus: 401,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class Forbidden extends Schema.ErrorClass<Forbidden>("Forbidden")(
+    {
+        _tag: Schema.tagDefaultOmit("Forbidden"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "Forbidden",
+        description: "Forbidden",
+        httpApiStatus: 403,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class NotFound extends Schema.ErrorClass<NotFound>("NotFound")(
+    {
+        _tag: Schema.tagDefaultOmit("NotFound"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "NotFound",
+        description: "NotFound",
+        httpApiStatus: 404,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class MethodNotAllowed extends Schema.ErrorClass<MethodNotAllowed>("MethodNotAllowed")(
+    {
+        _tag: Schema.tagDefaultOmit("MethodNotAllowed"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "MethodNotAllowed",
+        description: "MethodNotAllowed",
+        httpApiStatus: 405,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class NotAcceptable extends Schema.ErrorClass<NotAcceptable>("NotAcceptable")(
+    {
+        _tag: Schema.tagDefaultOmit("NotAcceptable"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "NotAcceptable",
+        description: "NotAcceptable",
+        httpApiStatus: 406,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class RequestTimeout extends Schema.ErrorClass<RequestTimeout>("RequestTimeout")(
+    {
+        _tag: Schema.tagDefaultOmit("RequestTimeout"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "RequestTimeout",
+        description: "RequestTimeout",
+        httpApiStatus: 408,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class Conflict extends Schema.ErrorClass<Conflict>("Conflict")(
+    {
+        _tag: Schema.tagDefaultOmit("Conflict"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "Conflict",
+        description: "Conflict",
+        httpApiStatus: 409,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class Gone extends Schema.ErrorClass<Gone>("Gone")(
+    {
+        _tag: Schema.tagDefaultOmit("Gone"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "Gone",
+        description: "Gone",
+        httpApiStatus: 410,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class UnprocessableEntity extends Schema.ErrorClass<UnprocessableEntity>("UnprocessableEntity")(
+    {
+        _tag: Schema.tagDefaultOmit("UnprocessableEntity"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "UnprocessableEntity",
+        description: "UnprocessableEntity",
+        httpApiStatus: 422,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class InternalServerError extends Schema.ErrorClass<InternalServerError>("InternalServerError")(
+    {
+        _tag: Schema.tagDefaultOmit("InternalServerError"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "InternalServerError",
+        description: "InternalServerError",
+        httpApiStatus: 500,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class NotImplemented extends Schema.ErrorClass<NotImplemented>("NotImplemented")(
+    {
+        _tag: Schema.tagDefaultOmit("NotImplemented"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "NotImplemented",
+        description: "NotImplemented",
+        httpApiStatus: 501,
+    }
+) {}
+
+/** @since 1.0.0 */
+export class ServiceUnavailable extends Schema.ErrorClass<ServiceUnavailable>("ServiceUnavailable")(
+    {
+        _tag: Schema.tagDefaultOmit("ServiceUnavailable"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "ServiceUnavailable",
+        description: "ServiceUnavailable",
+        httpApiStatus: 503,
+    }
+) {}

package/src/internal/endpoints/execs.ts

@@ -1,67 +1,91 @@
-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 type { MultiplexedSocket, RawSocket } from "../../MobyDemux.js";
-import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import type { MultiplexedSocket, RawSocket } from "../../MobyDemux.ts";
+
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { responseToStreamingSocketOrFailUnsafe } from "../demux/hijack.ts";
 import {
     ContainerExecStartOptions,
     ContainerExecOptions as ExecConfig,
     ContainerExecInspect as ExecInspectResponse,
-} from "../generated/index.js";
-import { ExecIdentifier } from "../schemas/id.js";
+} from "../generated/index.ts";
+import { ExecIdentifier } from "../schemas/id.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, Conflict, HttpApiSocket, InternalServerError, NotFound } from "./httpApiHacks.js";
+import { BadRequest, Conflict, InternalServerError, NotFound } from "./errors.ts";
 
 /** @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
+const createExecEndpoint = HttpApiEndpoint.post("container", "/containers/:id/exec", {
+    params: { id: Schema.String },
+    payload: ExecConfig,
+    success: Schema.Struct({ Id: ExecIdentifier }).pipe(HttpApiSchema.status(201)), // 201 Created
+    error: [
+        NotFound, // 404 No such container
+        Conflict, // 409 Container is not running
+        InternalServerError,
+    ],
+});
 
 /** @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
+const startExecEndpoint = HttpApiEndpoint.post("start", "/exec/:id/start", {
+    params: { id: ExecIdentifier },
+    headers: {
+        Upgrade: Schema.Literal("tcp"),
+        Connection: Schema.Literal("Upgrade"),
+    },
+    payload: ContainerExecStartOptions,
+    success: [
+        HttpApiSchema.Empty(101), // 101 Switching Protocols
+        HttpApiSchema.Empty(200), // 200 OK
+    ],
+    error: [
+        NotFound, // 404 No such Exec instance
+        Conflict, // 409 Container is not running
+        InternalServerError,
+    ],
+});
 
 /** @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
+const resizeExecEndpoint = HttpApiEndpoint.post("resize", "/exec/:id/resize", {
+    params: { id: ExecIdentifier },
+    query: {
+        h: Schema.Number,
+        w: Schema.Number,
+    },
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        BadRequest, // 400 Invalid parameters
+        NotFound, // 404 No such Exec instance
+        InternalServerError,
+    ],
+});
 
 /** @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);
+const inspectExecEndpoint = HttpApiEndpoint.get("inspect", "/exec/:id/json", {
+    params: { id: ExecIdentifier },
+    success: ExecInspectResponse, // 200 OK
+    error: [
+        NotFound, // 404 No such Exec instance
+        InternalServerError,
+    ],
+});
 
 /** @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);
+const ExecsGroup = HttpApiGroup.make("exec").add(
+    createExecEndpoint,
+    startExecEndpoint,
+    resizeExecEndpoint,
+    inspectExecEndpoint
+);
 
 /**
  * @since 1.0.0
@@ -75,53 +99,45 @@ export const ExecsApi = HttpApi.make("ExecsApi").add(ExecsGroup);
  * @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: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Execs extends Context.Service<Execs>()("@the-moby-effect/endpoints/Execs", {
+    make: Effect.gen(function* () {
         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 container_ = (id: string, payload: (typeof ExecConfig)["~type.make.in"]) =>
+            ExecConfig.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.container({ params: { id }, payload })),
+                Effect.mapError(ExecsError("container"))
             );
         const start_ = <const T extends boolean = false>(
             id: ExecIdentifier,
-            payload: Omit<ConstructorParameters<typeof ContainerExecStartOptions>[0], "Detach"> & { Detach: T }
+            payload: Omit<(typeof ContainerExecStartOptions)["~type.make.in"], "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" }, // FIXME: Broken on undici
-            })
-                .pipe(
-                    Effect.map(
-                        (socket) =>
-                            (payload.Detach === true ? void 0 : socket) as [T] extends [false]
-                                ? RawSocket | MultiplexedSocket
-                                : void
-                    )
-                )
-                .pipe(Effect.mapError(ExecsError("start")));
+            ContainerExecStartOptions.makeEffect(payload).pipe(
+                Effect.flatMap((startOptions) =>
+                    client.start({
+                        params: { id },
+                        payload: startOptions,
+                        headers: { Connection: "Upgrade", Upgrade: "tcp" }, // FIXME: Broken on undici
+                        responseMode: "response-only",
+                    })
+                ),
+                Effect.flatMap(responseToStreamingSocketOrFailUnsafe),
+                Effect.map(
+                    (socket) =>
+                        (payload.Detach === true ? void 0 : socket) as [T] extends [false]
+                            ? RawSocket | MultiplexedSocket
+                            : void
+                ),
+                Effect.mapError(ExecsError("start"))
+            );
         const resize_ = (id: ExecIdentifier, params: { w: number; h: number }) =>
-            Effect.mapError(client.resize({ path: { id }, urlParams: { ...params } }), ExecsError("resize"));
+            client.resize({ params: { id }, query: { ...params } }).pipe(Effect.mapError(ExecsError("resize")));
         const inspect_ = (id: ExecIdentifier) =>
-            Effect.mapError(client.inspect({ path: { id } }), ExecsError("inspect"));
+            client.inspect({ params: { id } }).pipe(Effect.mapError(ExecsError("inspect")));
 
         return {
             container: container_,
@@ -137,11 +153,19 @@ 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 ExecsLayerLocalSocket: Layer.Layer<Execs, never, HttpClient.HttpClient> = Execs.Default;
+export const ExecsLayer: Layer.Layer<Execs, never, HttpClient.HttpClient> = Layer.effect(Execs, Execs.make);
 
 /**
  * @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;
+export const ExecsLayerLocalSocket: Layer.Layer<Execs, never, HttpClient.HttpClient> = ExecsLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);

package/src/internal/endpoints/filters.ts

@@ -0,0 +1,43 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaIssue from "effect/SchemaIssue";
+
+/**
+ * Docker parses the values of a filters query parameter as map[string][]string
+ * (or the legacy map[string]map[string]bool), so scalar filter values must
+ * encode as single-element arrays - a bare string, number, or boolean value is
+ * rejected by the daemon with a 400.
+ *
+ * @internal
+ */
+export const StringFilter = Schema.Tuple([Schema.String]).pipe(
+    Schema.decodeTo(Schema.String, {
+        decode: SchemaGetter.transform(([value]: readonly [string]) => value),
+        encode: SchemaGetter.transform((value: string) => [value] as const),
+    })
+);
+
+/** @internal */
+export const NumberFilter = Schema.Tuple([Schema.NumberFromString]).pipe(
+    Schema.decodeTo(Schema.Number, {
+        decode: SchemaGetter.transform(([value]: readonly [number]) => value),
+        encode: SchemaGetter.transform((value: number) => [value] as const),
+    })
+);
+
+/** @internal */
+export const BooleanFilter = (filterName: string) =>
+    Schema.Tuple([Schema.String]).pipe(
+        Schema.decodeTo(Schema.Boolean, {
+            decode: SchemaGetter.transformOrFail((fromA: readonly [string]) =>
+                Effect.fail(
+                    new SchemaIssue.InvalidValue(Option.some(fromA), {
+                        message: `Decoding '${filterName}' filter is not supported`,
+                    })
+                )
+            ),
+            encode: SchemaGetter.transform((bool: boolean) => [bool ? "true" : "false"] as const),
+        })
+    );