testcontainers 9.2.0 → 9.3.0

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "testcontainers",
     "author": "Cristian Greco",
-    "version": "9.2.0",
+    "version": "9.3.0",
     "main": "dist/src/index",
     "types": "dist/src/index",
     "keywords": [

package/dist/src/bound-ports.d.ts

@@ -0,0 +1,12 @@
+import { PortWithOptionalBinding } from "./port";
+import { InspectResult } from "./docker/functions/container/inspect-container";
+import { HostIps } from "./docker/lookup-host-ips";
+export declare class BoundPorts {
+    private readonly ports;
+    getBinding(port: number): number;
+    getFirstBinding(): number;
+    setBinding(key: number, value: number): void;
+    iterator(): Iterable<[number, number]>;
+    filter(ports: PortWithOptionalBinding[]): BoundPorts;
+    static fromInspectResult(hostIps: HostIps, inspectResult: InspectResult): BoundPorts;
+}

package/dist/src/bound-ports.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundPorts = void 0;
+const port_1 = require("./port");
+class BoundPorts {
+    constructor() {
+        this.ports = new Map();
+    }
+    getBinding(port) {
+        const binding = this.ports.get(port);
+        if (!binding) {
+            throw new Error(`No port binding found for :${port}`);
+        }
+        return binding;
+    }
+    getFirstBinding() {
+        const firstBinding = this.ports.values().next().value;
+        if (!firstBinding) {
+            throw new Error("No port bindings found");
+        }
+        else {
+            return firstBinding;
+        }
+    }
+    setBinding(key, value) {
+        this.ports.set(key, value);
+    }
+    iterator() {
+        return this.ports;
+    }
+    filter(ports) {
+        const boundPorts = new BoundPorts();
+        const containerPorts = ports.map((port) => (0, port_1.getContainerPort)(port));
+        for (const [internalPort, hostPort] of this.iterator()) {
+            if (containerPorts.includes(internalPort)) {
+                boundPorts.setBinding(internalPort, hostPort);
+            }
+        }
+        return boundPorts;
+    }
+    static fromInspectResult(hostIps, inspectResult) {
+        const boundPorts = new BoundPorts();
+        Object.entries(inspectResult.ports).forEach(([containerPort, hostBindings]) => {
+            const hostPort = (0, port_1.resolveHostPortBinding)(hostIps, hostBindings);
+            boundPorts.setBinding(parseInt(containerPort), hostPort);
+        });
+        return boundPorts;
+    }
+}
+exports.BoundPorts = BoundPorts;

package/dist/src/clock.d.ts

@@ -0,0 +1,7 @@
+export type Time = number;
+export interface Clock {
+    getTime(): Time;
+}
+export declare class SystemClock implements Clock {
+    getTime(): Time;
+}

package/dist/src/clock.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemClock = void 0;
+class SystemClock {
+    getTime() {
+        return Date.now();
+    }
+}
+exports.SystemClock = SystemClock;

package/dist/src/docker/docker-client-config.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+export type DockerClientConfig = {
+    dockerHost?: string;
+    dockerTlsVerify?: string;
+    dockerCertPath?: string;
+};
+export declare const getDockerClientConfig: (env?: NodeJS.ProcessEnv) => Promise<DockerClientConfig>;

package/dist/src/docker/docker-client-config.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDockerClientConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const properties_reader_1 = __importDefault(require("properties-reader"));
+const getDockerClientConfig = (env = process.env) => __awaiter(void 0, void 0, void 0, function* () {
+    let dockerHost;
+    let dockerTlsVerify;
+    let dockerCertPath;
+    const file = path_1.default.resolve((0, os_1.homedir)(), ".testcontainers.properties");
+    if ((0, fs_1.existsSync)(file)) {
+        logger_1.log.debug("Found .testcontainers.properties file");
+        const string = yield (0, promises_1.readFile)(file, { encoding: "utf-8" });
+        const properties = (0, properties_reader_1.default)("").read(string);
+        const host = properties.get("docker.host");
+        if (host !== null) {
+            dockerHost = host;
+        }
+        const tlsVerify = properties.get("docker.tls.verify");
+        if (tlsVerify !== null) {
+            dockerTlsVerify = `${tlsVerify}`;
+        }
+        const certPath = properties.get("docker.cert.path");
+        if (certPath !== null) {
+            dockerCertPath = certPath;
+        }
+    }
+    if (env["DOCKER_HOST"] !== undefined) {
+        dockerHost = env["DOCKER_HOST"];
+    }
+    if (env["DOCKER_TLS_VERIFY"] !== undefined) {
+        dockerTlsVerify = env["DOCKER_TLS_VERIFY"];
+    }
+    if (env["DOCKER_CERT_PATH"] !== undefined) {
+        dockerCertPath = env["DOCKER_CERT_PATH"];
+    }
+    let logStr = "Loaded properties: ";
+    if (dockerHost !== undefined) {
+        logStr += `dockerHost=${dockerHost}, `;
+    }
+    if (dockerTlsVerify !== undefined) {
+        logStr += `dockerTlsVerify=${dockerTlsVerify}, `;
+    }
+    if (dockerCertPath !== undefined) {
+        logStr += `dockerCertPath=${dockerCertPath}`;
+    }
+    logger_1.log.debug(logStr);
+    return { dockerHost, dockerTlsVerify, dockerCertPath };
+});
+exports.getDockerClientConfig = getDockerClientConfig;

package/dist/src/docker/docker-client.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import Dockerode from "dockerode";
+import { HostIps } from "./lookup-host-ips";
+type DockerClient = {
+    uri: string;
+    host: string;
+    hostIps: HostIps;
+    dockerode: Dockerode;
+    indexServerAddress: string;
+    composeEnvironment: NodeJS.ProcessEnv;
+};
+export type DockerClientInit = {
+    uri: string;
+    dockerode: Dockerode;
+    composeEnvironment: NodeJS.ProcessEnv;
+};
+export interface DockerClientStrategy {
+    init?(): Promise<void>;
+    isApplicable(): boolean;
+    getDockerClient(): Promise<DockerClientInit>;
+    getName(): string;
+}
+export declare const dockerClient: () => Promise<DockerClient>;
+export {};

package/dist/src/docker/docker-client.js

@@ -0,0 +1,198 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerClient = void 0;
+const dockerode_1 = __importDefault(require("dockerode"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const url_1 = require("url");
+const fs_1 = require("fs");
+const run_in_container_1 = require("./functions/run-in-container");
+const session_id_1 = require("./session-id");
+const lookup_host_ips_1 = require("./lookup-host-ips");
+const system_info_1 = require("../system-info");
+const rootless_unix_socket_strategy_1 = require("./rootless-unix-socket-strategy");
+const stream_utils_1 = require("../stream-utils");
+const stream_1 = require("stream");
+const docker_client_config_1 = require("./docker-client-config");
+const getDockerClient = () => __awaiter(void 0, void 0, void 0, function* () {
+    const strategies = [
+        new ConfigurationStrategy(),
+        new UnixSocketStrategy(),
+        new rootless_unix_socket_strategy_1.RootlessUnixSocketStrategy(),
+        new NpipeSocketStrategy(),
+    ];
+    for (const strategy of strategies) {
+        if (strategy.init) {
+            yield strategy.init();
+        }
+        if (strategy.isApplicable()) {
+            logger_1.log.debug(`Found applicable Docker client strategy: ${strategy.getName()}`);
+            const { uri, dockerode, composeEnvironment } = yield strategy.getDockerClient();
+            logger_1.log.debug(`Testing Docker client strategy URI: ${uri}`);
+            if (yield isDockerDaemonReachable(dockerode)) {
+                const indexServerAddress = (yield (0, system_info_1.getSystemInfo)(dockerode)).dockerInfo.indexServerAddress;
+                const host = yield resolveHost(dockerode, indexServerAddress, uri);
+                const hostIps = yield (0, lookup_host_ips_1.lookupHostIps)(host);
+                logger_1.log.info(`Using Docker client strategy: ${strategy.getName()}, Docker host: ${host} (${hostIps
+                    .map((hostIp) => hostIp.address)
+                    .join(", ")})`);
+                return { uri, host, hostIps, dockerode, indexServerAddress, composeEnvironment };
+            }
+            else {
+                logger_1.log.warn(`Docker client strategy ${strategy.getName()} is not reachable`);
+            }
+        }
+    }
+    throw new Error("No Docker client strategy found");
+});
+const isDockerDaemonReachable = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield dockerode.ping();
+        return (yield (0, stream_utils_1.streamToString)(stream_1.Readable.from(response))) === "OK";
+    }
+    catch (err) {
+        logger_1.log.warn(`Docker daemon is not reachable: ${err}`);
+        return false;
+    }
+});
+class ConfigurationStrategy {
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.dockerConfig = yield (0, docker_client_config_1.getDockerClientConfig)();
+        });
+    }
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dockerHost, dockerTlsVerify, dockerCertPath } = this.dockerConfig;
+            const dockerOptions = { headers: { "x-tc-sid": session_id_1.sessionId } };
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const { pathname, hostname, port } = new url_1.URL(dockerHost);
+            if (hostname !== "") {
+                dockerOptions.host = hostname;
+                dockerOptions.port = port;
+            }
+            else {
+                dockerOptions.socketPath = pathname;
+            }
+            if (dockerTlsVerify === "1" && dockerCertPath !== undefined) {
+                dockerOptions.ca = yield fs_1.promises.readFile(path_1.default.resolve(dockerCertPath, "ca.pem"));
+                dockerOptions.cert = yield fs_1.promises.readFile(path_1.default.resolve(dockerCertPath, "cert.pem"));
+                dockerOptions.key = yield fs_1.promises.readFile(path_1.default.resolve(dockerCertPath, "key.pem"));
+            }
+            return {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                uri: dockerHost,
+                dockerode: new dockerode_1.default(dockerOptions),
+                composeEnvironment: {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    DOCKER_HOST: dockerHost,
+                    DOCKER_TLS_VERIFY: dockerTlsVerify,
+                    DOCKER_CERT_PATH: dockerCertPath,
+                },
+            };
+        });
+    }
+    isApplicable() {
+        return this.dockerConfig.dockerHost !== undefined;
+    }
+    getName() {
+        return "ConfigurationStrategy";
+    }
+}
+class UnixSocketStrategy {
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                uri: "unix:///var/run/docker.sock",
+                dockerode: new dockerode_1.default({ socketPath: "/var/run/docker.sock" }),
+                composeEnvironment: {},
+            };
+        });
+    }
+    isApplicable() {
+        return (process.platform === "linux" || process.platform === "darwin") && (0, fs_1.existsSync)("/var/run/docker.sock");
+    }
+    getName() {
+        return "UnixSocketStrategy";
+    }
+}
+class NpipeSocketStrategy {
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                uri: "npipe:////./pipe/docker_engine",
+                dockerode: new dockerode_1.default({ socketPath: "//./pipe/docker_engine" }),
+                composeEnvironment: {},
+            };
+        });
+    }
+    isApplicable() {
+        return process.platform === "win32";
+    }
+    getName() {
+        return "NpipeSocketStrategy";
+    }
+}
+const resolveHost = (dockerode, indexServerAddress, uri) => __awaiter(void 0, void 0, void 0, function* () {
+    if (process.env.TESTCONTAINERS_HOST_OVERRIDE !== undefined) {
+        return process.env.TESTCONTAINERS_HOST_OVERRIDE;
+    }
+    const { protocol, hostname } = new url_1.URL(uri);
+    switch (protocol) {
+        case "http:":
+        case "https:":
+        case "tcp:":
+            return hostname;
+        case "unix:":
+        case "npipe:": {
+            if (isInContainer()) {
+                const gateway = yield findGateway(dockerode);
+                if (gateway !== undefined) {
+                    return gateway;
+                }
+                const defaultGateway = yield findDefaultGateway(dockerode, indexServerAddress);
+                if (defaultGateway !== undefined) {
+                    return defaultGateway;
+                }
+            }
+            return "localhost";
+        }
+        default:
+            throw new Error(`Unsupported protocol: ${protocol}`);
+    }
+});
+const findGateway = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    logger_1.log.debug(`Checking gateway for Docker host`);
+    const inspectResult = yield dockerode.getNetwork("bridge").inspect();
+    return (_c = (_b = (_a = inspectResult === null || inspectResult === void 0 ? void 0 : inspectResult.IPAM) === null || _a === void 0 ? void 0 : _a.Config) === null || _b === void 0 ? void 0 : _b.find((config) => config.Gateway !== undefined)) === null || _c === void 0 ? void 0 : _c.Gateway;
+});
+const findDefaultGateway = (dockerode, indexServerAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.debug(`Checking default gateway for Docker host`);
+    return (0, run_in_container_1.runInContainer)(dockerode, indexServerAddress, "alpine:3.14", [
+        "sh",
+        "-c",
+        "ip route|awk '/default/ { print $3 }'",
+    ]);
+});
+const isInContainer = () => (0, fs_1.existsSync)("/.dockerenv");
+let _dockerClient;
+const dockerClient = () => {
+    if (!_dockerClient) {
+        _dockerClient = getDockerClient();
+    }
+    return _dockerClient;
+};
+exports.dockerClient = dockerClient;

package/dist/src/docker/functions/container/attach-container.d.ts

@@ -0,0 +1,3 @@
+import { Readable } from "stream";
+import Dockerode from "dockerode";
+export declare const attachContainer: (dockerode: Dockerode, container: Dockerode.Container) => Promise<Readable>;

package/dist/src/docker/functions/container/attach-container.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachContainer = void 0;
+const demux_stream_1 = require("../demux-stream");
+const logger_1 = require("../../../logger");
+const attachContainer = (dockerode, container) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const stream = (yield container.attach({ stream: true, stdout: true, stderr: true }));
+        return (0, demux_stream_1.demuxStream)(dockerode, stream);
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to attach to container ${container.id}: ${err}`);
+        throw err;
+    }
+});
+exports.attachContainer = attachContainer;

package/dist/src/docker/functions/container/container-logs.d.ts

@@ -0,0 +1,6 @@
+import Dockerode from "dockerode";
+import { Readable } from "stream";
+export type ContainerLogsOptions = {
+    since?: Date;
+};
+export declare const containerLogs: (container: Dockerode.Container, options?: ContainerLogsOptions) => Promise<Readable>;

package/dist/src/docker/functions/container/container-logs.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerLogs = void 0;
+const logger_1 = require("../../../logger");
+const demux_stream_1 = require("../demux-stream");
+const docker_client_1 = require("../../docker-client");
+const containerLogs = (container, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const stream = (yield container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true,
+            since: options.since ? options.since.getTime() / 1000 : 0,
+        }));
+        stream.socket.unref();
+        return (0, demux_stream_1.demuxStream)((yield (0, docker_client_1.dockerClient)()).dockerode, stream);
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to get container logs: ${err}`);
+        throw err;
+    }
+});
+exports.containerLogs = containerLogs;

package/dist/src/docker/functions/container/create-container.d.ts

@@ -0,0 +1,30 @@
+import { DockerImageName } from "../../../docker-image-name";
+import Dockerode from "dockerode";
+import { PortWithOptionalBinding } from "../../../port";
+import { BindMount, Environment, ExtraHost, HealthCheck, Labels, ResourcesQuota, TmpFs, Ulimits } from "../../types";
+export type CreateContainerOptions = {
+    imageName: DockerImageName;
+    environment: Environment;
+    command: string[];
+    entrypoint?: string[];
+    bindMounts: BindMount[];
+    tmpFs: TmpFs;
+    exposedPorts: PortWithOptionalBinding[];
+    name?: string;
+    reusable: boolean;
+    labels?: Labels;
+    networkMode?: string;
+    healthCheck?: HealthCheck;
+    useDefaultLogDriver: boolean;
+    privilegedMode: boolean;
+    autoRemove: boolean;
+    extraHosts: ExtraHost[];
+    ipcMode?: string;
+    ulimits?: Ulimits;
+    addedCapabilities?: string[];
+    droppedCapabilities?: string[];
+    user?: string;
+    workingDir?: string;
+    resourcesQuota?: ResourcesQuota;
+};
+export declare const createContainer: (options: CreateContainerOptions) => Promise<Dockerode.Container>;

package/dist/src/docker/functions/container/create-container.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContainer = void 0;
+const logger_1 = require("../../../logger");
+const docker_client_1 = require("../../docker-client");
+const port_1 = require("../../../port");
+const create_labels_1 = require("../create-labels");
+const createContainer = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    try {
+        logger_1.log.info(`Creating container for image: ${options.imageName}`);
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        return yield dockerode.createContainer({
+            name: options.name,
+            User: options.user,
+            Image: options.imageName.toString(),
+            Env: getEnvironment(options.environment),
+            ExposedPorts: getExposedPorts(options.exposedPorts),
+            Cmd: options.command,
+            Entrypoint: options.entrypoint,
+            Labels: (0, create_labels_1.createLabels)(options.reusable, options.imageName, options.labels),
+            Healthcheck: getHealthCheck(options.healthCheck),
+            WorkingDir: options.workingDir,
+            HostConfig: {
+                IpcMode: options.ipcMode,
+                ExtraHosts: getExtraHosts(options.extraHosts),
+                AutoRemove: options.autoRemove,
+                NetworkMode: options.networkMode,
+                PortBindings: getPortBindings(options.exposedPorts),
+                Binds: getBindMounts(options.bindMounts),
+                Tmpfs: options.tmpFs,
+                LogConfig: getLogConfig(options.useDefaultLogDriver),
+                Privileged: options.privilegedMode,
+                Ulimits: getUlimits(options.ulimits),
+                CapAdd: options.addedCapabilities,
+                CapDrop: options.droppedCapabilities,
+                Memory: (_a = options.resourcesQuota) === null || _a === void 0 ? void 0 : _a.memory,
+                NanoCpus: (_b = options.resourcesQuota) === null || _b === void 0 ? void 0 : _b.cpu,
+            },
+        });
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to create container for image ${options.imageName}: ${err}`);
+        throw err;
+    }
+});
+exports.createContainer = createContainer;
+const getEnvironment = (environment) => Object.entries(environment).reduce((dockerodeEnvironment, [key, value]) => [...dockerodeEnvironment, `${key}=${value}`], []);
+const getExposedPorts = (exposedPorts) => {
+    const dockerodeExposedPorts = {};
+    for (const exposedPort of exposedPorts) {
+        dockerodeExposedPorts[(0, port_1.getContainerPort)(exposedPort).toString()] = {};
+    }
+    return dockerodeExposedPorts;
+};
+const getExtraHosts = (extraHosts) => {
+    return extraHosts.map((extraHost) => `${extraHost.host}:${extraHost.ipAddress}`);
+};
+const getPortBindings = (exposedPorts) => {
+    const dockerodePortBindings = {};
+    for (const exposedPort of exposedPorts) {
+        if ((0, port_1.hasHostBinding)(exposedPort)) {
+            dockerodePortBindings[exposedPort.container] = [{ HostPort: exposedPort.host.toString() }];
+        }
+        else {
+            dockerodePortBindings[exposedPort] = [{ HostPort: "0" }];
+        }
+    }
+    return dockerodePortBindings;
+};
+const getBindMounts = (bindMounts) => {
+    return bindMounts.map(({ source, target, mode }) => `${source}:${target}:${mode}`);
+};
+const getHealthCheck = (healthCheck) => {
+    if (healthCheck === undefined) {
+        return undefined;
+    }
+    return {
+        Test: healthCheck.test,
+        Interval: healthCheck.interval ? toNanos(healthCheck.interval) : 0,
+        Timeout: healthCheck.timeout ? toNanos(healthCheck.timeout) : 0,
+        Retries: healthCheck.retries || 0,
+        StartPeriod: healthCheck.startPeriod ? toNanos(healthCheck.startPeriod) : 0,
+    };
+};
+const toNanos = (duration) => duration * 1e6;
+const getLogConfig = (useDefaultLogDriver) => {
+    if (!useDefaultLogDriver) {
+        return undefined;
+    }
+    return {
+        Type: "json-file",
+        Config: {},
+    };
+};
+const getUlimits = (ulimits) => {
+    if (!ulimits) {
+        return undefined;
+    }
+    return Object.entries(ulimits).map(([key, value]) => ({
+        Name: key,
+        Hard: value.hard,
+        Soft: value.soft,
+    }));
+};

package/dist/src/docker/functions/container/exec-container.d.ts

@@ -0,0 +1,9 @@
+import { ExecResult } from "../../types";
+import Dockerode from "dockerode";
+type ExecContainerOptions = {
+    tty: boolean;
+    stdin: boolean;
+    detach: boolean;
+};
+export declare const execContainer: (container: Dockerode.Container, command: string[], options: ExecContainerOptions, shouldLog?: boolean) => Promise<ExecResult>;
+export {};