@lakutata/docker 3.0.0-beta.0

package/dist/esm/docker/lib/DockerContainerTTY.js

@@ -0,0 +1,154 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Provider, DTO } from '@lakutata/core';
+import { Configurable, Transient } from '@lakutata/core/decorator/di';
+import { ContainerTTYConsoleSizeOptions } from '../options/container/ContainerTTYConsoleSizeOptions.js';
+import { Accept } from '@lakutata/core/decorator/dto';
+/**
+ * An interactive command running with a TTY in a container, as `docker exec -it`: what is written to it is the
+ * command's input, its output (stdout and stderr together, with the terminal's control sequences) is read from it. It is
+ * not created with `new`: {@link DockerContainer.createTTY} returns it, its command started.
+ *
+ * The command runs until it exits (`exit` written to a shell), or until the stream is closed (`tty.raw.end()`,
+ * `tty.raw.destroy()`); the stream then ends. A command which cannot be started (not found in the image) does not fail
+ * the creation: its error message is the output, then the stream ends. The write failures are logged by the
+ * application's `log` component, else by the console.
+ * @example
+ * ```typescript
+ * import {type DockerContainer, type DockerContainerTTY} from 'lakutata/com/docker'
+ *
+ * declare const container: DockerContainer
+ *
+ * //A shell: /bin/sh by default
+ * const tty: DockerContainerTTY = await container.createTTY({consoleSize: {cols: 120, rows: 40}})
+ * tty.onData((chunk: Buffer): void => {
+ *     process.stdout.write(chunk)
+ * })
+ * tty.raw.once('end', (): void => console.log('The shell exited'))
+ * tty.write('ls -l /\n')
+ * await tty.resize({cols: 160, rows: 50})
+ * tty.write('exit\n')
+ * ```
+ */
+let DockerContainerTTY = class DockerContainerTTY extends Provider {
+    #execId;
+    #duplexStream;
+    /**
+     * The logger of the write failures: the application's log component, else the console
+     */
+    #log;
+    /**
+     * Create the execution of the command and start it, attached to its TTY.
+     * @throws {DockerContainerNotFoundException} When the container was removed.
+     * @throws {DockerRequestException} When the container is not running (HTTP 409).
+     * @protected
+     */
+    async init() {
+        try {
+            this.#log = await this.getObject('log');
+        }
+        catch {
+            //An application without a log component
+            this.#log = console;
+        }
+        const exec = await this.getClient().createExec(this.containerId, {
+            AttachStderr: true,
+            AttachStdin: true,
+            AttachStdout: true,
+            Cmd: this.cmd ? Array.isArray(this.cmd) ? this.cmd : [this.cmd] : undefined,
+            Tty: true,
+            ConsoleSize: [this.initialConsoleSize?.rows ? this.initialConsoleSize.rows : 0, this.initialConsoleSize?.cols ? this.initialConsoleSize.cols : 0]
+        });
+        this.#execId = exec.Id;
+        //Started with its TTY: its output is not multiplexed
+        this.#duplexStream = await this.getClient().startExec(this.#execId, { Detach: false, Tty: true });
+    }
+    /**
+     * Close the stream of the TTY, which ends the command's input.
+     * @protected
+     */
+    async destroy() {
+        //Not created when its execution failed to start
+        if (this.#duplexStream && !this.#duplexStream.destroyed) {
+            this.#duplexStream.removeAllListeners();
+            this.#duplexStream.destroy();
+        }
+    }
+    /**
+     * The stream of the TTY, both ways: written, the command's input; read, its output. Its `end` event tells that the
+     * command exited, once its output is read (with {@link DockerContainerTTY.onData} or a `data` listener).
+     */
+    get raw() {
+        return this.#duplexStream;
+    }
+    /**
+     * The stream of the TTY, typed as its writable side: the command's input.
+     */
+    get writable() {
+        return this.#duplexStream;
+    }
+    /**
+     * The stream of the TTY, typed as its readable side: the command's output.
+     */
+    get readable() {
+        return this.#duplexStream;
+    }
+    /**
+     * Change the size of the TTY's console, as a terminal window resized does (the command gets `SIGWINCH`).
+     * @param options The number of columns (`cols`) and rows (`rows`).
+     * @throws {DockerRequestException} When the command has exited (HTTP 404, no such exec; HTTP 500).
+     * @throws {DockerContainerNotFoundException} When the container was removed.
+     */
+    async resize(options) {
+        await this.getClient().resizeExec(this.#execId, {
+            w: options.cols,
+            h: options.rows
+        });
+    }
+    /**
+     * Receive the command's output as it comes. Each call adds a handler.
+     * @param handler Called with each chunk of the output: raw bytes, the terminal's control sequences included.
+     */
+    onData(handler) {
+        this.#duplexStream.on('data', handler);
+    }
+    write(data) {
+        this.#duplexStream.write(data, (error) => {
+            if (error)
+                this.#log.warn('Write data to duplex stream error: %s', error.message);
+        });
+    }
+};
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], DockerContainerTTY.prototype, "getClient", void 0);
+__decorate([
+    Configurable(DTO.String()),
+    __metadata("design:type", String)
+], DockerContainerTTY.prototype, "containerId", void 0);
+__decorate([
+    Configurable(DTO.Alternatives(DTO.String(), DTO.Array(DTO.String()).min(1))),
+    __metadata("design:type", Object)
+], DockerContainerTTY.prototype, "cmd", void 0);
+__decorate([
+    Configurable(ContainerTTYConsoleSizeOptions.optional()),
+    __metadata("design:type", ContainerTTYConsoleSizeOptions)
+], DockerContainerTTY.prototype, "initialConsoleSize", void 0);
+__decorate([
+    Accept(ContainerTTYConsoleSizeOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ContainerTTYConsoleSizeOptions]),
+    __metadata("design:returntype", Promise)
+], DockerContainerTTY.prototype, "resize", null);
+DockerContainerTTY = __decorate([
+    Transient()
+], DockerContainerTTY);
+export { DockerContainerTTY };

package/dist/esm/docker/lib/DockerImage.js

@@ -0,0 +1,270 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Provider, DTO } from '@lakutata/core';
+import { Transient, Configurable } from '@lakutata/core/decorator/di';
+import { followProgress } from '../../client/DockerStreams.js';
+import { Time } from '@lakutata/utils/Time';
+import { ImageTagOptions } from '../options/image/ImageTagOptions.js';
+import { Accept } from '@lakutata/core/decorator/dto';
+import { ImageExportOptions } from '../options/image/ImageExportOptions.js';
+import { createWriteStream } from 'node:fs';
+import { pipeline } from 'stream/promises';
+import { DockerImageRepoTagNotFoundException } from '../exceptions/DockerImageRepoTagNotFoundException.js';
+import { ImageRemoveOptions } from '../options/image/ImageRemoveOptions.js';
+import { ImagePushOptions } from '../options/image/ImagePushOptions.js';
+import { DockerImagePushException } from '../exceptions/DockerImagePushException.js';
+import { isAbortError, As } from '@lakutata/utils';
+import { parseRepositoryTag } from './ParseRepositoryTag.js';
+import { parseEnvToRecord } from './ParseEnvToRecord.js';
+import { ContainerSettingOptions } from '../options/container/ContainerSettingOptions.js';
+import { registryAuth } from './RegistryAuth.js';
+/**
+ * An image of the Docker daemon, with its tags, platform, size and configuration as inspected, and its operations: tag,
+ * export, push, remove, and run a container. It is not created with `new`: {@link Docker.getImage},
+ * {@link Docker.listImages}, {@link Docker.pullImage}, {@link Docker.buildImage}, {@link Docker.importImage} and
+ * {@link DockerContainer.commit} return it.
+ *
+ * Its properties are a snapshot, taken when it is obtained and refreshed by `tag()` and `push()`. Its operations reject
+ * with {@link DockerImageNotFoundException} when the image was removed, with {@link DockerRequestException} when the
+ * daemon refuses them otherwise (used by a container: HTTP 409), and with the network error of Node.js when the daemon
+ * cannot be reached.
+ * @example
+ * ```typescript
+ * import {type Docker, type DockerContainer, type DockerImage} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image: DockerImage = await docker.buildImage({workdir: '/srv/app', files: ['Dockerfile', 'src', 'package.json'], repoTag: 'app:1.0.0'})
+ * console.log(image.id, image.platform, image.size, image.config.ports)
+ * await image.tag({repo: 'registry.example.com/team/app', tag: '1.0.0'})
+ * await image.push({
+ *     repo: 'registry.example.com/team/app',
+ *     tag: '1.0.0',
+ *     auth: {serverAddress: 'registry.example.com', username: 'ci', password: 'secret'}
+ * })
+ * await image.export({destination: '/tmp/app-1.0.0.tar', repoTag: 'app:1.0.0'})
+ * const container: DockerContainer = await image.run({name: 'app', ports: [{port: 3000, type: 'tcp', hostPorts: [3000]}]})
+ * console.log(container.state.status)
+ * ```
+ */
+let DockerImage = class DockerImage extends Provider {
+    #abortController = new AbortController();
+    /**
+     * Inspect the image.
+     * @throws {DockerImageNotFoundException} When the image does not exist.
+     * @protected
+     */
+    async init() {
+        await this.syncImageInfo();
+    }
+    /**
+     * Abort the export in progress of the object (the image itself is left as it is).
+     * @protected
+     */
+    async destroy() {
+        this.#abortController.abort();
+    }
+    /**
+     * Refresh the properties from the daemon's inspection of the image.
+     * @throws {DockerImageNotFoundException} When the image does not exist.
+     * @protected
+     */
+    async syncImageInfo() {
+        const inspectInfo = await this.getClient().inspectImage(this.id);
+        this.repoTags = inspectInfo.RepoTags;
+        this.createdAt = new Time(inspectInfo.Created);
+        this.arch = inspectInfo.Architecture;
+        this.os = inspectInfo.Os;
+        this.platform = `${this.os}/${this.arch}`;
+        this.size = inspectInfo.Size;
+        const exposePorts = [];
+        const exposePortMap = new Map();
+        if (inspectInfo.Config.ExposedPorts) {
+            Object.keys(inspectInfo.Config.ExposedPorts).forEach((portWithType) => {
+                const portInfos = portWithType.split('/');
+                const port = parseInt(portInfos[0]);
+                const type = As(portInfos[1].toLowerCase());
+                if (!exposePortMap.has(port))
+                    exposePortMap.set(port, { tcp: false, udp: false });
+                const portType = exposePortMap.get(port);
+                portType[type] = true;
+                exposePortMap.set(port, portType);
+            });
+            exposePortMap.forEach((portType, port) => exposePorts.push({ port: port, ...portType }));
+        }
+        this.config = {
+            hostname: inspectInfo.Config.Hostname,
+            user: inspectInfo.Config.User,
+            env: parseEnvToRecord(inspectInfo.Config.Env),
+            cmd: inspectInfo.Config.Cmd,
+            entrypoint: inspectInfo.Config.Entrypoint
+                ? Array.isArray(inspectInfo.Config.Entrypoint)
+                    ? inspectInfo.Config.Entrypoint
+                    : [inspectInfo.Config.Entrypoint]
+                : [],
+            volumes: inspectInfo.Config.Volumes ? Object.keys(inspectInfo.Config.Volumes) : [],
+            ports: exposePorts
+        };
+    }
+    /**
+     * Add a tag to the image, as `docker tag`, then refresh its properties. A tag already given to another image moves to
+     * this one.
+     * @param options The repository (`registry.example.com/team/app`) and the tag (`latest` by default).
+     * @throws {DockerImageNotFoundException} When the image was removed.
+     * @throws {DockerRequestException} When the name is invalid (HTTP 400).
+     */
+    async tag(options) {
+        try {
+            await this.getClient().tagImage(this.id, { repo: options.repo, tag: options.tag });
+            await this.syncImageInfo();
+        }
+        catch (e) {
+            if (!isAbortError(e))
+                throw e;
+        }
+    }
+    /**
+     * Save the image as a tar archive, as `docker save`, which {@link Docker.importImage} loads. With `repoTag`, the
+     * archive holds that tag (restored when it is loaded); without it, the image is saved by ID, without its tags.
+     * @param options The `destination` (a file path, created or overwritten, or a writable stream, ended after the
+     * archive), the tag saved (`repoTag`), and `createRepoTagIfNotExists` (`true` by default) to add that tag to the image
+     * when it does not have it.
+     * @throws {DockerImageRepoTagNotFoundException} When the image does not have `repoTag` and
+     * `createRepoTagIfNotExists` is `false`.
+     * @throws {DockerImageNotFoundException} When the image was removed.
+     * @throws {Error} The error of the destination.
+     */
+    async export(options) {
+        try {
+            let name = this.id;
+            if (options.repoTag) {
+                if (!this.repoTags.includes(options.repoTag)) {
+                    if (!options.createRepoTagIfNotExists)
+                        throw new DockerImageRepoTagNotFoundException('The current image does not contain the RepoTag of {0}', [options.repoTag]);
+                    const { repo, tag } = parseRepositoryTag(options.repoTag);
+                    await this.tag({ repo: repo, tag: tag });
+                }
+                name = options.repoTag;
+            }
+            const readableStream = await this.getClient().exportImage(name);
+            const destStream = typeof options.destination === 'string'
+                ? createWriteStream(options.destination, { signal: this.#abortController.signal })
+                : options.destination;
+            await pipeline(readableStream, destStream);
+        }
+        catch (e) {
+            if (!isAbortError(e))
+                throw e;
+        }
+    }
+    /**
+     * Push the image to its registry, as `docker push`, and wait for its end. The image is first tagged `repo:tag` (the
+     * tag is kept afterwards).
+     * @param options The repository, with its registry (`registry.example.com/team/app`); the tag (`latest` by default);
+     * the registry credentials; and a callback receiving each progress message.
+     * @throws {DockerImagePushException} When the registry refuses the push (refused credentials, a repository not
+     * found).
+     * @throws {DockerImageNotFoundException} When the image was removed.
+     * @throws {DockerRequestException} When the daemon refuses to push it.
+     */
+    async push(options) {
+        const tag = options.tag ? options.tag : 'latest';
+        await this.tag({ repo: options.repo, tag: tag });
+        await this.syncImageInfo();
+        let pushException;
+        const readableStream = await this.getClient().pushImage(options.repo, { tag: tag }, registryAuth(options.auth));
+        await followProgress(readableStream, (outputObject) => {
+            if (outputObject.error && !pushException)
+                pushException = new DockerImagePushException(outputObject.error);
+            if (options.outputCallback)
+                options.outputCallback(outputObject);
+        });
+        if (pushException)
+            throw pushException;
+    }
+    /**
+     * Remove the image, as `docker rmi -f` by default: forced, it is removed with all its tags, even when a stopped
+     * container uses it.
+     * @param options `force` (`true` by default; `false` refuses an image with several tags or used by a container) and
+     * `noprune` (keeps its untagged parent images; `false` by default).
+     * @throws {DockerImageNotFoundException} When the image was already removed.
+     * @throws {DockerRequestException} When it is used by a running container or, without `force`, by any container or
+     * with several tags (HTTP 409).
+     */
+    async remove(options) {
+        try {
+            await this.getClient().removeImage(this.id, { force: options?.force, noprune: options?.noprune });
+        }
+        catch (e) {
+            if (!isAbortError(e))
+                throw e;
+        }
+    }
+    /**
+     * Create a container from the image, for its platform, then start it, as `docker run -d`.
+     * @param options The container's settings: name, command, environment, ports, binds, devices, networks, limits…
+     * @returns The container, started.
+     * @throws {DockerRequestException} When the name is already used (HTTP 409), or the start fails (HTTP 500: a command
+     * not found, a port already used); the container then stays created.
+     * @throws {DockerNetworkNotFoundException} When a network of the settings is not found.
+     * @throws {InvalidMethodAcceptException} When the settings are invalid.
+     */
+    async run(options) {
+        const container = await this.getDocker().createContainer(this.id, this.platform, options);
+        await container.start();
+        return container;
+    }
+};
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], DockerImage.prototype, "getClient", void 0);
+__decorate([
+    Configurable(DTO.Function()),
+    __metadata("design:type", Function)
+], DockerImage.prototype, "getDocker", void 0);
+__decorate([
+    Configurable(DTO.String()),
+    __metadata("design:type", String)
+], DockerImage.prototype, "id", void 0);
+__decorate([
+    Accept(ImageTagOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageTagOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "tag", null);
+__decorate([
+    Accept(ImageExportOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageExportOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "export", null);
+__decorate([
+    Accept(ImagePushOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImagePushOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "push", null);
+__decorate([
+    Accept(ImageRemoveOptions.optional().default({ force: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageRemoveOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "remove", null);
+__decorate([
+    Accept(ContainerSettingOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ContainerSettingOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "run", null);
+DockerImage = __decorate([
+    Transient()
+], DockerImage);
+export { DockerImage };

package/dist/esm/docker/lib/EngineSettings.js

@@ -0,0 +1,78 @@
+/**
+ * The networks Docker creates itself: the addresses of their endpoints cannot be set
+ */
+const RESERVED_NETWORKS = ['bridge', 'host', 'none'];
+/**
+ * The restart policy of the Engine API: "on-failure:3" is the policy on-failure with 3 retries at most
+ * @param restartPolicy
+ */
+export function engineRestartPolicy(restartPolicy) {
+    const [name, retries] = restartPolicy.split(':');
+    return retries === undefined ? { Name: name } : { Name: name, MaximumRetryCount: Number.parseInt(retries, 10) };
+}
+/**
+ * The restart policy of a container, from the one of the Engine API
+ * @param restartPolicy
+ */
+export function parseRestartPolicy(restartPolicy) {
+    if (!restartPolicy?.Name)
+        return '';
+    if (restartPolicy.Name === 'on-failure' && restartPolicy.MaximumRetryCount)
+        return `on-failure:${restartPolicy.MaximumRetryCount}`;
+    return restartPolicy.Name;
+}
+/**
+ * The port bindings of the Engine API ("80/tcp": [{HostPort: "8080"}]): each host port once, null for a port published
+ * on no host port
+ * @param ports
+ */
+export function enginePortBindings(ports) {
+    const hostPortsMap = new Map();
+    for (const port of ports) {
+        const key = `${port.port}/${port.type}`;
+        const hostPorts = hostPortsMap.get(key) ?? new Set();
+        port.hostPorts?.forEach((hostPort) => hostPorts.add(hostPort));
+        hostPortsMap.set(key, hostPorts);
+    }
+    const portBindings = {};
+    hostPortsMap.forEach((hostPorts, key) => {
+        portBindings[key] = hostPorts.size ? [...hostPorts].map((hostPort) => ({ HostPort: hostPort.toString() })) : null;
+    });
+    return portBindings;
+}
+/**
+ * The bind mounts of the Engine API ("hostPath:containerPath:rw")
+ * @param binds
+ */
+export function engineBinds(binds) {
+    return binds.map((bind) => `${bind.hostPath}:${bind.containerPath}:${bind.rw ? 'rw' : 'ro'}`);
+}
+/**
+ * The devices of the Engine API
+ * @param devices
+ */
+export function engineDevices(devices) {
+    return devices.map((device) => ({
+        PathOnHost: device.hostPath,
+        PathInContainer: device.containerPath,
+        CgroupPermissions: device.cgroupPermissions
+    }));
+}
+/**
+ * The endpoints of the Engine API, by network: the static addresses given, none on the reserved networks
+ * @param networks
+ */
+export function engineEndpoints(networks) {
+    const endpoints = {};
+    for (const network of networks) {
+        endpoints[network.networkName] = RESERVED_NETWORKS.includes(network.networkName)
+            ? {}
+            : {
+                IPAMConfig: {
+                    IPv4Address: network.ip ? network.ip : undefined,
+                    IPv6Address: network.ipv6 ? network.ipv6 : undefined
+                }
+            };
+    }
+    return endpoints;
+}

package/dist/esm/docker/lib/ParseBaseImages.js

@@ -0,0 +1,47 @@
+/**
+ * The images of the FROM instructions of a Dockerfile, pulled before a build with credentials: their flags (--platform)
+ * and their stage names (AS build) are skipped, the stages of the Dockerfile and scratch are not images, the variables
+ * are the ARG declared before the first FROM (with their defaults) and the build arguments. The images whose variables
+ * are unknown are skipped
+ * @param dockerfile the content of the Dockerfile
+ * @param buildargs
+ */
+export function parseBaseImages(dockerfile, buildargs = {}) {
+    //The instructions continued on the next lines (a backslash at the end of a line)
+    const instructions = dockerfile.replace(/\\\r?\n/g, ' ').split(/\r?\n/).map((line) => line.trim()).filter((line) => !!line && !line.startsWith('#'));
+    const variables = {};
+    const stages = new Set();
+    const images = [];
+    let beforeFirstFrom = true;
+    for (const instruction of instructions) {
+        const [keyword, ...rest] = instruction.split(/\s+/);
+        if (keyword.toUpperCase() === 'ARG' && beforeFirstFrom) {
+            for (const declaration of rest) {
+                const [name, value] = declaration.split(/=(.*)/s);
+                if (buildargs[name] !== undefined)
+                    variables[name] = buildargs[name];
+                else if (value !== undefined)
+                    variables[name] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+        if (keyword.toUpperCase() !== 'FROM')
+            continue;
+        beforeFirstFrom = false;
+        const words = rest.filter((word) => !word.startsWith('--'));
+        const [reference, as, stage] = words;
+        if (as?.toUpperCase() === 'AS' && stage)
+            stages.add(stage.toLowerCase());
+        if (!reference)
+            continue;
+        let unknown = false;
+        const image = reference.replace(/\$\{?([A-Za-z_][A-Za-z0-9_]*)}?/g, (_, name) => {
+            if (variables[name] === undefined)
+                unknown = true;
+            return variables[name] ?? '';
+        });
+        if (unknown || !image || image.toLowerCase() === 'scratch' || stages.has(image.toLowerCase()) || images.includes(image))
+            continue;
+        images.push(image);
+    }
+    return images;
+}

package/dist/esm/docker/lib/ParseEnvToRecord.js

@@ -0,0 +1,22 @@
+/**
+ * Turn a list of environment variables as the Engine API gives them (`['PATH=/usr/bin', 'MODE=a=b']`) into a record by
+ * name. A variable is split at its first `=`; an entry without `=` is skipped; a repeated name keeps its last value.
+ * @param rawEnv The `NAME=value` entries; `null` or `undefined` for none.
+ * @returns The values by name (`{PATH: '/usr/bin', MODE: 'a=b'}`).
+ * @example
+ * ```typescript
+ * import {parseEnvToRecord} from 'lakutata/com/docker'
+ *
+ * const env: Record<string, string> = parseEnvToRecord(['PATH=/usr/bin', 'MODE=a=b', 'EMPTY='])
+ * console.log(env) //{PATH: '/usr/bin', MODE: 'a=b', EMPTY: ''}
+ * ```
+ */
+export function parseEnvToRecord(rawEnv) {
+    const environments = {};
+    for (const envString of rawEnv ?? []) {
+        const splitPos = envString.indexOf('=');
+        if (splitPos !== -1)
+            environments[envString.substring(0, splitPos)] = envString.substring(splitPos + 1);
+    }
+    return environments;
+}

package/dist/esm/docker/lib/ParseRepositoryTag.js

@@ -0,0 +1,45 @@
+/**
+ * Split an image reference into its repository and its tag (or digest). A digest (`@`) wins over a tag; the port of a
+ * registry (`registry:5000/app`) is not taken for a tag.
+ * @param input The image reference: `alpine`, `alpine:3.20`, `registry.example.com:5000/team/app:1.0`,
+ * `alpine@sha256:…`.
+ * @returns The repository, and the tag (or the digest, without its `@`) when the reference has one.
+ * @example
+ * ```typescript
+ * import {parseRepositoryTag, type RepositoryTag} from 'lakutata/com/docker'
+ *
+ * const reference: RepositoryTag = parseRepositoryTag('registry.example.com:5000/team/app:1.0')
+ * console.log(reference) //{repo: 'registry.example.com:5000/team/app', tag: '1.0'}
+ * console.log(parseRepositoryTag('registry.example.com:5000/team/app')) //{repo: 'registry.example.com:5000/team/app'}
+ * ```
+ */
+export function parseRepositoryTag(input) {
+    let separatorPos;
+    const digestPos = input.indexOf('@');
+    const colonPos = input.lastIndexOf(':');
+    // @ symbol is more important
+    if (digestPos >= 0) {
+        separatorPos = digestPos;
+    }
+    else if (colonPos >= 0) {
+        separatorPos = colonPos;
+    }
+    else {
+        // no colon nor @
+        return {
+            repo: input
+        };
+    }
+    // last colon is either the tag (or part of a port designation)
+    const tag = input.slice(separatorPos + 1);
+    // if it contains a / its not a tag and is part of the url
+    if (tag.indexOf('/') === -1) {
+        return {
+            repo: input.slice(0, separatorPos),
+            tag: tag
+        };
+    }
+    return {
+        repo: input
+    };
+}

package/dist/esm/docker/lib/RegistryAuth.js

@@ -0,0 +1,12 @@
+export function registryAuth(auth) {
+    if (!auth)
+        return undefined;
+    return {
+        username: auth.username,
+        password: auth.password,
+        serveraddress: auth.serverAddress,
+        email: auth.email,
+        identitytoken: auth.identityToken,
+        registrytoken: auth.registryToken
+    };
+}

package/dist/esm/docker/options/DockerPruneOptions.js

@@ -0,0 +1,43 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '@lakutata/core';
+import { Expect } from '@lakutata/core/decorator/dto';
+/**
+ * Which unused resources {@link Docker.prune} removes, each kind as its `docker … prune` command does without options.
+ * Called without options, it prunes the containers and the images; the networks and the volumes only when asked (the
+ * volumes, as `docker system prune --volumes`).
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * //The stopped containers and the unused networks, keeping the images and the volumes
+ * await docker.prune({containers: true, images: false, networks: true, volumes: false})
+ * ```
+ */
+export class DockerPruneOptions extends DTO {
+}
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "containers", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "images", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "networks", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], DockerPruneOptions.prototype, "volumes", void 0);