the-moby-effect 1.51.6 → 1.54.1

package/src/internal/endpoints/plugins.ts

@@ -1,113 +1,154 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Array, Effect, ParseResult, 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 { mapError } from "../convey/sinks.ts";
-import { JSONMessage, TypesPlugin as Plugin, RuntimePluginPrivilege as PluginPrivilege } from "../generated/index.js";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { JSONMessage, TypesPlugin as Plugin, RuntimePluginPrivilege as PluginPrivilege } from "../generated/index.ts";
 import { WithRegistryAuthHeader } from "./auth.ts";
 import { DockerError } from "./circular.ts";
-import { HttpApiStreamingRequest, HttpApiStreamingResponse, InternalServerError, NotFound } from "./httpApiHacks.js";
+import { InternalServerError, NotFound } from "./errors.ts";
+import { BooleanFilter } from "./filters.ts";
 
 /** @since 1.0.0 */
-export class ListFilters extends Schema.parseJson(
+export const ListFilters = Schema.fromJsonString(
     Schema.Struct({
         capability: Schema.optional(Schema.Array(Schema.String)),
-        enabled: Schema.transformOrFail(Schema.Tuple(Schema.String), Schema.BooleanFromString, {
-            decode: (_fromA, _options, ast) =>
-                ParseResult.fail(new ParseResult.Forbidden(ast, _fromA, "Decoding 'enabled' filter is not supported")),
-            encode: (automated) => ParseResult.succeed([automated] as const),
-        }).pipe(Schema.optional),
+        enabled: BooleanFilter("enabled").pipe(Schema.optional),
     })
-) {}
+);
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginList */
-const listPluginsEndpoint = HttpApiEndpoint.get("list", "/")
-    .setUrlParams(Schema.Struct({ filters: Schema.optional(ListFilters) }))
-    .addSuccess(Schema.Array(Plugin), { status: 200 });
+const listPluginsEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: { filters: Schema.optional(ListFilters) },
+    success: Schema.Array(Plugin), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/GetPluginPrivileges */
-const getPrivilegesEndpoint = HttpApiEndpoint.get("getPrivileges", "/privileges")
-    .setUrlParams(Schema.Struct({ remote: Schema.String }))
-    .addSuccess(Schema.Array(PluginPrivilege), { status: 200 });
+const getPrivilegesEndpoint = HttpApiEndpoint.get("getPrivileges", "/privileges", {
+    query: { remote: Schema.String },
+    success: Schema.Array(PluginPrivilege), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginPull */
-const pullPluginEndpoint = HttpApiEndpoint.post("pull", "/pull")
-    .setUrlParams(Schema.Struct({ remote: Schema.String, name: Schema.optional(Schema.String) }))
-    .setHeaders(Schema.Struct({ "X-Registry-Auth": Schema.optional(Schema.String) }))
-    .setPayload(Schema.Array(PluginPrivilege))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addSuccess(HttpApiSchema.Empty(204)); // 204 No Content
+const pullPluginEndpoint = HttpApiEndpoint.post("pull", "/pull", {
+    query: { remote: Schema.String, name: Schema.optional(Schema.String) },
+    headers: { "X-Registry-Auth": Schema.optional(Schema.String) },
+    payload: Schema.Array(PluginPrivilege),
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginInspect */
-const inspectPluginEndpoint = HttpApiEndpoint.get("inspect", "/:name/json")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .addSuccess(Plugin, { status: 200 })
-    .addError(NotFound); // 404 No such plugin
+const inspectPluginEndpoint = HttpApiEndpoint.get("inspect", "/:name/json", {
+    params: { name: Schema.String },
+    success: Plugin, // 200 OK
+    error: [
+        NotFound, // 404 No such plugin
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginDelete */
-const deletePluginEndpoint = HttpApiEndpoint.del("delete", "/:name")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ force: Schema.optional(Schema.BooleanFromString) }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 No such plugin
+const deletePluginEndpoint = HttpApiEndpoint.delete("delete", "/:name", {
+    params: { name: Schema.String },
+    query: { force: Schema.optional(Schema.Boolean) },
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        NotFound, // 404 No such plugin
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginEnable */
-const enablePluginEndpoint = HttpApiEndpoint.post("enable", "/:name/enable")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ timeout: Schema.optional(Schema.NumberFromString) }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 No such plugin
+const enablePluginEndpoint = HttpApiEndpoint.post("enable", "/:name/enable", {
+    params: { name: Schema.String },
+    query: { timeout: Schema.optional(Schema.Number) },
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        NotFound, // 404 No such plugin
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginDisable */
-const disablePluginEndpoint = HttpApiEndpoint.post("disable", "/:name/disable")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ force: Schema.optional(Schema.BooleanFromString) }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 No such plugin
+const disablePluginEndpoint = HttpApiEndpoint.post("disable", "/:name/disable", {
+    params: { name: Schema.String },
+    query: { force: Schema.optional(Schema.Boolean) },
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        NotFound, // 404 No such plugin
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginUpgrade */
-const upgradePluginEndpoint = HttpApiEndpoint.post("upgrade", "/:name/upgrade")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setUrlParams(Schema.Struct({ remote: Schema.String }))
-    .setHeaders(Schema.Struct({ "X-Registry-Auth": Schema.optional(Schema.String) }))
-    .setPayload(Schema.Array(PluginPrivilege))
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-    .addError(NotFound); // 404 No such plugin
+const upgradePluginEndpoint = HttpApiEndpoint.post("upgrade", "/:name/upgrade", {
+    params: { name: Schema.String },
+    query: { remote: Schema.String },
+    headers: { "X-Registry-Auth": Schema.optional(Schema.String) },
+    payload: Schema.Array(PluginPrivilege),
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming json progress response)
+    error: [
+        NotFound, // 404 No such plugin
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginCreate */
-const createPluginEndpoint = HttpApiEndpoint.post("create", "/create")
-    .setUrlParams(Schema.Struct({ name: Schema.String }))
-    .addSuccess(HttpApiSchema.NoContent); // 204 No Content
+const createPluginEndpoint = HttpApiEndpoint.post("create", "/create", {
+    query: { name: Schema.String },
+    payload: HttpApiSchema.StreamUint8Array(),
+    success: HttpApiSchema.NoContent, // 204 No Content
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginPush */
-const pushPluginEndpoint = HttpApiEndpoint.post("push", "/:name/push")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .addSuccess(HttpApiSchema.Empty(200))
-    .addError(NotFound); // 404 No such plugin
+const pushPluginEndpoint = HttpApiEndpoint.post("push", "/:name/push", {
+    params: { name: Schema.String },
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        NotFound, // 404 No such plugin
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin/operation/PluginSet */
-const setPluginEndpoint = HttpApiEndpoint.post("set", "/:name/set")
-    .setPath(Schema.Struct({ name: Schema.String }))
-    .setPayload(Schema.Array(Schema.String))
-    .addSuccess(HttpApiSchema.NoContent) // 204 No Content
-    .addError(NotFound); // 404 No such plugin
+const setPluginEndpoint = HttpApiEndpoint.post("set", "/:name/set", {
+    params: { name: Schema.String },
+    payload: Schema.Array(Schema.String),
+    success: HttpApiSchema.NoContent, // 204 No Content
+    error: [
+        NotFound, // 404 No such plugin
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin */
 const PluginsGroup = HttpApiGroup.make("plugins")
-    .add(listPluginsEndpoint)
-    .add(getPrivilegesEndpoint)
-    .add(pullPluginEndpoint)
-    .add(inspectPluginEndpoint)
-    .add(deletePluginEndpoint)
-    .add(enablePluginEndpoint)
-    .add(disablePluginEndpoint)
-    .add(upgradePluginEndpoint)
-    .add(createPluginEndpoint)
-    .add(pushPluginEndpoint)
-    .add(setPluginEndpoint)
-    .addError(InternalServerError)
+    .add(
+        listPluginsEndpoint,
+        getPrivilegesEndpoint,
+        pullPluginEndpoint,
+        inspectPluginEndpoint,
+        deletePluginEndpoint,
+        enablePluginEndpoint,
+        disablePluginEndpoint,
+        upgradePluginEndpoint,
+        createPluginEndpoint,
+        pushPluginEndpoint,
+        setPluginEndpoint
+    )
     .prefix("/plugins");
 
 /**
@@ -122,21 +163,13 @@ export const PluginsApi = HttpApi.make("PluginsApi").add(PluginsGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin
  */
-export class Plugins extends Effect.Service<Plugins>()("@the-moby-effect/endpoints/Plugins", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
-        type Options<Name extends (typeof PluginsGroup.endpoints)[number]["name"]> =
-            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
-                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof PluginsGroup.endpoints)[number], Name>
-            >;
+export class Plugins extends Context.Service<Plugins>()("@the-moby-effect/endpoints/Plugins", {
+    make: Effect.gen(function* () {
+        type PluginsEndpoints = HttpApiGroup.Endpoints<typeof PluginsGroup>;
+        type Options<Name extends PluginsEndpoints["identifier"]> = HttpApiEndpoint.WithIdentifier<
+            PluginsEndpoints,
+            Name
+        >["~Query"]["Type"];
 
         const httpClient = yield* Effect.map(
             HttpClient.HttpClient,
@@ -146,67 +179,72 @@ export class Plugins extends Effect.Service<Plugins>()("@the-moby-effect/endpoin
         const PluginsError = DockerError.WrapForModule("plugins");
         const client = yield* HttpApiClient.group(PluginsApi, { group: "plugins", httpClient });
 
-        const list_ = (filters?: Schema.Schema.Type<ListFilters> | undefined) =>
-            Effect.mapError(client.list({ urlParams: { filters } }), PluginsError("list"));
+        const list_ = (filters?: Schema.Schema.Type<typeof ListFilters> | undefined) =>
+            client.list({ query: { filters } }).pipe(Effect.mapError(PluginsError("list")));
         const getPrivileges_ = (remote: string) =>
-            Effect.mapError(client.getPrivileges({ urlParams: { remote } }), PluginsError("getPrivileges"));
+            client.getPrivileges({ query: { remote } }).pipe(Effect.mapError(PluginsError("getPrivileges")));
         const pull_ = (
             remote: string,
             options?: {
                 name?: string | undefined;
-                privileges?: Array<ConstructorParameters<typeof PluginPrivilege>[0]> | undefined;
+                privileges?: Array<(typeof PluginPrivilege)["~type.make.in"]> | undefined;
             }
         ) =>
-            HttpApiStreamingResponse(
-                PluginsApi,
-                "plugins",
-                "pull",
-                httpClient
-            )({
-                headers: {},
-                urlParams: { remote, name: options?.name },
-                payload: Array.map(options?.privileges ?? [], (privilege) => PluginPrivilege.make(privilege)),
-            })
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson(JSONMessage))))
-                .pipe(mapError)
-                .pipe(Stream.mapError(PluginsError("pull")));
-        const inspect_ = (name: string) => Effect.mapError(client.inspect({ path: { name } }), PluginsError("inspect"));
+            Effect.forEach(options?.privileges ?? [], (privilege) => PluginPrivilege.makeEffect(privilege)).pipe(
+                Effect.flatMap((payload) =>
+                    client.pull({
+                        headers: {},
+                        query: { remote, name: options?.name },
+                        payload,
+                    })
+                ),
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => Schema.decodeEffect(Schema.fromJsonString(JSONMessage))(line)),
+                Stream.mapError(PluginsError("pull"))
+            );
+        const inspect_ = (name: string) =>
+            client.inspect({ params: { name } }).pipe(Effect.mapError(PluginsError("inspect")));
         const delete_ = (name: string, options?: Options<"delete">) =>
-            Effect.mapError(client.delete({ path: { name }, urlParams: { ...options } }), PluginsError("delete"));
+            client.delete({ params: { name }, query: { ...options } }).pipe(Effect.mapError(PluginsError("delete")));
         const enable_ = (name: string, options?: Options<"enable">) =>
-            Effect.mapError(
-                client.enable({
-                    path: { name },
-                    urlParams: { timeout: options?.timeout ?? 0 },
-                }),
-                PluginsError("enable")
-            );
+            client
+                .enable({
+                    params: { name },
+                    query: { timeout: options?.timeout ?? 0 },
+                })
+                .pipe(Effect.mapError(PluginsError("enable")));
         const disable_ = (name: string, options?: Options<"disable">) =>
-            Effect.mapError(client.disable({ path: { name }, urlParams: { ...options } }), PluginsError("disable"));
+            client.disable({ params: { name }, query: { ...options } }).pipe(Effect.mapError(PluginsError("disable")));
         const upgrade_ = (
             name: string,
             remote: string,
-            privileges?: Array<ConstructorParameters<typeof PluginPrivilege>[0]> | undefined
+            privileges?: Array<(typeof PluginPrivilege)["~type.make.in"]> | undefined
         ) =>
-            Effect.mapError(
-                client.upgrade({
-                    headers: {},
-                    path: { name },
-                    urlParams: { remote },
-                    payload: Array.map(privileges ?? [], (privilege) => PluginPrivilege.make(privilege)),
-                }),
-                PluginsError("upgrade")
+            Effect.forEach(privileges ?? [], (privilege) => PluginPrivilege.makeEffect(privilege)).pipe(
+                Effect.flatMap((payload) =>
+                    client.upgrade({
+                        headers: {},
+                        params: { name },
+                        query: { remote },
+                        payload,
+                    })
+                ),
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => Schema.decodeEffect(Schema.fromJsonString(JSONMessage))(line)),
+                Stream.runDrain,
+                Effect.mapError(PluginsError("upgrade"))
             );
         const create_ = <E, R>(name: string, tar: Stream.Stream<Uint8Array, E, R>) =>
-            Effect.mapError(
-                HttpApiStreamingRequest(PluginsApi, "plugins", "create", httpClient, tar)({ urlParams: { name } }),
-                PluginsError("create")
-            );
-        const push_ = (name: string) => Effect.mapError(client.push({ path: { name } }), PluginsError("push"));
+            Effect.contextWith((context: Context.Context<R>) =>
+                client.create({ query: { name }, payload: Stream.provideContext(tar, context) })
+            ).pipe(Effect.mapError(PluginsError("create")));
+        const push_ = (name: string) => client.push({ params: { name } }).pipe(Effect.mapError(PluginsError("push")));
         const set_ = (name: string, body: ReadonlyArray<string>) =>
-            Effect.mapError(client.set({ path: { name }, payload: body }), PluginsError("set"));
+            client.set({ params: { name }, payload: body }).pipe(Effect.mapError(PluginsError("set")));
 
         return {
             list: list_,
@@ -229,11 +267,19 @@ export class Plugins extends Effect.Service<Plugins>()("@the-moby-effect/endpoin
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin
  */
-export const PluginsLayerLocalSocket: Layer.Layer<Plugins, never, HttpClient.HttpClient> = Plugins.Default;
+export const PluginsLayer: Layer.Layer<Plugins, never, HttpClient.HttpClient> = Layer.effect(Plugins, Plugins.make);
 
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Plugin
  */
-export const PluginsLayer: Layer.Layer<Plugins, never, HttpClient.HttpClient> = Plugins.DefaultWithoutDependencies;
+export const PluginsLayerLocalSocket: Layer.Layer<Plugins, never, HttpClient.HttpClient> = PluginsLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);

package/src/internal/endpoints/secrets.ts

@@ -1,68 +1,97 @@
-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 { SwarmSecret, SwarmSecretSpec } from "../generated/index.js";
-import { SecretIdentifier } from "../schemas/id.js";
+import { MobyConnectionOptions } from "../../MobyConnection.ts";
+import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.ts";
+import { SwarmSecret, SwarmSecretSpec } from "../generated/index.ts";
+import { SecretIdentifier } 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({
         id: Schema.optional(Schema.Array(Schema.String)),
         label: Schema.optional(Schema.Array(Schema.String)),
         name: Schema.optional(Schema.Array(Schema.String)),
     })
-) {}
+);
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretList */
-const listSecretsEndpoint = HttpApiEndpoint.get("list", "/")
-    .setUrlParams(Schema.Struct({ filters: Schema.optional(ListFilters) }))
-    .addSuccess(Schema.Array(SwarmSecret), { status: 200 }) // 200 OK
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const listSecretsEndpoint = HttpApiEndpoint.get("list", "/", {
+    query: { filters: Schema.optional(ListFilters) },
+    success: Schema.Array(SwarmSecret), // 200 OK
+    error: [
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretCreate */
-const createSecretEndpoint = HttpApiEndpoint.post("create", "/create")
-    .setPayload(SwarmSecretSpec)
-    .addSuccess(Schema.rename(Schema.Struct({ ID: SecretIdentifier }), { ID: "Id" }), { status: 201 }) // 201 Created
-    .addError(Conflict) // 409 name conflicts with an existing object
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const createSecretEndpoint = HttpApiEndpoint.post("create", "/create", {
+    payload: SwarmSecretSpec,
+    success: Schema.Struct({
+        Id: SecretIdentifier,
+    }).pipe(
+        Schema.encodeKeys({
+            Id: "ID",
+        }),
+        HttpApiSchema.status(201)
+    ), // 201 Created
+    error: [
+        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/Secret/operation/SecretInspect */
-const inspectSecretEndpoint = HttpApiEndpoint.get("inspect", "/:id")
-    .setPath(Schema.Struct({ id: Schema.String }))
-    .addSuccess(SwarmSecret, { status: 200 }) // 200 OK
-    .addError(NotFound) // 404 No such secret
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const inspectSecretEndpoint = HttpApiEndpoint.get("inspect", "/:id", {
+    params: { id: Schema.String },
+    success: SwarmSecret, // 200 OK
+    error: [
+        NotFound, // 404 No such secret
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretDelete */
-const deleteSecretEndpoint = HttpApiEndpoint.del("delete", "/:id")
-    .setPath(Schema.Struct({ id: Schema.String }))
-    .addSuccess(HttpApiSchema.NoContent) // 204 No Content
-    .addError(NotFound) // 404 No such secret
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const deleteSecretEndpoint = HttpApiEndpoint.delete("delete", "/:id", {
+    params: { id: Schema.String },
+    success: HttpApiSchema.NoContent, // 204 No Content
+    error: [
+        NotFound, // 404 No such secret
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret/operation/SecretUpdate */
-const updateSecretEndpoint = HttpApiEndpoint.post("update", "/:id/update")
-    .setPath(Schema.Struct({ id: Schema.String }))
-    .setUrlParams(Schema.Struct({ version: Schema.BigInt }))
-    .setPayload(SwarmSecretSpec)
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addError(BadRequest) // 400 Bad request
-    .addError(NotFound) // 404 No such secret
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const updateSecretEndpoint = HttpApiEndpoint.post("update", "/:id/update", {
+    params: { id: Schema.String },
+    query: { version: Schema.BigIntFromString },
+    payload: SwarmSecretSpec,
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        BadRequest, // 400 Bad request
+        NotFound, // 404 No such secret
+        ServiceUnavailable, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret */
 const SecretsGroup = HttpApiGroup.make("secrets")
-    .add(listSecretsEndpoint)
-    .add(createSecretEndpoint)
-    .add(inspectSecretEndpoint)
-    .add(deleteSecretEndpoint)
-    .add(updateSecretEndpoint)
-    .addError(InternalServerError)
+    .add(listSecretsEndpoint, createSecretEndpoint, inspectSecretEndpoint, deleteSecretEndpoint, updateSecretEndpoint)
     .prefix("/secrets");
 
 /**
@@ -83,29 +112,27 @@ export const SecretsApi = HttpApi.make("SecretsApi").add(SecretsGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret
  */
-export class Secrets extends Effect.Service<Secrets>()("@the-moby-effect/endpoints/Secrets", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Secrets extends Context.Service<Secrets>()("@the-moby-effect/endpoints/Secrets", {
+    make: Effect.gen(function* () {
         const httpClient = yield* HttpClient.HttpClient;
         const SecretsError = DockerError.WrapForModule("secrets");
         const client = yield* HttpApiClient.group(SecretsApi, { group: "secrets", httpClient });
 
-        const list_ = (filters?: Schema.Schema.Type<ListFilters>) =>
-            Effect.mapError(client.list({ urlParams: { filters } }), SecretsError("list"));
-        const create_ = (payload: SwarmSecretSpec) =>
-            Effect.mapError(client.create({ payload }), SecretsError("create"));
-        const inspect_ = (id: string) => Effect.mapError(client.inspect({ path: { id } }), SecretsError("inspect"));
-        const delete_ = (id: string) => Effect.mapError(client.delete({ path: { id } }), SecretsError("delete"));
-        const update_ = (id: string, version: bigint, payload: SwarmSecretSpec) =>
-            Effect.mapError(client.update({ path: { id }, urlParams: { version }, payload }), SecretsError("update"));
+        const list_ = (filters?: Schema.Schema.Type<typeof ListFilters>) =>
+            client.list({ query: { filters } }).pipe(Effect.mapError(SecretsError("list")));
+        const create_ = (payload: (typeof SwarmSecretSpec)["~type.make.in"]) =>
+            SwarmSecretSpec.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.create({ payload })),
+                Effect.mapError(SecretsError("create"))
+            );
+        const inspect_ = (id: string) =>
+            client.inspect({ params: { id } }).pipe(Effect.mapError(SecretsError("inspect")));
+        const delete_ = (id: string) => client.delete({ params: { id } }).pipe(Effect.mapError(SecretsError("delete")));
+        const update_ = (id: string, version: bigint, payload: (typeof SwarmSecretSpec)["~type.make.in"]) =>
+            SwarmSecretSpec.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.update({ params: { id }, query: { version }, payload })),
+                Effect.mapError(SecretsError("update"))
+            );
 
         return {
             list: list_,
@@ -125,7 +152,7 @@ export class Secrets extends Effect.Service<Secrets>()("@the-moby-effect/endpoin
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret
  */
-export const SecretsLayer: Layer.Layer<Secrets, never, HttpClient.HttpClient> = Secrets.DefaultWithoutDependencies;
+export const SecretsLayer: Layer.Layer<Secrets, never, HttpClient.HttpClient> = Layer.effect(Secrets, Secrets.make);
 
 /**
  * Secrets are sensitive data that can be used by services. Swarm mode must be
@@ -135,4 +162,12 @@ export const SecretsLayer: Layer.Layer<Secrets, never, HttpClient.HttpClient> =
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Secret
  */
-export const SecretsLayerLocalSocket: Layer.Layer<Secrets, never, HttpClient.HttpClient> = Secrets.Default;
+export const SecretsLayerLocalSocket: Layer.Layer<Secrets, never, HttpClient.HttpClient> = SecretsLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);