testcontainers 9.2.0 → 9.3.0

package/dist/src/docker/functions/image/list-images.js

@@ -0,0 +1,34 @@
+"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.listImages = void 0;
+const docker_image_name_1 = require("../../../docker-image-name");
+const logger_1 = require("../../../logger");
+const listImages = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const images = yield dockerode.listImages();
+        return images.reduce((dockerImageNames, image) => {
+            var _a;
+            if (isDanglingImage(image)) {
+                return dockerImageNames;
+            }
+            const repoTags = (_a = image.RepoTags) !== null && _a !== void 0 ? _a : [];
+            const dockerImageNamesForImage = repoTags.map((imageRepoTag) => docker_image_name_1.DockerImageName.fromString(imageRepoTag));
+            return [...dockerImageNames, ...dockerImageNamesForImage];
+        }, []);
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to list images: ${err}`);
+        throw err;
+    }
+});
+exports.listImages = listImages;
+const isDanglingImage = (image) => image.RepoTags === null;

package/dist/src/docker/functions/image/pull-image.d.ts

@@ -0,0 +1,7 @@
+import { DockerImageName } from "../../../docker-image-name";
+import Dockerode from "dockerode";
+export type PullImageOptions = {
+    imageName: DockerImageName;
+    force: boolean;
+};
+export declare const pullImage: (dockerode: Dockerode, indexServerAddress: string, options: PullImageOptions) => Promise<void>;

package/dist/src/docker/functions/image/pull-image.js

@@ -0,0 +1,41 @@
+"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.pullImage = void 0;
+const logger_1 = require("../../../logger");
+const pull_stream_parser_1 = require("../../pull-stream-parser");
+const image_exists_1 = require("./image-exists");
+const get_auth_config_1 = require("../../../registry-auth-locator/get-auth-config");
+const async_lock_1 = __importDefault(require("async-lock"));
+const imagePullLock = new async_lock_1.default();
+const pullImage = (dockerode, indexServerAddress, options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return imagePullLock.acquire(options.imageName.toString(), () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            if (!options.force && (yield (0, image_exists_1.imageExists)(dockerode, options.imageName))) {
+                logger_1.log.debug(`Not pulling image as it already exists: ${options.imageName}`);
+                return;
+            }
+            logger_1.log.info(`Pulling image: ${options.imageName}`);
+            const authconfig = yield (0, get_auth_config_1.getAuthConfig)((_a = options.imageName.registry) !== null && _a !== void 0 ? _a : indexServerAddress);
+            const stream = yield dockerode.pull(options.imageName.toString(), { authconfig });
+            yield new pull_stream_parser_1.PullStreamParser(options.imageName, logger_1.log).consume(stream);
+        }));
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to pull image "${options.imageName}": ${err}`);
+        throw err;
+    }
+});
+exports.pullImage = pullImage;

package/dist/src/docker/functions/network/connect-network.d.ts

@@ -0,0 +1,6 @@
+export type ConnectNetworkOptions = {
+    containerId: string;
+    networkId: string;
+    networkAliases: string[];
+};
+export declare const connectNetwork: (options: ConnectNetworkOptions) => Promise<void>;

package/dist/src/docker/functions/network/connect-network.js

@@ -0,0 +1,27 @@
+"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.connectNetwork = void 0;
+const logger_1 = require("../../../logger");
+const docker_client_1 = require("../../docker-client");
+const connectNetwork = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        logger_1.log.info(`Connecting container ${options.containerId} to network ${options.networkId}`);
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const network = dockerode.getNetwork(options.networkId);
+        yield network.connect({ Container: options.containerId, EndpointConfig: { Aliases: options.networkAliases } });
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to connect container ${options.containerId} to network ${options.networkId}: ${err}`);
+        throw err;
+    }
+});
+exports.connectNetwork = connectNetwork;

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

@@ -0,0 +1,16 @@
+export type CreateNetworkOptions = {
+    name: string;
+    driver: "bridge" | "overlay" | string;
+    checkDuplicate: boolean;
+    internal: boolean;
+    attachable: boolean;
+    ingress: boolean;
+    enableIPv6: boolean;
+    labels?: {
+        [key: string]: string;
+    };
+    options?: {
+        [key: string]: string;
+    };
+};
+export declare const createNetwork: (options: CreateNetworkOptions) => Promise<string>;

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

@@ -0,0 +1,38 @@
+"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.createNetwork = void 0;
+const logger_1 = require("../../../logger");
+const docker_client_1 = require("../../docker-client");
+const create_labels_1 = require("../create-labels");
+const createNetwork = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        logger_1.log.info(`Creating network ${options.name}`);
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const network = yield dockerode.createNetwork({
+            Name: options.name,
+            CheckDuplicate: options.checkDuplicate,
+            Driver: options.driver,
+            Internal: options.internal,
+            Attachable: options.attachable,
+            Ingress: options.ingress,
+            EnableIPv6: options.enableIPv6,
+            Options: options.options,
+            Labels: Object.assign(Object.assign({}, options.labels), (0, create_labels_1.createLabels)(false)),
+        });
+        return network.id;
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to create network: ${err}`);
+        throw err;
+    }
+});
+exports.createNetwork = createNetwork;

package/dist/src/docker/functions/network/remove-network.d.ts

@@ -0,0 +1 @@
+export declare const removeNetwork: (id: string) => Promise<void>;

package/dist/src/docker/functions/network/remove-network.js

@@ -0,0 +1,30 @@
+"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.removeNetwork = void 0;
+const logger_1 = require("../../../logger");
+const docker_client_1 = require("../../docker-client");
+const removeNetwork = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        logger_1.log.info(`Removing network ${id}`);
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const network = dockerode.getNetwork(id);
+        const { message } = yield network.remove();
+        if (message) {
+            logger_1.log.warn(message);
+        }
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to remove network ${id}: ${err}`);
+        throw err;
+    }
+});
+exports.removeNetwork = removeNetwork;

package/dist/src/docker/functions/run-in-container.d.ts

@@ -0,0 +1,2 @@
+import Dockerode from "dockerode";
+export declare const runInContainer: (dockerode: Dockerode, indexServerAddress: string, image: string, command: string[]) => Promise<string | undefined>;

package/dist/src/docker/functions/run-in-container.js

@@ -0,0 +1,39 @@
+"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.runInContainer = void 0;
+const logger_1 = require("../../logger");
+const docker_image_name_1 = require("../../docker-image-name");
+const pull_image_1 = require("./image/pull-image");
+const start_container_1 = require("./container/start-container");
+const attach_container_1 = require("./container/attach-container");
+const stream_utils_1 = require("../../stream-utils");
+const runInContainer = (dockerode, indexServerAddress, image, command) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield (0, pull_image_1.pullImage)(dockerode, indexServerAddress, { imageName: docker_image_name_1.DockerImageName.fromString(image), force: false });
+        logger_1.log.debug(`Creating container: ${image} with command: ${command.join(" ")}`);
+        const container = yield dockerode.createContainer({ Image: image, Cmd: command });
+        logger_1.log.debug(`Attaching to container: ${container.id}`);
+        const stream = yield (0, attach_container_1.attachContainer)(dockerode, container);
+        logger_1.log.debug(`Starting container: ${container.id}`);
+        yield (0, start_container_1.startContainer)(container);
+        logger_1.log.debug(`Waiting for container output: ${container.id}`);
+        const output = yield (0, stream_utils_1.streamToString)(stream, { trim: true });
+        logger_1.log.debug(`Removing container: ${container.id}`);
+        yield container.remove({ force: true, v: true });
+        return output.length === 0 ? undefined : output;
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to run command in container: "${command.join(" ")}", error: "${err}"`);
+        return undefined;
+    }
+});
+exports.runInContainer = runInContainer;

package/dist/src/docker/get-remote-docker-unix-socket-path.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+export declare const getRemoteDockerUnixSocketPath: (uri: string, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv) => string;

package/dist/src/docker/get-remote-docker-unix-socket-path.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRemoteDockerUnixSocketPath = void 0;
+const getRemoteDockerUnixSocketPath = (uri, platform = process.platform, env = process.env) => {
+    if (env["TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE"] !== undefined) {
+        return env["TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE"];
+    }
+    let socketPath;
+    if (uri.startsWith("unix://")) {
+        socketPath = uri.replace("unix://", "");
+    }
+    else {
+        socketPath = "/var/run/docker.sock";
+    }
+    return platform === "win32" ? `/${socketPath}` : socketPath;
+};
+exports.getRemoteDockerUnixSocketPath = getRemoteDockerUnixSocketPath;

package/dist/src/docker/lookup-host-ips.d.ts

@@ -0,0 +1,5 @@
+export type HostIps = Array<{
+    address: string;
+    family: number;
+}>;
+export declare const lookupHostIps: (host: string) => Promise<HostIps>;

package/dist/src/docker/lookup-host-ips.js

@@ -0,0 +1,26 @@
+"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.lookupHostIps = void 0;
+const net_1 = __importDefault(require("net"));
+const dns_1 = __importDefault(require("dns"));
+const lookupHostIps = (host) => __awaiter(void 0, void 0, void 0, function* () {
+    if (net_1.default.isIP(host) === 0) {
+        return yield dns_1.default.promises.lookup(host, { all: true });
+    }
+    else {
+        return [{ address: host, family: net_1.default.isIP(host) }];
+    }
+});
+exports.lookupHostIps = lookupHostIps;

package/dist/src/docker/pull-stream-parser.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import { Logger } from "../logger";
+import { DockerImageName } from "../docker-image-name";
+export declare class PullStreamParser {
+    private readonly dockerImageName;
+    private readonly logger;
+    constructor(dockerImageName: DockerImageName, logger: Logger);
+    consume(stream: Readable): Promise<void>;
+    private getOrElse;
+}

package/dist/src/docker/pull-stream-parser.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PullStreamParser = void 0;
+const byline_1 = __importDefault(require("byline"));
+class PullStreamParser {
+    constructor(dockerImageName, logger) {
+        this.dockerImageName = dockerImageName;
+        this.logger = logger;
+    }
+    consume(stream) {
+        const messagesById = new Map();
+        const statusesById = new Map();
+        return new Promise((resolve) => {
+            (0, byline_1.default)(stream).on("data", (line) => {
+                try {
+                    const json = JSON.parse(line);
+                    const { id, status } = json;
+                    const prefix = id
+                        ? `Pulling ${this.dockerImageName.toString()} - ${id}`
+                        : `Pulling ${this.dockerImageName.toString()}`;
+                    if (status === "Downloading") {
+                        const { current, total } = json.progressDetail;
+                        const percentage = Math.round(100 * (current / total));
+                        const message = `${prefix} - ${json.status} ${percentage}%`;
+                        const messages = this.getOrElse(messagesById, id, new Set());
+                        if (!messages.has(message)) {
+                            messages.add(message);
+                            this.logger.trace(message);
+                        }
+                    }
+                    else {
+                        const statuses = this.getOrElse(statusesById, id, new Set());
+                        if (!statuses.has(status)) {
+                            statuses.add(status);
+                            const message = `${prefix} - ${json.status}`;
+                            const messages = this.getOrElse(messagesById, id, new Set());
+                            if (!messages.has(message)) {
+                                messages.add(message);
+                                this.logger.trace(message);
+                            }
+                        }
+                    }
+                }
+                catch (_a) {
+                    this.logger.warn(`Unexpected message format: ${line}`);
+                }
+            });
+            stream.on("end", resolve);
+        });
+    }
+    getOrElse(map, key, orElse) {
+        const value = map.get(key);
+        if (value === undefined) {
+            map.set(key, orElse);
+            return orElse;
+        }
+        return value;
+    }
+}
+exports.PullStreamParser = PullStreamParser;

package/dist/src/docker/rootless-unix-socket-strategy.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { DockerClientInit, DockerClientStrategy } from "./docker-client";
+export declare class RootlessUnixSocketStrategy implements DockerClientStrategy {
+    private readonly platform;
+    private readonly env;
+    private applicable;
+    private socketPath;
+    constructor(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv);
+    init(): Promise<void>;
+    private getSocketPathFromEnv;
+    private getSocketPathFromHomeDir;
+    private getSocketPathFromRunDir;
+    getDockerClient(): Promise<DockerClientInit>;
+    isApplicable(): boolean;
+    getName(): string;
+}

package/dist/src/docker/rootless-unix-socket-strategy.js

@@ -0,0 +1,69 @@
+"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.RootlessUnixSocketStrategy = void 0;
+const type_guards_1 = require("../type-guards");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const dockerode_1 = __importDefault(require("dockerode"));
+class RootlessUnixSocketStrategy {
+    constructor(platform = process.platform, env = process.env) {
+        this.platform = platform;
+        this.env = env;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.platform !== "linux" && this.platform !== "darwin") {
+                this.applicable = false;
+                return;
+            }
+            this.socketPath = [this.getSocketPathFromEnv(), this.getSocketPathFromHomeDir(), this.getSocketPathFromRunDir()]
+                .filter(type_guards_1.isDefined)
+                .find((candidateSocketPath) => (0, fs_1.existsSync)(candidateSocketPath));
+            this.applicable = this.socketPath !== undefined;
+        });
+    }
+    getSocketPathFromEnv() {
+        const xdgRuntimeDir = this.env["XDG_RUNTIME_DIR"];
+        if (xdgRuntimeDir !== undefined) {
+            return path_1.default.join(xdgRuntimeDir, "docker.sock");
+        }
+        else {
+            return undefined;
+        }
+    }
+    getSocketPathFromHomeDir() {
+        return path_1.default.join(os_1.default.homedir(), ".docker", "run", "docker.sock");
+    }
+    getSocketPathFromRunDir() {
+        return path_1.default.join("/run", "user", `${os_1.default.userInfo().uid}`, "docker.sock");
+    }
+    getDockerClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                uri: `unix://${this.socketPath}`,
+                dockerode: new dockerode_1.default({ socketPath: this.socketPath }),
+                composeEnvironment: {},
+            };
+        });
+    }
+    isApplicable() {
+        return this.applicable;
+    }
+    getName() {
+        return "RootlessUnixSocketStrategy";
+    }
+}
+exports.RootlessUnixSocketStrategy = RootlessUnixSocketStrategy;

package/dist/src/docker/session-id.d.ts

@@ -0,0 +1 @@
+export declare const sessionId: string;

package/dist/src/docker/session-id.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionId = void 0;
+const uuid_1 = require("../uuid");
+exports.sessionId = new uuid_1.RandomUuid().nextUuid();

package/dist/src/docker/types.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from "stream";
+export type Environment = {
+    [key in string]: string;
+};
+export type BindMode = "rw" | "ro" | "z" | "Z";
+export type BindMount = {
+    source: string;
+    target: string;
+    mode?: BindMode;
+};
+export type FileToCopy = {
+    source: string;
+    target: string;
+};
+export type Content = string | Buffer | Readable;
+export type ContentToCopy = {
+    content: Content;
+    target: string;
+};
+export type TmpFs = {
+    [dir in string]: string;
+};
+export type Ulimits = {
+    [name: string]: {
+        hard: number | undefined;
+        soft: number | undefined;
+    };
+};
+export type ResourcesQuota = {
+    memory?: number;
+    cpu?: number;
+};
+export type HealthCheck = {
+    test: ["CMD-SHELL", string] | ["CMD", ...string[]];
+    interval?: number;
+    timeout?: number;
+    retries?: number;
+    startPeriod?: number;
+};
+export type ExtraHost = {
+    host: string;
+    ipAddress: string;
+};
+export type Labels = {
+    [key: string]: string;
+};
+export type HostPortBindings = Array<{
+    hostIp: string;
+    hostPort: number;
+}>;
+export type Ports = {
+    [containerPort: number]: HostPortBindings;
+};
+export type AuthConfig = {
+    username: string;
+    password: string;
+    registryAddress: string;
+    email?: string;
+};
+export type RegistryConfig = {
+    [registryAddress: string]: {
+        username: string;
+        password: string;
+    };
+};
+export type BuildArgs = {
+    [key in string]: string;
+};
+export type ExecResult = {
+    output: string;
+    exitCode: number;
+};
+export type HealthCheckStatus = "none" | "starting" | "unhealthy" | "healthy";
+export type NetworkSettings = {
+    networkId: string;
+    ipAddress: string;
+};

package/dist/src/docker/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/docker-compose/default-docker-compose-options.d.ts

@@ -0,0 +1,3 @@
+import { IDockerComposeOptions } from "docker-compose";
+import { DockerComposeOptions } from "./docker-compose-options";
+export declare const defaultDockerComposeOptions: ({ environment, ...options }: DockerComposeOptions) => Promise<Partial<IDockerComposeOptions>>;

package/dist/src/docker-compose/default-docker-compose-options.js

@@ -0,0 +1,37 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultDockerComposeOptions = void 0;
+const docker_client_1 = require("../docker/docker-client");
+const defaultDockerComposeOptions = (_a) => __awaiter(void 0, void 0, void 0, function* () {
+    var { environment = {} } = _a, options = __rest(_a, ["environment"]);
+    const { composeEnvironment } = yield (0, docker_client_1.dockerClient)();
+    return {
+        log: false,
+        cwd: options.filePath,
+        config: options.files,
+        composeOptions: options.composeOptions,
+        commandOptions: options.commandOptions,
+        env: Object.assign(Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), composeEnvironment), environment),
+    };
+});
+exports.defaultDockerComposeOptions = defaultDockerComposeOptions;

package/dist/src/docker-compose/docker-compose-options.d.ts

@@ -0,0 +1,9 @@
+import { Environment } from "../docker/types";
+export type DockerComposeOptions = {
+    filePath: string;
+    files: string | string[];
+    projectName: string;
+    commandOptions?: string[];
+    composeOptions?: string[];
+    environment?: Environment;
+};

package/dist/src/docker-compose/docker-compose-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/docker-compose/functions/container-name-resolver.d.ts

@@ -0,0 +1 @@
+export declare const resolveContainerName: (projectName: string, containerName: string) => string;

package/dist/src/docker-compose/functions/container-name-resolver.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveContainerName = void 0;
+const resolveContainerName = (projectName, containerName) => {
+    if (containerName.includes(projectName)) {
+        return containerName.substring(`/${projectName}_`.length);
+    }
+    else if (containerName.startsWith("/")) {
+        return containerName.substring(1);
+    }
+    else {
+        throw new Error(`Unable to resolve container name for container name: "${containerName}", project name: "${projectName}"`);
+    }
+};
+exports.resolveContainerName = resolveContainerName;