testcontainers 9.2.0 → 9.3.0

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

@@ -0,0 +1,59 @@
+"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.execContainer = void 0;
+const logger_1 = require("../../../logger");
+const byline_1 = __importDefault(require("byline"));
+const execContainer = (container, command, options, shouldLog = true) => __awaiter(void 0, void 0, void 0, function* () {
+    const chunks = [];
+    try {
+        const exec = yield container.exec({
+            Cmd: command,
+            AttachStdout: true,
+            AttachStderr: true,
+        });
+        const stream = yield startExec(exec, options);
+        stream.on("data", (chunk) => chunks.push(chunk));
+        if (shouldLog && logger_1.execLog.enabled()) {
+            (0, byline_1.default)(stream).on("data", (line) => logger_1.execLog.trace(`${container.id}: ${line}`));
+        }
+        const exitCode = yield waitForExec(exec, stream);
+        stream.destroy();
+        return { output: chunks.join(""), exitCode };
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to exec container ${container.id} with command "${command.join(" ")}": ${err}. Container output: ${chunks.join("")}`);
+        throw err;
+    }
+});
+exports.execContainer = execContainer;
+const startExec = (exec, options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const stream = yield exec.start(options);
+        stream.setEncoding("utf-8");
+        return stream;
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to start exec: ${err}`);
+        throw err;
+    }
+});
+const waitForExec = (exec, stream) => __awaiter(void 0, void 0, void 0, function* () {
+    yield new Promise((res, rej) => {
+        stream.on("end", res);
+        stream.on("error", rej);
+    });
+    const inspectResult = yield exec.inspect();
+    return inspectResult.ExitCode === null ? -1 : inspectResult.ExitCode;
+});

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

@@ -0,0 +1,3 @@
+import Dockerode from "dockerode";
+export declare const getContainerById: (id: string) => Promise<Dockerode.Container>;
+export declare const getContainerByHash: (hash: string) => Promise<Dockerode.Container | undefined>;

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

@@ -0,0 +1,49 @@
+"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.getContainerByHash = exports.getContainerById = void 0;
+const docker_client_1 = require("../../docker-client");
+const logger_1 = require("../../../logger");
+const labels_1 = require("../../../labels");
+const getContainerById = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        return dockerode.getContainer(id);
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to get container by ID: ${err}`);
+        throw err;
+    }
+});
+exports.getContainerById = getContainerById;
+const getContainerByHash = (hash) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const containers = yield dockerode.listContainers({
+            limit: 1,
+            filters: {
+                status: ["running"],
+                label: [`${labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH}=${hash}`],
+            },
+        });
+        if (containers.length === 0) {
+            return undefined;
+        }
+        else {
+            return yield (0, exports.getContainerById)(containers[0].Id);
+        }
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to get container by hash (${hash}): ${err}`);
+        throw err;
+    }
+});
+exports.getContainerByHash = getContainerByHash;

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

@@ -0,0 +1,19 @@
+import { HealthCheckStatus, Labels, NetworkSettings, Ports } from "../../types";
+import Dockerode from "dockerode";
+export type InspectResult = {
+    name: string;
+    hostname: string;
+    ports: Ports;
+    healthCheckStatus: HealthCheckStatus;
+    networkSettings: {
+        [networkName: string]: NetworkSettings;
+    };
+    state: {
+        status: string;
+        running: boolean;
+        startedAt: Date;
+        finishedAt: Date | undefined;
+    };
+    labels: Labels;
+};
+export declare const inspectContainer: (container: Dockerode.Container) => Promise<InspectResult>;

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

@@ -0,0 +1,67 @@
+"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.inspectContainer = void 0;
+const logger_1 = require("../../../logger");
+const inspectContainer = (container) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const inspectResult = yield container.inspect();
+        const finishedAt = new Date(inspectResult.State.FinishedAt);
+        return {
+            name: inspectResult.Name,
+            hostname: inspectResult.Config.Hostname,
+            ports: getPorts(inspectResult),
+            healthCheckStatus: getHealthCheckStatus(inspectResult),
+            networkSettings: getNetworkSettings(inspectResult),
+            state: {
+                status: inspectResult.State.Status,
+                running: inspectResult.State.Running,
+                startedAt: new Date(inspectResult.State.StartedAt),
+                finishedAt: finishedAt.getTime() < 0 ? undefined : finishedAt,
+            },
+            labels: inspectResult.Config.Labels,
+        };
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to inspect container ${container.id}: ${err}`);
+        throw err;
+    }
+});
+exports.inspectContainer = inspectContainer;
+const getPorts = (inspectInfo) => Object.entries(inspectInfo.NetworkSettings.Ports)
+    .filter(([, hostPorts]) => hostPorts !== null)
+    .map(([containerPortAndProtocol, hostPorts]) => {
+    const containerPort = parseInt(containerPortAndProtocol.split("/")[0]);
+    return {
+        [containerPort]: hostPorts.map((hostPort) => ({
+            hostIp: hostPort.HostIp,
+            hostPort: parseInt(hostPort.HostPort),
+        })),
+    };
+})
+    .reduce((acc, curr) => (Object.assign(Object.assign({}, acc), curr)), {});
+const getHealthCheckStatus = (inspectResult) => {
+    const health = inspectResult.State.Health;
+    if (health === undefined) {
+        return "none";
+    }
+    else {
+        return health.Status;
+    }
+};
+const getNetworkSettings = (inspectResult) => Object.entries(inspectResult.NetworkSettings.Networks)
+    .map(([networkName, network]) => ({
+    [networkName]: {
+        networkId: network.NetworkID,
+        ipAddress: network.IPAddress,
+    },
+}))
+    .reduce((prev, next) => (Object.assign(Object.assign({}, prev), next)), {});

package/dist/src/docker/functions/container/list-containers.d.ts

@@ -0,0 +1,2 @@
+import Dockerode from "dockerode";
+export declare const listContainers: () => Promise<Dockerode.ContainerInfo[]>;

package/dist/src/docker/functions/container/list-containers.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.listContainers = void 0;
+const docker_client_1 = require("../../docker-client");
+const logger_1 = require("../../../logger");
+const listContainers = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        return yield dockerode.listContainers();
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to list containers: ${err}`);
+        throw err;
+    }
+});
+exports.listContainers = listContainers;

package/dist/src/docker/functions/container/put-container-archive.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import Dockerode from "dockerode";
+export type PutContainerArchiveOptions = {
+    container: Dockerode.Container;
+    stream: Readable;
+    containerPath: string;
+};
+export declare const putContainerArchive: (options: PutContainerArchiveOptions) => Promise<void>;

package/dist/src/docker/functions/container/put-container-archive.js

@@ -0,0 +1,23 @@
+"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.putContainerArchive = void 0;
+const logger_1 = require("../../../logger");
+const putContainerArchive = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield options.container.putArchive(options.stream, { path: options.containerPath });
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to put archive to container ${options.container.id}: ${err}`);
+        throw err;
+    }
+});
+exports.putContainerArchive = putContainerArchive;

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

@@ -0,0 +1,5 @@
+import Dockerode from "dockerode";
+export type RemoveContainerOptions = {
+    removeVolumes: boolean;
+};
+export declare const removeContainer: (container: Dockerode.Container, options: RemoveContainerOptions) => Promise<void>;

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

@@ -0,0 +1,23 @@
+"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.removeContainer = void 0;
+const logger_1 = require("../../../logger");
+const removeContainer = (container, options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield container.remove({ v: options.removeVolumes });
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to remove container ${container.id}: ${err}`);
+        throw err;
+    }
+});
+exports.removeContainer = removeContainer;

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

@@ -0,0 +1,5 @@
+import Dockerode from "dockerode";
+export type RestartContainerOptions = {
+    timeout: number;
+};
+export declare const restartContainer: (container: Dockerode.Container, options: RestartContainerOptions) => Promise<void>;

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

@@ -0,0 +1,23 @@
+"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.restartContainer = void 0;
+const logger_1 = require("../../../logger");
+const restartContainer = (container, options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield container.restart({ t: options.timeout / 1000 });
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to restart container ${container.id}: ${err}`);
+        throw err;
+    }
+});
+exports.restartContainer = restartContainer;

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

@@ -0,0 +1,2 @@
+import Dockerode from "dockerode";
+export declare const startContainer: (container: Dockerode.Container) => Promise<void>;

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

@@ -0,0 +1,23 @@
+"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.startContainer = void 0;
+const logger_1 = require("../../../logger");
+const startContainer = (container) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield container.start();
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to start container ${container.id}: ${err}`);
+        throw err;
+    }
+});
+exports.startContainer = startContainer;

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

@@ -0,0 +1,5 @@
+import Dockerode from "dockerode";
+export type StopContainerOptions = {
+    timeout: number;
+};
+export declare const stopContainer: (container: Dockerode.Container, options: StopContainerOptions) => Promise<void>;

package/dist/src/docker/functions/container/stop-container.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.stopContainer = void 0;
+const logger_1 = require("../../../logger");
+const stopContainer = (container, options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield container.stop({ t: options.timeout / 1000 });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (err) {
+        if (err.statusCode === 304) {
+            logger_1.log.info(`Container has already been stopped: ${container.id}`);
+        }
+        else {
+            logger_1.log.error(`Failed to stop container ${container.id}: ${err}`);
+            throw err;
+        }
+    }
+});
+exports.stopContainer = stopContainer;

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

@@ -0,0 +1,3 @@
+import { DockerImageName } from "../../docker-image-name";
+import { Labels } from "../types";
+export declare const createLabels: (reusable: boolean, dockerImageName?: DockerImageName, extraLabels?: Labels) => Labels;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLabels = void 0;
+const session_id_1 = require("../session-id");
+const labels_1 = require("../../labels");
+const package_json_1 = require("../../../package.json");
+const createLabels = (reusable, dockerImageName, extraLabels = {}) => {
+    const labels = Object.assign(Object.assign({}, extraLabels), { [labels_1.LABEL_TESTCONTAINERS]: "true", [labels_1.LABEL_TESTCONTAINERS_LANG]: "node", [labels_1.LABEL_TESTCONTAINERS_VERSION]: package_json_1.version });
+    if (dockerImageName && dockerImageName.isReaper()) {
+        return labels;
+    }
+    if (!reusable) {
+        labels[labels_1.LABEL_TESTCONTAINERS_SESSION_ID] = session_id_1.sessionId;
+    }
+    return labels;
+};
+exports.createLabels = createLabels;

package/dist/src/docker/functions/demux-stream.d.ts

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

package/dist/src/docker/functions/demux-stream.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.demuxStream = void 0;
+const stream_1 = require("stream");
+const logger_1 = require("../../logger");
+const demuxStream = (dockerode, stream) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const demuxedStream = new stream_1.PassThrough({ autoDestroy: true, encoding: "utf-8" });
+        dockerode.modem.demuxStream(stream, demuxedStream, demuxedStream);
+        stream.on("end", () => demuxedStream.end());
+        demuxedStream.on("close", () => {
+            if (!stream.destroyed) {
+                stream.destroy();
+            }
+        });
+        return demuxedStream;
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to demux stream: ${err}`);
+        throw err;
+    }
+});
+exports.demuxStream = demuxStream;

package/dist/src/docker/functions/get-info.d.ts

@@ -0,0 +1,11 @@
+import Dockerode from "dockerode";
+export type DockerInfo = {
+    serverVersion: number;
+    operatingSystem: string;
+    operatingSystemType: string;
+    architecture: string;
+    cpus: number;
+    memory: number;
+    indexServerAddress: string;
+};
+export declare const getDockerInfo: (dockerode: Dockerode) => Promise<DockerInfo>;

package/dist/src/docker/functions/get-info.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.getDockerInfo = void 0;
+const logger_1 = require("../../logger");
+const getDockerInfo = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield dockerode.info();
+    return {
+        serverVersion: info.ServerVersion,
+        operatingSystem: info.OperatingSystem,
+        operatingSystemType: info.OSType,
+        architecture: info.Architecture,
+        cpus: info.NCPU,
+        memory: info.MemTotal,
+        indexServerAddress: getIndexServerAddress(info),
+    };
+});
+exports.getDockerInfo = getDockerInfo;
+// https://github.com/containers/podman/issues/17776
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const getIndexServerAddress = (info) => {
+    if (isUndefinedOrEmpty(info.IndexServerAddress)) {
+        logger_1.log.debug("Index server address is not set, using default");
+        return "https://index.docker.io/v1/";
+    }
+    else {
+        return info.IndexServerAddress;
+    }
+};
+const isUndefinedOrEmpty = (value) => value === undefined || value.length === 0;

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

@@ -0,0 +1,13 @@
+import { DockerImageName } from "../../../docker-image-name";
+import { PullPolicy } from "../../../pull-policy";
+import { BuildArgs, RegistryConfig } from "../../types";
+export type BuildImageOptions = {
+    imageName: DockerImageName;
+    context: string;
+    dockerfileName: string;
+    buildArgs: BuildArgs;
+    pullPolicy: PullPolicy;
+    registryConfig: RegistryConfig;
+    cache: boolean;
+};
+export declare const buildImage: (options: BuildImageOptions) => Promise<void>;

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

@@ -0,0 +1,76 @@
+"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.buildImage = void 0;
+const logger_1 = require("../../../logger");
+const tar_fs_1 = __importDefault(require("tar-fs"));
+const byline_1 = __importDefault(require("byline"));
+const docker_client_1 = require("../../docker-client");
+const create_labels_1 = require("../create-labels");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const dockerignore_1 = __importDefault(require("@balena/dockerignore"));
+const buildImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        logger_1.log.info(`Building image '${options.imageName.toString()}' with context '${options.context}'`);
+        const isDockerIgnored = yield createIsDockerIgnoredFunction(options.context);
+        const tarStream = tar_fs_1.default.pack(options.context, {
+            ignore: (aPath) => {
+                const relativePath = path_1.default.relative(options.context, aPath);
+                if (relativePath === options.dockerfileName) {
+                    return false;
+                }
+                else {
+                    return isDockerIgnored(relativePath);
+                }
+            },
+        });
+        const { dockerode } = yield (0, docker_client_1.dockerClient)();
+        const buildImageOptions = {
+            dockerfile: options.dockerfileName,
+            nocache: !options.cache,
+            buildargs: options.buildArgs,
+            t: options.imageName.toString(),
+            labels: (0, create_labels_1.createLabels)(false, options.imageName),
+            registryconfig: options.registryConfig,
+            pull: options.pullPolicy.shouldPull() ? "true" : undefined,
+        };
+        return new Promise((resolve) => {
+            dockerode
+                .buildImage(tarStream, buildImageOptions)
+                .then((stream) => (0, byline_1.default)(stream))
+                .then((stream) => {
+                stream.setEncoding("utf-8");
+                stream.on("data", (line) => logger_1.log.trace(`${options.imageName.toString()}: ${line}`));
+                stream.on("end", () => resolve());
+            });
+        });
+    }
+    catch (err) {
+        logger_1.log.error(`Failed to build image: ${err}`);
+        throw err;
+    }
+});
+exports.buildImage = buildImage;
+const createIsDockerIgnoredFunction = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const dockerIgnoreFilePath = path_1.default.join(context, ".dockerignore");
+    if (!(0, fs_1.existsSync)(dockerIgnoreFilePath)) {
+        return () => false;
+    }
+    const instance = (0, dockerignore_1.default)({ ignorecase: false });
+    const dockerIgnorePatterns = yield fs_1.promises.readFile(dockerIgnoreFilePath, { encoding: "utf-8" });
+    instance.add(dockerIgnorePatterns);
+    const filter = instance.createFilter();
+    return (aPath) => !filter(aPath);
+});

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

@@ -0,0 +1,3 @@
+import { DockerImageName } from "../../../docker-image-name";
+import Dockerode from "dockerode";
+export declare const imageExists: (dockerode: Dockerode, imageName: DockerImageName) => Promise<boolean>;

package/dist/src/docker/functions/image/image-exists.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageExists = void 0;
+const logger_1 = require("../../../logger");
+const async_lock_1 = __importDefault(require("async-lock"));
+const list_images_1 = require("./list-images");
+const existingImages = new Set();
+const imageCheckLock = new async_lock_1.default();
+const imageExists = (dockerode, imageName) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.debug(`Checking if image exists: ${imageName}`);
+    return imageCheckLock.acquire(imageName.toString(), () => __awaiter(void 0, void 0, void 0, function* () {
+        if (existingImages.has(imageName.toString())) {
+            return true;
+        }
+        const images = yield (0, list_images_1.listImages)(dockerode);
+        images.forEach((name) => {
+            existingImages.add(name.toString());
+        });
+        return existingImages.has(imageName.toString());
+    }));
+});
+exports.imageExists = imageExists;

package/dist/src/docker/functions/image/list-images.d.ts

@@ -0,0 +1,3 @@
+import { DockerImageName } from "../../../docker-image-name";
+import Dockerode from "dockerode";
+export declare const listImages: (dockerode: Dockerode) => Promise<DockerImageName[]>;