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

package/src/internal/demux/stdio.ts

@@ -0,0 +1,128 @@
+import type * as Socket from "@effect/platform/Socket";
+import type * as Channel from "effect/Channel";
+import type * as Chunk from "effect/Chunk";
+import type * as ParseResult from "effect/ParseResult";
+import type * as Scope from "effect/Scope";
+
+import * as Console from "effect/Console";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+
+import {
+    asMultiplexedChannel,
+    demuxMultiplexedToSeparateSinks,
+    EitherMultiplexedInput,
+    makeMultiplexedChannel,
+} from "./multiplexed.js";
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class StdinError extends Data.TaggedError("StdinError")<{ message: string; cause: unknown }> {}
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class StdoutError extends Data.TaggedError("StdoutError")<{ message: string; cause: unknown }> {}
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class StderrError extends Data.TaggedError("StderrError")<{ message: string; cause: unknown }> {}
+
+/**
+ * Demux either a raw stream socket or a multiplexed stream socket from stdin to
+ * stdout and stderr. If given a raw stream socket, then stdout and stderr will
+ * be combined on the same sink. If given a multiplexed stream socket, then
+ * stdout and stderr will be forwarded to different sinks. If given multiple raw
+ * stream sockets, then you can provide different individual sockets for stdin,
+ * stdout, and stderr.
+ *
+ * If you are looking for a way to demux to the console instead of stdin,
+ * stdout, and stderr then see {@link demuxSocketWithInputToConsole}. Since we
+ * are interacting with stdin, stdout, and stderr this function dynamically
+ * imports the `@effect/platform-node` package.
+ *
+ * @since 1.0.0
+ * @category DemuxStdio
+ */
+export const demuxFromStdinToStdoutAndStderr = <IE = never, OE = Socket.SocketError, R = never>(
+    sockets: EitherMultiplexedInput<IE, OE, R>,
+    options?: { bufferSize?: number | undefined; encoding?: string | undefined } | undefined
+): Effect.Effect<
+    void,
+    IE | OE | StdinError | StdoutError | StderrError | ParseResult.ParseError,
+    Exclude<R, Scope.Scope>
+> =>
+    Effect.flatMap(
+        Effect.all(
+            {
+                NodeSinkLazy: Effect.promise(() => import("@effect/platform-node/NodeSink")),
+                NodeStreamLazy: Effect.promise(() => import("@effect/platform-node/NodeStream")),
+            },
+            { concurrency: 2 }
+        ),
+        ({ NodeSinkLazy, NodeStreamLazy }) => {
+            const stdin: Stream.Stream<Uint8Array, StdinError, never> = NodeStreamLazy.fromReadable(
+                () => process.stdin,
+                (cause: unknown) => new StdinError({ cause, message: "stdin is not readable" })
+            );
+            const stdout: Sink.Sink<void, string | Uint8Array, never, StdoutError, never> = NodeSinkLazy.fromWritable(
+                () => process.stdout,
+                (cause: unknown) => new StdoutError({ cause, message: "stdout is not writable" }),
+                { endOnDone: false }
+            );
+            const stderr: Sink.Sink<void, string | Uint8Array, never, StderrError, never> = NodeSinkLazy.fromWritable(
+                () => process.stderr,
+                (cause: unknown) => new StderrError({ cause, message: "stderr is not writable" }),
+                { endOnDone: false }
+            );
+
+            const { underlying } = asMultiplexedChannel(sockets);
+            const multiplexedChannel = makeMultiplexedChannel<IE | StdinError, IE | OE | StdinError, R>(
+                underlying as Channel.Channel<
+                    Chunk.Chunk<Uint8Array>,
+                    Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
+                    IE | OE | StdinError,
+                    IE | StdinError,
+                    void,
+                    unknown,
+                    R
+                >
+            );
+
+            return demuxMultiplexedToSeparateSinks(multiplexedChannel, stdin, stdout, stderr, options);
+        }
+    );
+
+/**
+ * Demux either a raw stream socket or a multiplexed stream socket to the
+ * console. If given a raw stream socket, then stdout and stderr will be
+ * combined on the same sink. If given a multiplexed stream socket, then stdout
+ * and stderr will be forwarded to different sinks. If given multiple raw stream
+ * sockets, then you can provide different individual sockets for stdin, stdout,
+ * and stderr.
+ *
+ * If you are looking for a way to demux to stdin, stdout, and stderr instead of
+ * the console then see {@link demuxSocketFromStdinToStdoutAndStderr}.
+ *
+ * @since 1.0.0
+ * @category DemuxStdio
+ */
+export const demuxWithInputToConsole = <E, R1, IE = never, OE = Socket.SocketError, R2 = never>(
+    sockets: EitherMultiplexedInput<E | IE, OE, R2>,
+    input: Stream.Stream<string | Uint8Array, E, R1>,
+    options?: { bufferSize?: number | undefined; encoding?: string | undefined } | undefined
+): Effect.Effect<void, E | IE | OE | ParseResult.ParseError, Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
+    demuxMultiplexedToSeparateSinks(
+        sockets,
+        input,
+        Sink.forEach<string, void, never, never>(Console.log),
+        Sink.forEach<string, void, never, never>(Console.error),
+        options
+    );

package/src/internal/endpoints/common.ts

@@ -0,0 +1,60 @@
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Array from "effect/Array";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+import * as Tuple from "effect/Tuple";
+
+/**
+ * Takes a key and an optional value and returns a function that either adds the
+ * key and value to the query parameters of a request if the value was a Some or
+ * does nothing to the request if the value is a None.
+ *
+ * @internal
+ */
+export const maybeAddQueryParameter = (
+    key: string,
+    value: Option.Option<unknown>
+): ((self: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest) =>
+    Option.match({
+        onNone: Function.constant(Function.identity),
+        onSome: (val: unknown) => HttpClientRequest.setUrlParam(key, String(val)),
+    })(value);
+
+/**
+ * Takes a key and an optional value and returns a function that either adds the
+ * key and value to the headers of a request if the value was a Some or does
+ * nothing to the request if the values is a None.
+ *
+ * @internal
+ */
+export const maybeAddHeader = (
+    key: string,
+    value: Option.Option<string>
+): ((self: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest) =>
+    Option.match({
+        onNone: Function.constant(Function.identity),
+        onSome: (val: string) => HttpClientRequest.setHeader(key, val),
+    })(value);
+
+/**
+ * For a given set of filters, returns a function that adds the filters to the
+ * http request as a query parameter.
+ *
+ * @internal
+ */
+export const maybeAddFilters = (
+    filters?: Record<string, Record<string, string> | string | number | boolean | undefined | null> | undefined
+): ((self: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest) =>
+    maybeAddQueryParameter(
+        "filters",
+        Function.pipe(
+            filters,
+            Option.fromNullable,
+            Option.map(
+                Record.map((val) => (Predicate.isNullable(val) ? Array.empty : Tuple.make(JSON.stringify(val))))
+            ),
+            Option.map(JSON.stringify)
+        )
+    );

package/src/internal/endpoints/configs.ts

@@ -0,0 +1,164 @@
+import * as PlatformError from "@effect/platform/Error";
+import * as HttpBody from "@effect/platform/HttpBody";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Tuple from "effect/Tuple";
+
+import { SwarmConfig, SwarmConfigCreateResponse, SwarmConfigSpec } from "../generated/index.js";
+import { maybeAddFilters, maybeAddQueryParameter } from "./common.js";
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const ConfigsErrorTypeId: unique symbol = Symbol.for(
+    "@the-moby-effect/endpoints/ConfigsError"
+) as ConfigsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export type ConfigsErrorTypeId = typeof ConfigsErrorTypeId;
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export const isConfigsError = (u: unknown): u is ConfigsError => Predicate.hasProperty(u, ConfigsErrorTypeId);
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class ConfigsError extends PlatformError.TypeIdError(ConfigsErrorTypeId, "ConfigsError")<{
+    method: string;
+    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
+}> {
+    get message() {
+        return `${this.method}`;
+    }
+}
+
+/**
+ * Configs are application configurations that can be used by services. Swarm
+ * mode must be enabled for these endpoints to work.
+ *
+ * @since 1.0.0
+ * @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: [],
+
+    effect: Effect.gen(function* () {
+        const contextClient = yield* HttpClient.HttpClient;
+        const client = contextClient.pipe(HttpClient.filterStatusOk);
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigList */
+        const list_ = (
+            options?:
+                | {
+                      readonly filters?: {
+                          id?: string | undefined;
+                          label?: Record<string, string> | undefined;
+                          name?: string | undefined;
+                          names?: string | undefined;
+                      };
+                  }
+                | undefined
+        ): Effect.Effect<ReadonlyArray<SwarmConfig>, ConfigsError, never> =>
+            Function.pipe(
+                HttpClientRequest.get("/configs"),
+                maybeAddFilters(options?.filters),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(SwarmConfig))),
+                Effect.mapError((cause) => new ConfigsError({ method: "list", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigCreate */
+        const create_ = (
+            options: typeof SwarmConfigSpec.Encoded
+        ): Effect.Effect<Readonly<SwarmConfigCreateResponse>, ConfigsError, never> =>
+            Function.pipe(
+                Schema.decode(SwarmConfigSpec)(options),
+                Effect.map((body) => Tuple.make(HttpClientRequest.post("/configs/create"), body)),
+                Effect.flatMap(Function.tupled(HttpClientRequest.schemaBodyJson(SwarmConfigSpec))),
+                Effect.flatMap(client.execute),
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmConfigCreateResponse)),
+                Effect.mapError((cause) => new ConfigsError({ method: "create", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigDelete */
+        const delete_ = (id: string): Effect.Effect<void, ConfigsError, never> =>
+            Function.pipe(
+                HttpClientRequest.del(`/configs/${encodeURIComponent(id)}`),
+                client.execute,
+                Effect.asVoid,
+                Effect.mapError((cause) => new ConfigsError({ method: "delete", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigInspect */
+        const inspect_ = (id: string): Effect.Effect<Readonly<SwarmConfig>, ConfigsError, never> =>
+            Function.pipe(
+                HttpClientRequest.get(`/configs/${encodeURIComponent(id)}`),
+                client.execute,
+                Effect.flatMap(HttpClientResponse.schemaBodyJson(SwarmConfig)),
+                Effect.mapError((cause) => new ConfigsError({ method: "inspect", cause }))
+            );
+
+        /** @see https://docs.docker.com/reference/api/engine/latest/#tag/Config/operation/ConfigUpdate */
+        const update_ = (
+            id: string,
+            options: {
+                /**
+                 * The spec of the config to update. Currently, only the Labels
+                 * field can be updated. All other fields must remain unchanged
+                 * from the ConfigInspect response values.
+                 */
+                readonly spec: SwarmConfigSpec;
+                /**
+                 * The version number of the config object being updated. This
+                 * is required to avoid conflicting writes.
+                 */
+                readonly version: number;
+            }
+        ): Effect.Effect<void, ConfigsError, never> =>
+            Function.pipe(
+                HttpClientRequest.post(`/configs/${encodeURIComponent(id)}/update`),
+                maybeAddQueryParameter("version", Option.some(options.version)),
+                HttpClientRequest.schemaBodyJson(SwarmConfigSpec)(options.spec),
+                Effect.flatMap(client.execute),
+                Effect.asVoid,
+                Effect.mapError((cause) => new ConfigsError({ method: "update", cause }))
+            );
+
+        return {
+            list: list_,
+            create: create_,
+            delete: delete_,
+            inspect: inspect_,
+            update: update_,
+        };
+    }),
+}) {}
+
+/**
+ * Configs are application configurations that can be used by services. Swarm
+ * mode must be enabled for these endpoints to work.
+ *
+ * @since 1.0.0
+ * @category Layers
+ * @see https://docs.docker.com/reference/api/engine/latest/#tag/Config
+ */
+export const ConfigsLayer: Layer.Layer<Configs, never, HttpClient.HttpClient> = Configs.Default;