the-moby-effect 1.45.0-alpha.20 → 1.45.0-alpha.21

package/src/engines/Docker.ts

@@ -85,6 +85,14 @@ export const layerUndici: (connectionOptions: MobyConnectionOptions) => DockerLa
 export const layerWeb: (connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged) => DockerLayer =
     Moby.layerWeb;
 
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerFetch: (
+    connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged
+) => DockerLayer = Moby.layerFetch;
+
 /**
  * @since 1.0.0
  * @category Layers

package/src/engines/DockerCompose.ts

@@ -279,6 +279,15 @@ export const layerWeb = (
 ): Layer.Layer<DockerCompose, SystemsError | ContainersError, never> =>
     Layer.provide(Layer.scoped(DockerCompose, make), DockerEngine.layerWeb(connectionOptions));
 
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerFetch = (
+    connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged
+): Layer.Layer<DockerCompose, SystemsError | ContainersError, never> =>
+    Layer.provide(Layer.scoped(DockerCompose, make), DockerEngine.layerFetch(connectionOptions));
+
 /**
  * @since 1.0.0
  * @category Layers

package/src/engines/Moby.ts

@@ -32,6 +32,7 @@ import { Volumes, VolumesLayer } from "../endpoints/Volumes.js";
 import { makeAgnosticHttpClientLayer } from "../platforms/Agnostic.js";
 import { makeBunHttpClientLayer } from "../platforms/Bun.js";
 import { makeDenoHttpClientLayer } from "../platforms/Deno.js";
+import { makeFetchHttpClientLayer } from "../platforms/Fetch.js";
 import { makeNodeHttpClientLayer } from "../platforms/Node.js";
 import { makeUndiciHttpClientLayer } from "../platforms/Undici.js";
 import { makeWebHttpClientLayer } from "../platforms/Web.js";
@@ -132,6 +133,13 @@ export const layerUndici = (connectionOptions: MobyConnectionOptions): MobyLayer
 export const layerWeb = (connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged): MobyLayer =>
     Layer.provide(layerWithoutHttpCLient, makeWebHttpClientLayer(connectionOptions));
 
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerFetch = (connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged): MobyLayer =>
+    Layer.provide(layerWithoutHttpCLient, makeFetchHttpClientLayer(connectionOptions));
+
 /**
  * @since 1.0.0
  * @category Layers

package/src/engines/Podman.ts

@@ -88,6 +88,14 @@ export const layerUndici: (connectionOptions: MobyConnectionOptions) => PodmanLa
 export const layerWeb: (connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged) => PodmanLayer =
     Moby.layerWeb;
 
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerFetch: (
+    connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged
+) => PodmanLayer = Moby.layerFetch;
+
 /**
  * @since 1.0.0
  * @category Layers

package/src/platforms/Agnostic.ts

@@ -4,8 +4,6 @@
  * @since 1.0.0
  */
 
-import * as assert from "node:assert";
-
 import * as HttpClient from "@effect/platform/HttpClient";
 import * as HttpClientError from "@effect/platform/HttpClientError";
 import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
@@ -15,30 +13,33 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
 import * as Scope from "effect/Scope";
+import * as Types from "effect/Types";
 
 import { MobyConnectionOptions } from "../MobyConnection.js";
 
-/**
- * @since 1.0.0
- * @category Helpers
- */
+/** @internal */
+const makeVersionPath = (connectionOptions: MobyConnectionOptions): string =>
+    Predicate.isNotUndefined(connectionOptions.version) ? `/v${connectionOptions.version}` : "";
+
+/** @internal */
 const makeHttpRequestUrl: (connectionOptions: MobyConnectionOptions) => string = MobyConnectionOptions.$match({
-    ssh: () => "http://0.0.0.0" as const,
-    socket: () => "http://0.0.0.0" as const,
-    http: (options) => `http://${options.host}:${options.port}${options.path ?? ""}` as const,
-    https: (options) => `https://${options.host}:${options.port}${options.path ?? ""}` as const,
+    ssh: (options) => `http://0.0.0.0${makeVersionPath(options)}` as const,
+    socket: (options) => `http://0.0.0.0${makeVersionPath(options)}` as const,
+    http: (options) =>
+        `http://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}` as const,
+    https: (options) =>
+        `https://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}` as const,
 });
 
-/**
- * @since 1.0.0
- * @category Helpers
- */
+/** @internal */
 const makeWebsocketRequestUrl: (connectionOptions: MobyConnectionOptions) => string = MobyConnectionOptions.$match({
-    ssh: () => "ws://0.0.0.0" as const,
-    socket: (options) => `ws+unix://${options.socketPath}:` as const,
-    http: (options) => `ws://${options.host}:${options.port}${options.path ?? ""}` as const,
-    https: (options) => `wss://${options.host}:${options.port}${options.path ?? ""}` as const,
+    ssh: (options) => `ws://0.0.0.0${makeVersionPath(options)}` as const,
+    socket: (options) => `ws+unix://${options.socketPath}${makeVersionPath(options)}:` as const,
+    http: (options) => `ws://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}` as const,
+    https: (options) =>
+        `wss://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}` as const,
 });
 
 /** @internal */
@@ -48,7 +49,7 @@ const HttpClientMobyConnectionOptions: unique symbol = Symbol.for(
 
 /** @internal */
 interface HttpClientExtension<E = HttpClientError.HttpClientError, R = Scope.Scope>
-    extends HttpClient.HttpClient<E, R> {
+    extends HttpClient.HttpClient.With<E, R> {
     readonly [HttpClientMobyConnectionOptions]: MobyConnectionOptions;
 }
 
@@ -61,7 +62,9 @@ export const websocketRequest = (
 
         const { hash, url, urlParams } = request;
         const { [HttpClientMobyConnectionOptions]: connectionOptions } = client as HttpClientExtension;
-        assert.ok(connectionOptions);
+        if (Predicate.isUndefined(connectionOptions)) {
+            return yield* Effect.dieMessage("What happened to the connection options?");
+        }
 
         const websocketUrl = yield* UrlParams.makeUrl(
             `${makeWebsocketRequestUrl(connectionOptions)}${url}`,
@@ -94,20 +97,10 @@ export const makeAgnosticHttpClientLayer = (
             })
         ),
         Layer.map((context) => {
-            const tag: Context.Tag<
-                HttpClient.HttpClient<HttpClientError.HttpClientError, Scope.Scope>,
-                HttpClient.HttpClient<HttpClientError.HttpClientError, Scope.Scope>
-            > = HttpClient.HttpClient;
+            const tag = HttpClient.HttpClient;
             const oldClient = Context.get(context, tag);
-            type Mutable<T> = { -readonly [P in keyof T]: T[P] };
-            (oldClient as Mutable<HttpClientExtension>)[HttpClientMobyConnectionOptions] = connectionOptions;
+            (oldClient as Types.Mutable<HttpClientExtension>)[HttpClientMobyConnectionOptions] = connectionOptions;
             return Context.make(tag, oldClient);
-        }),
-        Layer.tap((context) => {
-            const client = Context.get(context, HttpClient.HttpClient);
-            const { [HttpClientMobyConnectionOptions]: savedConnectionOptions } = client as HttpClientExtension;
-            assert.deepStrictEqual(savedConnectionOptions, connectionOptions);
-            return Effect.void;
         })
     );
 
@@ -124,6 +117,7 @@ export const makeAgnosticWebsocketLayer = (
     Layer.effect(
         Socket.WebSocketConstructor,
         Effect.gen(function* () {
+            // Only the ws package supports unix socket connection options
             if (MobyConnectionOptions.$is("socket")(connectionOptions)) {
                 const ws = yield* Effect.promise(() => import("ws"));
                 return (url, protocols) => new ws.WebSocket(url, protocols) as unknown as globalThis.WebSocket;