the-moby-effect 1.51.6 → 1.54.1

package/src/internal/endpoints/swarm.ts

@@ -1,86 +1,139 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, Schema, type Layer } from "effect";
-
-import { MobyConnectionOptions } from "../../MobyConnection.js";
-import { makeAgnosticHttpClientLayer } from "../../MobyPlatforms.js";
-import { SwarmSwarm as SwarmData, SwarmInitRequest, SwarmJoinRequest, SwarmSpec } from "../generated/index.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 { SwarmSwarm as SwarmData, SwarmInitRequest, SwarmJoinRequest, SwarmSpec } from "../generated/index.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, InternalServerError, NotFound } from "./httpApiHacks.ts";
+import { BadRequest, InternalServerError, NotFound } from "./errors.ts";
 
 /** @since 1.0.0 */
-export class NodeNotPartOfSwarm extends HttpApiSchema.EmptyError<NodeNotPartOfSwarm>()({
-    tag: "NodeNotPartOfSwarm",
-    status: 503,
-}) {}
+export class NodeNotPartOfSwarm extends Schema.ErrorClass<NodeNotPartOfSwarm>(
+    "@the-moby-effect/endpoints/NodeNotPartOfSwarm"
+)(
+    {
+        _tag: Schema.tagDefaultOmit("NodeNotPartOfSwarm"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "NodeNotPartOfSwarm",
+        description: "NodeNotPartOfSwarm",
+        httpApiStatus: 503,
+    }
+) {}
 
 /** @since 1.0.0 */
-export class NodeAlreadyPartOfSwarm extends HttpApiSchema.EmptyError<NodeAlreadyPartOfSwarm>()({
-    tag: "NodeAlreadyPartOfSwarm",
-    status: 503,
-}) {}
+export class NodeAlreadyPartOfSwarm extends Schema.ErrorClass<NodeAlreadyPartOfSwarm>(
+    "@the-moby-effect/endpoints/NodeAlreadyPartOfSwarm"
+)(
+    {
+        _tag: Schema.tagDefaultOmit("NodeAlreadyPartOfSwarm"),
+        message: Schema.optionalKey(Schema.String),
+    },
+    {
+        identifier: "NodeAlreadyPartOfSwarm",
+        description: "NodeAlreadyPartOfSwarm",
+        httpApiStatus: 503,
+    }
+) {}
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmInspect */
-const inspectSwarmEndpoint = HttpApiEndpoint.get("inspect", "/")
-    .addSuccess(SwarmData, { status: 200 }) // 200 OK
-    .addError(NotFound) // 404 No such swarm
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const inspectSwarmEndpoint = HttpApiEndpoint.get("inspect", "/", {
+    success: SwarmData, // 200 OK
+    error: [
+        NotFound, // 404 No such swarm
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmInit */
-const initSwarmEndpoint = HttpApiEndpoint.post("init", "/init")
-    .setPayload(SwarmInitRequest)
-    .addSuccess(Schema.String, { status: 200 }) // 200 OK
-    .addError(BadRequest) // 400 Bad parameter
-    .addError(NodeAlreadyPartOfSwarm); // 503 Node is already part of a swarm
+const initSwarmEndpoint = HttpApiEndpoint.post("init", "/init", {
+    payload: SwarmInitRequest,
+    success: Schema.String, // 200 OK
+    error: [
+        BadRequest, // 400 Bad parameter
+        NodeAlreadyPartOfSwarm, // 503 Node is already part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmJoin */
-const joinSwarmEndpoint = HttpApiEndpoint.post("join", "/join")
-    .setPayload(SwarmJoinRequest)
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addError(BadRequest) // 400 Bad parameter
-    .addError(NodeAlreadyPartOfSwarm); // 503 Node is already part of a swarm
+const joinSwarmEndpoint = HttpApiEndpoint.post("join", "/join", {
+    payload: SwarmJoinRequest,
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        BadRequest, // 400 Bad parameter
+        NodeAlreadyPartOfSwarm, // 503 Node is already part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmLeave */
-const leaveSwarmEndpoint = HttpApiEndpoint.post("leave", "/leave")
-    .setUrlParams(Schema.Struct({ force: Schema.optional(Schema.BooleanFromString) }))
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const leaveSwarmEndpoint = HttpApiEndpoint.post("leave", "/leave", {
+    query: { force: Schema.optional(Schema.Boolean) },
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmUpdate */
-const updateSwarmEndpoint = HttpApiEndpoint.post("update", "/update")
-    .setUrlParams(
-        Schema.Struct({
-            version: Schema.BigInt,
-            rotateWorkerToken: Schema.optional(Schema.BooleanFromString),
-            rotateManagerToken: Schema.optional(Schema.BooleanFromString),
-            rotateManagerUnlockKey: Schema.optional(Schema.BooleanFromString),
-        })
-    )
-    .setPayload(SwarmSpec)
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addError(BadRequest) // 400 Bad parameter
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const updateSwarmEndpoint = HttpApiEndpoint.post("update", "/update", {
+    query: {
+        version: Schema.BigIntFromString,
+        rotateWorkerToken: Schema.optional(Schema.Boolean),
+        rotateManagerToken: Schema.optional(Schema.Boolean),
+        rotateManagerUnlockKey: Schema.optional(Schema.Boolean),
+    },
+    payload: SwarmSpec,
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        BadRequest, // 400 Bad parameter
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmUnlockkey */
-const unlockkeySwarmEndpoint = HttpApiEndpoint.get("unlockkey", "/unlockkey")
-    .addSuccess(Schema.Struct({ UnlockKey: Schema.String }), { status: 200 }) // 200 OK
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const unlockkeySwarmEndpoint = HttpApiEndpoint.get("unlockkey", "/unlockkey", {
+    success: Schema.Struct({ UnlockKey: Schema.String }), // 200 OK
+    error: [
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm/operation/SwarmUnlock */
-const unlockSwarmEndpoint = HttpApiEndpoint.post("unlock", "/unlock")
-    .setPayload(Schema.Struct({ UnlockKey: Schema.String }))
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addError(NodeNotPartOfSwarm); // 503 Node is not part of a swarm
+const unlockSwarmEndpoint = HttpApiEndpoint.post("unlock", "/unlock", {
+    payload: Schema.Struct({ UnlockKey: Schema.String }),
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [
+        NodeNotPartOfSwarm, // 503 Node is not part of a swarm
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm */
 const SwarmGroup = HttpApiGroup.make("swarm")
-    .add(inspectSwarmEndpoint)
-    .add(initSwarmEndpoint)
-    .add(joinSwarmEndpoint)
-    .add(leaveSwarmEndpoint)
-    .add(updateSwarmEndpoint)
-    .add(unlockkeySwarmEndpoint)
-    .add(unlockSwarmEndpoint)
-    .addError(InternalServerError)
+    .add(
+        inspectSwarmEndpoint,
+        initSwarmEndpoint,
+        joinSwarmEndpoint,
+        leaveSwarmEndpoint,
+        updateSwarmEndpoint,
+        unlockkeySwarmEndpoint,
+        unlockSwarmEndpoint
+    )
     .prefix("/swarm");
 
 /**
@@ -101,29 +154,27 @@ export const SwarmApi = HttpApi.make("SwarmApi").add(SwarmGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm
  */
-export class Swarm extends Effect.Service<Swarm>()("@the-moby-effect/endpoints/Swarm", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
+export class Swarm extends Context.Service<Swarm>()("@the-moby-effect/endpoints/Swarm", {
+    make: Effect.gen(function* () {
         const httpClient = yield* HttpClient.HttpClient;
         const SwarmsError = DockerError.WrapForModule("swarm");
         const client = yield* HttpApiClient.group(SwarmApi, { group: "swarm", httpClient });
 
-        const inspect_ = () => Effect.mapError(client.inspect(), SwarmsError("inspect"));
-        const init_ = (payload: ConstructorParameters<typeof SwarmInitRequest>[0]) =>
-            Effect.mapError(client.init({ payload: SwarmInitRequest.make(payload) }), SwarmsError("init"));
-        const join_ = (payload: SwarmJoinRequest) => Effect.mapError(client.join({ payload }), SwarmsError("join"));
+        const inspect_ = () => client.inspect().pipe(Effect.mapError(SwarmsError("inspect")));
+        const init_ = (payload: (typeof SwarmInitRequest)["~type.make.in"]) =>
+            SwarmInitRequest.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.init({ payload })),
+                Effect.mapError(SwarmsError("init"))
+            );
+        const join_ = (payload: (typeof SwarmJoinRequest)["~type.make.in"]) =>
+            SwarmJoinRequest.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.join({ payload })),
+                Effect.mapError(SwarmsError("join"))
+            );
         const leave_ = (options?: { force?: boolean | undefined } | undefined) =>
-            Effect.mapError(client.leave({ urlParams: { ...options } }), SwarmsError("leave"));
+            client.leave({ query: { ...options } }).pipe(Effect.mapError(SwarmsError("leave")));
         const update_ = (
-            spec: SwarmSpec,
+            spec: (typeof SwarmSpec)["~type.make.in"],
             version: bigint,
             rotate?:
                 | {
@@ -133,16 +184,18 @@ export class Swarm extends Effect.Service<Swarm>()("@the-moby-effect/endpoints/S
                   }
                 | undefined
         ) =>
-            Effect.mapError(
-                client.update({
-                    payload: spec,
-                    urlParams: { version, ...rotate },
-                }),
-                SwarmsError("update")
+            SwarmSpec.makeEffect(spec).pipe(
+                Effect.flatMap((payload) =>
+                    client.update({
+                        payload,
+                        query: { version, ...rotate },
+                    })
+                ),
+                Effect.mapError(SwarmsError("update"))
             );
-        const unlockkey_ = () => Effect.mapError(client.unlockkey(), SwarmsError("unlockkey"));
+        const unlockkey_ = () => client.unlockkey().pipe(Effect.mapError(SwarmsError("unlockkey")));
         const unlock_ = (unlockKey: string) =>
-            Effect.mapError(client.unlock({ payload: { UnlockKey: unlockKey } }), SwarmsError("unlock"));
+            client.unlock({ payload: { UnlockKey: unlockKey } }).pipe(Effect.mapError(SwarmsError("unlock")));
 
         return {
             inspect: inspect_,
@@ -164,7 +217,7 @@ export class Swarm extends Effect.Service<Swarm>()("@the-moby-effect/endpoints/S
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm
  */
-export const SwarmLayer: Layer.Layer<Swarm, never, HttpClient.HttpClient> = Swarm.DefaultWithoutDependencies;
+export const SwarmLayer: Layer.Layer<Swarm, never, HttpClient.HttpClient> = Layer.effect(Swarm, Swarm.make);
 
 /**
  * Engines can be clustered together in a swarm. Refer to the swarm mode
@@ -174,4 +227,12 @@ export const SwarmLayer: Layer.Layer<Swarm, never, HttpClient.HttpClient> = Swar
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/latest/#tag/Swarm
  */
-export const SwarmLayerLocalSocket: Layer.Layer<Swarm, never, HttpClient.HttpClient> = Swarm.Default;
+export const SwarmLayerLocalSocket: Layer.Layer<Swarm, never, HttpClient.HttpClient> = SwarmLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);

package/src/internal/endpoints/system.ts

@@ -1,79 +1,96 @@
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, HttpClient } from "@effect/platform";
-import { Effect, type Layer, Schema, Stream } from "effect";
-
-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 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 {
     RegistryAuthenticateOKBody as AuthResponse,
     TypesDiskUsage as DiskUsage,
     RegistryAuthConfig,
     SystemInfo,
     TypesVersion as SystemVersion,
-} from "../generated/index.js";
+} from "../generated/index.ts";
 import { DockerError } from "./circular.ts";
-import { BadRequest, HttpApiStreamingResponse, InternalServerError, Unauthorized } from "./httpApiHacks.js";
+import { BadRequest, InternalServerError, Unauthorized } from "./errors.ts";
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/System/operation/SystemAuth */
-const authEndpoint = HttpApiEndpoint.post("auth", "/auth")
-    .setPayload(RegistryAuthConfig)
-    .addSuccess(AuthResponse, { status: 200 }) // 200 OK
-    .addSuccess(HttpApiSchema.Empty(204)) // 204 No Content
-    .addError(Unauthorized); // 401 Unauthorized
+const authEndpoint = HttpApiEndpoint.post("auth", "/auth", {
+    payload: RegistryAuthConfig,
+    success: [
+        AuthResponse, // 200 OK
+        HttpApiSchema.Empty(204), // 204 No Content
+    ],
+    error: [
+        Unauthorized, // 401 Unauthorized
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/System/operation/SystemInfo */
-const infoEndpoint = HttpApiEndpoint.get("info", "/info").addSuccess(SystemInfo, { status: 200 });
+const infoEndpoint = HttpApiEndpoint.get("info", "/info", {
+    success: SystemInfo, // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/System/operation/SystemVersion */
-const versionEndpoint = HttpApiEndpoint.get("version", "/version").addSuccess(SystemVersion, { status: 200 });
+const versionEndpoint = HttpApiEndpoint.get("version", "/version", {
+    success: SystemVersion, // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/System/operation/SystemPing */
-const pingEndpoint = HttpApiEndpoint.get("ping", "/_ping").addSuccess(
-    HttpApiSchema.withEncoding(Schema.Literal("OK"), { kind: "Text", contentType: "text/plain" }),
-    { status: 200 }
-);
+const pingEndpoint = HttpApiEndpoint.get("ping", "/_ping", {
+    success: Schema.Literal("OK").pipe(HttpApiSchema.asText({ contentType: "text/plain" })), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/System/operation/SystemPingHead */
-const pingHeadEndpoint = HttpApiEndpoint.head("pingHead", "/_ping").addSuccess(HttpApiSchema.Empty(200));
+const pingHeadEndpoint = HttpApiEndpoint.head("pingHead", "/_ping", {
+    success: HttpApiSchema.Empty(200), // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/System/operation/SystemEvents */
-const eventsEndpoint = HttpApiEndpoint.get("events", "/events")
-    .setUrlParams(
-        Schema.Struct({
-            since: Schema.optional(Schema.String),
-            until: Schema.optional(Schema.String),
-        })
-    )
-    .addSuccess(HttpApiSchema.Empty(200)) // 200 OK
-    .addError(BadRequest); // 400 Bad request
+const eventsEndpoint = HttpApiEndpoint.get("events", "/events", {
+    query: {
+        since: Schema.optional(Schema.String),
+        until: Schema.optional(Schema.String),
+    },
+    success: HttpApiSchema.StreamUint8Array(), // 200 OK (streaming response)
+    error: [
+        BadRequest, // 400 Bad request
+        InternalServerError,
+    ],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/latest/#tag/System/operation/SystemDataUsage */
-const dataUsageEndpoint = HttpApiEndpoint.get("dataUsage", "/system/df")
-    .setUrlParams(
-        Schema.Struct({
-            type: Schema.optional(
-                Schema.Array(
-                    Schema.Union(
-                        Schema.Literal("container"),
-                        Schema.Literal("image"),
-                        Schema.Literal("volume"),
-                        Schema.Literal("build-cache")
-                    )
-                )
-            ),
-        })
-    )
-    .addSuccess(DiskUsage, { status: 200 }); // 200 OK
+const dataUsageEndpoint = HttpApiEndpoint.get("dataUsage", "/system/df", {
+    query: {
+        type: Schema.optional(Schema.Array(Schema.Literals(["container", "image", "volume", "build-cache"]))),
+    },
+    success: DiskUsage, // 200 OK
+    error: [InternalServerError],
+});
 
 /** @see https://docs.docker.com/reference/api/engine/version/v1.51/#tag/System */
-const SystemGroup = HttpApiGroup.make("system")
-    .add(authEndpoint)
-    .add(infoEndpoint)
-    .add(versionEndpoint)
-    .add(pingEndpoint)
-    .add(pingHeadEndpoint)
-    .add(eventsEndpoint)
-    .add(dataUsageEndpoint)
-    .addError(InternalServerError);
+const SystemGroup = HttpApiGroup.make("system").add(
+    authEndpoint,
+    infoEndpoint,
+    versionEndpoint,
+    pingEndpoint,
+    pingHeadEndpoint,
+    eventsEndpoint,
+    dataUsageEndpoint
+);
 
 /**
  * @since 1.0.0
@@ -87,41 +104,37 @@ export const SystemApi = HttpApi.make("SystemApi").add(SystemGroup);
  * @category Services
  * @see https://docs.docker.com/reference/api/engine/version/v1.51/#tag/System
  */
-export class System extends Effect.Service<System>()("@the-moby-effect/endpoints/System", {
-    accessors: false,
-    dependencies: [
-        makeAgnosticHttpClientLayer(
-            MobyConnectionOptions.socket({
-                socketPath: "/var/run/docker.sock",
-            })
-        ),
-    ],
-
-    effect: Effect.gen(function* () {
-        type Options<Name extends (typeof SystemGroup.endpoints)[number]["name"]> =
-            HttpApiEndpoint.HttpApiEndpoint.UrlParams<
-                HttpApiEndpoint.HttpApiEndpoint.WithName<(typeof SystemGroup.endpoints)[number], Name>
-            >;
+export class System extends Context.Service<System>()("@the-moby-effect/endpoints/System", {
+    make: Effect.gen(function* () {
+        type SystemEndpoints = HttpApiGroup.Endpoints<typeof SystemGroup>;
+        type Options<Name extends SystemEndpoints["identifier"]> = HttpApiEndpoint.WithIdentifier<
+            SystemEndpoints,
+            Name
+        >["~Query"]["Type"];
 
         const httpClient = yield* HttpClient.HttpClient;
         const SystemsError = DockerError.WrapForModule("system");
         const client = yield* HttpApiClient.group(SystemApi, { group: "system", httpClient });
 
-        const auth_ = (payload: RegistryAuthConfig) => Effect.mapError(client.auth({ payload }), SystemsError("auth"));
-        const info_ = () => Effect.mapError(client.info(), SystemsError("info"));
-        const version_ = () => Effect.mapError(client.version(), SystemsError("version"));
-        const ping_ = () => Effect.mapError(client.ping(), SystemsError("ping"));
-        const pingHead_ = () => Effect.mapError(client.pingHead(), SystemsError("pingHead"));
+        const auth_ = (payload: (typeof RegistryAuthConfig)["~type.make.in"]) =>
+            RegistryAuthConfig.makeEffect(payload).pipe(
+                Effect.flatMap((payload) => client.auth({ payload })),
+                Effect.mapError(SystemsError("auth"))
+            );
+        const info_ = () => client.info().pipe(Effect.mapError(SystemsError("info")));
+        const version_ = () => client.version().pipe(Effect.mapError(SystemsError("version")));
+        const ping_ = () => client.ping().pipe(Effect.mapError(SystemsError("ping")));
+        const pingHead_ = () => client.pingHead().pipe(Effect.mapError(SystemsError("pingHead")));
         const events_ = (options?: Options<"events">) =>
-            Stream.mapError(
-                HttpApiStreamingResponse(SystemApi, "system", "events", httpClient)({ urlParams: { ...options } }),
-                SystemsError("events")
-            )
-                .pipe(Stream.decodeText())
-                .pipe(Stream.splitLines)
-                .pipe(Stream.mapEffect(Schema.decode(Schema.parseJson())));
+            client.events({ query: { ...options } }).pipe(
+                Stream.unwrap,
+                Stream.decodeText(),
+                Stream.splitLines,
+                Stream.mapEffect((line) => Schema.decodeEffect(Schema.UnknownFromJsonString)(line)),
+                Stream.mapError(SystemsError("events"))
+            );
         const dataUsage_ = (params?: Options<"dataUsage">) =>
-            Effect.mapError(client.dataUsage({ urlParams: { ...params } }), SystemsError("dataUsage"));
+            client.dataUsage({ query: { ...params } }).pipe(Effect.mapError(SystemsError("dataUsage")));
 
         return {
             auth: auth_,
@@ -140,11 +153,19 @@ export class System extends Effect.Service<System>()("@the-moby-effect/endpoints
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/version/v1.51/#tag/System
  */
-export const SystemLayerLocalSocket: Layer.Layer<System, never, HttpClient.HttpClient> = System.Default;
+export const SystemLayer: Layer.Layer<System, never, HttpClient.HttpClient> = Layer.effect(System, System.make);
 
 /**
  * @since 1.0.0
  * @category Layers
  * @see https://docs.docker.com/reference/api/engine/version/v1.51/#tag/System
  */
-export const SystemLayer: Layer.Layer<System, never, HttpClient.HttpClient> = System.DefaultWithoutDependencies;
+export const SystemLayerLocalSocket: Layer.Layer<System, never, HttpClient.HttpClient> = SystemLayer.pipe(
+    Layer.provide(
+        makeAgnosticHttpClientLayer(
+            MobyConnectionOptions.socket({
+                socketPath: "/var/run/docker.sock",
+            })
+        )
+    )
+);