testcontainers 9.2.0 → 9.3.0

package/dist/src/docker-compose/functions/docker-compose-down.d.ts

@@ -0,0 +1,3 @@
+import { DockerComposeOptions } from "../docker-compose-options";
+import { DockerComposeDownOptions } from "../../test-container";
+export declare const dockerComposeDown: (options: DockerComposeOptions, downOptions: DockerComposeDownOptions) => Promise<void>;

package/dist/src/docker-compose/functions/docker-compose-down.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.dockerComposeDown = void 0;
+const logger_1 = require("../../logger");
+const default_docker_compose_options_1 = require("../default-docker-compose-options");
+const docker_compose_1 = require("docker-compose");
+const dockerComposeDown = (options, downOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.info(`Downing DockerCompose environment`);
+    try {
+        yield (0, docker_compose_1.down)(Object.assign(Object.assign({}, (yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options))), { commandOptions: commandOptions(downOptions) }));
+        logger_1.log.info(`Downed DockerCompose environment`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (err) {
+        const errorMessage = err.err || err.message || err;
+        logger_1.log.error(`Failed to down DockerCompose environment: ${errorMessage}`);
+        throw new Error(errorMessage);
+    }
+});
+exports.dockerComposeDown = dockerComposeDown;
+const commandOptions = (options) => {
+    const result = [];
+    if (options.removeVolumes) {
+        result.push("-v");
+    }
+    if (options.timeout) {
+        result.push("-t", `${options.timeout / 1000}`);
+    }
+    return result;
+};

package/dist/src/docker-compose/functions/docker-compose-stop.d.ts

@@ -0,0 +1,2 @@
+import { DockerComposeOptions } from "../docker-compose-options";
+export declare const dockerComposeStop: (options: DockerComposeOptions) => Promise<void>;

package/dist/src/docker-compose/functions/docker-compose-stop.js

@@ -0,0 +1,29 @@
+"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.dockerComposeStop = void 0;
+const logger_1 = require("../../logger");
+const docker_compose_1 = require("docker-compose");
+const default_docker_compose_options_1 = require("../default-docker-compose-options");
+const dockerComposeStop = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.info(`Stopping DockerCompose environment`);
+    try {
+        yield (0, docker_compose_1.stop)(yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
+        logger_1.log.info(`Stopped DockerCompose environment`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (err) {
+        const errorMessage = err.err || err.message || err;
+        logger_1.log.error(`Failed to stop DockerCompose environment: ${errorMessage}`);
+        throw new Error(errorMessage);
+    }
+});
+exports.dockerComposeStop = dockerComposeStop;

package/dist/src/docker-compose/functions/docker-compose-up.d.ts

@@ -0,0 +1,2 @@
+import { DockerComposeOptions } from "../docker-compose-options";
+export declare const dockerComposeUp: (options: DockerComposeOptions, services?: Array<string>) => Promise<void>;

package/dist/src/docker-compose/functions/docker-compose-up.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerComposeUp = void 0;
+const logger_1 = require("../../logger");
+const docker_compose_1 = require("docker-compose");
+const default_docker_compose_options_1 = require("../default-docker-compose-options");
+const docker_compose_down_1 = require("./docker-compose-down");
+const dockerComposeUp = (options, services) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.info(`Upping DockerCompose environment`);
+    try {
+        if (services) {
+            yield (0, docker_compose_1.upMany)(services, yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
+        }
+        else {
+            yield (0, docker_compose_1.upAll)(yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
+        }
+        logger_1.log.info(`Upped DockerCompose environment`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (err) {
+        const errorMessage = err.err || err.message || err;
+        logger_1.log.error(`Failed to up DockerCompose environment: ${errorMessage}`);
+        try {
+            yield (0, docker_compose_down_1.dockerComposeDown)(options, { removeVolumes: true, timeout: 0 });
+        }
+        catch (_a) {
+            logger_1.log.warn(`Failed to down DockerCompose environment after failed up`);
+        }
+        throw new Error(errorMessage);
+    }
+});
+exports.dockerComposeUp = dockerComposeUp;

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

@@ -0,0 +1,25 @@
+import { WaitStrategy } from "../wait-strategy";
+import { Uuid } from "../uuid";
+import { Environment } from "../docker/types";
+import { StartedDockerComposeEnvironment } from "./started-docker-compose-environment";
+export declare class DockerComposeEnvironment {
+    private readonly composeFilePath;
+    private readonly composeFiles;
+    private projectName;
+    private build;
+    private recreate;
+    private environmentFile;
+    private profiles;
+    private environment;
+    private waitStrategy;
+    private startupTimeout;
+    constructor(composeFilePath: string, composeFiles: string | string[], uuid?: Uuid);
+    withBuild(): this;
+    withEnvironment(environment: Environment): this;
+    withEnvironmentFile(environmentFile: string): this;
+    withProfiles(...profiles: string[]): this;
+    withNoRecreate(): this;
+    withWaitStrategy(containerName: string, waitStrategy: WaitStrategy): this;
+    withStartupTimeout(startupTimeout: number): this;
+    up(services?: Array<string>): Promise<StartedDockerComposeEnvironment>;
+}

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

@@ -0,0 +1,134 @@
+"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.DockerComposeEnvironment = void 0;
+const bound_ports_1 = require("../bound-ports");
+const container_name_resolver_1 = require("../docker-compose/functions/container-name-resolver");
+const started_generic_container_1 = require("../generic-container/started-generic-container");
+const logger_1 = require("../logger");
+const wait_strategy_1 = require("../wait-strategy");
+const reaper_1 = require("../reaper");
+const uuid_1 = require("../uuid");
+const list_containers_1 = require("../docker/functions/container/list-containers");
+const get_container_1 = require("../docker/functions/container/get-container");
+const docker_client_1 = require("../docker/docker-client");
+const inspect_container_1 = require("../docker/functions/container/inspect-container");
+const container_logs_1 = require("../docker/functions/container/container-logs");
+const started_docker_compose_environment_1 = require("./started-docker-compose-environment");
+const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
+const docker_compose_up_1 = require("../docker-compose/functions/docker-compose-up");
+const wait_for_container_1 = require("../wait-for-container");
+class DockerComposeEnvironment {
+    constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
+        this.build = false;
+        this.recreate = true;
+        this.environmentFile = "";
+        this.profiles = [];
+        this.environment = {};
+        this.waitStrategy = {};
+        this.startupTimeout = 60000;
+        this.composeFilePath = composeFilePath;
+        this.composeFiles = composeFiles;
+        this.projectName = `testcontainers-${uuid.nextUuid()}`;
+    }
+    withBuild() {
+        this.build = true;
+        return this;
+    }
+    withEnvironment(environment) {
+        this.environment = Object.assign(Object.assign({}, this.environment), environment);
+        return this;
+    }
+    withEnvironmentFile(environmentFile) {
+        this.environmentFile = environmentFile;
+        return this;
+    }
+    withProfiles(...profiles) {
+        this.profiles = [...this.profiles, ...profiles];
+        return this;
+    }
+    withNoRecreate() {
+        this.recreate = false;
+        this.projectName = "testcontainers-node";
+        return this;
+    }
+    withWaitStrategy(containerName, waitStrategy) {
+        this.waitStrategy[containerName] = waitStrategy;
+        return this;
+    }
+    withStartupTimeout(startupTimeout) {
+        this.startupTimeout = startupTimeout;
+        return this;
+    }
+    up(services) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.info(`Starting DockerCompose environment: ${this.projectName}`);
+            (yield reaper_1.ReaperInstance.getInstance()).addProject(this.projectName);
+            const options = {
+                filePath: this.composeFilePath,
+                files: this.composeFiles,
+                projectName: this.projectName,
+            };
+            const commandOptions = [];
+            if (this.build) {
+                commandOptions.push("--build");
+            }
+            if (!this.recreate) {
+                commandOptions.push("--no-recreate");
+            }
+            const composeOptions = [];
+            if (this.environmentFile) {
+                composeOptions.push("--env-file", this.environmentFile);
+            }
+            this.profiles.forEach((profile) => composeOptions.push("--profile", profile));
+            yield (0, docker_compose_up_1.dockerComposeUp)(Object.assign(Object.assign({}, options), { commandOptions, composeOptions, environment: this.environment }), services);
+            const startedContainers = (yield (0, list_containers_1.listContainers)()).filter((container) => container.Labels["com.docker.compose.project"] === this.projectName);
+            const startedContainerNames = startedContainers.reduce((containerNames, startedContainer) => [
+                ...containerNames,
+                startedContainer.Names.join(", "),
+            ], []);
+            logger_1.log.info(`Started the following containers: ${startedContainerNames.join(", ")}`);
+            const startedGenericContainers = (yield Promise.all(startedContainers.map((startedContainer) => __awaiter(this, void 0, void 0, function* () {
+                const container = yield (0, get_container_1.getContainerById)(startedContainer.Id);
+                const containerName = (0, container_name_resolver_1.resolveContainerName)(this.projectName, startedContainer.Names[0]);
+                const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
+                const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
+                const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult);
+                const waitStrategy = (this.waitStrategy[containerName] ? this.waitStrategy[containerName] : (0, wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+                (yield (0, container_logs_1.containerLogs)(container))
+                    .on("data", (data) => logger_1.containerLog.trace(`${containerName}: ${data}`))
+                    .on("err", (data) => logger_1.containerLog.error(`${containerName}: ${data}`));
+                try {
+                    logger_1.log.info(`Waiting for container ${containerName} to be ready`);
+                    yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
+                    logger_1.log.info(`Container ${containerName} is ready`);
+                }
+                catch (err) {
+                    logger_1.log.error(`Container ${containerName} failed to be ready: ${err}`);
+                    try {
+                        yield (0, docker_compose_down_1.dockerComposeDown)(options, { removeVolumes: true, timeout: 0 });
+                    }
+                    catch (_a) {
+                        logger_1.log.warn(`Failed to stop DockerCompose environment after failed up`);
+                    }
+                    throw err;
+                }
+                return new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, containerName, waitStrategy);
+            })))).reduce((map, startedGenericContainer) => {
+                const containerName = startedGenericContainer.getName();
+                return Object.assign(Object.assign({}, map), { [containerName]: startedGenericContainer });
+            }, {});
+            logger_1.log.info(`DockerCompose environment started: ${Object.keys(startedGenericContainers).join(", ")}`);
+            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, Object.assign(Object.assign({}, options), { composeOptions, environment: this.environment }));
+        });
+    }
+}
+exports.DockerComposeEnvironment = DockerComposeEnvironment;

package/dist/src/docker-compose-environment/downed-docker-compose-environment.d.ts

@@ -0,0 +1,2 @@
+export declare class DownedDockerComposeEnvironment {
+}

package/dist/src/docker-compose-environment/downed-docker-compose-environment.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownedDockerComposeEnvironment = void 0;
+class DownedDockerComposeEnvironment {
+}
+exports.DownedDockerComposeEnvironment = DownedDockerComposeEnvironment;

package/dist/src/docker-compose-environment/started-docker-compose-environment.d.ts

@@ -0,0 +1,15 @@
+import { StartedGenericContainer } from "../generic-container/started-generic-container";
+import { StoppedDockerComposeEnvironment } from "./stopped-docker-compose-environment";
+import { DownedDockerComposeEnvironment } from "./downed-docker-compose-environment";
+import { DockerComposeOptions } from "../docker-compose/docker-compose-options";
+import { DockerComposeDownOptions } from "../test-container";
+export declare class StartedDockerComposeEnvironment {
+    private readonly startedGenericContainers;
+    private readonly options;
+    constructor(startedGenericContainers: {
+        [containerName: string]: StartedGenericContainer;
+    }, options: DockerComposeOptions);
+    stop(): Promise<StoppedDockerComposeEnvironment>;
+    down(options?: Partial<DockerComposeDownOptions>): Promise<DownedDockerComposeEnvironment>;
+    getContainer(containerName: string): StartedGenericContainer;
+}

package/dist/src/docker-compose-environment/started-docker-compose-environment.js

@@ -0,0 +1,46 @@
+"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.StartedDockerComposeEnvironment = void 0;
+const logger_1 = require("../logger");
+const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
+const docker_compose_stop_1 = require("../docker-compose/functions/docker-compose-stop");
+const stopped_docker_compose_environment_1 = require("./stopped-docker-compose-environment");
+const downed_docker_compose_environment_1 = require("./downed-docker-compose-environment");
+class StartedDockerComposeEnvironment {
+    constructor(startedGenericContainers, options) {
+        this.startedGenericContainers = startedGenericContainers;
+        this.options = options;
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, docker_compose_stop_1.dockerComposeStop)(this.options);
+            return new stopped_docker_compose_environment_1.StoppedDockerComposeEnvironment(this.options);
+        });
+    }
+    down(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const downOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
+            yield (0, docker_compose_down_1.dockerComposeDown)(this.options, downOptions);
+            return new downed_docker_compose_environment_1.DownedDockerComposeEnvironment();
+        });
+    }
+    getContainer(containerName) {
+        const container = this.startedGenericContainers[containerName];
+        if (!container) {
+            const error = `Cannot get container "${containerName}" as it is not running`;
+            logger_1.log.error(error);
+            throw new Error(error);
+        }
+        return container;
+    }
+}
+exports.StartedDockerComposeEnvironment = StartedDockerComposeEnvironment;

package/dist/src/docker-compose-environment/stopped-docker-compose-environment.d.ts

@@ -0,0 +1,8 @@
+import { DownedDockerComposeEnvironment } from "./downed-docker-compose-environment";
+import { DockerComposeOptions } from "../docker-compose/docker-compose-options";
+import { DockerComposeDownOptions } from "../test-container";
+export declare class StoppedDockerComposeEnvironment {
+    private readonly options;
+    constructor(options: DockerComposeOptions);
+    down(options?: Partial<DockerComposeDownOptions>): Promise<DownedDockerComposeEnvironment>;
+}

package/dist/src/docker-compose-environment/stopped-docker-compose-environment.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.StoppedDockerComposeEnvironment = void 0;
+const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
+const downed_docker_compose_environment_1 = require("./downed-docker-compose-environment");
+class StoppedDockerComposeEnvironment {
+    constructor(options) {
+        this.options = options;
+    }
+    down(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolvedOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
+            yield (0, docker_compose_down_1.dockerComposeDown)(this.options, resolvedOptions);
+            return new downed_docker_compose_environment_1.DownedDockerComposeEnvironment();
+        });
+    }
+}
+exports.StoppedDockerComposeEnvironment = StoppedDockerComposeEnvironment;

package/dist/src/docker-image-name.d.ts

@@ -0,0 +1,15 @@
+export declare class DockerImageName {
+    readonly registry: string | undefined;
+    readonly image: string;
+    readonly tag: string;
+    private readonly string;
+    private static readonly HELPER_CONTAINERS;
+    constructor(registry: string | undefined, image: string, tag: string);
+    equals(other: DockerImageName): boolean;
+    toString(): string;
+    isReaper(): boolean;
+    isHelperContainer(): boolean;
+    static fromString(string: string): DockerImageName;
+    private static getRegistry;
+    private static isRegistry;
+}

package/dist/src/docker-image-name.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerImageName = void 0;
+const images_1 = require("./images");
+class DockerImageName {
+    constructor(registry, image, tag) {
+        this.registry = registry;
+        this.image = image;
+        this.tag = tag;
+        if (this.registry) {
+            if (this.tag.startsWith("sha256:")) {
+                this.string = `${this.registry}/${this.image}@${this.tag}`;
+            }
+            else {
+                this.string = `${this.registry}/${this.image}:${this.tag}`;
+            }
+        }
+        else if (this.tag.startsWith("sha256:")) {
+            this.string = `${this.image}@${this.tag}`;
+        }
+        else {
+            this.string = `${this.image}:${this.tag}`;
+        }
+    }
+    equals(other) {
+        return this.registry === other.registry && this.image === other.image && this.tag === other.tag;
+    }
+    toString() {
+        return this.string;
+    }
+    isReaper() {
+        return this.string === images_1.REAPER_IMAGE;
+    }
+    isHelperContainer() {
+        return DockerImageName.HELPER_CONTAINERS.has(this.string);
+    }
+    static fromString(string) {
+        const registry = this.getRegistry(string);
+        const stringWithoutRegistry = registry ? string.split("/").slice(1).join("/") : string;
+        if (stringWithoutRegistry.includes("@")) {
+            const [image, tag] = stringWithoutRegistry.split("@");
+            return new DockerImageName(registry, image, tag);
+        }
+        else if (stringWithoutRegistry.includes(":")) {
+            const [image, tag] = stringWithoutRegistry.split(":");
+            return new DockerImageName(registry, image, tag);
+        }
+        else {
+            return new DockerImageName(registry, stringWithoutRegistry, "latest");
+        }
+    }
+    static getRegistry(string) {
+        const parts = string.split("/");
+        if (parts.length > 1 && this.isRegistry(parts[0])) {
+            return parts[0];
+        }
+    }
+    static isRegistry(string) {
+        return string.includes(".") || string.includes(":") || string === "localhost";
+    }
+}
+exports.DockerImageName = DockerImageName;
+DockerImageName.HELPER_CONTAINERS = new Set([images_1.REAPER_IMAGE, images_1.SSHD_IMAGE]);

package/dist/src/dockerfile-parser.d.ts

@@ -0,0 +1,3 @@
+import { DockerImageName } from "./docker-image-name";
+import { BuildArgs } from "./docker/types";
+export declare const getDockerfileImages: (dockerfile: string, buildArgs: BuildArgs) => Promise<DockerImageName[]>;

package/dist/src/dockerfile-parser.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.getDockerfileImages = void 0;
+const os_1 = require("os");
+const fs_1 = require("fs");
+const logger_1 = require("./logger");
+const docker_image_name_1 = require("./docker-image-name");
+const buildArgRegex = /\${([^{]+)}/g;
+const getDockerfileImages = (dockerfile, buildArgs) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return (yield parseImages(dockerfile))
+            .map((line) => line.replace(buildArgRegex, (_, arg) => { var _a; return (_a = buildArgs[arg]) !== null && _a !== void 0 ? _a : ""; }))
+            .map((line) => docker_image_name_1.DockerImageName.fromString(line));
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to read Dockerfile "${dockerfile}": ${err}`);
+        throw err;
+    }
+});
+exports.getDockerfileImages = getDockerfileImages;
+function parseImages(dockerfile) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Array.from((yield fs_1.promises.readFile(dockerfile, "utf8"))
+            .split(os_1.EOL)
+            .filter((line) => line.toUpperCase().startsWith("FROM"))
+            .map((line) => line.split(" ").filter((part) => part !== "")[1])
+            .reduce((prev, next) => prev.add(next), new Set())
+            .values());
+    });
+}

package/dist/src/generic-container/generic-container-builder.d.ts

@@ -0,0 +1,18 @@
+import { BuildArgs } from "../docker/types";
+import { PullPolicy } from "../pull-policy";
+import { Uuid } from "../uuid";
+import { GenericContainer } from "./generic-container";
+export declare class GenericContainerBuilder {
+    private readonly context;
+    private readonly dockerfileName;
+    private readonly uuid;
+    private buildArgs;
+    private pullPolicy;
+    private cache;
+    constructor(context: string, dockerfileName: string, uuid?: Uuid);
+    withBuildArgs(buildArgs: BuildArgs): GenericContainerBuilder;
+    withPullPolicy(pullPolicy: PullPolicy): this;
+    withCache(cache: boolean): this;
+    build(image?: string): Promise<GenericContainer>;
+    private getRegistryConfig;
+}

package/dist/src/generic-container/generic-container-builder.js

@@ -0,0 +1,98 @@
+"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.GenericContainerBuilder = void 0;
+const pull_policy_1 = require("../pull-policy");
+const uuid_1 = require("../uuid");
+const reaper_1 = require("../reaper");
+const docker_image_name_1 = require("../docker-image-name");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const dockerfile_parser_1 = require("../dockerfile-parser");
+const build_image_1 = require("../docker/functions/image/build-image");
+const get_auth_config_1 = require("../registry-auth-locator/get-auth-config");
+const generic_container_1 = require("./generic-container");
+const docker_client_1 = require("../docker/docker-client");
+const image_exists_1 = require("../docker/functions/image/image-exists");
+class GenericContainerBuilder {
+    constructor(context, dockerfileName, uuid = new uuid_1.RandomUuid()) {
+        this.context = context;
+        this.dockerfileName = dockerfileName;
+        this.uuid = uuid;
+        this.buildArgs = {};
+        this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
+        this.cache = true;
+    }
+    withBuildArgs(buildArgs) {
+        this.buildArgs = buildArgs;
+        return this;
+    }
+    withPullPolicy(pullPolicy) {
+        this.pullPolicy = pullPolicy;
+        return this;
+    }
+    withCache(cache) {
+        this.cache = cache;
+        return this;
+    }
+    // https://github.com/containers/buildah/issues/1034
+    build(image = `localhost/${this.uuid.nextUuid()}:${this.uuid.nextUuid()}`) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const imageName = docker_image_name_1.DockerImageName.fromString(image);
+            yield reaper_1.ReaperInstance.getInstance();
+            const dockerfile = path_1.default.resolve(this.context, this.dockerfileName);
+            logger_1.log.debug(`Preparing to build Dockerfile: ${dockerfile}`);
+            const imageNames = yield (0, dockerfile_parser_1.getDockerfileImages)(dockerfile, this.buildArgs);
+            const { dockerode, indexServerAddress } = yield (0, docker_client_1.dockerClient)();
+            const registryConfig = yield this.getRegistryConfig(indexServerAddress, imageNames);
+            yield (0, build_image_1.buildImage)({
+                imageName: imageName,
+                context: this.context,
+                dockerfileName: this.dockerfileName,
+                buildArgs: this.buildArgs,
+                pullPolicy: this.pullPolicy,
+                cache: this.cache,
+                registryConfig,
+            });
+            const container = new generic_container_1.GenericContainer(imageName.toString());
+            if (!(yield (0, image_exists_1.imageExists)(dockerode, imageName))) {
+                throw new Error("Failed to build image");
+            }
+            return Promise.resolve(container);
+        });
+    }
+    getRegistryConfig(indexServerAddress, imageNames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const authConfigs = [];
+            yield Promise.all(imageNames.map((imageName) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const authConfig = yield (0, get_auth_config_1.getAuthConfig)((_a = imageName.registry) !== null && _a !== void 0 ? _a : indexServerAddress);
+                if (authConfig !== undefined) {
+                    authConfigs.push(authConfig);
+                }
+            })));
+            return authConfigs
+                .map((authConfig) => {
+                return {
+                    [authConfig.registryAddress]: {
+                        username: authConfig.username,
+                        password: authConfig.password,
+                    },
+                };
+            })
+                .reduce((prev, next) => (Object.assign(Object.assign({}, prev), next)), {});
+        });
+    }
+}
+exports.GenericContainerBuilder = GenericContainerBuilder;