build-strap 3.0.0-dev.42 → 4.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Justin Murray
+Copyright (c) 2021 Justin Murray
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,7 +1,7 @@
 # build-strap
-A suite of functions to help with writing build scripts using javascript code (which run on node).
+A suite of functions to help with writing build scripts using TypeScript (or javascript) code (which run on node).
 
-This project builds itself, so take a look in the `tools/` folder for an example project. Run `./bs` to build.
+This project builds itself, so take a look in the `targets/` folder for an example. Run `./bs` to build.
 
 [![CI Build](https://github.com/murrayju/build-strap/workflows/CI%20Build/badge.svg?branch=master)](https://github.com/murrayju/build-strap/actions?query=workflow%3A%22CI+Build%22)
 [![version](https://img.shields.io/github/v/tag/murrayju/build-strap.svg?label=version&sort=semver)](https://github.com/murrayju/build-strap/releases/latest)
@@ -41,39 +41,14 @@ By default, the build tools read project-specific configuration from your `packa
     "npm": {
       "publish": true,
     },
-    "artifactory": {
-      "root": "https://artifactory.your-company.com/artifactory/",
-      "path": "com/your-company/your-project-name",
-      "version-folders": false,
-      "integration": "integration-repo",
-      "integration-branch-folders": true,
-      "integration-days-to-keep": 14,
-      "integration-max-to-keep": 10,
-      "release": "releases-repo",
-      "release-branch": "master",
-      "npm": "npm-repo",
-      "npm-clean": "internal-npm-repo"
-    },
     "docker": {
-      "registry": "artifactory.your-company.com",
+      "registry": "ghcr.io",
       "repository": "your-company",
       "name": "your-project-name"
     }
   }
 }
 ```
-### artifactory
-* **root**: base URL for the artifactory server
-* **path**: path to project root in the artifactory tree.
-* **version-folders**: if `true`, artifacts will be organized into subfolders for each version number
-* **integration**: name of the artifactory repo in which to place integration (not official release) artifacts.
-* **integration-branch-folders**: if `true`, artifacts will be organized into subfolders for each branch.
-* **integration-days-to-keep**: for artifact cleanup, specifies the max age in days before an artifact will be deleted.
-* **integration-max-to-keep**: for artifact cleanup, specifies the maximum number of artifacts to keep, regardless of age. Only the newest N artifacts will be kept.
-* **release**: name of the artifactory repo in which to place release artifacts.
-* **release-branch**: name of the mercurial branch from which official releases are built/published. Defaults to `master`.
-* **npm**: name of the artifactory repo in which to publish npm artifacts.
-* **npm-clean**: for artifact cleanup, the name of the artifactory repo used to find and delete old npm artifacts.
 
 ### docker
 * **registry**: base URL for the docker registry, as needed by `docker push`.
@@ -135,9 +110,3 @@ In order to publish to NPM, proper credentials must be provided to the script. B
 ```
 { "email": "builder@your-company.com", "username":"builder", "password":"abc123" }
 ```
-
-## Artifactory Credentials
-In order to publish and/or delete things from Artifactory, proper credentials must be provided to the script. By default, these are read from the `ARTIFACTORY_CREDS` environment variable, but it is also possible to pass them as an argument to most functions. This is expected to be a JSON encoded string in the following format:
-```
-{ "email": "builder@your-company.com", "username":"builder", "password":"abc123" }
-```

package/dist/src/ant.d.ts

@@ -0,0 +1,19 @@
+import { SpawnOptions } from './cp.js';
+/**
+ * Named value pair to use when configuring an Ant build property
+ */
+export interface AntPropertyConfiguration {
+    name: string;
+    value: string;
+}
+export interface AntSpawnOptions {
+    args?: string[];
+    properties?: AntPropertyConfiguration[];
+    spawnOptions?: SpawnOptions;
+}
+/**
+ * Executes the given ant command
+ * @param {string} target the ant target to invoke
+ * @param {AntSpawnOptions} options
+ */
+export declare function ant(target: string, opts?: AntSpawnOptions): Promise<void>;

package/dist/src/ant.js

@@ -0,0 +1,18 @@
+import { spawn } from './cp.js';
+/**
+ * Executes the given ant command
+ * @param {string} target the ant target to invoke
+ * @param {AntSpawnOptions} options
+ */
+export async function ant(target, opts) {
+    const { properties = [], args = [], spawnOptions } = opts || {};
+    await spawn('ant', [
+        target,
+        ...args,
+        ...properties.map(({ name, value }) => `-D${name}=${value}`),
+    ], {
+        pipeOutput: true,
+        stdio: 'inherit',
+        ...spawnOptions,
+    });
+}

package/dist/src/cert.d.ts

@@ -0,0 +1,12 @@
+export interface CertConfig {
+    commonName?: string;
+    countryName?: string;
+    emailAddress?: string;
+    localityName?: string;
+    organizationName?: string;
+    organizationalUnitName?: string;
+    stateOrProvinceName?: string;
+}
+export declare const getCertConfig: () => CertConfig;
+export declare const getIpAddresses: () => string[];
+export declare function generateCert(targetDir: string, force?: boolean): Promise<void>;

package/dist/src/cert.js

@@ -0,0 +1,91 @@
+import fs from 'fs-extra';
+import fetch from 'node-fetch';
+import os from 'os';
+import path from 'path';
+import { spawn } from './cp.js';
+import { readDir } from './fs.js';
+import { getCfg } from './pkg.js';
+import { buildLog } from './run.js';
+export const getCertConfig = () => getCfg().cert ?? {};
+export const getIpAddresses = () => Object.values(os.networkInterfaces()).flatMap((iFaces) => iFaces?.map((iFace) => iFace.address) ?? []);
+// Generate a self-signed certificate (if it doesn't exist)
+export async function generateCert(targetDir, force = process.argv.includes('--force-generateCert')) {
+    if (process.argv.includes('--no-generateCert')) {
+        buildLog('Skipping due to --no-generateCert');
+        return;
+    }
+    buildLog(`scanning ${targetDir} for certificates...`);
+    if (!force &&
+        (await readDir(`${targetDir}/server.@(crt|key)`)).length === 2) {
+        buildLog('Skipping certificate generation: certificate already exists');
+        return;
+    }
+    buildLog('Generating self-signed certificate...');
+    const { commonName = 'app.company.com', countryName = 'US', emailAddress = 'contact@company.com', localityName = 'SomeCity', organizationName = 'Company', organizationalUnitName = 'Product', stateOrProvinceName = 'Pennsylvania', } = getCertConfig();
+    const hostname = os.hostname();
+    buildLog(`hostname: ${hostname}`);
+    const ipAddresses = getIpAddresses();
+    buildLog(`ip addresses: ${JSON.stringify(ipAddresses)}`);
+    const ifconfig = await fetch('https://ifconfig.co').then((r) => r.json());
+    const externalIp4 = ifconfig.ip;
+    buildLog(`external ipv4: ${externalIp4}`);
+    const dnsName = ifconfig.hostname;
+    buildLog(`dnsName: ${dnsName}`);
+    await fs.ensureDir(targetDir);
+    const keyFile = path.resolve(targetDir, 'server.key');
+    const csrFile = path.resolve(targetDir, 'server.csr');
+    const crtFile = path.resolve(targetDir, 'server.crt');
+    const confTemplateFile = path.resolve(__dirname, 'cert.conf');
+    const confFile = path.resolve(targetDir, 'cert.conf.generated');
+    const confTemplate = await fs.readFile(confTemplateFile, 'utf8');
+    await fs.writeFile(confFile, confTemplate
+        .replace('{{countryName}}', countryName)
+        .replace('{{stateOrProvinceName}}', stateOrProvinceName)
+        .replace('{{localityName}}', localityName)
+        .replace('{{organizationName}}', organizationName)
+        .replace('{{organizationalUnitName}}', organizationalUnitName)
+        .replace('{{commonName}}', commonName)
+        .replace('{{emailAddress}}', emailAddress)
+        .replace('{{SAN_IP}}', ipAddresses.reduce((acc, next) => `${acc},IP:${next}`, ''))
+        .replace('{{SAN_DNS}}', `,DNS:${hostname},DNS:${dnsName}`), 'utf8');
+    buildLog('generating key file...');
+    await spawn('openssl', [
+        'genpkey',
+        '-algorithm',
+        'RSA',
+        '-pkeyopt',
+        'rsa_keygen_bits:2048',
+        '-out',
+        keyFile,
+    ], { pipeOutput: true });
+    buildLog('generating csr file...');
+    await spawn('openssl', [
+        'req',
+        '-new',
+        '-key',
+        keyFile,
+        '-out',
+        csrFile,
+        '-subj',
+        `/C=${countryName}/ST=${stateOrProvinceName}/L=${localityName}/O=${organizationName}/OU=${organizationalUnitName}/CN=${commonName}/CN=${externalIp4}/CN=${hostname}/CN=${dnsName}${ipAddresses.reduce((acc, next) => `${acc}/CN=${next}`)}/CN=localhost`,
+        '-config',
+        confFile,
+    ], { pipeOutput: true });
+    buildLog('generating cert...');
+    await spawn('openssl', [
+        'x509',
+        '-req',
+        '-days',
+        '365',
+        '-in',
+        csrFile,
+        '-signkey',
+        keyFile,
+        '-out',
+        crtFile,
+        '-extfile',
+        confFile,
+        '-extensions',
+        'v3_req',
+    ], { pipeOutput: true });
+}

package/dist/src/clean.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Cleans up the build output directories.
+ */
+export declare function clean(globs?: string[]): Promise<void>;

package/dist/src/clean.js

@@ -0,0 +1,11 @@
+import { cleanDir } from './fs.js';
+/**
+ * Cleans up the build output directories.
+ */
+export async function clean(globs = ['dist/*', 'out/*', 'build/*']) {
+    await Promise.all(globs.map((glob) => cleanDir(glob, {
+        dot: true,
+        ignore: ['.git', '.hg'],
+        nosort: true,
+    })));
+}

package/dist/src/copy.d.ts

@@ -0,0 +1,7 @@
+export interface CopySrcOptions {
+    cbFn?: () => void;
+    from: string;
+    to: string;
+    watch?: boolean;
+}
+export declare function copySrc({ from, to, watch, cbFn, }: CopySrcOptions): Promise<void>;

package/dist/src/copy.js

@@ -0,0 +1,53 @@
+import chokidar from 'chokidar';
+import fs from 'fs-extra';
+import path from 'path';
+import { onKillSignal } from './cp.js';
+import { cleanDir, copyDir } from './fs.js';
+import { buildLog } from './run.js';
+let timer = null;
+async function throttledCallback(cbFn) {
+    if (!cbFn || typeof cbFn !== 'function') {
+        return;
+    }
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    timer = setTimeout(() => {
+        timer = null;
+        cbFn();
+    }, 200);
+}
+export async function copySrc({ from, to, watch = process.argv.includes('--watch'), cbFn, }) {
+    await copyDir(from, to);
+    if (cbFn)
+        await cbFn();
+    if (watch) {
+        const watcher = chokidar.watch([path.join(from, '/**/*')], {
+            ignoreInitial: true,
+        });
+        watcher.on('all', async (event, filePath) => {
+            const start = new Date();
+            const src = path.relative(from, filePath);
+            const dest = path.join(to, src);
+            switch (event) {
+                case 'add':
+                case 'change':
+                    await fs.ensureDir(path.dirname(dest));
+                    await fs.copyFile(filePath, dest);
+                    break;
+                case 'unlink':
+                case 'unlinkDir':
+                    cleanDir(dest, { dot: true, nosort: true });
+                    break;
+                default:
+                    return;
+            }
+            const end = new Date();
+            const time = end.getTime() - start.getTime();
+            buildLog(`${event} '${dest}' after ${time} ms`, end);
+            throttledCallback(cbFn);
+        });
+        onKillSignal(() => watcher.close());
+    }
+}

package/dist/src/cp.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import cp from 'child_process';
+export interface SpawnOptions extends cp.SpawnOptions {
+    captureOutput?: boolean;
+    pipeOutput?: boolean;
+    rejectOnErrorCode?: boolean;
+}
+export interface SpawnResult {
+    code: number;
+    output: string;
+    signal: string;
+    stderr: string;
+    stdout: string;
+}
+export declare function spawn(command: string, args?: string[], opts?: SpawnOptions | null): Promise<SpawnResult>;
+export declare const exec: typeof cp.exec.__promisify__;
+export declare const onKillSignal: (cbFn: () => void) => void;

package/dist/src/cp.js

@@ -0,0 +1,88 @@
+import cp from 'child_process';
+import crossSpawn from 'cross-spawn';
+import { promisify } from 'util';
+import { buildLog } from './run.js';
+export async function spawn(command, args, opts) {
+    const { captureOutput = false, pipeOutput = false, rejectOnErrorCode = true, ...options } = opts || {};
+    return new Promise((resolve, reject) => {
+        try {
+            const toStr = () => `${command}${args ? ` ${args.join(' ')}` : ''}`;
+            const p = crossSpawn(command, args, {
+                ...(pipeOutput && !captureOutput ? { stdio: 'inherit' } : {}),
+                ...options,
+            });
+            let output = '';
+            let stdout = '';
+            let stderr = '';
+            if (captureOutput) {
+                if (p.stdout) {
+                    if (pipeOutput) {
+                        p.stdout.pipe(process.stdout);
+                    }
+                    p.stdout.on('data', (d) => {
+                        const str = d.toString();
+                        stdout += str;
+                        output += str;
+                    });
+                }
+                else {
+                    buildLog(`Warning: cannot capture stdout for \`${toStr()}\``);
+                }
+                if (p.stderr) {
+                    if (pipeOutput) {
+                        p.stderr.pipe(process.stderr);
+                    }
+                    p.stderr.on('data', (d) => {
+                        const str = d.toString();
+                        stderr += str;
+                        output += str;
+                    });
+                }
+                else {
+                    buildLog(`Warning: cannot capture stderr for \`${toStr()}\``);
+                }
+            }
+            let exitHandled = false;
+            const handleExit = (code, signal) => {
+                if (!exitHandled) {
+                    if (rejectOnErrorCode && code) {
+                        reject(new Error(`${toStr()} => ${code} (error)`));
+                    }
+                    else {
+                        resolve({
+                            code,
+                            output,
+                            signal,
+                            stderr,
+                            stdout,
+                        });
+                    }
+                    exitHandled = true;
+                }
+            };
+            p.on('close', handleExit);
+            p.on('exit', handleExit);
+            // only fires if we failed to spawn
+            p.on('error', (err) => {
+                // Here we have a workaround that reverses a "feature" of cross-spawn on Windows. See:
+                // https://github.com/moxystudio/node-cross-spawn/blob/master/lib/enoent.js#L23
+                // https://github.com/moxystudio/node-cross-spawn/issues/104
+                if (process.platform === 'win32' &&
+                    err.code === 'ENOENT' &&
+                    err.errno === 'ENOENT') {
+                    handleExit(1, 'ENOENT');
+                }
+                else {
+                    reject(err);
+                }
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+export const exec = promisify(cp.exec);
+export const onKillSignal = (cbFn) => {
+    ['SIGINT', 'SIGTERM'].forEach((sig) => process.on(sig, cbFn));
+};

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

@@ -0,0 +1,73 @@
+import { SpawnOptions } from './cp.js';
+interface DockerContainerInspectOutput {
+    State: {
+        Running: boolean;
+    };
+}
+interface Port {
+    dest: number;
+    iface: string;
+    src: number;
+}
+export interface DockerContainer {
+    command: string;
+    created: Date;
+    exists: () => Promise<boolean>;
+    exited: boolean;
+    id: string;
+    image: string;
+    inspect: () => Promise<DockerContainerInspectOutput | undefined>;
+    isRunning: () => Promise<boolean>;
+    kill: (ignoreError?: boolean) => Promise<void>;
+    labels: string[];
+    mounts: string[];
+    name: string;
+    names: string[];
+    networks: string[];
+    ports: Port[];
+    restart: () => Promise<void>;
+    rm: (ignoreError?: boolean) => Promise<void>;
+    runningFor: string;
+    size: number;
+    start: () => Promise<void>;
+    status: string;
+    stop: (ignoreError?: boolean) => Promise<void>;
+    teardown: (verbose?: boolean) => Promise<void>;
+}
+interface DockerContainerLsOptions {
+    all?: boolean;
+    filter?: (container: DockerContainer) => boolean;
+}
+export declare function unthrottledDockerContainerLs({ all, filter, }?: DockerContainerLsOptions): Promise<DockerContainer[]>;
+export declare const dockerContainerLs: (options: DockerContainerLsOptions | undefined) => Promise<DockerContainer[]> | undefined;
+export declare function dockerContainerFind(search: string, options?: DockerContainerLsOptions): Promise<DockerContainer | null>;
+export declare function dockerContainerStop(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function dockerContainerKill(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function dockerTryStopContainer(id: string | null, name?: string): Promise<void>;
+export declare function dockerContainerRm(id: string | string[], ignoreErrors?: boolean): Promise<void>;
+export declare function dockerContainerRestart(id: string | string[]): Promise<void>;
+export declare function dockerContainerStart(id: string | string[]): Promise<void>;
+export declare function unthrottledDockerContainerInspect(id: string | string[]): Promise<DockerContainerInspectOutput[]>;
+export declare const dockerContainerInspect: (id: string | string[]) => Promise<DockerContainerInspectOutput[]> | undefined;
+interface DockerContainerRunDaemonArgs {
+    cmd?: string[];
+    image: string;
+    runArgs?: string[];
+    waitAttempts?: number;
+    waitDuration?: number;
+}
+interface DockerContainerRunArgs extends DockerContainerRunDaemonArgs {
+    spawnOptions?: SpawnOptions | null;
+}
+export declare function dockerContainerRun({ image, runArgs, cmd, spawnOptions, }: DockerContainerRunArgs): Promise<string>;
+export declare function dockerContainerRunDaemon({ image, runArgs, cmd, waitAttempts, waitDuration, }: DockerContainerRunDaemonArgs): Promise<DockerContainer>;
+/**
+ * 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 declare const dockerContainerWaitForStart: (container: DockerContainer, testFn: (container: DockerContainer) => Promise<boolean>, timeoutMs?: number, maxAttempts?: number) => Promise<void>;
+export {};