the-moby-effect 1.48.4 → 1.51.0

package/src/index.ts

@@ -1,83 +1,87 @@
+/**
+ * @since 1.0.0
+ */
+
 /**
  * Docker engine callbacks api
  *
  * @since 1.0.0
  */
-export * as Callbacks from "./Callbacks.js"
+export * as Callbacks from "./Callbacks.ts"
 
 /**
  * Docker in docker engine.
  *
  * @since 1.0.0
  */
-export * as DindEngine from "./DindEngine.js"
+export * as DindEngine from "./DindEngine.ts"
 
 /**
  * Docker compose engine.
  *
  * @since 1.0.0
  */
-export * as DockerComposeEngine from "./DockerComposeEngine.js"
+export * as DockerComposeEngine from "./DockerComposeEngine.ts"
 
 /**
  * Docker engine.
  *
  * @since 1.0.0
  */
-export * as DockerEngine from "./DockerEngine.js"
+export * as DockerEngine from "./DockerEngine.ts"
 
 /**
  * Http, https, ssh, and unix socket connection agents for all platforms.
  *
  * @since 1.0.0
  */
-export * as MobyConnection from "./MobyConnection.js"
+export * as MobyConnection from "./MobyConnection.ts"
 
 /**
  * Convenance utilities for Docker input and output streams.
  *
  * @since 1.0.0
  */
-export * as MobyConvey from "./MobyConvey.js"
+export * as MobyConvey from "./MobyConvey.ts"
 
 /**
  * Demux utilities for different types of docker streams.
  *
  * @since 1.0.0
  */
-export * as MobyDemux from "./MobyDemux.js"
+export * as MobyDemux from "./MobyDemux.ts"
 
 /**
  * Moby endpoints.
  *
  * @since 1.0.0
  */
-export * as MobyEndpoints from "./MobyEndpoints.js"
+export * as MobyEndpoints from "./MobyEndpoints.ts"
 
 /**
  * Http client layers for all platforms.
  *
  * @since 1.0.0
  */
-export * as MobyPlatforms from "./MobyPlatforms.js"
+export * as MobyPlatforms from "./MobyPlatforms.ts"
 
 /**
  * Moby schemas.
  *
  * @since 1.0.0
  */
-export * as MobySchemas from "./MobySchemas.js"
+export * as MobySchemas from "./MobySchemas.ts"
 
 /**
  * Podman engine
  *
  * @since 1.0.0
  */
-export * as PodmanEngine from "./PodmanEngine.js"
+export * as PodmanEngine from "./PodmanEngine.ts"
 
 /**
  * Docker engine promises api
  *
  * @since 1.0.0
  */
-export * as Promises from "./Promises.js"
+export * as Promises from "./Promises.ts"

package/src/internal/blobs/http.ts

@@ -1,7 +1,8 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 
 EXPOSE 2375

package/src/internal/blobs/https.ts

@@ -1,7 +1,8 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 
 EXPOSE 2376

package/src/internal/blobs/socket.ts

@@ -1,6 +1,7 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 `;

package/src/internal/blobs/ssh.ts

@@ -1,7 +1,8 @@
 import * as BlobConstants from "./constants.js";
 
 /** @internal */
-export const content = `ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
+export const content = /* dockerfile */ `
+ARG DIND_BASE_IMAGE="${BlobConstants.DefaultDindBaseImage}"
 FROM \${DIND_BASE_IMAGE}
 USER root
 

package/src/internal/convey/sinks.ts

@@ -1,34 +1,62 @@
 import type * as Chunk from "effect/Chunk";
 import type * as Scope from "effect/Scope";
-import type { JSONMessage } from "../generated/JSONMessage.generated.js";
+import type * as MobySchemas from "../generated/index.js";
 
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
+import * as Match from "effect/Match";
 import * as Predicate from "effect/Predicate";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 
 /** @internal */
 export const waitForProgressToComplete = <E1, R1>(
-    stream: Stream.Stream<JSONMessage, E1, R1>
-): Effect.Effect<Chunk.Chunk<JSONMessage>, E1, Exclude<R1, Scope.Scope>> => Stream.run(stream, Sink.collectAll());
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+): Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
+    Stream.run(stream, Sink.collectAll());
 
 /** @internal */
-export const followProgressSink = Sink.forEach<JSONMessage, void, never, never>(
+export const followProgressSink = Sink.forEach<MobySchemas.JSONMessage, void, never, never>(
     Effect.fnUntraced(function* (message) {
         if (Predicate.isNotUndefined(message.status)) {
             yield* Console.log(`${message.status}${message.progress ? " " : ""}${message.progress ?? ""}`);
         } else if (Predicate.isNotUndefined(message.stream)) {
             yield* Console.log(message.stream);
-        } else if (Predicate.isNotUndefined(message.aux)) {
-            yield* Console.log(message.aux.ID);
         }
     })
 );
 
 /** @internal */
 export const followProgressInConsole = <E1, R1>(
-    stream: Stream.Stream<JSONMessage, E1, R1>
-): Effect.Effect<Chunk.Chunk<JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+): Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
     Function.pipe(stream, Stream.tapSink(followProgressSink), waitForProgressToComplete);
+
+/** @internal */
+export const mapError = <E1, R1>(
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+): Stream.Stream<MobySchemas.JSONMessage, E1 | Error, R1> =>
+    Stream.mapEffect(stream, (message) => {
+        if (Predicate.isNotUndefined(message.error)) {
+            const cause = Function.pipe(
+                Match.value(message.errorDetail!),
+                Match.when(
+                    { code: Match.undefined, message: Match.undefined },
+                    () => "Errored with an unknown reason with an unknown code"
+                ),
+                Match.when({ message: Match.string }, ({ message }) => `Errored with ${message} and an unknown code`),
+                Match.when({ code: Match.number }, ({ code }) => `Errored with an unknown reason and code ${code}`),
+                Match.when(
+                    { code: Match.number, message: Match.string },
+                    ({ code, message }) => `Errored with ${message} and code ${code}`
+                ),
+                Match.orElseAbsurd,
+                (message) => new Error(message)
+            );
+
+            return Effect.fail(cause);
+        } else {
+            return Effect.succeed(message);
+        }
+    });

package/src/internal/demux/fan.ts

@@ -20,8 +20,14 @@ import { makeRawChannel, rawFromStreamWith } from "./raw.js";
 /** @internal */
 export const fan = Function.dual<
     <IE = never, OE = Socket.SocketError, R = never>(options: {
-        requestedCapacity: number;
-        encoding?: string | undefined;
+        readonly requestedCapacity:
+            | number
+            | {
+                  readonly stdinCapacity: number;
+                  readonly stdoutCapacity: number;
+                  readonly stderrCapacity: number;
+              };
+        readonly encoding?: string | undefined;
     }) => (multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>) => Effect.Effect<
         {
             stdin: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
@@ -33,7 +39,16 @@ export const fan = Function.dual<
     >,
     <IE = never, OE = Socket.SocketError, R = never>(
         multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) => Effect.Effect<
         {
             stdin: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
@@ -47,17 +62,31 @@ export const fan = Function.dual<
     (arguments_) => isMultiplexedChannel(arguments_[0]) || isMultiplexedSocket(arguments_[0]),
     Effect.fnUntraced(function* <IE = never, OE = Socket.SocketError, R = never>(
         multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) {
         const mutex = yield* Effect.makeSemaphore(1);
         const context = yield* Effect.context<Exclude<R, Scope.Scope>>();
 
         // Internal buffers
-        const stdoutConsumerQueue = yield* Queue.bounded<string>(options.requestedCapacity);
-        const stderrConsumerQueue = yield* Queue.bounded<string>(options.requestedCapacity);
+        const capacity = options.requestedCapacity;
+        const stdoutConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stdoutCapacity
+        );
+        const stderrConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stderrCapacity
+        );
         const stdinProducerQueue = yield* Queue.bounded<
             Either.Either<Chunk.Chunk<Uint8Array | string | Socket.CloseEvent>, Exit.Exit<void, IE>>
-        >(options.requestedCapacity);
+        >(typeof capacity === "number" ? capacity : capacity.stdinCapacity);
 
         // We MUST only touch the underlying once!!! Very important!!!
         // Demux everything to and fro the correct places. We can touch

package/src/internal/demux/hijack.ts

@@ -1,10 +1,10 @@
 import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
 import type * as MobyDemux from "../../MobyDemux.js";
-import type { IExposeSocketOnEffectClientResponseHack } from "../platforms/node.js";
 
 import * as Socket from "@effect/platform/Socket";
 import * as Effect from "effect/Effect";
 
+import type { IExposeSocketOnEffectClientResponseHack } from "../platforms/node.js";
 import { makeMultiplexedSocket, responseIsMultiplexedResponse } from "./multiplexed.js";
 import { makeRawSocket, responseIsRawResponse } from "./raw.js";
 

package/src/internal/demux/multiplexed.ts

@@ -75,11 +75,14 @@ export const responseIsMultiplexedResponse = (response: HttpClientResponse.HttpC
     response.headers["content-type"] === MultiplexedContentType;
 
 /** @internal */
-export enum MultiplexedHeaderType {
-    Stdin = 0,
-    Stdout = 1,
-    Stderr = 2,
-}
+export const MultiplexedHeaderType = {
+    Stdin: 0,
+    Stdout: 1,
+    Stderr: 2,
+} as const;
+
+/** @internal */
+export type MultiplexedHeaderType = (typeof MultiplexedHeaderType)[keyof typeof MultiplexedHeaderType];
 
 /** @internal */
 export type MultiplexedAccumulator = {

package/src/internal/demux/pack.ts

@@ -31,8 +31,14 @@ export const pack = Function.dual<
         R2 = never,
         R3 = never,
     >(options: {
-        requestedCapacity: number;
-        encoding?: string | undefined;
+        readonly requestedCapacity:
+            | number
+            | {
+                  readonly stdinCapacity: number;
+                  readonly stdoutCapacity: number;
+                  readonly stderrCapacity: number;
+              };
+        readonly encoding?: string | undefined;
     }) => (
         stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>
     ) => Effect.Effect<
@@ -52,7 +58,16 @@ export const pack = Function.dual<
         R3 = never,
     >(
         stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) => Effect.Effect<
         MobyDemux.MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
         never,
@@ -72,7 +87,16 @@ export const pack = Function.dual<
         R3 = never,
     >(
         stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
-        options: { requestedCapacity: number; encoding?: string | undefined }
+        options: {
+            readonly requestedCapacity:
+                | number
+                | {
+                      readonly stdinCapacity: number;
+                      readonly stdoutCapacity: number;
+                      readonly stderrCapacity: number;
+                  };
+            readonly encoding?: string | undefined;
+        }
     ) {
         const mutex = yield* Effect.makeSemaphore(1);
         const context = yield* Effect.context<
@@ -81,10 +105,15 @@ export const pack = Function.dual<
 
         const capacity = options.requestedCapacity;
         type CanReceive = Uint8Array | string | Socket.CloseEvent;
-        const stdoutConsumerQueue = yield* Queue.bounded<string>(capacity);
-        const stderrConsumerQueue = yield* Queue.bounded<string>(capacity);
-        const stdinProducerQueue =
-            yield* Queue.bounded<Either.Either<Chunk.Chunk<CanReceive>, Exit.Exit<void, IE1>>>(capacity);
+        const stdoutConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stdoutCapacity
+        );
+        const stderrConsumerQueue = yield* Queue.bounded<string>(
+            typeof capacity === "number" ? capacity : capacity.stderrCapacity
+        );
+        const stdinProducerQueue = yield* Queue.bounded<Either.Either<Chunk.Chunk<CanReceive>, Exit.Exit<void, IE1>>>(
+            typeof capacity === "number" ? capacity : capacity.stdinCapacity
+        );
 
         // Demux everything to and fro the correct places. We can touch
         // this more than once because it is wrapped in the mutex.

package/src/internal/demux/stdio.ts

@@ -1,3 +1,4 @@
+import type * as PlatformError from "@effect/platform/Error";
 import type * as Socket from "@effect/platform/Socket";
 import type * as Channel from "effect/Channel";
 import type * as Chunk from "effect/Chunk";
@@ -7,39 +8,16 @@ import type * as Stream from "effect/Stream";
 import type * as MobyDemux from "../../MobyDemux.js";
 
 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 { asMultiplexedChannel, demuxMultiplexedToSeparateSinks, 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 }> {}
-
 /** @internal */
 export const demuxFromStdinToStdoutAndStderr = <IE = never, OE = Socket.SocketError, R = never>(
     sockets: MobyDemux.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.Effect<void, IE | OE | PlatformError.PlatformError | ParseResult.ParseError, Exclude<R, Scope.Scope>> =>
     Effect.flatMap(
         Effect.all(
             {
@@ -49,35 +27,26 @@ export const demuxFromStdinToStdoutAndStderr = <IE = never, OE = Socket.SocketEr
             { 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>(
+            const multiplexedChannel = makeMultiplexedChannel<IE, IE | OE, R>(
                 underlying as Channel.Channel<
                     Chunk.Chunk<Uint8Array>,
                     Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
-                    IE | OE | StdinError,
-                    IE | StdinError,
+                    OE,
+                    IE,
                     void,
                     unknown,
                     R
                 >
             );
 
-            return demuxMultiplexedToSeparateSinks(multiplexedChannel, stdin, stdout, stderr, options);
+            return demuxMultiplexedToSeparateSinks(
+                multiplexedChannel,
+                NodeStreamLazy.stdin,
+                NodeSinkLazy.stdout,
+                NodeSinkLazy.stderr,
+                options
+            );
         }
     );
 

package/src/internal/endpoints/circular.ts

@@ -0,0 +1,42 @@
+import type * as DockerEngine from "../../DockerEngine.ts";
+
+import * as PlatformError from "@effect/platform/Error";
+import * as Predicate from "effect/Predicate";
+
+/** @internal */
+export const DockerErrorTypeId: DockerEngine.DockerErrorTypeId = Symbol.for(
+    "@the-moby-effect/engines/Docker/DockerError"
+) as DockerEngine.DockerErrorTypeId;
+
+/** @internal */
+export const isDockerError = (u: unknown): u is DockerError => Predicate.hasProperty(u, DockerErrorTypeId);
+
+/** @internal */
+export class DockerError extends PlatformError.TypeIdError(DockerErrorTypeId, "DockerError")<{
+    module:
+        | "configs"
+        | "containers"
+        | "distributions"
+        | "execs"
+        | "images"
+        | "networks"
+        | "nodes"
+        | "plugins"
+        | "secrets"
+        | "services"
+        | "session"
+        | "swarm"
+        | "system"
+        | "tasks"
+        | "volumes";
+    method: string;
+    cause: unknown;
+}> {
+    public override get message() {
+        return `When calling ${this.method} in ${this.module}`;
+    }
+
+    public static WrapForModule(module: DockerError["module"]) {
+        return (method: string) => (cause: unknown) => new this({ module, method, cause });
+    }
+}