the-moby-effect 1.45.0-alpha.8 → 1.48.0

package/src/internal/platforms/node.ts

@@ -0,0 +1,160 @@
+import type * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
+import type * as HttpClient from "@effect/platform/HttpClient";
+import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import type * as Socket from "@effect/platform/Socket";
+import type * as Scope from "effect/Scope";
+import type * as http from "node:http";
+import type * as https from "node:https";
+import type * as net from "node:net";
+import type * as stream from "node:stream";
+import type * as ssh2 from "ssh2";
+import type * as MobyConnection from "../../MobyConnection.js";
+
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as internalAgnostic from "./agnostic.js";
+import * as internalConnection from "./connection.js";
+
+/**
+ * Helper interface to expose the underlying socket from the effect HttpClient
+ * response. Useful for hijacking the response stream. This is a hack, and it
+ * will only work when using the NodeJS http layer.
+ *
+ * @since 1.0.0
+ * @category NodeJS
+ * @internal
+ */
+export interface IExposeSocketOnEffectClientResponseHack extends HttpClientResponse.HttpClientResponse {
+    original: {
+        source: {
+            socket: net.Socket;
+        };
+    };
+}
+
+/** @internal */
+export const makeNodeSshAgent = (
+    httpLazy: typeof http,
+    ssh2Lazy: typeof ssh2,
+    connectionOptions: MobyConnection.SshConnectionOptions
+): http.Agent =>
+    new (class extends httpLazy.Agent {
+        // The ssh client that will be connecting to the server
+        public readonly sshClient: ssh2.Client;
+
+        // How to connect to the remote server and where the moby socket is located.
+        public readonly connectConfig: MobyConnection.SshConnectionOptions;
+
+        public constructor(
+            ssh2ConnectConfig: MobyConnection.SshConnectionOptions,
+            agentOptions?: http.AgentOptions | undefined
+        ) {
+            super(agentOptions);
+            this.sshClient = new ssh2Lazy.Client();
+            this.connectConfig = ssh2ConnectConfig;
+        }
+
+        /**
+         * When creating a new connection, first start by trying to connect to
+         * the remote server over ssh. Then, if that was successful, we send a
+         * forwardOurStreamLocal request which is an OpenSSH extension that
+         * opens a connection to the unix domain socket at socketPath on the
+         * remote server and forwards traffic.
+         *
+         * @since 1.0.0
+         * @see https://nodejs.org/api/http.html#agentcreateconnectionoptions-callback
+         */
+        public createConnection(
+            _options: http.ClientRequestArgs,
+            callback: (error: Error | undefined, socket?: stream.Duplex | undefined) => void
+        ): void {
+            this.sshClient
+                .on("ready", () => {
+                    this.sshClient.openssh_forwardOutStreamLocal(
+                        this.connectConfig.remoteSocketPath,
+                        (error: Error | undefined, stream: ssh2.ClientChannel) => {
+                            if (error) {
+                                this.sshClient.end();
+                                return callback(error);
+                            }
+
+                            stream.once("close", () => {
+                                stream.end();
+                                stream.destroy();
+                                this.sshClient.end();
+                            });
+
+                            callback(undefined, stream);
+                        }
+                    );
+                })
+                .on("error", (error) => callback(error, undefined))
+                .connect(this.connectConfig);
+        }
+    })(connectionOptions);
+
+/** @internal */
+export const getNodeAgent = (
+    connectionOptions: MobyConnection.MobyConnectionOptions
+): Effect.Effect<NodeHttpClient.HttpAgent, never, Scope.Scope> =>
+    Function.pipe(
+        Effect.all(
+            {
+                httpLazy: Effect.promise(() => import("node:http")),
+                httpsLazy: Effect.promise(() => import("node:https")),
+                nodeHttpClientLazy: Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
+            },
+            { concurrency: 3 }
+        ),
+        Effect.flatMap(({ httpLazy, httpsLazy, nodeHttpClientLazy }) => {
+            const AcquireNodeHttpAgent = internalConnection.MobyConnectionOptions.$match({
+                http: (options) => Effect.succeed(new httpLazy.Agent({ host: options.host, port: options.port })),
+                socket: (options) =>
+                    Effect.succeed(new httpLazy.Agent({ socketPath: options.socketPath } as http.AgentOptions)),
+                ssh: (options) =>
+                    Effect.map(
+                        Effect.promise(() => import("ssh2")),
+                        (ssh2Lazy) => makeNodeSshAgent(httpLazy, ssh2Lazy, options)
+                    ),
+                https: (options) =>
+                    Effect.succeed(
+                        new httpsLazy.Agent({
+                            ca: options.ca,
+                            key: options.key,
+                            cert: options.cert,
+                            host: options.host,
+                            port: options.port,
+                            passphrase: options.passphrase,
+                        })
+                    ),
+            });
+
+            const releaseNodeHttpAgent = (agent: http.Agent) => Effect.sync(() => agent.destroy());
+            const resource = Effect.acquireRelease(AcquireNodeHttpAgent(connectionOptions), releaseNodeHttpAgent);
+
+            return Effect.map(resource, (agent) => ({
+                http: agent as http.Agent,
+                https: agent as https.Agent,
+                [nodeHttpClientLazy.HttpAgentTypeId]: nodeHttpClientLazy.HttpAgentTypeId,
+            }));
+        })
+    );
+
+/** @internal */
+export const makeNodeHttpClientLayer = (
+    connectionOptions: MobyConnection.MobyConnectionOptions
+): Layer.Layer<HttpClient.HttpClient | Socket.WebSocketConstructor, never, never> => {
+    const nodeHttpClientLayer = Function.pipe(
+        Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
+        Effect.map((nodeHttpClientLazy) =>
+            Layer.provide(
+                nodeHttpClientLazy.layerWithoutAgent,
+                Layer.scoped(nodeHttpClientLazy.HttpAgent, getNodeAgent(connectionOptions))
+            )
+        ),
+        Layer.unwrapEffect
+    );
+    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
+    return Layer.provide(agnosticHttpClientLayer, nodeHttpClientLayer);
+};

package/src/internal/platforms/undici.ts

@@ -0,0 +1,132 @@
+import type * as HttpClient from "@effect/platform/HttpClient";
+import type * as Socket from "@effect/platform/Socket";
+import type * as Scope from "effect/Scope";
+import type * as net from "node:net";
+import type * as ssh2 from "ssh2";
+import type * as undici from "undici";
+import type * as MobyConnection from "../../MobyConnection.js";
+
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as internalAgnostic from "./agnostic.js";
+import * as internalConnection from "./connection.js";
+
+/** @internal */
+export const makeUndiciSshConnector = (
+    connectionOptions: MobyConnection.SshConnectionOptions
+): Effect.Effect<undici.buildConnector.connector, never, Scope.Scope> =>
+    Effect.Do.pipe(
+        Effect.bind("ssh2Lazy", () => Effect.promise(() => import("ssh2"))),
+        Effect.let("acquire", ({ ssh2Lazy }) => Effect.sync(() => new ssh2Lazy.Client())),
+        Effect.let(
+            "release",
+            () => (client: ssh2.Client) =>
+                Effect.sync(() => {
+                    client.end();
+                    client.destroy();
+                })
+        ),
+        Effect.flatMap(({ acquire, release }) => Effect.acquireRelease(acquire, release)),
+        Effect.flatMap((sshClient) =>
+            Effect.async<ssh2.Client, Error>((resume) => {
+                sshClient
+                    .once("ready", () => {
+                        sshClient.removeAllListeners("error");
+                        sshClient.removeAllListeners("ready");
+                        resume(Effect.succeed(sshClient));
+                    })
+                    .once("error", (error) => {
+                        sshClient.removeAllListeners("error");
+                        sshClient.removeAllListeners("ready");
+                        resume(Effect.fail(error));
+                    })
+                    .connect(connectionOptions);
+            })
+        ),
+        Effect.map((sshClient) => (_opts: undici.buildConnector.Options, callback: undici.buildConnector.Callback) => {
+            sshClient.openssh_forwardOutStreamLocal(
+                connectionOptions.remoteSocketPath,
+                (error: Error | undefined, socket: ssh2.ClientChannel) => {
+                    if (error) {
+                        return callback(error, null);
+                    }
+
+                    socket.once("close", () => {
+                        socket.end();
+                        socket.destroy();
+                    });
+
+                    return callback(null, socket as unknown as net.Socket);
+                }
+            );
+        }),
+        Effect.orDie
+    );
+
+/** @internal */
+export const getUndiciDispatcher = (
+    connectionOptions: MobyConnection.MobyConnectionOptions
+): Effect.Effect<undici.Dispatcher, never, Scope.Scope> =>
+    Effect.flatMap(
+        Effect.promise(() => import("undici")),
+        (undiciLazy) => {
+            const AcquireUndiciDispatcher = internalConnection.MobyConnectionOptions.$match({
+                socket: (options) =>
+                    Effect.succeed(
+                        new undiciLazy.Agent({
+                            connect: { socketPath: options.socketPath },
+                        })
+                    ),
+                http: (options) =>
+                    Effect.succeed(
+                        new undiciLazy.Agent({
+                            connect: { host: options.host, port: options.port, path: options.path },
+                        })
+                    ),
+                https: (options) =>
+                    Effect.succeed(
+                        new undiciLazy.Agent({
+                            connect: {
+                                ca: options.ca,
+                                key: options.key,
+                                cert: options.cert,
+                                passphrase: options.passphrase,
+                                host: options.host,
+                                port: options.port,
+                                path: options.path,
+                            },
+                        })
+                    ),
+                ssh: (options) =>
+                    Effect.map(
+                        makeUndiciSshConnector(options),
+                        (connector) => new undiciLazy.Agent({ connect: connector })
+                    ),
+            });
+
+            const releaseUndiciDispatcher = (dispatcher: undici.Dispatcher) =>
+                Effect.promise(() => dispatcher.destroy());
+
+            return Effect.acquireRelease(AcquireUndiciDispatcher(connectionOptions), releaseUndiciDispatcher);
+        }
+    );
+
+/** @internal */
+export const makeUndiciHttpClientLayer = (
+    connectionOptions: MobyConnection.MobyConnectionOptions
+): Layer.Layer<HttpClient.HttpClient | Socket.WebSocketConstructor, never, never> => {
+    const undiciLayer = Function.pipe(
+        Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
+        Effect.map((nodeHttpClientLazy) =>
+            Layer.provide(
+                nodeHttpClientLazy.layerUndiciWithoutDispatcher,
+                Layer.scoped(nodeHttpClientLazy.Dispatcher, getUndiciDispatcher(connectionOptions))
+            )
+        ),
+        Layer.unwrapEffect
+    );
+
+    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
+    return Layer.provide(agnosticHttpClientLayer, undiciLayer);
+};

package/src/internal/platforms/web.ts

@@ -0,0 +1,21 @@
+import type * as HttpClient from "@effect/platform/HttpClient";
+import type * as Socket from "@effect/platform/Socket";
+import type * as MobyConnection from "../../MobyConnection.js";
+
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as internalAgnostic from "./agnostic.js";
+
+/** @internal */
+export const makeWebHttpClientLayer = (
+    connectionOptions: MobyConnection.HttpConnectionOptionsTagged | MobyConnection.HttpsConnectionOptionsTagged
+): Layer.Layer<HttpClient.HttpClient | Socket.WebSocketConstructor, never, never> => {
+    const browserLayer = Function.pipe(
+        Effect.promise(() => import("@effect/platform-browser/BrowserHttpClient")),
+        Effect.map((browserHttpClientLazy) => browserHttpClientLazy.layerXMLHttpRequest),
+        Layer.unwrapEffect
+    );
+    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
+    return Layer.provide(agnosticHttpClientLayer, browserLayer);
+};

package/src/internal/schemas/address.ts

@@ -0,0 +1,114 @@
+/**
+ * IPv4 or IPv6 addresses schema.
+ *
+ * @since 1.0.0
+ */
+
+import * as Schema from "effect/Schema";
+import * as IPv4 from "./ipv4.js";
+import * as IPv6 from "./ipv6.js";
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $AddressString extends Schema.Union<[IPv4.$IPv4String, IPv6.$IPv6String]> {}
+
+/**
+ * @since 1.0.0
+ * @category Decoded types
+ */
+export type AddressString = Schema.Schema.Type<$AddressString>;
+
+/**
+ * @since 1.0.0
+ * @category Encoded types
+ */
+export type AddressStringEncoded = Schema.Schema.Encoded<$AddressString>;
+
+/**
+ * An IP address in string format, which is either an IPv4 or IPv6 address.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const AddressString: $AddressString = Schema.Union(IPv4.IPv4String, IPv6.IPv6String).annotations({
+    identifier: "AddressString",
+    description: "An ipv4 or ipv6 address in string format",
+});
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $Address extends Schema.Union<[IPv4.$IPv4, IPv6.$IPv6]> {}
+
+/**
+ * @since 1.0.0
+ * @category Decoded types
+ */
+export type Address = Schema.Schema.Type<$Address>;
+
+/**
+ * @since 1.0.0
+ * @category Encoded types
+ */
+export type AddressEncoded = Schema.Schema.Encoded<$Address>;
+
+/**
+ * An IP address, which is either an IPv4 or IPv6 address.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ * @example
+ *     import * as Schema from "effect/Schema";
+ *     import { Address } from "the-moby-effect/schemas/index.js";
+ *
+ *     const decodeAddress = Schema.decodeSync(Address);
+ *
+ *     assert.throws(() => decodeAddress("1.1.b.1"));
+ *     assert.throws(() =>
+ *         decodeAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334:")
+ *     );
+ *
+ *     assert.doesNotThrow(() => decodeAddress("1.1.1.2"));
+ *     assert.doesNotThrow(() =>
+ *         decodeAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+ *     );
+ *
+ * @see {@link IPv4.IPv4}
+ * @see {@link IPv6.IPv6}
+ */
+export const Address: $Address = Schema.Union(IPv4.IPv4, IPv6.IPv6).annotations({
+    identifier: "Address",
+    description: "An ipv4 or ipv6 address",
+});
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $AddressBigint extends Schema.Union<[IPv4.$IPv4Bigint, IPv6.$IPv6Bigint]> {}
+
+/**
+ * @since 1.0.0
+ * @category Decoded types
+ */
+export type AddressBigint = Schema.Schema.Type<$AddressBigint>;
+
+/**
+ * @since 1.0.0
+ * @category Encoded types
+ */
+export type AddressBigintEncoded = Schema.Schema.Encoded<$AddressBigint>;
+
+/**
+ * An IP address as a bigint.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const AddressBigint: $AddressBigint = Schema.Union(IPv4.IPv4Bigint, IPv6.IPv6Bigint).annotations({
+    identifier: "AddressBigint",
+    description: "An ipv4 or ipv6 address as a bigint",
+});