build-strap 4.0.0-dev.46 → 4.0.0

package/dist/src/npm.js

@@ -0,0 +1,104 @@
+import fs from 'fs-extra';
+import { platform } from 'os';
+import path from 'path';
+import { exec, spawn } from './cp.js';
+import { getCfg, getPkgName } from './pkg.js';
+import { buildLog } from './run.js';
+import { getDevBranch, getVersion } from './version.js';
+export function getNpmConfig() {
+    return getCfg().npm || {};
+}
+const envNpmCreds = (process.env.NPM_CREDS && JSON.parse(process.env.NPM_CREDS)) || null;
+const npmExe = (npmPath) => npmPath || (platform() === 'win32' ? 'npm.cmd' : 'npm');
+export async function npmExec(args, npmPath) {
+    return (await exec(`${npmExe(npmPath)} ${args.join(' ')}`)).stdout.toString();
+}
+export async function npmGetVersions(packageName, npmPath) {
+    try {
+        return JSON.parse(await npmExec(['show', packageName, 'versions'], npmPath));
+    }
+    catch (err) {
+        buildLog(`warning: failed to find existing package for ${packageName} in npm registry: ${err.message}`);
+        return [];
+    }
+}
+export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath = '.', skipExisting = false, tag, workDir: passedWorkDir, writeNpmrc = false, } = {}) {
+    const creds = npmCreds || envNpmCreds;
+    const authToken = npmAuthToken || process.env.NPM_TOKEN;
+    const name = getPkgName();
+    const { access, dryRun, publish, registry } = npmConfig || getNpmConfig();
+    if (!publish) {
+        buildLog('npm publish info missing from package.json, skipping npm publish');
+        return false;
+    }
+    const resolvedPath = path.resolve(publishPath);
+    const workDir = passedWorkDir ||
+        ((await fs.stat(resolvedPath)).isDirectory()
+            ? resolvedPath
+            : path.dirname(resolvedPath));
+    if (!(await fs.pathExists(path.join(workDir, 'package.json')))) {
+        buildLog(`warning: no package.json found in ${workDir}, skipping npm publish`);
+        return false;
+    }
+    if (writeNpmrc && (creds || registry || authToken)) {
+        // Write out .npmrc with credentials
+        const theRegistry = registry || 'https://registry.npmjs.org/';
+        const [, host] = /^(?:http(?:s)?:\/\/)?(.+)$/.exec(theRegistry) || [];
+        await fs.mkdirp(workDir);
+        await fs.writeFile(path.join(workDir, '.npmrc'), `registry=${theRegistry}
+${authToken ? `//${host}:_authToken=${authToken}` : ''}
+${creds
+            ? `_auth=${Buffer.from(`${creds.username}:${creds.password}`).toString('base64')}
+always-auth=true
+email=${creds.email}`
+            : ''}`);
+    }
+    const existing = await npmGetVersions(name, npmPath);
+    const { branch, isRelease, npm: npmVersion } = await getVersion();
+    if (existing.includes(npmVersion)) {
+        if (skipExisting) {
+            buildLog('npm package with this same version already exists. Skipping publish...');
+            return false;
+        }
+        throw new Error('Failed to publish npm package, this version already exists!');
+    }
+    await spawn(npmExe(npmPath), [
+        'publish',
+        resolvedPath,
+        '--tag',
+        tag ||
+            (isRelease
+                ? 'latest'
+                : branch === (await getDevBranch())
+                    ? 'next'
+                    : 'branch'),
+        ...(access ? ['--access', access] : []),
+        ...(dryRun ? ['--dry-run'] : []),
+        '--color=always',
+    ], {
+        cwd: workDir,
+        env: {
+            ...process.env,
+            NPM_TOKEN: authToken,
+        },
+        stdio: 'inherit',
+    });
+    return true;
+}
+export async function npmPack({ destination, npmConfig, npmPath, workDir = '.', }) {
+    const { dryRun } = npmConfig || getNpmConfig();
+    if (destination) {
+        await fs.ensureDir(destination);
+    }
+    const { stdout } = await spawn(npmExe(npmPath), [
+        'pack',
+        ...(dryRun ? ['--dry-run'] : []),
+        ...(destination ? ['--pack-destination', destination] : []),
+        '--color=always',
+    ], {
+        captureOutput: true,
+        cwd: workDir,
+        pipeOutput: true,
+    });
+    return path.resolve(destination || '.', stdout.trim());
+}

package/dist/src/pkg.d.ts

@@ -0,0 +1,33 @@
+import { CertConfig } from './cert.js';
+import { DockerConfig } from './docker.js';
+import { NpmConfig } from './npm.js';
+export interface BuildStrapConfig {
+    cert?: CertConfig;
+    copyright?: string;
+    devBranch?: string;
+    docker?: DockerConfig;
+    npm?: NpmConfig;
+    releaseBranch?: string;
+    repoType?: 'git' | 'hg';
+}
+export interface PackageJson {
+    authors?: string[];
+    buildStrap: BuildStrapConfig;
+    dependencies?: Record<string, string>;
+    description?: string;
+    devDependencies?: Record<string, string>;
+    engines?: Record<string, string>;
+    license?: string;
+    main?: string;
+    name: string;
+    peerDependencies?: Record<string, string>;
+    private?: boolean;
+    repository?: string;
+    scripts?: Record<string, string>;
+    version: string;
+}
+export declare function getPkg(): PackageJson;
+export declare function getCfg(): BuildStrapConfig;
+export declare function setPkg(p: PackageJson): void;
+export declare function getPkgName(includeScope?: boolean): string;
+export declare function getPkgScope(): null | string;

package/dist/src/pkg.js

@@ -0,0 +1,33 @@
+// eslint-disable-next-line no-underscore-dangle
+let _pkg = null;
+export function getPkg() {
+    if (_pkg == null) {
+        throw new Error('Must call setPkg() with package.json content before building.');
+    }
+    return _pkg;
+}
+export function getCfg() {
+    return getPkg().buildStrap || {};
+}
+export function setPkg(p) {
+    _pkg = p;
+}
+const pkgNameRegex = /^(?:(@[^/]+)\/)?(.+)$/i;
+export function getPkgName(includeScope = false) {
+    const pkg = getPkg();
+    if (!(pkg.name && pkg.name.length)) {
+        throw new Error('Package name not found in package.json, but this is a required property!');
+    }
+    if (includeScope) {
+        return pkg.name;
+    }
+    const [, , shortName] = pkg.name.match(pkgNameRegex) || [];
+    if (!shortName) {
+        throw new Error('Package name in package.json has invalid format.');
+    }
+    return shortName;
+}
+export function getPkgScope() {
+    const pkgName = getPkgName(true);
+    return pkgName.match(pkgNameRegex)?.[1] || null;
+}

package/dist/src/publish.d.ts

@@ -0,0 +1,27 @@
+import { NpmConfig, NpmCreds } from './npm.js';
+import { ArtifactInfo } from './tgz.js';
+import { type Version } from './version.js';
+export interface CreateArtifactOptions {
+    distDir: string;
+    fileName?: string;
+    outDir: string;
+}
+export interface Artifact {
+    fileName: string;
+    filePath: string;
+    info: ArtifactInfo;
+    name: string;
+    version: Version;
+}
+export declare function createArtifact({ distDir, fileName, outDir, }: CreateArtifactOptions): Promise<Artifact>;
+export interface PublishConfiguration extends CreateArtifactOptions {
+    doPublish: boolean;
+    npmAuthToken?: string;
+    npmConfig?: NpmConfig;
+    npmCreds?: NpmCreds;
+    npmPath?: string;
+    npmSkipExisting?: boolean;
+    npmTag?: string;
+    prePublishFn?: () => any;
+}
+export declare function publish({ distDir, doPublish, fileName, npmAuthToken, npmConfig, npmCreds, npmPath, npmSkipExisting, npmTag, outDir, prePublishFn, }: PublishConfiguration): Promise<void>;

package/dist/src/publish.js

@@ -0,0 +1,57 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { npmPublish } from './npm.js';
+import { getPkgName } from './pkg.js';
+import { buildLog, run } from './run.js';
+import { tgzDir } from './tgz.js';
+import { getVersion } from './version.js';
+// create tgz from distDir in outDir
+export async function createArtifact({ distDir, fileName, outDir, }) {
+    const version = await getVersion();
+    const name = getPkgName();
+    buildLog(`gzipping ${name} v${version.info}...`);
+    const tgzFileName = fileName || `${name}-${version.info}.tgz`;
+    const tgzFilePath = path.join(outDir, tgzFileName);
+    const info = await tgzDir(distDir, tgzFilePath, {
+        prefix: 'package',
+    });
+    buildLog(`md5: ${info.md5}`);
+    buildLog(`sha1: ${info.sha1}`);
+    buildLog(`sha512: ${info.sha512}`);
+    buildLog(`size: ${info.size} bytes`);
+    return {
+        fileName: tgzFileName,
+        filePath: tgzFilePath,
+        info,
+        name,
+        version,
+    };
+}
+// tgz the distDir, and copy it to the outDir
+export async function publish({ distDir, doPublish, fileName, npmAuthToken, npmConfig, npmCreds, npmPath, npmSkipExisting = false, npmTag, outDir, prePublishFn, }) {
+    if (typeof prePublishFn === 'function') {
+        await run(async () => {
+            await prePublishFn();
+        });
+    }
+    const { filePath: tgzFilePath } = await createArtifact({
+        distDir,
+        fileName,
+        outDir,
+    });
+    if (!doPublish) {
+        buildLog('Skipping publish for dev build. Use `--publish` arg to publish for real.');
+        return;
+    }
+    // Publish to all repos configured in package.json
+    await fs.copyFile(path.join(distDir, 'package.json'), path.join(outDir, 'package.json'));
+    await npmPublish({
+        npmAuthToken,
+        npmConfig,
+        npmCreds,
+        npmPath,
+        publishPath: tgzFilePath,
+        skipExisting: npmSkipExisting,
+        tag: npmTag,
+    });
+}

package/dist/src/run.d.ts

@@ -0,0 +1,13 @@
+export declare function format(time?: Date): string;
+export declare function buildLog(msg: string, time?: Date): void;
+export declare type RunnableModule<Args extends string[], Result> = ((...args: Args) => Promise<Result>) | {
+    default: (...args: Args) => Promise<Result>;
+};
+export declare function run<Args extends string[], Result>(fn: RunnableModule<Args, Result>, ...options: Args): Promise<Result>;
+export interface RunCliOptions<Args extends string[], Result> {
+    argv?: string[];
+    defaultAction?: string | RunnableModule<Args, Result>;
+    passthroughArgv?: Args | boolean;
+    resolveFn?: (path: string) => Promise<RunnableModule<Args, Result>> | RunnableModule<Args, Result>;
+}
+export declare function runCli<Args extends string[], Result>({ resolveFn, defaultAction, argv, passthroughArgv, }?: RunCliOptions<Args, Result>): Promise<Result>;

package/dist/src/run.js

@@ -0,0 +1,44 @@
+export function format(time = new Date()) {
+    return time.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, '$1');
+}
+const silenceLogs = process.argv.includes('--silence-buildLog');
+export function buildLog(msg, time) {
+    if (silenceLogs) {
+        return;
+    }
+    console.info(`[${format(time || new Date())}] ${msg}`);
+}
+export async function run(fn, ...options) {
+    if (fn == null) {
+        throw new Error(`Invalid argument passed to run(${fn})`);
+    }
+    const task = typeof fn === 'function' ? fn : fn.default;
+    if (typeof task !== 'function') {
+        throw new Error('First argument to run must be a function or module with default function.');
+    }
+    const start = new Date();
+    buildLog(`Starting '${task.name}'...`, start);
+    const result = await task(...options);
+    const end = new Date();
+    const time = end.getTime() - start.getTime();
+    buildLog(`Finished '${task.name}' after ${time} ms`, end);
+    return result;
+}
+export async function runCli({ resolveFn = async (path) => import(`./${path}.js`), defaultAction = 'build', argv = process.argv, passthroughArgv = false, } = {}) {
+    const module = argv.length > 2
+        ? await resolveFn(argv[2])
+        : typeof defaultAction === 'string'
+            ? await resolveFn(defaultAction)
+            : defaultAction;
+    const args = Array.isArray(passthroughArgv)
+        ? passthroughArgv.includes(argv[2] || defaultAction)
+            ? argv.slice(3)
+            : []
+        : passthroughArgv
+            ? argv.slice(3)
+            : [];
+    return run(module, ...args).catch((err) => {
+        console.error((err && err.stack) || err);
+        process.exit(1);
+    });
+}

package/dist/src/tgz.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import tar from 'tar';
+export declare type ArtifactInfo = {
+    contentType?: string;
+    md5: string;
+    sha1: string;
+    sha512: string;
+    size: number;
+};
+export declare const generateFileHash: (filePath: string, type: 'md5' | 'sha1' | 'sha512') => Promise<string>;
+export declare function getArtifactInfo(artifact: string | Readable): Promise<ArtifactInfo>;
+export declare function tgzDir(srcDir: string, outPath: string, options?: tar.CreateOptions): Promise<ArtifactInfo>;

package/dist/src/tgz.js

@@ -0,0 +1,67 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+import path from 'path';
+import StreamCounter from 'stream-counter';
+import tar from 'tar';
+import { buildLog } from './run.js';
+const generateHash = async (stream, type) => new Promise((resolve, reject) => {
+    stream
+        .pipe(crypto.createHash(type).setEncoding('hex'))
+        .on('finish', function onFinish() {
+        resolve(this.read());
+    })
+        .on('end', function onEnd() {
+        resolve(this.read());
+    })
+        .on('error', (err) => reject(err));
+});
+export const generateFileHash = async (filePath, type) => generateHash(fs.createReadStream(filePath), type);
+const countBytes = async (stream) => new Promise((resolve, reject) => {
+    const counter = new StreamCounter();
+    stream
+        .pipe(counter)
+        .on('finish', () => resolve(counter.bytes))
+        .on('end', () => resolve(counter.bytes))
+        .on('error', (err) => reject(err));
+});
+const writeStreamToFile = async (stream, filePath) => new Promise((resolve, reject) => {
+    stream
+        .pipe(fs.createWriteStream(filePath))
+        .on('finish', () => {
+        buildLog(`Successfully wrote file: ${filePath}`);
+        resolve();
+    })
+        .on('error', (err) => reject(err));
+});
+// Take the given file (path or stream) and compute metadata for it.
+// md5 + sha hashes, and size in bytes
+export async function getArtifactInfo(artifact) {
+    // make it into a stream
+    const stream = typeof artifact === 'string' ? fs.createReadStream(artifact) : artifact;
+    const [md5, sha1, sha512, size] = await Promise.all([
+        generateHash(stream, 'md5'),
+        generateHash(stream, 'sha1'),
+        generateHash(stream, 'sha512'),
+        countBytes(stream),
+    ]);
+    return { md5, sha1, sha512, size };
+}
+// Creates a gzipped tarball of a directory, returns sha1 + md5 hash and size of resulting file
+export async function tgzDir(srcDir, outPath, options) {
+    await fs.ensureDir(path.dirname(outPath));
+    const tgzStream = tar.c({
+        cwd: srcDir,
+        gzip: true,
+        portable: true,
+        ...options,
+    }, ['.']);
+    // write the file to disk (outPath)
+    const [info] = await Promise.all([
+        getArtifactInfo(tgzStream),
+        writeStreamToFile(tgzStream, `${outPath}`),
+    ]);
+    return {
+        ...info,
+        contentType: 'application/gzip',
+    };
+}

package/dist/src/version.d.ts

@@ -0,0 +1,34 @@
+export declare function getBuild(): string;
+export declare function getReleaseBranch(): string;
+declare enum RepoType {
+    git = "git",
+    hg = "hg",
+    unknown = "unknown"
+}
+export declare function getRepoType(): Promise<RepoType>;
+declare type RepoInfo = {
+    branch: string;
+    revision: string;
+};
+export declare function getRepoInfo(): Promise<RepoInfo>;
+export declare function getDevBranch(): Promise<string>;
+export declare function getIsRelease(passedBranch?: null | string, releaseOverride?: null | boolean): Promise<boolean>;
+export declare function useVersionCache(useCache?: boolean): void;
+export interface Version {
+    branch: string;
+    build: string;
+    info: string;
+    isRelease: boolean;
+    major: string;
+    minor: string;
+    name: string;
+    npm: string;
+    patch: string;
+    revision: string;
+    short: string;
+}
+export declare function getVersion(logIt?: boolean, release?: null | boolean): Promise<Version>;
+export declare function getBanner(): Promise<string>;
+export declare function getVersionCode(): Promise<string>;
+export declare function getUniqueBuildTag(): Promise<string>;
+export {};

package/dist/src/version.js

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import { gitInfo } from './git.js';
+import { getCfg, getPkg } from './pkg.js';
+import { buildLog } from './run.js';
+export function getBuild() {
+    const arg = process.argv.find((el) => /^--buildNum=\d+$/.test(el));
+    return (arg && arg.substring(11)) || process.env.BUILD_NUMBER || '0';
+}
+export function getReleaseBranch() {
+    const { releaseBranch } = getCfg();
+    return releaseBranch || 'master';
+}
+var RepoType;
+(function (RepoType) {
+    RepoType["git"] = "git";
+    RepoType["hg"] = "hg";
+    RepoType["unknown"] = "unknown";
+})(RepoType || (RepoType = {}));
+export async function getRepoType() {
+    const { repoType } = getCfg();
+    return (repoType ||
+        (fs.existsSync('./.git')
+            ? RepoType.git
+            : fs.existsSync('./.hg')
+                ? RepoType.hg
+                : RepoType.unknown));
+}
+export async function getRepoInfo() {
+    const repoType = await getRepoType();
+    if (repoType !== RepoType.git) {
+        throw new Error(`Unsupported repo type: ${repoType}`);
+    }
+    const { branch, revision } = await gitInfo();
+    if (!branch || !revision) {
+        throw new Error('Failed to parse branch and revision from source repo.');
+    }
+    return { branch, revision };
+}
+export async function getDevBranch() {
+    const { devBranch } = getCfg();
+    return devBranch || (await getRepoType()) === 'hg' ? 'default' : 'dev';
+}
+export async function getIsRelease(passedBranch = null, releaseOverride = null) {
+    const branch = passedBranch || (await getRepoInfo()).branch;
+    return releaseOverride != null
+        ? releaseOverride
+        : process.argv.includes('--force-release-version')
+            ? true
+            : branch === getReleaseBranch();
+}
+let cacheVersion = true;
+export function useVersionCache(useCache = true) {
+    cacheVersion = useCache;
+}
+let version = null;
+export async function getVersion(logIt = true, release = null) {
+    if (!cacheVersion || version == null) {
+        const { name, version: pkgVers } = getPkg();
+        const { branch, revision } = await getRepoInfo();
+        const [, major, minor, patch] = pkgVers.match(/^(\d+)\.(\d+)\.(\d+)$/) || [];
+        if (!major || !minor || !patch) {
+            throw new Error('Invalid version format in package.json');
+        }
+        const build = getBuild();
+        const isRelease = await getIsRelease(branch, release);
+        const short = `${major}.${minor}.${patch}`;
+        const npm = `${short}${isRelease ? '' : `-${branch}.${build}`}`;
+        const info = `${short}${isRelease ? `+${build}.` : `-${branch}.${build}+`}${revision}`;
+        version = {
+            branch,
+            build,
+            info,
+            isRelease,
+            major,
+            minor,
+            name,
+            npm,
+            patch,
+            revision,
+            short,
+        };
+        if (logIt) {
+            buildLog(`Building version ${info}`);
+        }
+    }
+    return version;
+}
+export async function getBanner() {
+    const { copyright = '' } = getCfg();
+    const { info, name } = await getVersion();
+    const today = new Date();
+    return `${name} v${info} | (c) ${today.getFullYear()} ${copyright} | built on ${today.toISOString()}`;
+}
+export async function getVersionCode() {
+    return `// This file is auto-generated
+export const version = ${JSON.stringify(await getVersion(), null, 2)}`;
+}
+export async function getUniqueBuildTag() {
+    const { branch, build, revision } = await getVersion();
+    return `${branch}-${revision}-${build}`;
+}

package/dist/src/yarn.d.ts

@@ -0,0 +1,26 @@
+import { SpawnOptions, SpawnResult } from './cp.js';
+export interface YarnOptions {
+    args?: string[];
+    spawnOptions?: SpawnOptions;
+}
+export declare function yarn({ args, spawnOptions, }?: YarnOptions): Promise<SpawnResult>;
+export declare const yarnFiles: string[];
+export interface YarnInstallOptions {
+    force?: boolean;
+    hashFilePath?: string;
+    nodeModulesPath?: string;
+}
+export declare function yarnInstall({ force, hashFilePath, nodeModulesPath, }?: YarnInstallOptions): Promise<void>;
+export interface YarnUpgradeOptions {
+    /**
+     * `false` by default
+     * we assume any package with an explicit version shouldn't be touched
+     */
+    all?: boolean;
+    /**
+     * Use `yarn outdated` to find packages that should be upgraded
+     * May include breaking changes (major version changes)
+     */
+    outdated?: boolean;
+}
+export declare function yarnUpgrade({ all, outdated, }?: YarnUpgradeOptions): Promise<void>;

package/dist/src/yarn.js

@@ -0,0 +1,75 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { spawn } from './cp.js';
+import { readDir } from './fs.js';
+import { getPkg } from './pkg.js';
+import { buildLog } from './run.js';
+import { generateFileHash } from './tgz.js';
+export async function yarn({ args = [], spawnOptions, } = {}) {
+    const localYarn = path.join(path.dirname(process.execPath), '/node_modules/yarn/bin/yarn.js');
+    const spawnOpts = {
+        env: process.env,
+        shell: true,
+        stdio: 'inherit',
+        ...spawnOptions,
+    };
+    return (await fs.pathExists(localYarn))
+        ? // prefer to use local copy of yarn
+            spawn(process.execPath, [localYarn, ...args], spawnOpts)
+        : // fall back to globally installed yarn
+            spawn('yarn', args, spawnOpts);
+}
+export const yarnFiles = ['./package.json', './yarn.lock'];
+// Smart yarn invocation, only if package changed
+export async function yarnInstall({ force = false, hashFilePath = './download/buildHash_yarn.md5', nodeModulesPath = './node_modules', } = {}) {
+    await fs.ensureDir(nodeModulesPath);
+    const currentHash = (await Promise.all(yarnFiles.map(async (f) => generateFileHash(f, 'md5')))).join('|');
+    await fs.ensureFile(hashFilePath);
+    const prevHash = await fs.readFile(hashFilePath, 'utf8');
+    if (currentHash !== prevHash) {
+        buildLog('node package definition changed since last build, invoking yarn.');
+    }
+    else if (!(await readDir(`${nodeModulesPath}/**/*.js`)).length) {
+        buildLog('node packages missing, invoking yarn.');
+    }
+    else if (force) {
+        buildLog('node packages unchanged, but yarn forced on command line...');
+    }
+    else {
+        buildLog('node packages unchanged since last build, skipping yarn.');
+        return;
+    }
+    await yarn();
+    await fs.writeFile(hashFilePath, currentHash);
+}
+export async function yarnUpgrade({ all = false, outdated = false, } = {}) {
+    if (outdated) {
+        const { code, stdout } = await yarn({
+            args: ['outdated'],
+            spawnOptions: {
+                captureOutput: true,
+                rejectOnErrorCode: false,
+                stdio: 'pipe',
+            },
+        });
+        if (code === 0) {
+            buildLog('No outdated packages.');
+        }
+        else {
+            const { dependencies = {}, devDependencies = {} } = getPkg();
+            const packages = stdout
+                .split('\n')
+                .slice(5, -1)
+                .map((l) => l.split(/\s+/)[0])
+                .filter((p) => all || !/^\d/.test(dependencies[p] || devDependencies[p] || ''));
+            if (packages.length) {
+                await yarn({ args: ['add', ...packages] });
+                buildLog(`Upgraded: ${packages.join(', ')}`);
+            }
+            else {
+                buildLog('No eligible outdated packages');
+            }
+        }
+    }
+    await yarn({ args: ['upgrade'] });
+}