testcontainers 8.15.0 → 9.0.0

package/README.md

@@ -5,8 +5,6 @@
 [![Node.js CI](https://github.com/testcontainers/testcontainers-node/actions/workflows/node.js.yml/badge.svg?branch=master)](https://github.com/testcontainers/testcontainers-node/actions/workflows/node.js.yml)
 [![npm version](https://badge.fury.io/js/testcontainers.svg)](https://www.npmjs.com/package/testcontainers)
 [![npm version](https://img.shields.io/npm/dm/testcontainers.svg)](https://www.npmjs.com/package/testcontainers)
-[![Thundra Foresight](https://thundra-assets-prod.s3.us-west-2.amazonaws.com/images/badges/thundra-foresight-badge-enabled.svg)](https://foresight.thundra.live/testRuns/57175ecb-d5ac-4129-957a-9dd617fd27d0)
-[![Foresight Test Summary](https://foresight.service.thundra.us/public/api/v1/badge/test/57175ecb-d5ac-4129-957a-9dd617fd27d0)](https://foresight.thundra.live/testruns/57175ecb-d5ac-4129-957a-9dd617fd27d0)
 
 ## Install
 
@@ -22,8 +20,11 @@ The following environment variables are supported:
 
 - `DEBUG=testcontainers` Enable testcontainers logs
 - `DEBUG=testcontainers:containers` Enable container logs
+- `DEBUG=testcontainers:exec` Enable container exec logs
 - `DEBUG=testcontainers*` Enable all logs
 
+Note that you can enable specific loggers, e.g: `DEBUG=testcontainers,testcontainers:exec`.
+
 ### Docker
 
 - `DOCKER_HOST=tcp://docker:2375` Sets the URL of the docker daemon
@@ -117,7 +118,10 @@ const { GenericContainer } = require("testcontainers");
 const buildContext = path.resolve(__dirname, "dir-containing-dockerfile");
 
 const container = await GenericContainer.fromDockerfile(buildContext)
-  .withBuildArg("ARG_KEY", "ARG_VALUE")
+  .withBuildArgs({
+    ARG_1: "ARG_VALUE_1",    
+    ARG_2: "ARG_VALUE_2",    
+  })
   .build();
 
 const startedContainer = await container
@@ -134,6 +138,16 @@ const container = await GenericContainer.fromDockerfile(buildContext, "my-docker
   .build();
 ```
 
+Build the image without using the cache:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await GenericContainer.fromDockerfile(buildContext, "my-dockerfile")
+  .withCache(false)
+  .build();
+```
+
 Creating a container with multiple exposed ports:
 
 ```javascript
@@ -150,12 +164,12 @@ Enabling container reuse, note that two containers are considered equal if their
 const { GenericContainer } = require("testcontainers");
 
 const container1 = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .withReuse()
   .start();
 
 const container2 = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .withReuse()
   .start();
 
@@ -189,7 +203,17 @@ Creating a container with a command:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
+  .start();
+```
+
+Creating a container with entrypoint:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("alpine")
+  .withEntrypoint(["cat"])
   .start();
 ```
 
@@ -199,7 +223,7 @@ Execute commands inside a running container:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .start();
 
 const { output, exitCode } = await container.exec(["echo", "hello", "world"]);
@@ -217,7 +241,6 @@ stream
     .on("data", line => console.log(line))
     .on("err", line => console.error(line))
     .on("end", () => console.log("Stream closed"));
-
 ```
 
 Creating a container with bind mounts:
@@ -226,8 +249,14 @@ Creating a container with bind mounts:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withBindMount("/local/file.txt", "/remote/file.txt")
-  .withBindMount("/local/dir", "/remote/dir", "ro")
+  .withBindMounts([{ 
+    source: "/local/file.txt", 
+    target:"/remote/file.txt" 
+  }, {
+    source: "/local/dir",
+    target:"/remote/dir",
+    mode: "ro"
+  }])
   .start();
 ```
 
@@ -249,8 +278,14 @@ const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("postgres")
   .withExposedPorts(5432)
-  .withCopyFileToContainer("/local/file.txt", "/remote/file1.txt")
-  .withCopyContentToContainer("hello world", "/remote/file2.txt")
+  .withCopyFilesToContainer([{ 
+    source: "/local/file.txt", 
+    target: "/remote/file1.txt"
+  }])
+  .withCopyContentToContainer([{ 
+    content: "hello world",
+    target: "/remote/file2.txt"
+  }])
   .start();
 ```
 
@@ -260,7 +295,10 @@ Creating a container with environment variables:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withEnv("ENV_KEY", "ENV_VALUE")
+  .withEnvironment({ 
+    ENV_1: "ENV_VALUE_1", 
+    ENV_2: "ENV_VALUE_2", 
+  })
   .start();
 ```
 
@@ -284,7 +322,7 @@ const { GenericContainer, Wait } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
   .withHealthCheck({
-    test: "curl -f http://localhost || exit 1",
+    test: ["CMD-SHELL", "curl -f http://localhost || exit 1"],
     interval: 1000,
     timeout: 3000,
     retries: 5,
@@ -294,32 +332,44 @@ const container = await new GenericContainer("alpine")
   .start();
 ```
 
-Creating a container that connects to a specific network:
+To execute the `test` in a shell use the form `["CMD-SHELL", "command"]`, for example:
 
 ```javascript
-const { GenericContainer } = require("testcontainers");
+["CMD-SHELL", "curl -f http://localhost:8000 || exit 1"]
+```
 
-const container = await new GenericContainer("alpine")
-  .withNetworkMode("network_name")
-  .start();
+To execute the `test` without a shell, use the form: `["CMD", "command", "arg1", "arg2"]`, for example:
+
+```javascript
+["CMD", "/usr/bin/wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/hello-world"]
 ```
 
-Create user-defined bridge network and attach the container to it:
+Creating a container within a network:
 
 ```javascript
 const { GenericContainer, Network } = require("testcontainers");
 
 const network = await new Network()
-    .start();
+  .start();
 
 const container = await new GenericContainer("alpine")
-  .withNetworkMode(network.getName())
+  .withNetwork(network)
   .start();
 
 await container.stop();
 await network.stop();
 ```
 
+Creating a container with a network mode:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("alpine")
+  .withNetworkMode("bridge")
+  .start();
+```
+
 Communicate to containers on the same network via aliases:
 
 ```javascript
@@ -329,17 +379,17 @@ const network = await new Network()
     .start();
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
-  .withNetworkMode(network.getName())
+  .withCommand(["sleep", "infinity"])
+  .withNetwork(network)
   .start();
 
 const fooContainer = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
-  .withNetworkMode(network.getName())
+  .withCommand(["sleep", "infinity"])
+  .withNetwork(network)
   .withNetworkAliases("foo", "bar")
   .start();
 
-expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
+expect((await container.exec(["getent", "hosts", "foo"])).exitCode).toBe(0);
 ```
 
 Add hostname mappings:
@@ -348,14 +398,17 @@ Add hostname mappings:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withExtraHosts(
-    { host: "foo", ipAddress: "10.11.12.13" },
-    { host: "bar", ipAddress: "11.12.13.14" }
-  )
+  .withExtraHosts([{
+    host: "foo",
+    ipAddress: "10.11.12.13"
+  }, {
+    host: "bar",
+    ipAddress: "11.12.13.14"
+  }])
   .start();
 
-expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
-expect((await container.exec(["nslookup", "bar"])).exitCode).toBe(0);
+expect((await container.exec(["getent", "hosts", "foo"])).exitCode).toBe(0);
+expect((await container.exec(["getent", "hosts", "bar"])).exitCode).toBe(0);
 ```
 
 Specifying a pull policy. Note that if omitted will use the `DefaultPullPolicy` which will use a locally cached image
@@ -414,6 +467,41 @@ const container = await new GenericContainer("alpine")
   .start();
 ```
 
+Creating a container with added [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withAddedCapabilities("NET_ADMIN", "IPC_LOCK")
+  .start();
+```
+
+Creating a container with dropped [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withDroppedCapabilities("NET_ADMIN", "IPC_LOCK")
+  .start();
+```
+
+Creating a container with ulimits:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withUlimits({ 
+    memlock: { 
+      hard: -1, 
+      soft: -1 
+    }
+  })
+  .start();
+```
+
 Creating a container with [IPC mode](https://docs.docker.com/engine/reference/run/#ipc-settings---ipc):
 
 ```javascript
@@ -462,7 +550,7 @@ const network = await new Network()
   .start();
 
 const container = await new GenericContainer("alpine")
-  .withNetworkMode(network.getName())
+  .withNetwork(network)
   .start();
 
 const networkIpAddress = container.getIpAddress(network.getName());
@@ -483,7 +571,7 @@ server.listen(8000);
 await TestContainers.exposeHostPorts(8000);
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["sleep", "infinity"])
+  .withCommand(["sleep", "infinity"])
   .start();
 
 const { output } = await container.exec(["curl", `http://host.testcontainers.internal:8000`]);
@@ -582,7 +670,8 @@ Once the environment has started, you can interact with the containers as you wo
 ```javascript
 const { DockerComposeEnvironment } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
 
 const container = environment.getContainer("alpine_1");
 const { output, exitCode } = await container.exec(["echo", "hello", "world"]);
@@ -593,7 +682,8 @@ You can supply [multiple compose files](https://docs.docker.com/compose/extends/
 ```javascript
 const { DockerComposeEnvironment } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, [composeFile1, composeFile2]).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, [composeFile1, composeFile2])
+  .up();
 
 await environment.stop();
 ```
@@ -603,7 +693,8 @@ If you have multiple docker-compose environments which share dependencies such a
 ```javascript
 const { DockerComposeEnvironment } = require("testcontainers");
 
-const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
 
 await environment.stop();
 ```
@@ -662,10 +753,36 @@ Then we can set `TAG` as follows:
 const { DockerComposeEnvironment } = require("testcontainers");
 
 const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
-  .withEnv("TAG", "value")
+  .withEnvironment({ "TAG": "VALUE" })
   .up();
 ```
 
+Testcontainers will not wait for an environment to down, to override:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
+
+await environment.down({ 
+  timeout: 10000 
+});
+```
+
+Testcontainers will remove associated volumes created by the environment when downed, to override:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile)
+  .up();
+
+await environment.down({
+  removeVolumes: false
+});
+```
+
 ## Wait Strategies
 
 Ordinarily Testcontainers will wait for up to 60 seconds for the container's mapped network ports to start listening.
@@ -726,10 +843,10 @@ Testcontainers may need to create auxiliary containers to provide its functional
 
 To avoid Docker pull limits, you can host your own images and use them by setting the appropriate environment variables:
 
-| Container | Environment Variable | Default
-| --- | --- | --- |
-| ryuk | `RYUK_CONTAINER_IMAGE` | `testcontainers/ryuk:0.3.2` |
-| SSHd | `SSHD_CONTAINER_IMAGE` | `testcontainers/sshd:1.0.0` |
+| Container | Environment Variable   | Default                     |
+|-----------|------------------------|-----------------------------|
+| ryuk      | `RYUK_CONTAINER_IMAGE` | `testcontainers/ryuk:0.3.2` |
+| SSHd      | `SSHD_CONTAINER_IMAGE` | `testcontainers/sshd:1.0.0` |
 
 ### ryuk
 

package/dist/bound-ports.d.ts

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

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

@@ -1,8 +1,7 @@
 import Dockerode from "dockerode";
-import { Host } from "./types";
 import "../testcontainers-properties-file";
 declare type DockerClient = {
-    host: Host;
+    host: string;
     dockerode: Dockerode;
 };
 export declare const dockerClient: () => Promise<DockerClient>;

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

@@ -15,12 +15,7 @@ const demux_stream_1 = require("../demux-stream");
 const docker_client_1 = require("../../docker-client");
 const containerLogs = (container) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const options = {
-            follow: true,
-            stdout: true,
-            stderr: true,
-        };
-        const stream = (yield container.logs(options));
+        const stream = (yield container.logs({ follow: true, stdout: true, stderr: true }));
         stream.socket.unref();
         return (0, demux_stream_1.demuxStream)((yield (0, docker_client_1.dockerClient)()).dockerode, stream);
     }

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

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

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

@@ -22,11 +22,11 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
             name: options.name,
             User: options.user,
             Image: options.imageName.toString(),
-            Env: getEnv(options.env),
+            Env: getEnvironment(options.environment),
             ExposedPorts: getExposedPorts(options.exposedPorts),
-            Cmd: options.cmd,
+            Cmd: options.command,
+            Entrypoint: options.entrypoint,
             Labels: (0, create_labels_1.createLabels)(options.reusable, options.imageName, options.labels),
-            // @ts-ignore
             Healthcheck: getHealthCheck(options.healthCheck),
             HostConfig: {
                 IpcMode: options.ipcMode,
@@ -38,6 +38,9 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
                 Tmpfs: options.tmpFs,
                 LogConfig: getLogConfig(options.useDefaultLogDriver),
                 Privileged: options.privilegedMode,
+                Ulimits: getUlimits(options.ulimits),
+                CapAdd: options.addedCapabilities,
+                CapDrop: options.droppedCapabilities,
             },
         });
     }
@@ -47,7 +50,7 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
     }
 });
 exports.createContainer = createContainer;
-const getEnv = (env) => Object.entries(env).reduce((dockerodeEnvironment, [key, value]) => [...dockerodeEnvironment, `${key}=${value}`], []);
+const getEnvironment = (environment) => Object.entries(environment).reduce((dockerodeEnvironment, [key, value]) => [...dockerodeEnvironment, `${key}=${value}`], []);
 const getExposedPorts = (exposedPorts) => {
     const dockerodeExposedPorts = {};
     for (const exposedPort of exposedPorts) {
@@ -71,14 +74,14 @@ const getPortBindings = (exposedPorts) => {
     return dockerodePortBindings;
 };
 const getBindMounts = (bindMounts) => {
-    return bindMounts.map(({ source, target, bindMode }) => `${source}:${target}:${bindMode}`);
+    return bindMounts.map(({ source, target, mode }) => `${source}:${target}:${mode}`);
 };
 const getHealthCheck = (healthCheck) => {
     if (healthCheck === undefined) {
         return undefined;
     }
     return {
-        Test: ["CMD-SHELL", healthCheck.test],
+        Test: healthCheck.test,
         Interval: healthCheck.interval ? toNanos(healthCheck.interval) : 0,
         Timeout: healthCheck.timeout ? toNanos(healthCheck.timeout) : 0,
         Retries: healthCheck.retries || 0,
@@ -95,3 +98,13 @@ const getLogConfig = (useDefaultLogDriver) => {
         Config: {},
     };
 };
+const getUlimits = (ulimits) => {
+    if (!ulimits) {
+        return undefined;
+    }
+    return Object.entries(ulimits).map(([key, value]) => ({
+        Name: key,
+        Hard: value.hard,
+        Soft: value.soft,
+    }));
+};

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

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

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

@@ -8,10 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 execContainer = (container, command, options) => __awaiter(void 0, void 0, void 0, function* () {
+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,
@@ -19,14 +24,16 @@ const execContainer = (container, command, options) => __awaiter(void 0, void 0,
             AttachStderr: true,
         });
         const stream = yield startExec(exec, options);
-        const chunks = [];
         stream.on("data", (chunk) => chunks.push(chunk));
+        if (shouldLog) {
+            (0, byline_1.default)(stream).on("data", (line) => logger_1.execLog.trace(`${container.id}: ${line}`));
+        }
         const exitCode = yield waitForExec(exec);
         stream.destroy();
         return { output: chunks.join(""), exitCode };
     }
     catch (err) {
-        logger_1.log.error(`Failed to exec container ${container.id} with command "${command.join(" ")}": ${err}`);
+        logger_1.log.error(`Failed to exec container ${container.id} with command "${command.join(" ")}": ${err}. Container output: ${chunks.join("")}`);
         throw err;
     }
 });

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

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

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

@@ -1,7 +1,7 @@
-import { ContainerName, HealthCheckStatus, Labels, NetworkSettings, Ports } from "../../types";
+import { HealthCheckStatus, Labels, NetworkSettings, Ports } from "../../types";
 import Dockerode from "dockerode";
 export declare type InspectResult = {
-    name: ContainerName;
+    name: string;
     hostname: string;
     ports: Ports;
     healthCheckStatus: HealthCheckStatus;

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

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

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

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

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

@@ -37,21 +37,26 @@ const buildImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
             },
         });
         const { dockerode } = yield (0, docker_client_1.dockerClient)();
-        return new Promise((resolve) => dockerode
-            .buildImage(tarStream, {
+        const buildImageOptions = {
             dockerfile: options.dockerfileName,
+            // @ts-ignore
+            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() ? "any" : undefined,
-        })
-            .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());
-        }));
+        };
+        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}`);

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

@@ -1,3 +1,2 @@
-import { Command } from "../types";
 import Dockerode from "dockerode";
-export declare const runInContainer: (dockerode: Dockerode, image: string, command: Command[]) => Promise<string | undefined>;
+export declare const runInContainer: (dockerode: Dockerode, image: string, command: string[]) => Promise<string | undefined>;