build-strap 3.0.0 → 4.0.0-dev.4

package/maps.js.flow

@@ -1,111 +0,0 @@
-// @flow
-// Util functions for using objects as maps and preserving type information
-
-/**
- * An object with arbitrary keys, where every key's value is of the same type.
- */
-export type ObjMap<V, K: string = string> = {
-  +[K]: V,
-};
-// Alias for above, generics in opposite order (for backwards compat)
-export type MapObj<K, V> = ObjMap<V, K>;
-
-/**
- * Given an input object, return an array of the keys.
- * This is a wrapper around the standard `Object.keys` that preserves type information.
- * @param {ObjMap} obj the input object
- * @returns {Array} an array of keys. These will always be strings, but flow may assign
- * a more specific type when possible
- */
-export const keys = <V, K: string = string>(obj?: ?ObjMap<V, K>): K[] =>
-  (Object.keys(obj || {}): any);
-
-/**
- * Given an input object, return an array of the values.
- * This is a wrapper around the standard `Object.values` that preserves type information.
- * @param {ObjMap} obj the input object
- * @returns {Array} an array of values
- */
-export const values = <V, K: string = string>(obj?: ?ObjMap<V, K>): V[] =>
-  (Object.values(obj || {}): any);
-
-/**
- * Given a `ObjMap`, return an array of the entries.
- * This is a wrapper around the standard `Object.entries` that preserves type information.
- * It assumes an object with homogenous values.
- * @param {ObjMap} obj the input object
- * @returns {Array} an array of entry [key, value] tuples
- */
-export const entries = <V, K: string = string>(obj?: ?ObjMap<V, K>): [K, V][] =>
-  (Object.entries(obj || {}): any);
-
-/**
- * Given a `ObjMap`, iterate over each entry and run it through the given `map` function.
- * @param {ObjMap} obj the input object
- * @param {Function} map the mapping operation
- * @returns {ObjMap} a new object
- */
-export const mapValues = <V, K: string, R>(
-  obj?: ?ObjMap<V, K>,
-  map: (V, K, ObjMap<V, K>) => R,
-): ObjMap<R, K> =>
-  entries(obj).reduce(
-    (acc, [k, v]) =>
-      Object.assign(acc, {
-        [k]: map(v, k, obj || {}),
-      }),
-    {},
-  );
-
-/**
- * Given a `ObjMap`, iterate over each entry and run it through the given async `map` function.
- * The promise returned by the `map` is awaited, such that the resulting `ObjMap` values are
- * the result of the resolved promise.
- * @param {ObjMap} obj the input object
- * @param {Function} map the async mapping operation
- * @returns {Promise} a promise for a new object
- */
-export const mapValuesAsync = async <V, K: string, R>(
-  obj?: ?ObjMap<V, K>,
-  map: (V, K, ObjMap<V, K>) => Promise<R>,
-): Promise<ObjMap<R, K>> =>
-  entries(obj).reduce(
-    async (acc, [k, v]) =>
-      Object.assign(await acc, {
-        [k]: await map(v, k, obj || {}),
-      }),
-    {},
-  );
-
-/**
- * Given a `ObjMap`, iterate over each entry and run it through the given `filter` function.
- * Any entry for which the `filter` returns `false` is removed from the resulting `ObjMap`.
- * All other entries are left as-is. The resulting output is a subset of the input.
- * If no `filter` is specified, default to filtering out nullish values.
- * @param {ObjMap} obj the input object
- * @param {Function} filter the filter operation
- * @returns {ObjMap} a new object, a subset of the input
- */
-export const filterKeys = <V, K: string = string>(
-  obj?: ?ObjMap<V, K>,
-  filter?: (V, K, ObjMap<V, K>) => boolean = (v) => v != null,
-): ObjMap<V, K> =>
-  entries(obj).reduce(
-    (acc, [k, v]) =>
-      filter(v, k, obj || {})
-        ? Object.assign(acc, {
-            [k]: v,
-          })
-        : acc,
-    {},
-  );
-
-/**
- * Given an object, removes any top level keys with a nullish value.
- * The type system should preserve the incoming object type, with all such keys typed as `empty`.
- * @param {Object} obj the input object
- * @returns {Object} a new object, a subset of the input
- */
-export const filterNullish = <T: { ... }>(
-  obj: T,
-): $ObjMap<T, <V>(V) => $NonMaybeType<V>> => filterKeys(obj);

package/npm.js.flow

@@ -1,144 +0,0 @@
-// @flow
-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 || {};
-}
-
-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 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 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) {
-    // 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 { 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;
-    }
-    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;
-}

package/pkg.js.flow

@@ -1,80 +0,0 @@
-// @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;
-}
-
-export function getCfg(): BuildStrapConfig {
-  return getPkg().buildStrap || {};
-}
-
-export function setPkg(p: PackageJson) {
-  _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 getPkgScope(): ?string {
-  const pkgName = getPkgName(true);
-  return pkgName.match(pkgNameRegex)?.[1] || null;
-}

package/publish.js.flow

@@ -1,144 +0,0 @@
-// @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,
-}
-
-// 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 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();
-    });
-  }
-
-  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/run.js.flow

@@ -1,89 +0,0 @@
-// @flow
-export function format(time?: Date = new Date()): string {
-  return time.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, '$1');
-}
-
-const silenceLogs = process.argv.includes('--silence-buildLog');
-
-export function buildLog(msg: string, time?: Date) {
-  if (silenceLogs) {
-    return;
-  }
-  console.info(`[${format(time || new Date())}] ${msg}`);
-}
-
-export type RunnableModule<T> =
-  | (() => Promise<T>)
-  | { default: () => Promise<T> };
-
-export async function run<T>(
-  fn: RunnableModule<T>,
-  ...options: any[]
-): Promise<T> {
-  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 type RunCliOptions<T> = {
-  resolveFn?: (path: string) => RunnableModule<T>,
-  defaultAction?: string | RunnableModule<T>,
-  argv?: string[],
-  passthroughArgv?: boolean,
-};
-
-export async function runCli<T>({
-  resolveFn = (path: string) =>
-    // $FlowFixMe
-    require(`./${path}`).default, // eslint-disable-line
-  defaultAction = 'publish',
-  argv = process.argv,
-  passthroughArgv = false,
-}: RunCliOptions<T> = {}): Promise<T> {
-  const module =
-    argv.length > 2
-      ? resolveFn(argv[2])
-      : typeof defaultAction === 'string'
-      ? 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);
-    throw err;
-  });
-}
-
-export function handleEntryPoint<T>(
-  mainModule: typeof module,
-  mainModuleFilename: string,
-  cliOptions?: RunCliOptions<T>,
-) {
-  if (require.main === mainModule) {
-    delete require.cache[mainModuleFilename]; // eslint-disable-line no-underscore-dangle
-    runCli(cliOptions);
-  }
-}
-
-handleEntryPoint(module, __filename);
-
-export default run;

package/src/ant.js

@@ -1,42 +0,0 @@
-// @flow
-import { spawn } from './cp';
-import type { SpawnOptions } from './cp';
-
-/**
- * Named value pair to use when configuring an Ant build property
- */
-export type AntPropertyConfiguration = {|
-  name: string,
-  value: string,
-|};
-
-export type AntSpawnOptions = {|
-  properties?: AntPropertyConfiguration[], // Ant property values to configure
-  args?: string[], // Any additional command line arguments to pass
-  spawnOptions?: SpawnOptions, // Optional spawn configuration. Defaults to run the project root directory
-|};
-
-/**
- * Executes the given ant command
- * @param {string} target the ant target to invoke
- * @param {AntSpawnOptions} options
- */
-export async function ant(target: string, opts?: AntSpawnOptions) {
-  const { properties = [], args = [], spawnOptions } = opts || {};
-
-  const execOptions = {
-    stdio: 'inherit',
-    pipeOutput: true,
-    ...spawnOptions,
-  };
-
-  await spawn(
-    'ant',
-    [
-      target,
-      ...args,
-      ...properties.map(({ name, value }) => `-D${name}=${value}`),
-    ],
-    execOptions,
-  );
-}