the-moby-effect 1.51.6 → 1.54.1

package/src/internal/endpoints/services.ts

@@ -1,121 +1,134 @@
-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 * 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.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { SwarmService, SwarmServiceSpec } from "../generated/index.ts";
+import { ServiceIdentifier } from "../schemas/id.ts";
 import { WithRegistryAuthHeader } from "./auth.ts";
 import { DockerError } from "./circular.ts";
-import {
-    BadRequest,
-    Conflict,
-    Forbidden,
-    HttpApiStreamingResponse,
-    InternalServerError,
-    NotFound,
-} from "./httpApiHacks.js";
-import { NodeNotPartOfSwarm } from "./swarm.js";
+import { BadRequest, Conflict, Forbidden, InternalServerError, NotFound, ServiceUnavailable } from "./errors.ts";
 
 /** @since 1.0.0 */
-export class ListFilters extends Schema.parseJson(
+export const ListFilters = Schema.fromJsonString(
     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"))),
+        mode: Schema.optional(Schema.Array(Schema.Literals(["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
+const listServicesEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: {
+        filters: Schema.optional(ListFilters),
+        status: Schema.optional(Schema.Boolean),
+    },
+    success: Schema.Array(SwarmService), // 200 OK
+    error: [
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const createServiceEndpoint = HttpApiEndpoint.post("create", "/create", {
+    payload: SwarmServiceSpec,
+    headers: { "X-Registry-Auth": Schema.optional(Schema.String) },
+    success: Schema.Struct({
+        ID: ServiceIdentifier,
+        Warnings: Schema.optional(Schema.Array(Schema.String)),
+    }).pipe(HttpApiSchema.status(201)), // 201 Created
+    error: [
+        BadRequest, // 400 Bad request
+        Forbidden, // 403 network is not eligible for services
+        Conflict, // 409 name conflicts with an existing object
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const deleteServiceEndpoint = HttpApiEndpoint.delete("delete", "/:id", {
+    params: { id: Schema.String },
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        NotFound, // 404 No such service
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const inspectServiceEndpoint = HttpApiEndpoint.get("inspect", "/:id", {
+    params: { id: Schema.String },
+    query: { insertDefaults: Schema.optional(Schema.Boolean) },
+    success: SwarmService, // 200 OK
+    error: [
+        NotFound, // 404 No such service
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const updateServiceEndpoint = HttpApiEndpoint.post("update", "/:id/update", {
+    params: { id: Schema.String },
+    query: {
+        version: Schema.Number,
+        rollback: Schema.optional(Schema.String),
+        registryAuthFrom: Schema.optional(Schema.String),
+    },
+    headers: { "X-Registry-Auth": Schema.optional(Schema.String) },
+    payload: SwarmServiceSpec,
+    success: Schema.Struct({ Warnings: Schema.optional(Schema.Array(Schema.String)) }), // 200 OK
+    error: [
+        BadRequest, // 400 Bad request
+        NotFound, // 404 No such service
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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
+const logsServiceEndpoint = 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 service
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @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)
+    .add(
+        listServicesEndpoint,
+        createServiceEndpoint,
+        deleteServiceEndpoint,
+        inspectServiceEndpoint,
+        updateServiceEndpoint,
+        logsServiceEndpoint
+    )
     .prefix("/services");
 
 /**
@@ -136,21 +149,13 @@ export const ServicesApi = HttpApi.make("ServicesApi").add(ServicesGroup);
  * @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: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
-        type Options<Name extends (typeof ServicesGroup.endpoints)[number]["name"]> =
-            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
-                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof ServicesGroup.endpoints)[number], Name>
-            >;
+export class Services extends Context.Service<Services>()("@the-moby-effect/endpoints/Services", {
+    make: Effect.gen(function* () {
+        type ServicesEndpoints = HttpApiGroup.Endpoints<typeof ServicesGroup>;
+        type Options<Name extends ServicesEndpoints["identifier"]> = HttpApiEndpoint.WithIdentifier<
+            ServicesEndpoints,
+            Name
+        >["~Query"]["Type"];
 
         const httpClient = yield* Effect.map(
             HttpClient.HttpClient,
@@ -161,42 +166,42 @@ export class Services extends Effect.Service<Services>()("@the-moby-effect/endpo
         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: ConstructorParameters<typeof SwarmServiceSpec>) =>
-            Effect.mapError(
-                client.create({
-                    headers: {},
-                    payload: SwarmServiceSpec.make(...payload),
-                }),
-                ServicesError("create")
+            client.list({ query: { ...options } }).pipe(Effect.mapError(ServicesError("list")));
+        const create_ = (payload: (typeof SwarmServiceSpec)["~type.make.in"]) =>
+            SwarmServiceSpec.makeEffect(payload).pipe(
+                Effect.flatMap((payload) =>
+                    client.create({
+                        headers: {},
+                        payload,
+                    })
+                ),
+                Effect.mapError(ServicesError("create"))
             );
-        const delete_ = (id: string) => Effect.mapError(client.delete({ path: { id } }), ServicesError("delete"));
+        const delete_ = (id: string) =>
+            client.delete({ params: { id } }).pipe(Effect.mapError(ServicesError("delete")));
         const inspect_ = (id: string, options?: Options<"inspect">) =>
-            Effect.mapError(client.inspect({ path: { id }, urlParams: { ...options } }), ServicesError("inspect"));
-        const update_ = (
-            id: string,
-            options: Options<"update">,
-            ...payload: ConstructorParameters<typeof SwarmServiceSpec>
-        ) =>
-            Effect.mapError(
-                client.update({
-                    headers: {},
-                    path: { id },
-                    urlParams: { ...options },
-                    payload: SwarmServiceSpec.make(...payload),
-                }),
-                ServicesError("update")
+            client.inspect({ params: { id }, query: { ...options } }).pipe(Effect.mapError(ServicesError("inspect")));
+        const update_ = (id: string, options: Options<"update">, payload: (typeof SwarmServiceSpec)["~type.make.in"]) =>
+            SwarmServiceSpec.makeEffect(payload).pipe(
+                Effect.flatMap((payload) =>
+                    client.update({
+                        headers: {},
+                        params: { id },
+                        query: { ...options },
+                        payload,
+                    })
+                ),
+                Effect.mapError(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")));
+            client
+                .logs({ params: { id }, query: { ...options } })
+                .pipe(
+                    Effect.map(Stream.decodeText()),
+                    Effect.map(Stream.splitLines),
+                    Effect.map(Stream.mapError(ServicesError("logs"))),
+                    Effect.mapError(ServicesError("logs"))
+                );
 
         return {
             list: list_,
@@ -217,7 +222,7 @@ 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 ServicesLayerLocalSocket: Layer.Layer<Services, never, HttpClient.HttpClient> = Services.Default;
+export const ServicesLayer: Layer.Layer<Services, never, HttpClient.HttpClient> = Layer.effect(Services, Services.make);
 
 /**
  * Services are the definitions of tasks to run on a swarm. Swarm mode must be
@@ -227,4 +232,12 @@ export const ServicesLayerLocalSocket: Layer.Layer<Services, never, HttpClient.H
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Service
  */
-export const ServicesLayer: Layer.Layer<Services, never, HttpClient.HttpClient> = Services.DefaultWithoutDependencies;
+export const ServicesLayerLocalSocket: Layer.Layer<Services, never, HttpClient.HttpClient> = ServicesLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);

package/src/internal/endpoints/session.ts

@@ -1,21 +1,30 @@
-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 { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { hijackResponseUnsafe } from "../demux/hijack.ts";
 import { DockerError } from "./circular.ts";
-import { HttpApiTcp } from "./httpApiHacks.js";
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Session/operation/Session */
-const sessionEndpoint = HttpApiEndpoint.post("session", "/session")
-    .setHeaders(
-        Schema.Struct({
-            Upgrade: Schema.Literal("h2c"),
-            Connection: Schema.Literal("Upgrade"),
-        })
-    )
-    .addSuccess(HttpApiSchema.Empty(101)) // 101 Switching Protocols
-    .addSuccess(HttpApiSchema.Empty(200)); // 200 OK
+const sessionEndpoint = HttpApiEndpoint.post("session", "/session", {
+    headers: {
+        Upgrade: Schema.Literal("h2c"),
+        Connection: Schema.Literal("Upgrade"),
+    },
+    success: [
+        HttpApiSchema.Empty(101), // 101 Switching Protocols
+        HttpApiSchema.Empty(200), // 200 OK
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Session */
 const SessionGroup = HttpApiGroup.make("session").add(sessionEndpoint);
@@ -32,36 +41,22 @@ export const SessionApi = HttpApi.make("SessionApi").add(SessionGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Session
  */
-export class Sessions extends Effect.Service<Sessions>()("@the-moby-effect/endpoints/Session", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Sessions extends Context.Service<Sessions>()("@the-moby-effect/endpoints/Session", {
+    make: Effect.gen(function* () {
         const httpClient = yield* HttpClient.HttpClient;
         const SessionsError = DockerError.WrapForModule("session");
-        yield* HttpApiClient.group(SessionApi, { group: "session", httpClient });
+        const client = yield* HttpApiClient.group(SessionApi, { group: "session", httpClient });
 
         const session_ = () =>
-            Effect.mapError(
-                HttpApiTcp(
-                    SessionApi,
-                    "session",
-                    "session",
-                    httpClient
-                )({
+            client
+                .session({
                     headers: {
                         Upgrade: "h2c",
                         Connection: "Upgrade",
                     },
-                }),
-                SessionsError("session")
-            );
+                    responseMode: "response-only",
+                })
+                .pipe(Effect.flatMap(hijackResponseUnsafe), Effect.mapError(SessionsError("session")));
 
         return { session: session_ };
     }),
@@ -72,11 +67,19 @@ export class Sessions extends Effect.Service<Sessions>()("@the-moby-effect/endpo
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Session
  */
-export const SessionsLayerLocalSocket: Layer.Layer<Sessions, never, HttpClient.HttpClient> = Sessions.Default;
+export const SessionsLayer: Layer.Layer<Sessions, never, HttpClient.HttpClient> = Layer.effect(Sessions, Sessions.make);
 
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Session
  */
-export const SessionsLayer: Layer.Layer<Sessions, never, HttpClient.HttpClient> = Sessions.DefaultWithoutDependencies;
+export const SessionsLayerLocalSocket: Layer.Layer<Sessions, never, HttpClient.HttpClient> = SessionsLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);