build-strap 3.0.0 → 4.0.0-dev.1

package/cert.js.flow

@@ -1,152 +0,0 @@
-// @flow
-import os from 'os';
-import rp from 'request-promise-native';
-import path from 'path';
-import fs from 'fs-extra';
-import { buildLog } from './run';
-import { readDir } from './fs';
-import { spawn } from './cp';
-import { getCfg } from './pkg';
-
-export type CertConfig = {
-  countryName?: string,
-  stateOrProvinceName?: string,
-  localityName?: string,
-  organizationName?: string,
-  organizationalUnitName?: string,
-  commonName?: string,
-  emailAddress?: string,
-};
-
-export function getCertConfig(): CertConfig {
-  return getCfg().cert || {};
-}
-
-export function getIpAddresses(): string[] {
-  const iFaces = os.networkInterfaces();
-  return Object.keys(iFaces).reduce(
-    (prev, ifName) => [
-      ...prev,
-      ...iFaces[ifName].map((iFace) => iFace.address),
-    ],
-    [],
-  );
-}
-
-// Generate a self-signed certificate (if it doesn't exist)
-export async function generateCert(
-  targetDir: string,
-  force: boolean = 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 {
-    countryName = 'US',
-    stateOrProvinceName = 'Pennsylvania',
-    localityName = 'SomeCity',
-    organizationName = 'Company',
-    organizationalUnitName = 'Product',
-    commonName = 'app.company.com',
-    emailAddress = 'contact@company.com',
-  } = getCertConfig();
-  const hostname = os.hostname();
-  buildLog(`hostname: ${hostname}`);
-  const ipAddresses = getIpAddresses();
-  buildLog(`ip addresses: ${JSON.stringify(ipAddresses)}`);
-  const ifconfig = await rp.get('https://ifconfig.co', { json: true });
-  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/clean.js.flow

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

package/copy.js.flow

@@ -1,79 +0,0 @@
-// @flow
-import path from 'path';
-import chokidar from 'chokidar';
-import { copyFile, makeDir, copyDir, cleanDir } from './fs';
-import { onKillSignal } from './cp';
-import { buildLog } from './run';
-import { dependencies } from './inline-resources';
-
-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 type CopySrcOptions = {
-  from: string,
-  to: string,
-  watch?: boolean,
-  cbFn?: () => Promise<any> | void,
-};
-
-export async function copySrc({
-  from,
-  to,
-  watch = process.argv.includes('--watch'),
-  cbFn,
-}: CopySrcOptions = {}) {
-  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 makeDir(path.dirname(dest));
-          await copyFile(filePath, dest);
-          break;
-        case 'unlink':
-        case 'unlinkDir':
-          cleanDir(dest, { nosort: true, dot: true });
-          break;
-        default:
-          return;
-      }
-      // Check dependencies
-      if (dependencies[dest]) {
-        await Promise.all(
-          dependencies[dest].map(async (dep) => {
-            const toCopy = path.join(from, path.relative(to, dep));
-            await copyFile(toCopy, dep);
-            buildLog(`copied '${dep}' due to changed dependency`);
-          }),
-        );
-      }
-      const end = new Date();
-      const time = end.getTime() - start.getTime();
-      buildLog(`${event} '${dest}' after ${time} ms`, end);
-      throttledCallback(cbFn);
-    });
-
-    onKillSignal(() => watcher.close());
-  }
-}

package/cp.js.flow

@@ -1,172 +0,0 @@
-// @flow
-import cp from 'child_process';
-import crossSpawn from 'cross-spawn';
-import { buildLog } from './run';
-
-export type NativeSpawnOptions = {|
-  cwd?: string,
-  env?: Object,
-  argv0?: string,
-  stdio?: string | Array<any>,
-  detached?: boolean,
-  uid?: number,
-  gid?: number,
-  shell?: boolean | string,
-  windowsVerbatimArguments?: boolean,
-  windowsHide?: boolean,
-|};
-
-export type SpawnOptions = {|
-  ...NativeSpawnOptions,
-  pipeOutput?: boolean,
-  captureOutput?: boolean,
-  rejectOnErrorCode?: boolean,
-|};
-
-export type SpawnResult = {|
-  output: string,
-  stdout: string,
-  stderr: string,
-  code: number,
-  signal: string,
-|};
-
-export async function spawnAdv(
-  command: string,
-  args?: string[],
-  opts?: ?SpawnOptions,
-): Promise<SpawnResult> {
-  const {
-    pipeOutput = false,
-    captureOutput = false,
-    rejectOnErrorCode = false,
-    ...options
-  } = opts || {};
-
-  return new Promise((resolve, reject) => {
-    try {
-      const toStr = () => `${command}${args ? ` ${args.join(' ')}` : ''}`;
-      const p = crossSpawn(command, args, {
-        ...options,
-        // $FlowFixMe
-        ...(pipeOutput && !captureOutput && !(options && options.stdio)
-          ? { stdio: 'inherit' }
-          : {}),
-      });
-
-      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({
-              output,
-              stdout,
-              stderr,
-              code,
-              signal,
-            });
-          }
-          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://jira.mmodal.com/browse/BTN-8
-        // 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);
-    }
-  });
-}
-
-// older, simpler interface that just returns a string
-export async function spawn(
-  command: string,
-  args?: string[],
-  opts?: ?SpawnOptions,
-): Promise<string> {
-  return spawnAdv(command, args, { rejectOnErrorCode: true, ...opts }).then(
-    (r) => r.output,
-  );
-}
-
-export type ExecOptions = {|
-  cwd?: string,
-  env?: Object,
-  encoding?: string,
-  shell?: string,
-  timeout?: number,
-  maxBuffer?: number,
-  killSignal?: string | number,
-  uid?: number,
-  gid?: number,
-  windowsHide?: boolean,
-|};
-
-export const exec = async (
-  command: string,
-  options?: ExecOptions,
-): Promise<{ stdout: string | Buffer, stderr: string | Buffer }> =>
-  new Promise((resolve, reject) => {
-    cp.exec(command, options, (err, stdout, stderr) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-
-      resolve({ stdout, stderr });
-    });
-  });
-
-export const onKillSignal = (cbFn: () => any) => {
-  ['SIGINT', 'SIGTERM'].forEach((sig) => process.on(sig, cbFn));
-};