the-moby-effect 1.51.6 → 1.54.1

package/src/internal/endpoints/tasks.ts

@@ -1,62 +1,77 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, Schema, Stream, 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 Stream from "effect/Stream";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
 
-import { MobyConnectionOptions } from "../../MobyConnection.js";
-import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
-import { SwarmTask } from "../generated/index.js";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { SwarmTask } from "../generated/index.ts";
 import { DockerError } from "./circular.ts";
-import { HttpApiStreamingResponse, InternalServerError, NotFound } from "./httpApiHacks.js";
-import { NodeNotPartOfSwarm } from "./swarm.js";
+import { InternalServerError, NotFound, ServiceUnavailable } from "./errors.ts";
 
 /** @since 1.0.0 */
-export class TaskListFilters extends Schema.parseJson(
+export const TaskListFilters = Schema.fromJsonString(
     Schema.Struct({
-        "desired-state": Schema.optional(Schema.Array(Schema.Literal("running", "shutdown", "accepted"))),
+        "desired-state": Schema.optional(Schema.Array(Schema.Literals(["running", "shutdown", "accepted"]))),
         id: Schema.optional(Schema.Array(Schema.String)),
         name: Schema.optional(Schema.Array(Schema.String)),
         node: Schema.optional(Schema.Array(Schema.String)),
         service: Schema.optional(Schema.Array(Schema.String)),
         label: Schema.optional(Schema.Array(Schema.String)),
     })
-) {}
+);
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Task/operation/TaskList */
-const listTasksEndpoint = HttpApiEndpoint.get("list", "/")
-    .setUrlParams(Schema.Struct({ filters: Schema.optional(TaskListFilters) }))
-    .addSuccess(Schema.Array(SwarmTask), { status: 200 }) // 200 OK
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const listTasksEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: { filters: Schema.optional(TaskListFilters) },
+    success: Schema.Array(SwarmTask), // 200 OK
+    error: [
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Task/operation/TaskInspect */
-const inspectTaskEndpoint = HttpApiEndpoint.get("inspect", "/:id")
-    .setPath(Schema.Struct({ id: Schema.String }))
-    .addSuccess(SwarmTask, { status: 200 }) // 200 OK
-    .addError(NotFound) // 404 No such task
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const inspectTaskEndpoint = HttpApiEndpoint.get("inspect", "/:id", {
+    params: { id: Schema.String },
+    success: SwarmTask, // 200 OK
+    error: [
+        NotFound, // 404 No such task
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Task/operation/TaskLogs */
-const logsTaskEndpoint = 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 task
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const logsTaskEndpoint = HttpApiEndpoint.get("logs", "/:id/logs", {
+    params: { id: Schema.String },
+    query: {
+        details: Schema.optional(Schema.Boolean),
+        follow: Schema.optional(Schema.Boolean),
+        stdout: Schema.optional(Schema.Boolean),
+        stderr: Schema.optional(Schema.Boolean),
+        since: Schema.optional(Schema.Number),
+        timestamps: Schema.optional(Schema.Boolean),
+        tail: Schema.optional(Schema.String),
+    },
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        NotFound, // 404 No such task
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Task */
 const TasksGroup = HttpApiGroup.make("tasks")
-    .add(listTasksEndpoint)
-    .add(inspectTaskEndpoint)
-    .add(logsTaskEndpoint)
-    .addError(InternalServerError)
+    .add(listTasksEndpoint, inspectTaskEndpoint, logsTaskEndpoint)
     .prefix("/tasks");
 
 /**
@@ -77,39 +92,31 @@ export const TasksApi = HttpApi.make("TasksApi").add(TasksGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Task
  */
-export class Tasks extends Effect.Service<Tasks>()("@the-moby-effect/endpoints/Tasks", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
-        type Options<Name extends (typeof TasksGroup.endpoints)[number]["name"]> =
-            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
-                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof TasksGroup.endpoints)[number], Name>
-            >;
+export class Tasks extends Context.Service<Tasks>()("@the-moby-effect/endpoints/Tasks", {
+    make: Effect.gen(function* () {
+        type TasksEndpoints = HttpApiGroup.Endpoints<typeof TasksGroup>;
+        type Options<Name extends TasksEndpoints["identifier"]> = HttpApiEndpoint.WithIdentifier<
+            TasksEndpoints,
+            Name
+        >["~Query"]["Type"];
 
         const httpClient = yield* HttpClient.HttpClient;
         const TasksError = DockerError.WrapForModule("tasks");
         const client = yield* HttpApiClient.group(TasksApi, { group: "tasks", httpClient });
 
-        const list_ = (filters?: Schema.Schema.Type<TaskListFilters>) =>
-            Effect.mapError(client.list({ urlParams: { filters } }), TasksError("list"));
-        const inspect_ = (id: string) => Effect.mapError(client.inspect({ path: { id } }), TasksError("inspect"));
+        const list_ = (filters?: Schema.Schema.Type<typeof TaskListFilters>) =>
+            client.list({ query: { filters } }).pipe(Effect.mapError(TasksError("list")));
+        const inspect_ = (id: string) =>
+            client.inspect({ params: { id } }).pipe(Effect.mapError(TasksError("inspect")));
         const logs_ = (id: string, options?: Options<"logs">) =>
-            HttpApiStreamingResponse(
-                TasksApi,
-                "tasks",
-                "logs",
-                httpClient
-            )({ path: { id }, urlParams: { ...options } })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapError(TasksError("logs")));
+            client
+                .logs({ params: { id }, query: { ...options } })
+                .pipe(
+                    Effect.map(Stream.decodeText()),
+                    Effect.map(Stream.splitLines),
+                    Effect.map(Stream.mapError(TasksError("logs"))),
+                    Effect.mapError(TasksError("logs"))
+                );
 
         return {
             list: list_,
@@ -127,7 +134,7 @@ export class Tasks extends Effect.Service<Tasks>()("@the-moby-effect/endpoints/T
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Task
  */
-export const TasksLayer: Layer.Layer<Tasks, never, HttpClient.HttpClient> = Tasks.DefaultWithoutDependencies;
+export const TasksLayer: Layer.Layer<Tasks, never, HttpClient.HttpClient> = Layer.effect(Tasks, Tasks.make);
 
 /**
  * A task is a container running on a swarm. It is the atomic scheduling unit of
@@ -137,4 +144,12 @@ export const TasksLayer: Layer.Layer<Tasks, never, HttpClient.HttpClient> = Task
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Task
  */
-export const TasksLayerLocalSocket: Layer.Layer<Tasks, never, HttpClient.HttpClient> = Tasks.Default;
+export const TasksLayerLocalSocket: Layer.Layer<Tasks, never, HttpClient.HttpClient> = TasksLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);

package/src/internal/endpoints/volumes.ts

@@ -1,97 +1,116 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, Schema, type Layer } from "effect";
-import { I64 } from "effect-schemas/Number";
-
-import { MobyConnectionOptions } from "../../MobyConnection.js";
-import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
 import {
     VolumeClusterVolumeSpec as ClusterVolumeSpec,
     VolumeVolume as Volume,
     VolumeCreateOptions,
-} from "../generated/index.js";
-import { VolumeIdentifier } from "../schemas/id.js";
+} from "../generated/index.ts";
+import { VolumeIdentifier } from "../schemas/id.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, Conflict, InternalServerError, NotFound } from "./httpApiHacks.ts";
-import { NodeNotPartOfSwarm } from "./swarm.js";
+import { BadRequest, Conflict, InternalServerError, NotFound, ServiceUnavailable } from "./errors.ts";
 
 /** @since 1.0.0 */
-export class ListFilters extends Schema.parseJson(
+export const ListFilters = Schema.fromJsonString(
     Schema.Struct({
         name: Schema.optional(Schema.Array(Schema.String)),
         driver: Schema.optional(Schema.Array(Schema.String)),
         label: Schema.optional(Schema.Array(Schema.String)),
-        dangling: Schema.optional(Schema.Array(Schema.Literal("true", "false", "1", "0"))),
+        dangling: Schema.optional(Schema.Array(Schema.Literals(["true", "false", "1", "0"]))),
     })
-) {}
+);
 
 /** @since 1.0.0 */
-export class PruneFilters extends Schema.parseJson(
+export const PruneFilters = Schema.fromJsonString(
     Schema.Struct({
         label: Schema.optional(Schema.Array(Schema.String)),
-        all: Schema.optional(Schema.Array(Schema.Literal("true", "false", "1", "0"))),
+        all: Schema.optional(Schema.Array(Schema.Literals(["true", "false", "1", "0"]))),
     })
-) {}
+);
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeList */
-const listVolumesEndpoint = HttpApiEndpoint.get("list", "/")
-    .setUrlParams(Schema.Struct({ filters: Schema.optional(ListFilters) }))
-    .addSuccess(
-        Schema.Struct({
-            Volumes: Schema.Array(Volume),
-            Warnings: Schema.NullOr(Schema.Array(Schema.String)),
-        }),
-        { status: 200 }
-    ); // 200 OK
+const listVolumesEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: { filters: Schema.optional(ListFilters) },
+    success: Schema.Struct({
+        Volumes: Schema.Array(Volume),
+        Warnings: Schema.NullOr(Schema.Array(Schema.String)),
+    }), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeCreate */
-const createVolumeEndpoint = HttpApiEndpoint.post("create", "/create")
-    .setPayload(VolumeCreateOptions)
-    .addSuccess(Volume, { status: 201 }); // 201 Created
+const createVolumeEndpoint = HttpApiEndpoint.post("create", "/create", {
+    payload: VolumeCreateOptions,
+    success: Volume.pipe(HttpApiSchema.status(201)), // 201 Created
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeInspect */
-const inspectVolumeEndpoint = HttpApiEndpoint.get("inspect", "/:name")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .addSuccess(Volume, { status: 200 }) // 200 OK
-    .addError(NotFound); // 404 Volume not found
+const inspectVolumeEndpoint = HttpApiEndpoint.get("inspect", "/:name", {
+    params: { name: Schema.String },
+    success: Volume, // 200 OK
+    error: [
+        NotFound, // 404 Volume not found
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeDelete */
-const deleteVolumeEndpoint = HttpApiEndpoint.del("delete", "/:name")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ force: Schema.optional(Schema.BooleanFromString) }))
-    .addSuccess(HttpApiSchema.NoContent) // 204 No Content
-    .addError(NotFound) // 404 Volume not found
-    .addError(Conflict); // 409 Volume is in use
+const deleteVolumeEndpoint = HttpApiEndpoint.delete("delete", "/:name", {
+    params: { name: Schema.String },
+    query: { force: Schema.optional(Schema.Boolean) },
+    success: HttpApiSchema.NoContent, // 204 No Content
+    error: [
+        NotFound, // 404 Volume not found
+        Conflict, // 409 Volume is in use
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumeUpdate */
-const updateVolumeEndpoint = HttpApiEndpoint.put("update", "/:name")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ version: Schema.NumberFromString }))
-    .setPayload(ClusterVolumeSpec)
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addError(BadRequest) // 400 Bad parameter
-    .addError(NotFound) // 404 Volume not found
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const updateVolumeEndpoint = HttpApiEndpoint.put("update", "/:name", {
+    params: { name: Schema.String },
+    query: { version: Schema.Number },
+    payload: ClusterVolumeSpec,
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        BadRequest, // 400 Bad parameter
+        NotFound, // 404 Volume not found
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume/operation/VolumePrune */
-const pruneVolumeEndpoint = HttpApiEndpoint.post("prune", "/prune")
-    .setUrlParams(Schema.Struct({ filters: Schema.optional(PruneFilters) }))
-    .addSuccess(
-        Schema.Struct({
-            VolumesDeleted: Schema.optional(Schema.Array(VolumeIdentifier)),
-            SpaceReclaimed: I64,
-        }),
-        { status: 200 }
-    ); // 200 OK
+const pruneVolumeEndpoint = HttpApiEndpoint.post("prune", "/prune", {
+    query: { filters: Schema.optional(PruneFilters) },
+    success: Schema.Struct({
+        VolumesDeleted: Schema.optional(Schema.Array(VolumeIdentifier)),
+        SpaceReclaimed: Schema.BigIntFromString.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n })),
+    }), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume */
 const VolumesGroup = HttpApiGroup.make("volumes")
-    .add(listVolumesEndpoint)
-    .add(createVolumeEndpoint)
-    .add(inspectVolumeEndpoint)
-    .add(deleteVolumeEndpoint)
-    .add(updateVolumeEndpoint)
-    .add(pruneVolumeEndpoint)
-    .addError(InternalServerError)
+    .add(
+        listVolumesEndpoint,
+        createVolumeEndpoint,
+        inspectVolumeEndpoint,
+        deleteVolumeEndpoint,
+        updateVolumeEndpoint,
+        pruneVolumeEndpoint
+    )
     .prefix("/volumes");
 
 /**
@@ -106,35 +125,30 @@ export const VolumesApi = HttpApi.make("VolumesApi").add(VolumesGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export class Volumes extends Effect.Service<Volumes>()("@the-moby-effect/endpoints/Volumes", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Volumes extends Context.Service<Volumes>()("@the-moby-effect/endpoints/Volumes", {
+    make: Effect.gen(function* () {
         const httpClient = yield* HttpClient.HttpClient;
         const VolumesError = DockerError.WrapForModule("volumes");
         const client = yield* HttpApiClient.group(VolumesApi, { group: "volumes", httpClient });
 
-        const list_ = (filters?: Schema.Schema.Type<ListFilters>) =>
-            Effect.mapError(client.list({ urlParams: { filters } }), VolumesError("list"));
-        const create_ = (options: VolumeCreateOptions) =>
-            Effect.mapError(client.create({ payload: options }), VolumesError("create"));
-        const inspect_ = (name: string) => Effect.mapError(client.inspect({ path: { name } }), VolumesError("inspect"));
+        const list_ = (filters?: Schema.Schema.Type<typeof ListFilters>) =>
+            client.list({ query: { filters } }).pipe(Effect.mapError(VolumesError("list")));
+        const create_ = (options: (typeof VolumeCreateOptions)["~type.make.in"]) =>
+            VolumeCreateOptions.makeEffect(options).pipe(
+                Effect.flatMap((payload) => client.create({ payload })),
+                Effect.mapError(VolumesError("create"))
+            );
+        const inspect_ = (name: string) =>
+            client.inspect({ params: { name } }).pipe(Effect.mapError(VolumesError("inspect")));
         const delete_ = (name: string, options?: { force?: boolean | undefined } | undefined) =>
-            Effect.mapError(client.delete({ path: { name }, urlParams: { ...options } }), VolumesError("delete"));
-        const update_ = (name: string, version: number, spec: ClusterVolumeSpec) =>
-            Effect.mapError(
-                client.update({ path: { name }, urlParams: { version }, payload: spec }),
-                VolumesError("update")
+            client.delete({ params: { name }, query: { ...options } }).pipe(Effect.mapError(VolumesError("delete")));
+        const update_ = (name: string, version: number, spec: (typeof ClusterVolumeSpec)["~type.make.in"]) =>
+            ClusterVolumeSpec.makeEffect(spec).pipe(
+                Effect.flatMap((payload) => client.update({ params: { name }, query: { version }, payload })),
+                Effect.mapError(VolumesError("update"))
             );
-        const prune_ = (filters?: Schema.Schema.Type<PruneFilters>) =>
-            Effect.mapError(client.prune({ urlParams: { filters } }), VolumesError("prune"));
+        const prune_ = (filters?: Schema.Schema.Type<typeof PruneFilters>) =>
+            client.prune({ query: { filters } }).pipe(Effect.mapError(VolumesError("prune")));
 
         return {
             list: list_,
@@ -152,11 +166,19 @@ export class Volumes extends Effect.Service<Volumes>()("@the-moby-effect/endpoin
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export const VolumesLayerLocalSocket: Layer.Layer<Volumes, never, HttpClient.HttpClient> = Volumes.Default;
+export const VolumesLayer: Layer.Layer<Volumes, never, HttpClient.HttpClient> = Layer.effect(Volumes, Volumes.make);
 
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Volume
  */
-export const VolumesLayer: Layer.Layer<Volumes, never, HttpClient.HttpClient> = Volumes.DefaultWithoutDependencies;
+export const VolumesLayerLocalSocket: Layer.Layer<Volumes, never, HttpClient.HttpClient> = VolumesLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);