build-strap 4.0.0-dev.46 → 4.0.0-dev.54

package/src/npm.js

@@ -1,144 +1,141 @@
-// @flow
+import fs from 'fs-extra';
 import { platform } from 'os';
 import path from 'path';
-import fs from 'fs-extra';
-
-import { spawn, exec } from './cp';
-import { getCfg, getPkgName } from './pkg';
-import { getVersion, getDevBranch } from './version';
-import { buildLog } from './run';
-
-export type NpmCreds = {
-  username: string,
-  password: string,
-  email: string,
-};
-
-export type NpmConfig = {
-  publish: boolean,
-  registry?: string,
-  access?: 'public' | 'restricted',
-  dryRun?: boolean,
-};
-
-export function getNpmConfig(): NpmConfig {
-  return getCfg().npm || {};
+import { 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: ?NpmCreds =
-  (process.env.NPM_CREDS && JSON.parse(process.env.NPM_CREDS)) || null;
-
-const npmExe = (npmPath?: string) =>
-  npmPath || (platform() === 'win32' ? 'npm.cmd' : 'npm');
-
-export async function npmExec(
-  args: string[],
-  npmPath?: string,
-): Promise<string> {
-  return (await exec(`${npmExe(npmPath)} ${args.join(' ')}`)).stdout.toString();
+export 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 npm({ args = [], spawnOptions, npmPath, } = {}) {
+    const localNpm = path.join(path.dirname(process.execPath), 'lib/node_modules/npm/bin/npm-cli.js');
+    const spawnOpts = {
+        env: process.env,
+        shell: true,
+        stdio: 'inherit',
+        ...spawnOptions,
+    };
+    return npmPath
+        ? spawn(npmPath, args, spawnOpts)
+        : (await fs.pathExists(localNpm))
+            ? // prefer to use local copy of npm
+                spawn(process.execPath, [localNpm, ...args], spawnOpts)
+            : // fall back to globally installed npm
+                spawn(npmExe(), args, spawnOpts);
 }
-
-export async function npmGetVersions(
-  packageName: string,
-  npmPath?: string,
-): Promise<string[]> {
-  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 npmGetVersions(packageName, npmPath) {
+    try {
+        return JSON.parse((await npm({
+            args: ['show', packageName, 'versions', '--json'],
+            npmPath,
+            spawnOptions: {
+                captureOutput: true,
+                stdio: 'pipe',
+            },
+        })).stdout.trim());
+    }
+    catch (err) {
+        buildLog(`warning: failed to find existing package for ${packageName} in npm registry: ${err.message}`);
+        return [];
+    }
 }
-
-export type NpmPublishOptions = {|
-  publishPath: string, // distDir, or package.tgz file
-  npmConfig?: NpmConfig,
-  npmCreds?: NpmCreds,
-  npmAuthToken?: string,
-  tag?: string,
-  skipExisting?: boolean,
-  npmPath?: string, // path to executable
-|};
-
-export async function npmPublish({
-  publishPath,
-  npmConfig,
-  npmCreds,
-  npmAuthToken,
-  tag,
-  skipExisting = false,
-  npmPath,
-}: NpmPublishOptions = {}): Promise<boolean> {
-  const creds = npmCreds || envNpmCreds;
-  const authToken = npmAuthToken || process.env.NPM_TOKEN;
-  const name = getPkgName();
-  const { publish, registry, access, dryRun } = npmConfig || getNpmConfig();
-  if (!publish) {
-    buildLog(
-      'npm publish info missing from package.json, skipping npm publish',
-    );
-    return false;
-  }
-  const resolvedPath = path.resolve(publishPath);
-  const workDir = (await fs.stat(resolvedPath)).isDirectory()
-    ? resolvedPath
-    : path.dirname(resolvedPath);
-  if (creds || registry || authToken) {
+export async function npmWriteRc({ authToken, creds, outPath, registry, }) {
     // 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}
+    await fs.mkdirp(path.dirname(outPath));
+    await fs.writeFile(outPath, `registry=${theRegistry}
 ${authToken ? `//${host}:_authToken=${authToken}` : ''}
-${
-  creds
-    ? `_auth=${Buffer.from(`${creds.username}:${creds.password}`).toString(
-        'base64',
-      )}
+${creds
+        ? `_auth=${Buffer.from(`${creds.username}:${creds.password}`).toString('base64')}
 always-auth=true
 email=${creds.email}`
-    : ''
-}`,
-    );
-  }
-  const existing = await npmGetVersions(name, npmPath);
-  const { isRelease, npm: npmVersion, branch } = await getVersion();
-  if (existing.includes(npmVersion)) {
-    if (skipExisting) {
-      buildLog(
-        'npm package with this same version already exists. Skipping publish...',
-      );
-      return false;
+        : ''}`);
+}
+export async function npmPublish({ npmAuthToken, npmConfig, npmCreds, npmPath, publishPath = '.', skipExisting = false, tag, workDir: passedWorkDir, } = {}) {
+    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 (creds || registry || authToken) {
+        // Write out .npmrc with credentials
+        await npmWriteRc({
+            authToken: authToken ? `\${NPM_TOKEN}` : undefined,
+            creds,
+            outPath: path.join(workDir, '.npmrc'),
+            registry,
+        });
+    }
+    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 npm({
+        args: [
+            'publish',
+            resolvedPath,
+            '--tag',
+            tag ||
+                (isRelease
+                    ? 'latest'
+                    : branch === (await getDevBranch())
+                        ? 'next'
+                        : 'branch'),
+            ...(access ? ['--access', access] : []),
+            ...(dryRun ? ['--dry-run'] : []),
+            '--color=always',
+        ],
+        npmPath,
+        spawnOptions: {
+            cwd: workDir,
+            env: {
+                ...process.env,
+                NPM_TOKEN: authToken,
+            },
+        },
+    });
+    return true;
+}
+export async function npmPack({ destination, npmConfig, npmPath, workDir = '.', }) {
+    const { dryRun } = npmConfig || getNpmConfig();
+    if (destination) {
+        await fs.ensureDir(destination);
     }
-    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'] : []),
-    ],
-    {
-      stdio: 'inherit',
-      cwd: workDir,
-    },
-  );
-  return true;
+    const { stdout } = await npm({
+        args: [
+            'pack',
+            ...(dryRun ? ['--dry-run'] : []),
+            ...(destination ? ['--pack-destination', path.resolve(destination)] : []),
+            '--color=always',
+        ],
+        npmPath,
+        spawnOptions: {
+            captureOutput: true,
+            cwd: path.resolve(workDir),
+            pipeOutput: true,
+            stdio: 'pipe',
+        },
+    });
+    return path.resolve(destination || '.', stdout.trim());
 }

package/src/pkg.d.ts

@@ -0,0 +1,38 @@
+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 | {
+        type: string;
+        url: string;
+    };
+    scripts?: Record<string, string>;
+    type?: string;
+    types?: 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/src/pkg.js

@@ -1,80 +1,33 @@
-// @flow
-import type { ArtifactoryConfig } from './artifactory';
-import type { CertConfig } from './cert';
-import type { DockerConfig } from './docker';
-import type { NpmConfig } from './npm';
-
-export type BuildStrapConfig = {
-  repoType?: 'git' | 'hg',
-  copyright?: string,
-  releaseBranch?: string,
-  devBranch?: string,
-  artifactory?: ArtifactoryConfig,
-  cert?: CertConfig,
-  docker?: DockerConfig,
-  npm?: NpmConfig,
-};
-
-type StringMap = {
-  [string]: string,
-};
-
-export type PackageJson = {
-  name: string,
-  version: string,
-  description?: string,
-  private?: boolean,
-  license?: string,
-  authors?: string[],
-  repository?: string,
-  main?: string,
-  dependencies?: StringMap,
-  devDependencies?: StringMap,
-  peerDependencies?: StringMap,
-  engines?: StringMap,
-  scripts?: StringMap,
-  // our addition
-  buildStrap: BuildStrapConfig,
-};
-
-let _pkg: ?PackageJson = null;
-export function getPkg(): PackageJson {
-  if (_pkg == null) {
-    throw new Error(
-      'Must call setPkg() with package.json content before building.',
-    );
-  }
-  return _pkg;
+// 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(): BuildStrapConfig {
-  return getPkg().buildStrap || {};
+export function getCfg() {
+    return getPkg().buildStrap || {};
 }
-
-export function setPkg(p: PackageJson) {
-  _pkg = p;
+export function setPkg(p) {
+    _pkg = p;
 }
-
 const pkgNameRegex = /^(?:(@[^/]+)\/)?(.+)$/i;
-
-export function getPkgName(includeScope: boolean = false): string {
-  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 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(): ?string {
-  const pkgName = getPkgName(true);
-  return pkgName.match(pkgNameRegex)?.[1] || null;
+export function getPkgScope() {
+    const pkgName = getPkgName(true);
+    return pkgName.match(pkgNameRegex)?.[1] || null;
 }

package/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/src/publish.js

@@ -1,144 +1,57 @@
-// @flow
-import path from 'path';
 import fs from 'fs-extra';
-import { run, buildLog } from './run';
-import { getVersion, type Version } from './version';
-import { getPkgName } from './pkg';
-import {
-  artifactoryNpm,
-  artifactoryStandard,
-  type ArtifactoryConfig,
-  type ArtifactoryCreds,
-} from './artifactory';
-import { npmPublish } from './npm';
-import type { NpmConfig, NpmCreds } from './npm';
-import { tgzDir, type ArtifactInfo } from './tgz';
-
-export type CreateArtifactOptions = {
-  distDir: string, // What to bundle up and publish
-  outDir: string, // Where the bundled tgz file should go
-  fileName?: string, // (optional) Specify the tgz file name
-};
-
-export type Artifact = {
-  name: string,
-  version: Version,
-  info: ArtifactInfo,
-  fileName: string,
-  filePath: string,
-}
-
+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,
-  outDir,
-  fileName,
-}: CreateArtifactOptions): Promise<Artifact> {
-  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 {
-    name,
-    version,
-    info,
-    fileName: tgzFileName,
-    filePath: tgzFilePath,
-  };
+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,
+    };
 }
-
-export type PublishConfiguration = {
-  ...CreateArtifactOptions,
-  doPublish: boolean, // Actually publish?
-  prePublishFn?: () => any, // (optional) Callback to invoke before publishing
-  artifactoryConfig?: ArtifactoryConfig, // (optional) Artifactory config info (normally in package.json)
-  artifactoryCreds?: ArtifactoryCreds, // (optional) Artifactory credentials (normally from ENV var)
-  npmPath?: string, // (optional) Path to npm executable
-  npmTag?: string, // (optional) tag to apply to npm package
-  npmSkipExisting?: boolean, // (optional) if true, don't error when artifact already exists (skip publish)
-  npmConfig?: NpmConfig, // (optional) Npm config info (normally in package.json)
-  npmCreds?: NpmCreds, // (optional) Npm credentials (normally from ENV var)
-  npmAuthToken?: string, // (optional) Npm auth token (normally from ENV var)
-};
-
 // tgz the distDir, and copy it to the outDir
-// if toArtifactory is true, also publishes to artifactory
-export async function publish({
-  distDir,
-  outDir,
-  doPublish,
-  prePublishFn,
-  fileName,
-  artifactoryConfig,
-  artifactoryCreds,
-  npmPath,
-  npmTag,
-  npmSkipExisting = false,
-  npmConfig,
-  npmCreds,
-  npmAuthToken,
-}: PublishConfiguration) {
-  if (typeof prePublishFn === 'function') {
-    await run(async () => {
-      await prePublishFn();
+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,
     });
-  }
-
-  const {
-    info,
-    filePath: tgzFilePath,
-    fileName: tgzFileName,
-  } = await createArtifact({ distDir, outDir, fileName });
-
-  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'),
-  );
-  const artifact = fs.createReadStream(tgzFilePath);
-  await Promise.all([
-    npmPublish({
-      publishPath: tgzFilePath,
-      npmConfig,
-      npmCreds,
-      npmAuthToken,
-      tag: npmTag,
-      skipExisting: npmSkipExisting,
-      npmPath,
-    }),
-    artifactoryStandard(
-      artifact,
-      info,
-      tgzFileName,
-      artifactoryConfig,
-      artifactoryCreds,
-    ),
-    artifactoryNpm(
-      distDir,
-      artifactoryConfig,
-      artifactoryCreds,
-      npmPath,
-      npmTag,
-      npmSkipExisting,
-    ),
-  ]);
 }

package/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>;