the-moby-effect 1.51.6 → 1.54.1

package/src/internal/endpoints/configs.ts

@@ -1,65 +1,99 @@
-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 { SwarmConfig, SwarmConfigSpec } from "../generated/index.js";
-import { ConfigIdentifier } from "../schemas/id.js";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { SwarmConfig, SwarmConfigSpec } from "../generated/index.ts";
+import { ConfigIdentifier } 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 } from "./errors.ts";
+import { NodeNotPartOfSwarm } from "./swarm.ts";
 
 /** @since 1.0.0 */
-export class ListFilters extends Schema.parseJson(
+export const ListFilters = Schema.fromJsonString(
     Schema.Struct({
         id: Schema.optional(Schema.Array(ConfigIdentifier)),
         name: Schema.optional(Schema.Array(Schema.String)),
         names: Schema.optional(Schema.Array(Schema.String)),
         label: Schema.optional(Schema.Array(Schema.String)),
     })
-) {}
+);
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigList */
-const listConfigsEndpoint = HttpApiEndpoint.get("list", "/")
-    .setUrlParams(Schema.Struct({ filters: Schema.optional(ListFilters) }))
-    .addSuccess(Schema.Array(SwarmConfig), { status: 200 }); // 200 OK
+const listConfigsEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: { filters: Schema.optional(ListFilters) },
+    success: Schema.Array(SwarmConfig), // 200 OK
+    error: [
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError, // 500 Internal Server Error
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigCreate */
-const createConfigEndpoint = HttpApiEndpoint.post("create", "/create")
-    .setPayload(SwarmConfigSpec)
-    .addSuccess(Schema.rename(Schema.Struct({ ID: ConfigIdentifier }), { ID: "Id" }), { status: 201 }) // 201 Created
-    .addError(Conflict); // 409 Name conflicts with existing object
+const createConfigEndpoint = HttpApiEndpoint.post("create", "/create", {
+    payload: SwarmConfigSpec,
+    success: Schema.Struct({
+        Id: ConfigIdentifier,
+    }).pipe(
+        Schema.encodeKeys({
+            Id: "ID",
+        }),
+        HttpApiSchema.status(201)
+    ), // 201 Created
+    error: [
+        Conflict, // 409 Name conflicts with existing object
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError, // 500 Internal Server Error
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigInspect */
-const inspectConfigEndpoint = HttpApiEndpoint.get("inspect", "/:identifier")
-    .setPath(Schema.Struct({ identifier: ConfigIdentifier }))
-    .addSuccess(SwarmConfig, { status: 200 }) // 200 OK
-    .addError(NotFound); // 404 Config not found
+const inspectConfigEndpoint = HttpApiEndpoint.get("inspect", "/:identifier", {
+    params: { identifier: ConfigIdentifier },
+    success: SwarmConfig, // 200 OK
+    error: [
+        NotFound, // 404 Config not found
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError, // 500 Internal Server Error
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigDelete */
-const deleteConfigEndpoint = HttpApiEndpoint.del("delete", "/:identifier")
-    .setPath(Schema.Struct({ identifier: ConfigIdentifier }))
-    .addSuccess(HttpApiSchema.NoContent) // 204 No Content
-    .addError(NotFound); // 404 Config not found
+const deleteConfigEndpoint = HttpApiEndpoint.delete("delete", "/:identifier", {
+    params: { identifier: ConfigIdentifier },
+    success: HttpApiSchema.NoContent, // 204 No Content
+    error: [
+        NotFound, // 404 Config not found
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError, // 500 Internal Server Error
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigUpdate */
-const updateConfigEndpoint = HttpApiEndpoint.post("update", "/:identifier/update")
-    .setPath(Schema.Struct({ identifier: ConfigIdentifier }))
-    .setUrlParams(Schema.Struct({ version: Schema.BigInt }))
-    .setPayload(SwarmConfigSpec) // Note: Docker API states only Labels can be updated
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK, no response body
-    .addError(BadRequest) // 400 Bad parameter
-    .addError(NotFound); // 404 Config not found
+const updateConfigEndpoint = HttpApiEndpoint.post("update", "/:identifier/update", {
+    params: { identifier: ConfigIdentifier },
+    query: { version: Schema.BigIntFromString },
+    payload: SwarmConfigSpec, // Note: Docker API states only Labels can be updated
+    success: HttpApiSchema.Empty(200), // 200 OK, no response body
+    error: [
+        BadRequest, // 400 Bad parameter
+        NotFound, // 404 Config not found
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError, // 500 Internal Server Error
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config */
 const ConfigsGroup = HttpApiGroup.make("configs")
-    .add(listConfigsEndpoint)
-    .add(createConfigEndpoint)
-    .add(inspectConfigEndpoint)
-    .add(deleteConfigEndpoint)
-    .add(updateConfigEndpoint)
-    .addError(NodeNotPartOfSwarm) // 503 Node not part of swarm
-    .addError(InternalServerError) // 500 Server error
+    .add(listConfigsEndpoint, createConfigEndpoint, inspectConfigEndpoint, deleteConfigEndpoint, updateConfigEndpoint)
     .prefix("/configs"); // Prefix for endpoints in this group
 
 /**
@@ -80,41 +114,37 @@ export const ConfigsApi = HttpApi.make("ConfigsApi").add(ConfigsGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Config
  */
-export class Configs extends Effect.Service<Configs>()("@the-moby-effect/endpoints/Configs", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Configs extends Context.Service<Configs>()("@the-moby-effect/endpoints/Configs", {
+    make: Effect.gen(function* () {
         const httpClient = yield* HttpClient.HttpClient;
         const ConfigsError = DockerError.WrapForModule("configs");
         const client = yield* HttpApiClient.group(ConfigsApi, { group: "configs", httpClient });
 
-        const list_ = (filters?: Schema.Schema.Type<ListFilters> | undefined) =>
-            Effect.mapError(client.list({ urlParams: { filters } }), ConfigsError("list"));
-        const create_ = (...config: ConstructorParameters<typeof SwarmConfigSpec>) =>
-            Effect.mapError(client.create({ payload: SwarmConfigSpec.make(...config) }), ConfigsError("create"));
+        const list_ = (filters?: Schema.Schema.Type<typeof ListFilters> | undefined) =>
+            client.list({ query: { filters } }).pipe(Effect.mapError(ConfigsError("list")));
+        const create_ = (config: (typeof SwarmConfigSpec)["~type.make.in"]) =>
+            SwarmConfigSpec.makeEffect(config).pipe(
+                Effect.flatMap((payload) => client.create({ payload })),
+                Effect.mapError(ConfigsError("create"))
+            );
         const inspect_ = (identifier: ConfigIdentifier) =>
-            Effect.mapError(client.inspect({ path: { identifier } }), ConfigsError("inspect"));
+            client.inspect({ params: { identifier } }).pipe(Effect.mapError(ConfigsError("inspect")));
         const delete_ = (identifier: ConfigIdentifier) =>
-            Effect.mapError(client.delete({ path: { identifier } }), ConfigsError("delete"));
+            client.delete({ params: { identifier } }).pipe(Effect.mapError(ConfigsError("delete")));
         const update_ = (
             identifier: ConfigIdentifier,
             version: bigint,
-            ...config: ConstructorParameters<typeof SwarmConfigSpec>
+            config: (typeof SwarmConfigSpec)["~type.make.in"]
         ) =>
-            Effect.mapError(
-                client.update({
-                    path: { identifier },
-                    urlParams: { version },
-                    payload: SwarmConfigSpec.make(...config),
-                }),
-                ConfigsError("update")
+            SwarmConfigSpec.makeEffect(config).pipe(
+                Effect.flatMap((payload) =>
+                    client.update({
+                        params: { identifier },
+                        query: { version },
+                        payload,
+                    })
+                ),
+                Effect.mapError(ConfigsError("update"))
             );
 
         return {
@@ -135,7 +165,7 @@ export class Configs extends Effect.Service<Configs>()("@the-moby-effect/endpoin
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Config
  */
-export const ConfigsLayerLocalSocket: Layer.Layer<Configs, never, HttpClient.HttpClient> = Configs.Default;
+export const ConfigsLayer: Layer.Layer<Configs, never, HttpClient.HttpClient> = Layer.effect(Configs, Configs.make);
 
 /**
  * Configs are application configurations that can be used by services. Swarm
@@ -145,4 +175,12 @@ export const ConfigsLayerLocalSocket: Layer.Layer<Configs, never, HttpClient.Htt
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Config
  */
-export const ConfigsLayer: Layer.Layer<Configs, never, HttpClient.HttpClient> = Configs.DefaultWithoutDependencies;
+export const ConfigsLayerLocalSocket = ConfigsLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);