build-strap 4.0.0-dev.46 → 4.0.0

package/dist/src/docker.container.js

@@ -0,0 +1,247 @@
+import bytes from 'bytes';
+import { throttle } from 'lodash-es';
+import { spawn } from './cp.js';
+import { parseDockerDate } from './docker.js';
+import { buildLog } from './run.js';
+// calling this function in rapid succession can lead to errors.
+// prefer throttled version
+export async function unthrottledDockerContainerLs({ all, filter, } = {}) {
+    return (await spawn('docker', [
+        'container',
+        'ls',
+        ...(all ? ['--all'] : []),
+        '--no-trunc',
+        '--format',
+        '{{json .}}',
+    ], { captureOutput: true })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => {
+        const { Command: command, CreatedAt, ID: id, Image: image, Labels, Mounts, Names, Networks, Ports, RunningFor: runningFor, Size, Status: status, } = JSON.parse(line.trim());
+        const names = Names.split(',').map((n) => n.trim());
+        const [name] = names;
+        return {
+            command,
+            created: parseDockerDate(CreatedAt),
+            async exists() {
+                try {
+                    return !!(await this.inspect());
+                }
+                catch {
+                    return false;
+                }
+            },
+            exited: /^Exited/.test(status),
+            id,
+            image,
+            inspect: async () => (await dockerContainerInspect(id))?.[0],
+            async isRunning() {
+                try {
+                    return (await this.inspect())?.State?.Running || false;
+                }
+                catch {
+                    return false;
+                }
+            },
+            kill: async (ignoreError = true) => dockerContainerKill(id, ignoreError),
+            labels: Labels.split(',').map((l) => l.trim()),
+            mounts: Mounts.split(',').map((m) => m.trim()),
+            name,
+            names,
+            networks: Networks.split(',').map((n) => n.trim()),
+            ports: Ports.split(',').map((p) => {
+                const [, iface, src, dest] = p.match(/^([^:]+):(\d+)-\\u003e(\d+)/i) || [];
+                return {
+                    dest: parseInt(dest, 10),
+                    iface,
+                    src: parseInt(src, 10),
+                };
+            }),
+            restart: async () => dockerContainerRestart(id),
+            rm: async (ignoreError = true) => dockerContainerRm(id, ignoreError),
+            runningFor,
+            size: bytes.parse(Size),
+            start: async () => dockerContainerStart(id),
+            status,
+            stop: async (ignoreError = true) => dockerContainerStop(id, ignoreError),
+            async teardown(verbose = true) {
+                const log = (msg) => verbose && buildLog(msg);
+                if (await this.isRunning()) {
+                    try {
+                        log(`Stopping container: <${this.name}>...`);
+                        await this.stop(false);
+                        log(`<${this.name}> container stopped.`);
+                    }
+                    catch (e1) {
+                        log(`Failed to stop <${this.name}> container: ${e1.message}`);
+                        try {
+                            log(`Killing container: <${this.name}>...`);
+                            await this.kill(false);
+                            log(`<${this.name}> container killed.`);
+                        }
+                        catch (e2) {
+                            log(`Failed to kill <${this.name}> container: ${e2.message}`);
+                        }
+                    }
+                }
+                else {
+                    log(`<${this.name}> container not running, skipping stop.`);
+                }
+                if (await this.exists()) {
+                    await this.rm(true);
+                }
+                else {
+                    log(`<${this.name}> container does not exist, skipping rm.`);
+                }
+            },
+        };
+    })
+        .filter((c) => c.id && (typeof filter === 'function' ? filter(c) : true));
+}
+export const dockerContainerLs = throttle(unthrottledDockerContainerLs, 500, {
+    trailing: false,
+});
+export async function dockerContainerFind(search, options) {
+    return ((await dockerContainerLs(options))?.find((c) => c.name === search ||
+        c.id.startsWith(search) ||
+        c.names.includes(search)) || null);
+}
+export async function dockerContainerStop(id, ignoreErrors = true) {
+    const ids = Array.isArray(id) ? id : [id];
+    try {
+        await spawn('docker', ['container', 'stop', ...ids]);
+    }
+    catch (e) {
+        if (!ignoreErrors) {
+            throw new Error(`Failed to stop container(s): ${e.message}`);
+        }
+    }
+}
+export async function dockerContainerKill(id, ignoreErrors = true) {
+    const ids = Array.isArray(id) ? id : [id];
+    try {
+        await spawn('docker', ['container', 'kill', ...ids]);
+    }
+    catch (e) {
+        if (!ignoreErrors) {
+            throw new Error(`Failed to kill container(s): ${e.message}`);
+        }
+    }
+}
+export async function dockerTryStopContainer(id, name = '') {
+    if (id) {
+        try {
+            await dockerContainerStop(id, false);
+        }
+        catch (e) {
+            buildLog(`Failed to stop ${name} container: ${e.message}`);
+        }
+    }
+}
+export async function dockerContainerRm(id, ignoreErrors = true) {
+    const ids = Array.isArray(id) ? id : [id];
+    try {
+        await spawn('docker', ['container', 'rm', ...ids]);
+    }
+    catch (e) {
+        if (ignoreErrors) {
+            buildLog(`Warning (ignored Error): Failed to remove container(s): ${e.message}`);
+        }
+        else {
+            throw new Error(`Failed to remove container(s): ${e.message}`);
+        }
+    }
+}
+export async function dockerContainerRestart(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    await spawn('docker', ['container', 'restart', ...ids]);
+}
+export async function dockerContainerStart(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    await spawn('docker', ['container', 'start', ...ids]);
+}
+export async function unthrottledDockerContainerInspect(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    return ((await spawn('docker', ['container', 'inspect', '--format', '{{json .}}', ...ids], { captureOutput: true })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => JSON.parse(line.trim())) || []);
+}
+export const dockerContainerInspect = throttle(unthrottledDockerContainerInspect, 500, {
+    trailing: false,
+});
+export async function dockerContainerRun({ image, runArgs = [], cmd = [], spawnOptions, }) {
+    return (await spawn('docker', ['container', 'run', ...runArgs, image, ...cmd], {
+        pipeOutput: true,
+        stdio: 'inherit',
+        ...spawnOptions,
+    })).output;
+}
+export async function dockerContainerRunDaemon({ image, runArgs = [], cmd = [], waitAttempts = 10, waitDuration = 501, }) {
+    const id = (await dockerContainerRun({
+        cmd,
+        image,
+        runArgs: ['-d', ...runArgs],
+        spawnOptions: {
+            captureOutput: true,
+            pipeOutput: false,
+            stdio: 'pipe',
+        },
+    })).trim();
+    let container = await dockerContainerFind(id);
+    let attempts = 0;
+    // containers don't always show up in the list right away
+    /* eslint-disable no-await-in-loop */
+    while (!container && attempts < waitAttempts) {
+        await new Promise((resolve) => {
+            setTimeout(resolve, waitDuration);
+        });
+        container = await dockerContainerFind(id);
+        attempts += 1;
+    }
+    /* eslint-enable no-await-in-loop */
+    if (!container) {
+        throw new Error(`Failed to find newly created container: ${id}`);
+    }
+    return container;
+}
+const indicators = ['.', ':', '*', '+', '-', '=', '%', '$', '@', '^', '&'];
+let curIndicator = 0;
+/**
+ * Waits for the given container to be fully started. Checks that the container is
+ * running, and test with the provided testFn every second until it returns true.
+ * @param {DockerContainer} container The container to test
+ * @param {Function} testFn A function that validates that the container is ready (e.g. by calling an API on the container)
+ * @param {number} timeoutMs The amount of time to wait between attempts.
+ * @param {number} maxAttempts The maximum number of attempts before giving up (rejects promise)
+ */
+export const dockerContainerWaitForStart = async (container, testFn, timeoutMs = 1000, maxAttempts = 1200) => {
+    // claim an indicator
+    const indicator = indicators[curIndicator] || '.';
+    curIndicator = (curIndicator + 1) % indicators.length;
+    const { name } = container;
+    buildLog(`Waiting for ${name} to fully start... ${indicator}`);
+    await new Promise((resolve, reject) => {
+        const check = (tries = 0) => {
+            process.stdout.write(indicator);
+            setTimeout(async () => {
+                try {
+                    if (!(await container.isRunning())) {
+                        return reject(new Error(`The '${name}' container is no longer running.`));
+                    }
+                    if (await testFn(container)) {
+                        return resolve();
+                    }
+                }
+                catch (err) {
+                    // ignore
+                }
+                return tries < maxAttempts
+                    ? check(tries + 1)
+                    : reject(new Error(`Timeout waiting for '${name}' container to start.`));
+            }, timeoutMs);
+        };
+        check();
+    });
+    process.stdout.write('\n');
+};

package/dist/src/docker.d.ts

@@ -0,0 +1,68 @@
+export interface DockerConfig {
+    name?: string;
+    registry?: string;
+    repository?: string;
+}
+export declare function getDockerConfig(): DockerConfig;
+export declare const parseDockerDate: (date: string) => Date;
+export declare function dockerBuild(tags?: string[], buildArgs?: string[], target?: string | null, extraArgs?: string[], repo?: string, dockerFile?: string, workDir?: string): Promise<string>;
+export declare function dockerTag(imageId: string, tags?: string[], repo?: string): Promise<void>;
+/**
+ * Apply the standard convention for tagging the docker image for the project,
+ * based on the source control branch being built.
+ * For releases, applies `latest`, `M.m.p`, `M.m`, `M`
+ * For release candidates, applies `latest-rc`
+ * For feature branches, applies `latest-feature`
+ * For development branch, applies `latest-dev`
+ * All other branches, no tag is applies
+ * @param {string} imageId id of the docker image to which to apply the tags
+ * @param {string} repo optional override of the docker repo url to use (derived from package.json by default)
+ */
+export declare function dockerTagVersion(imageId: string, repo?: string): Promise<void>;
+export interface DockerImage {
+    created: Date;
+    digest: string;
+    id: string;
+    repository: string;
+    size: number;
+    tag: string;
+}
+export declare type DockerImageFilter = (i: DockerImage) => boolean;
+export declare function dockerImages(repo?: null | string, filter?: null | DockerImageFilter): Promise<DockerImage[]>;
+export declare function getDockerId(tag?: string, repo?: null | string): Promise<string>;
+export declare function getUntaggedDockerIds(repo?: string, filter?: null | DockerImageFilter): Promise<string[]>;
+export declare function getDockerTags(id?: null | string, repo?: null | string, fullName?: boolean, filter?: null | DockerImageFilter): Promise<string[]>;
+export declare function getDockerDigest(imageId: string, repo?: string): Promise<string>;
+interface DockerLoginOptions {
+    password?: string;
+    registry?: string;
+    user?: string;
+}
+export declare function dockerLogin({ password, registry, user, }?: DockerLoginOptions): Promise<void>;
+export declare function dockerPush(tags?: string[], repo?: string): Promise<void>;
+export interface DockerPullOptions {
+    image: string;
+    offline?: boolean;
+    testUrl?: string | null;
+}
+export declare function dockerPull({ image, offline, testUrl, }: DockerPullOptions): Promise<void>;
+export declare function dockerRmi(images?: string[], ignoreErrors?: boolean): Promise<void>;
+export declare function getDockerRepo(): string;
+export interface PullAndRunContainerOptions extends DockerPullOptions {
+    alias?: string | null;
+    cmd?: string[];
+    network?: string | null;
+    runArgs?: string[];
+}
+export declare function dockerPullAndRunContainer(options: PullAndRunContainerOptions): Promise<string>;
+export interface CopyFilePathConfig {
+    from: string;
+    to: string;
+}
+export interface CopyFilesFromDockerImageConfig {
+    filePaths: CopyFilePathConfig[];
+    ignoreErrors?: boolean;
+    imageId: string;
+}
+export declare function copyFilesFromDockerImage({ filePaths, ignoreErrors, imageId, }: CopyFilesFromDockerImageConfig): Promise<any>;
+export {};

package/dist/src/docker.js

@@ -0,0 +1,188 @@
+import bytes from 'bytes';
+import isReachable from 'is-reachable';
+import moment from 'moment';
+import path from 'path';
+import { spawn } from './cp.js';
+import { dockerContainerKill, dockerContainerRunDaemon, } from './docker.container.js';
+import { dockerNetworkConnect } from './docker.network.js';
+import { getCfg, getPkgName, getPkgScope } from './pkg.js';
+import { buildLog } from './run.js';
+import { getDevBranch, getVersion } from './version.js';
+export function getDockerConfig() {
+    return getCfg().docker || {};
+}
+export const parseDockerDate = (date) => moment(date, 'YYYY-MM-DD HH:mm:ss ZZ').toDate();
+export async function dockerBuild(tags = ['latest'], buildArgs = [], target = null, extraArgs = [], repo = getDockerRepo(), dockerFile = './Dockerfile', workDir = '.') {
+    const args = [
+        'build',
+        ...['-f', path.resolve(dockerFile)],
+        ...(target ? ['--target', target] : []),
+        ...tags.reduce((ar, t) => [...ar, '-t', `${repo}:${t}`], []),
+        ...buildArgs.reduce((ar, a) => [...ar, '--build-arg', a], []),
+        ...(extraArgs || []),
+        path.resolve(workDir),
+    ];
+    return (await spawn('docker', args, { stdio: 'inherit' })).output;
+}
+export async function dockerTag(imageId, tags = ['latest'], repo = getDockerRepo()) {
+    await Promise.all(tags.map(async (t) => {
+        await spawn('docker', ['tag', imageId, `${repo}:${t}`]);
+        buildLog(`Tagged image ${imageId} as ${repo}:${t}`);
+    }));
+}
+/**
+ * Apply the standard convention for tagging the docker image for the project,
+ * based on the source control branch being built.
+ * For releases, applies `latest`, `M.m.p`, `M.m`, `M`
+ * For release candidates, applies `latest-rc`
+ * For feature branches, applies `latest-feature`
+ * For development branch, applies `latest-dev`
+ * All other branches, no tag is applies
+ * @param {string} imageId id of the docker image to which to apply the tags
+ * @param {string} repo optional override of the docker repo url to use (derived from package.json by default)
+ */
+export async function dockerTagVersion(imageId, repo = getDockerRepo()) {
+    const { branch, isRelease, major, minor, patch } = await getVersion();
+    // determine what tags to apply
+    if (isRelease) {
+        await dockerTag(imageId, ['latest', `${major}`, `${major}.${minor}`, `${major}.${minor}.${patch}`], repo);
+    }
+    else if (branch === (await getDevBranch())) {
+        await dockerTag(imageId, ['latest-dev'], repo);
+    }
+    else if (branch.match(/^(release|patch)-/)) {
+        await dockerTag(imageId, ['latest-rc'], repo);
+    }
+    else if (branch.match(/^feature-/)) {
+        await dockerTag(imageId, ['latest-feature'], repo);
+    }
+}
+export async function dockerImages(repo = getDockerRepo(), filter = null) {
+    return (await spawn('docker', ['images', '--format', `{{json .}}`, ...(repo ? [repo] : [])], { captureOutput: true })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((l) => {
+        const { CreatedAt, Digest: digest, ID: id, Repository: repository, Size, Tag: tag, } = JSON.parse(l.trim());
+        return {
+            created: parseDockerDate(CreatedAt),
+            digest,
+            id,
+            repository,
+            size: bytes.parse(Size),
+            tag,
+        };
+    })
+        .filter((m) => (m && m.id) != null &&
+        (typeof filter === 'function' ? filter(m) : true));
+}
+export async function getDockerId(tag = 'latest', repo = null) {
+    return (await dockerImages(repo, (m) => m.tag === tag)).map((m) => m.id)[0];
+}
+export async function getUntaggedDockerIds(repo, filter = null) {
+    return (await dockerImages(repo, (m) => m.tag === '<none>' && (typeof filter === 'function' ? filter(m) : true))).map((m) => m.id);
+}
+export async function getDockerTags(id, repo, fullName = false, filter = null) {
+    return (await dockerImages(repo, (m) => (!id || m.id === id) &&
+        (typeof filter === 'function' ? filter(m) : true))).map((m) => (fullName ? `${m.repository}:${m.tag}` : m.tag));
+}
+export async function getDockerDigest(imageId, repo) {
+    return (await dockerImages(repo, (m) => m.id === imageId)).map((m) => m.digest)[0];
+}
+export async function dockerLogin({ password = process.env.DOCKER_PASSWORD, registry = process.env.DOCKER_REGISTRY, user = process.env.DOCKER_PASSWORD, } = {}) {
+    const reg = registry || getDockerConfig().registry;
+    await spawn('docker', ['login', '-u', user || '', '-p', password || '', ...(reg ? [reg] : [])], { stdio: 'inherit' });
+}
+export async function dockerPush(tags = ['latest'], repo = getDockerRepo()) {
+    // do this sequentially, so you don't push the same image simultaneously
+    await tags.reduce(async (prev, tag) => {
+        await prev;
+        await spawn('docker', ['push', `${repo}:${tag}`], { stdio: 'inherit' });
+    }, Promise.resolve());
+}
+export async function dockerPull({ image, offline = process.argv.includes('--offline'), testUrl, }) {
+    if (offline || !(await isReachable(testUrl || 'https://hub.docker.com'))) {
+        if (offline === false) {
+            throw new Error('Offline, cannot docker pull');
+        }
+        buildLog('It looks like you are offline, skipping docker pull');
+    }
+    else {
+        // throws on failure
+        await spawn('docker', ['pull', image], { stdio: 'inherit' });
+    }
+}
+export async function dockerRmi(images = [], ignoreErrors = true) {
+    // must do these sequentially, or they will interfere with each other
+    await images.reduce(async (prev, image) => {
+        await prev;
+        await spawn('docker', ['rmi', image], { stdio: 'inherit' }).catch((err) => {
+            if (ignoreErrors) {
+                buildLog(`Warning (ignored Error): Failed to rm image(s): ${err.message}`);
+            }
+            else {
+                throw err;
+            }
+        });
+    }, Promise.resolve());
+}
+export function getDockerRepo() {
+    const { name: dkrName, registry, repository: dkrRepo } = getDockerConfig();
+    const repository = dkrRepo || getPkgScope();
+    const name = dkrName || getPkgName(false);
+    if (!repository || !name) {
+        throw new Error('Docker configuration is missing or incomplete in package.json');
+    }
+    return `${registry ? `${registry}/` : ''}${repository}/${name}`;
+}
+export async function dockerPullAndRunContainer(options) {
+    const { image, runArgs = [], cmd = [], network, alias, offline = process.argv.includes('--offline'), testUrl, } = options;
+    try {
+        await dockerPull({ image, offline, testUrl });
+    }
+    catch (err) {
+        buildLog(`docker pull failed (${err.message}), attempting to continue...`);
+    }
+    const { id } = await dockerContainerRunDaemon({ cmd, image, runArgs });
+    if (network) {
+        await dockerNetworkConnect(network, id, alias);
+    }
+    return id;
+}
+export async function copyFilesFromDockerImage({ filePaths, ignoreErrors, imageId, }) {
+    const container = await dockerContainerRunDaemon({
+        cmd: ['read', '-p', 'pause'],
+        image: imageId,
+        runArgs: ['-it', '--rm', '--entrypoint=/bin/bash'],
+    });
+    buildLog(`Copying Files from Docker Image - imageId (${imageId})`);
+    const spawnOptions = {
+        captureOutput: false,
+        pipeOutput: true,
+        stdio: 'inherit',
+    };
+    const copyErrors = [];
+    try {
+        filePaths.forEach(async (fp) => {
+            // Try to copy from the Debug Folder
+            try {
+                await spawn('docker', ['cp', `${container.id}:${fp.from}`, fp.to], spawnOptions);
+                buildLog(`Copied ${fp.from} => ${fp.to}`);
+            }
+            catch (error) {
+                copyErrors.push(error);
+                buildLog(`Error copying file ${fp.from}`);
+            }
+        });
+    }
+    finally {
+        try {
+            await dockerContainerKill(container.id);
+        }
+        catch (error) {
+            copyErrors.push(error);
+        }
+    }
+    if (copyErrors.length > 0 && ignoreErrors !== true) {
+        throw new Error('Some files failed to copy');
+    }
+}

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

@@ -0,0 +1,42 @@
+export interface DockerNetwork {
+    IPv6: boolean;
+    created: Date;
+    driver: string;
+    exists: () => Promise<boolean>;
+    id: string;
+    labels: string[];
+    name: string;
+    rm: () => Promise<void>;
+    scope: string;
+}
+interface DockerNetworkLsOptions {
+    filter?: (network: DockerNetwork) => boolean;
+}
+export declare function unthrottledDockerNetworkLs({ filter, }?: DockerNetworkLsOptions): Promise<DockerNetwork[]>;
+export declare const dockerNetworkLs: (options?: DockerNetworkLsOptions) => Promise<DockerNetwork[]> | undefined;
+export declare function dockerNetworkFind(networkName: string, options?: DockerNetworkLsOptions): Promise<DockerNetwork | null>;
+export interface DockerNetworkCreateOptions {
+    auxAddresses?: string[];
+    driver?: string;
+    driverOpts?: Record<string, string>;
+    gateways?: string[];
+    ingress?: boolean;
+    internal?: boolean;
+    ipRange?: string;
+    ipv6?: boolean;
+    labels?: string[];
+    subnets?: string[];
+}
+export declare function dockerNetworkCreate(networkName: string, { driver, driverOpts, ipRange, gateways, subnets, auxAddresses, ingress, internal, ipv6, labels, }?: DockerNetworkCreateOptions): Promise<DockerNetwork | null>;
+/**
+ * Removes a network by id
+ * @param {string} id The id of the network
+ */
+export declare function dockerNetworkRm(id: string): Promise<void>;
+/**
+ * Removes all networks with the given name
+ * @param {string} networkName The name of the network
+ */
+export declare function dockerNetworkDelete(networkName: string): Promise<void>;
+export declare function dockerNetworkConnect(networkName: string, containerId: string, alias?: string | null): Promise<void>;
+export {};

package/dist/src/docker.network.js

@@ -0,0 +1,85 @@
+import { throttle } from 'lodash-es';
+import { spawn } from './cp.js';
+import { parseDockerDate } from './docker.js';
+// calling this function in rapid succession can lead to errors.
+// prefer throttled version
+export async function unthrottledDockerNetworkLs({ filter, } = {}) {
+    return (await spawn('docker', ['network', 'ls', '--format', '{{json .}}'], {
+        captureOutput: true,
+    })).output
+        .split('\n')
+        .filter((line) => !!line.trim())
+        .map((line) => {
+        const { CreatedAt, Driver: driver, ID: id, IPv6, Labels, Name: name, Scope: scope, } = JSON.parse(line.trim());
+        return {
+            IPv6: IPv6 === 'true',
+            created: parseDockerDate(CreatedAt),
+            driver,
+            exists: async () => !!(await dockerNetworkFind(id)),
+            id,
+            labels: Labels.split(',').map((l) => l.trim()),
+            name,
+            rm: async () => dockerNetworkRm(id),
+            scope,
+        };
+    })
+        .filter((n) => n.id && (typeof filter === 'function' ? filter(n) : true));
+}
+export const dockerNetworkLs = throttle(unthrottledDockerNetworkLs, 500, {
+    trailing: false,
+});
+export async function dockerNetworkFind(networkName, options) {
+    return ((await dockerNetworkLs(options))?.find((n) => n.name === networkName || n.id === networkName) || null);
+}
+export async function dockerNetworkCreate(networkName, { driver, driverOpts = {}, ipRange, gateways = [], subnets = [], auxAddresses = [], ingress, internal, ipv6, labels = [], } = {}) {
+    const existing = await dockerNetworkFind(networkName);
+    if (existing)
+        return existing;
+    await spawn('docker', [
+        'network',
+        'create',
+        ...labels.flatMap((l) => ['--label', l]),
+        ...gateways.flatMap((g) => ['--gateway', g]),
+        ...subnets.flatMap((s) => ['--subnet', s]),
+        ...auxAddresses.flatMap((a) => ['--aux-address', a]),
+        ...(ipRange ? ['--ip-range', ipRange] : []),
+        ...(ingress ? ['--ingress'] : []),
+        ...(internal ? ['--internal'] : []),
+        ...(ipv6 ? ['--ipv6'] : []),
+        ...(driver ? ['-d', driver] : []),
+        ...Object.entries(driverOpts).flatMap(([k, v]) => ['-o', `${k}=${v}`]),
+        networkName,
+    ]);
+    return dockerNetworkFind(networkName);
+}
+/**
+ * Removes a network by id
+ * @param {string} id The id of the network
+ */
+export async function dockerNetworkRm(id) {
+    await spawn('docker', ['network', 'rm', id]);
+}
+/**
+ * Removes all networks with the given name
+ * @param {string} networkName The name of the network
+ */
+export async function dockerNetworkDelete(networkName) {
+    let existing;
+    // eslint-disable-next-line no-cond-assign, no-await-in-loop
+    while ((existing = await dockerNetworkFind(networkName))) {
+        // eslint-disable-next-line no-await-in-loop
+        await existing.rm();
+    }
+}
+export async function dockerNetworkConnect(networkName, containerId, alias) {
+    const net = await dockerNetworkCreate(networkName);
+    if (!net)
+        throw new Error('Failed to create docker network');
+    await spawn('docker', [
+        'network',
+        'connect',
+        ...(alias ? ['--alias', alias] : []),
+        net.id,
+        containerId,
+    ]);
+}

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

@@ -0,0 +1,26 @@
+declare type DockerVolumeInspectOutput = Record<string, any>;
+export interface DockerVolume {
+    driver: string;
+    inspect: () => Promise<null | DockerVolumeInspectOutput>;
+    labels: string[];
+    mountPoint: string;
+    name: string;
+    rm: () => Promise<void>;
+    scope: string;
+}
+interface DockerVolumeLsOptions {
+    filter?: (vol: DockerVolume) => boolean;
+}
+export declare function unthrottledDockerVolumeLs({ filter, }?: DockerVolumeLsOptions): Promise<DockerVolume[]>;
+export declare const dockerVolumeLs: (options?: DockerVolumeLsOptions) => undefined | Promise<DockerVolume[]>;
+export declare function dockerVolumeFind(search: string, options?: DockerVolumeLsOptions): Promise<null | DockerVolume>;
+export interface DockerVolumeCreateOptions {
+    driver?: string;
+    driverOpts?: Record<string, string>;
+    labels?: string[];
+}
+export declare function dockerVolumeCreate(name: string, { labels, driver, driverOpts }?: DockerVolumeCreateOptions): Promise<null | DockerVolume>;
+export declare function dockerVolumeRm(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function unthrottledDockerVolumeInspect(id: string | string[]): Promise<DockerVolumeInspectOutput[]>;
+export declare const dockerVolumeInspect: (id: string | string[]) => undefined | Promise<DockerVolumeInspectOutput[]>;
+export {};