the-moby-effect 1.51.0 → 1.51.1

package/src/internal/generated/ContainerDefaultNetworkSettings.generated.ts

@@ -5,14 +5,14 @@ export class ContainerDefaultNetworkSettings extends Schema.Class<ContainerDefau
     "ContainerDefaultNetworkSettings"
 )(
     {
-        EndpointID: Schema.String,
-        Gateway: Schema.String,
-        GlobalIPv6Address: Schema.String,
-        GlobalIPv6PrefixLen: EffectSchemas.Number.I64,
-        IPAddress: Schema.String,
-        IPPrefixLen: EffectSchemas.Number.I64,
-        IPv6Gateway: Schema.String,
-        MacAddress: Schema.String,
+        EndpointID: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        Gateway: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        GlobalIPv6Address: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        GlobalIPv6PrefixLen: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
+        IPAddress: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        IPPrefixLen: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
+        IPv6Gateway: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        MacAddress: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
     },
     {
         identifier: "ContainerDefaultNetworkSettings",

package/src/internal/generated/ContainerNetworkSettingsBase.generated.ts

@@ -7,15 +7,15 @@ export class ContainerNetworkSettingsBase extends Schema.Class<ContainerNetworkS
     "ContainerNetworkSettingsBase"
 )(
     {
-        Bridge: Schema.String,
+        Bridge: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
         SandboxID: Schema.String,
         SandboxKey: Schema.String,
         Ports: Schema.NullOr(PortSchemas.PortMap),
-        HairpinMode: Schema.Boolean,
-        LinkLocalIPv6Address: Schema.String,
-        LinkLocalIPv6PrefixLen: EffectSchemas.Number.I64,
-        SecondaryIPAddresses: Schema.NullOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress))),
-        SecondaryIPv6Addresses: Schema.NullOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress))),
+        HairpinMode: Schema.optional(Schema.Boolean), // optional for docker.io/library/docker:26-dind-rootless
+        LinkLocalIPv6Address: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        LinkLocalIPv6PrefixLen: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
+        SecondaryIPAddresses: Schema.NullishOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress))), // optional for docker.io/library/docker:26-dind-rootless
+        SecondaryIPv6Addresses: Schema.NullishOr(Schema.Array(Schema.NullOr(NetworkAddress.NetworkAddress))), // optional for docker.io/library/docker:26-dind-rootless
     },
     {
         identifier: "ContainerNetworkSettingsBase",

package/src/internal/generated/ImageInspectResponse.generated.ts

@@ -14,13 +14,13 @@ export class ImageInspectResponse extends Schema.Class<ImageInspectResponse>("Im
         Id: Schema.String,
         RepoTags: Schema.NullOr(Schema.Array(Schema.String)),
         RepoDigests: Schema.NullOr(Schema.Array(MobyIdentifiers.Digest)),
-        Parent: Schema.String,
+        Parent: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
         Comment: Schema.String,
         Created: Schema.optional(Schema.String),
         Container: Schema.optional(Schema.String),
         ContainerConfig: Schema.optionalWith(ContainerConfig.ContainerConfig, { nullable: true }),
-        DockerVersion: Schema.String,
-        Author: Schema.String,
+        DockerVersion: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
+        Author: Schema.optional(Schema.String), // optional for docker.io/library/docker:26-dind-rootless
         Config: Schema.NullOr(V1DockerOCIImageConfig.V1DockerOCIImageConfig),
         Architecture: Schema.String,
         Variant: Schema.optional(Schema.String),
@@ -28,7 +28,7 @@ export class ImageInspectResponse extends Schema.Class<ImageInspectResponse>("Im
         OsVersion: Schema.optional(Schema.String),
         Size: EffectSchemas.Number.I64,
         VirtualSize: Schema.optional(EffectSchemas.Number.I64),
-        GraphDriver: Schema.NullOr(StorageDriverData.StorageDriverData),
+        GraphDriver: Schema.NullishOr(StorageDriverData.StorageDriverData), // optional for docker.io/library/docker:26-dind-rootless
         RootFS: Schema.NullOr(ImageRootFS.ImageRootFS),
         Metadata: Schema.NullOr(ImageMetadata.ImageMetadata),
         Descriptor: Schema.optionalWith(V1Descriptor.V1Descriptor, { nullable: true }),

package/src/internal/generated/NetworkCreateOptions.generated.ts

@@ -4,18 +4,18 @@ import * as NetworkIPAM from "./NetworkIPAM.generated.js";
 
 export class NetworkCreateOptions extends Schema.Class<NetworkCreateOptions>("NetworkCreateOptions")(
     {
-        Driver: Schema.String,
-        Scope: Schema.String,
+        Driver: Schema.String.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => "bridge")),
+        Scope: Schema.optionalWith(Schema.String, { nullable: true }),
         EnableIPv4: Schema.optionalWith(Schema.Boolean, { nullable: true }),
         EnableIPv6: Schema.optionalWith(Schema.Boolean, { nullable: true }),
-        IPAM: Schema.NullOr(NetworkIPAM.NetworkIPAM),
-        Internal: Schema.Boolean,
-        Attachable: Schema.Boolean,
-        Ingress: Schema.Boolean,
-        ConfigOnly: Schema.Boolean,
-        ConfigFrom: Schema.NullOr(NetworkConfigReference.NetworkConfigReference),
-        Options: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
-        Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
+        IPAM: Schema.optionalWith(NetworkIPAM.NetworkIPAM, { nullable: true }),
+        Internal: Schema.optionalWith(Schema.Boolean, { nullable: true }),
+        Attachable: Schema.optionalWith(Schema.Boolean, { nullable: true }),
+        Ingress: Schema.optionalWith(Schema.Boolean, { nullable: true }),
+        ConfigOnly: Schema.Boolean.pipe(Schema.propertySignature).pipe(Schema.withConstructorDefault(() => false)),
+        ConfigFrom: Schema.optionalWith(NetworkConfigReference.NetworkConfigReference, { nullable: true }),
+        Options: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
+        Labels: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.String }), { nullable: true }),
     },
     {
         identifier: "NetworkCreateOptions",

package/src/internal/generated/NetworkInspect.generated.ts

@@ -12,7 +12,7 @@ export class NetworkInspect extends Schema.Class<NetworkInspect>("NetworkInspect
         Created: Schema.NullOr(Schema.DateFromString),
         Scope: Schema.String,
         Driver: Schema.String,
-        EnableIPv4: Schema.Boolean,
+        EnableIPv4: Schema.optional(Schema.Boolean), // optional for docker.io/library/docker:27-dind-rootless
         EnableIPv6: Schema.Boolean,
         IPAM: Schema.NullOr(NetworkIPAM.NetworkIPAM),
         Internal: Schema.Boolean,
@@ -20,8 +20,8 @@ export class NetworkInspect extends Schema.Class<NetworkInspect>("NetworkInspect
         Ingress: Schema.Boolean,
         ConfigFrom: Schema.NullOr(NetworkConfigReference.NetworkConfigReference),
         ConfigOnly: Schema.Boolean,
-        Containers: Schema.NullOr(
-            Schema.Record({ key: Schema.String, value: Schema.NullOr(NetworkEndpointResource.NetworkEndpointResource) })
+        Containers: Schema.NullishOr(
+            Schema.Record({ key: Schema.String, value: Schema.NullOr(NetworkEndpointResource.NetworkEndpointResource) }) // optional for docker.io/library/docker:26-dind-rootless
         ),
         Options: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),
         Labels: Schema.NullOr(Schema.Record({ key: Schema.String, value: Schema.String })),

package/src/internal/generated/TypesDiskUsage.generated.ts

@@ -7,7 +7,7 @@ import * as VolumeVolume from "./VolumeVolume.generated.js";
 
 export class TypesDiskUsage extends Schema.Class<TypesDiskUsage>("TypesDiskUsage")(
     {
-        LayersSize: EffectSchemas.Number.I64,
+        LayersSize: Schema.optional(EffectSchemas.Number.I64), // optional for docker.io/library/docker:26-dind-rootless
         Images: Schema.NullOr(Schema.Array(Schema.NullOr(ImageSummary.ImageSummary))),
         Containers: Schema.NullOr(Schema.Array(Schema.NullOr(ContainerSummary.ContainerSummary))),
         Volumes: Schema.NullOr(Schema.Array(Schema.NullOr(VolumeVolume.VolumeVolume))),

package/src/internal/platforms/undici.ts

@@ -13,104 +13,135 @@ import * as internalAgnostic from "./agnostic.js";
 import * as internalConnection from "./connection.js";
 
 /** @internal */
-export const makeUndiciSshConnector = (
+export const makeDispatcher: (
+    agentOptions?: undici.Agent.Options | undefined
+) => Effect.Effect<undici.Agent, never, Scope.Scope> = Effect.fnUntraced(function* (
+    agentOptions?: undici.Agent.Options | undefined
+) {
+    const undiciLazy = yield* Effect.promise(() => import("undici"));
+    const acquire = Effect.sync(() => new undiciLazy.Agent(agentOptions));
+    const release = (agent: undici.Dispatcher) => Effect.promise(() => agent.destroy());
+    const resource = Effect.acquireRelease(acquire, release);
+    return yield* resource;
+});
+
+/** @internal */
+export const makeSshDispatcher: (
     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.Effect<undici.Agent, never, Scope.Scope> = Effect.fnUntraced(function* (
+    connectionOptions: MobyConnection.SshConnectionOptions
+) {
+    const ssh2Lazy = yield* Effect.promise(() => import("ssh2"));
+    const undiciLazy = yield* Effect.promise(() => import("undici"));
+    const sshClient = new ssh2Lazy.Client();
+
+    let sshConnection: "unopened" | "connecting" | "open-failed" | "ready" = "unopened";
+    let openFailedError: Error | null = null;
+
+    const connector: undici.buildConnector.connector = (
+        _options: undici.buildConnector.Options,
+        callback: undici.buildConnector.Callback
+    ) => {
+        const onError = (error: Error): void => callback(error, null);
+
+        // No connection yet, start connecting
+        if (sshConnection === "unopened") {
+            sshConnection = "connecting";
+            const unableToOpen = (error: Error & ssh2.ClientErrorExtensions) => {
+                sshConnection = "open-failed";
+                openFailedError = error;
+                onError(error);
+            };
+            sshClient
+                .once("ready", () => {
+                    sshConnection = "ready";
+                    sshClient.off("error", unableToOpen);
+                    connector(_options, callback);
                 })
-        ),
-        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);
+                .once("error", unableToOpen)
+                .connect(connectionOptions);
+        }
+
+        // Already tried to connect but failed
+        else if (sshConnection === "open-failed") {
+            callback(openFailedError!, null);
+        }
+
+        // Another connection attempt is already in progress, wait for it
+        else if (sshConnection === "connecting") {
+            sshClient
+                .once("ready", () => {
+                    sshClient.off("error", onError);
+                    connector(_options, callback);
+                })
+                .once("error", onError);
+        }
+
+        // We are connected to the ssh server, now forward our stream local
+        else if (sshConnection === "ready") {
+            sshClient
+                .openssh_forwardOutStreamLocal(
+                    connectionOptions.remoteSocketPath,
+                    (error: Error | undefined, stream: ssh2.ClientChannel) => {
+                        sshClient.off("error", onError);
+                        if (error) return callback(error, null);
+                        else return callback(null, stream as unknown as net.Socket);
                     }
+                )
+                .once("error", onError);
+        }
 
-                    socket.once("close", () => {
-                        socket.end();
-                        socket.destroy();
-                    });
+        // Should never happen
+        else {
+            return Function.absurd<undefined>(sshConnection);
+        }
+    };
 
-                    return callback(null, socket as unknown as net.Socket);
-                }
-            );
-        }),
-        Effect.orDie
-    );
+    const acquire = Effect.sync(() => new undiciLazy.Agent({ connect: connector }));
+    const release = (_agent: undici.Dispatcher) =>
+        Effect.promise(async () => {
+            sshClient.end();
+            sshClient.destroy();
+            // await agent.close();
+            // await agent.destroy();
+        });
+
+    const resource = Effect.acquireRelease(acquire, release);
+    return yield* resource;
+});
 
 /** @internal */
-export const getUndiciDispatcher = (
+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);
-        }
-    );
+) => Effect.Effect<undici.Dispatcher, never, Scope.Scope> = internalConnection.MobyConnectionOptions.$match({
+    ssh: (options) => makeSshDispatcher(options),
+    socket: (options) =>
+        makeDispatcher({
+            connect: {
+                socketPath: options.socketPath,
+            },
+        }),
+    http: (options) =>
+        makeDispatcher({
+            connect: {
+                host: options.host,
+                port: options.port,
+                path: options.path,
+            },
+        }),
+    https: (options) =>
+        makeDispatcher({
+            connect: {
+                ca: options.ca,
+                key: options.key,
+                cert: options.cert,
+                passphrase: options.passphrase,
+                host: options.host,
+                port: options.port,
+                path: options.path,
+            },
+        }),
+});
 
 /** @internal */
 export const getUndiciWebsocketConstructor = (

package/src/internal/schemas/id.ts

@@ -145,7 +145,7 @@ export type VolumeIdentifier = Schema.Schema.Type<typeof VolumeIdentifier>;
  */
 export const Digest = Function.pipe(
     Schema.String,
-    Schema.pattern(/^[a-z0-9]+(?:[.+_-][a-z0-9]+)*:[a-zA-Z0-9=_-]+$/),
+    Schema.pattern(/^[a-z0-9]+(?:[@.+_-][a-z0-9]+)*:[a-zA-Z0-9=_-]+$/),
     Schema.brand("Digest")
 );