@leverege/build-tools 2.4.9 → 2.5.0-beta.40

package/lib/server/repo-init/RepoInit.js

@@ -0,0 +1,176 @@
+"use strict";
+
+const chalk = require('chalk');
+
+const cliArgs = require('command-line-args');
+
+const cliHelp = require('command-line-usage');
+
+const execa = require('execa');
+
+const figlet = require('figlet');
+
+const {
+  Config
+} = require('./Config');
+
+const {
+  Gitter
+} = require('./gitter');
+
+const {
+  Templates
+} = require('./templates');
+
+const {
+  clear,
+  condir,
+  proceed,
+  Shell,
+  VersionCheck
+} = require('./utils');
+
+const thisPackage = require(`${Shell.findRepoRoot()}/package.json`); // eslint-disable-line
+
+
+const thisVersion = thisPackage.version;
+const optionList = [// Use optionList to tie into the Usage statements
+{
+  name: 'help',
+  type: Boolean,
+  default: false,
+  description: 'display this help screen'
+}, {
+  name: 'version',
+  type: Boolean,
+  default: false,
+  description: 'returns the build-tools repo version'
+}, {
+  name: 'verbose',
+  alias: 'v',
+  type: Boolean,
+  default: false,
+  description: 'emit additional info at run time'
+}];
+const sections = [{
+  header: 'The Leverege Repository Initialization Tool',
+  content: `
+      Generate something {italic very} important.
+      More stuff {blue rawr}
+`
+}, {
+  header: 'Options',
+  optionList
+}];
+const args = cliArgs(optionList, {
+  partial: true
+});
+const help = cliHelp(sections);
+
+if (args.version) {
+  console.log(`v${thisVersion}`);
+  process.exit(0);
+}
+
+if (args.help) {
+  console.log(help);
+  process.exit(0);
+}
+/**
+ * Checks the node and build-tools versions.
+ */
+
+
+const doVersionChecks = async () => {
+  /**
+   * Verify that node meets our minimum needs.
+   */
+  try {
+    VersionCheck.validate({
+      current: process.version,
+      // this is the node version
+      minimum: '12.16',
+      maximum: '13',
+      // must be less than this
+      preferred: '12.18.3'
+    });
+  } catch (err) {
+    console.log(err);
+    process.exit(1);
+  }
+  /**
+   * Check to see if we're running the latest version of build-tools.
+   */
+
+
+  try {
+    await execa('build-tools', ['--latest'], {
+      stdout: 'inherit'
+    });
+  } catch (err) {
+    /**
+     * An exitCode of 1 is simply how build-tools lets us know that an update
+     * exists for the build-tools repository.
+     */
+    if (err.exitCode !== 1) {
+      console.error(err);
+      process.exit(1);
+    }
+  }
+};
+/**
+ * Presents the opening greeting and then to proceed, or not to proceed,
+ * that is the question.
+ */
+
+
+const greet = async () => {
+  clear();
+  console.log(chalk.keyword('orange').bold(figlet.textSync('repo-init', {
+    horizontalLayout: 'full'
+  })), chalk.green`
+
+  Welcome to the Leverege repository bootstrapping utility. This utility
+  will help with the creation of a new git repository based on the standard
+  templates that are currently supported. It will also attempt to tune the
+  initial files based on the answers provided during this process.
+`);
+  await doVersionChecks();
+  await proceed();
+};
+/**
+ * Usage:
+ */
+
+
+const start = async () => {
+  await greet();
+  const config = new Config();
+  const gitter = new Gitter(config);
+  const gitSpec = await gitter.runInquiry();
+  const templates = new Templates(config);
+  const templateSpec = await templates.runInquiry(gitSpec);
+  const npmActions = ['install'];
+  const buildSpec = { ...gitSpec,
+    ...templateSpec,
+    npmActions
+  };
+  condir('Current Build Spec', buildSpec); // TODO: Clean this up to be a better info dump
+
+  await proceed('Proceed to populate and build the repository?');
+  await templates.build(buildSpec);
+  await gitter.build(buildSpec);
+  console.log(chalk.green.bold`
+  Repository setup complete.
+
+  Still to work out:`, chalk.yellow`
+    - figure out better approach for partial file read on transform
+    - add / flesh out remaining templates
+        - express-server
+        - library
+        - ui-lib
+        - ui-???
+`);
+};
+
+exports.start = start;

package/lib/server/repo-init/gitter/Gitter.js

@@ -0,0 +1,241 @@
+"use strict";
+
+/**
+ * All git interactions come through here.
+ */
+const chalk = require('chalk');
+
+const execa = require('execa');
+
+const fs = require('fs');
+
+const inquirer = require('inquirer');
+
+const Ora = require('ora');
+
+const SimpleGit = require('simple-git');
+
+const {
+  pause,
+  Shell
+} = require('../utils');
+
+const repoHosting = require('./RepoHosting');
+
+class Gitter {
+  constructor() {
+    this.git = new SimpleGit();
+  }
+
+  async runInquiry() {
+    if (await this.git.checkIsRepo()) {
+      console.log(chalk.keyword('orange').bold(`
+  The current working directory is a git repository, and continuing this
+  operation would create a nested repository, which is not supported. Try
+  changing to a plain old subdirectory before attempting to run repo-init.
+
+`));
+      process.exit(1);
+    }
+    /**
+     * Validates the name and checks to see if the subdirectory already exists.
+     */
+
+
+    const verifyRepositoryName = name => {
+      if (!RegExp('^\\w+(\\-*\\w*)+$').test(name)) {
+        console.log(chalk.yellow.bold(`
+  Invalid git repo name => [${chalk.red.bold(name)}]`));
+        return false;
+      }
+
+      if (fs.existsSync(name)) {
+        console.log(chalk.yellow.bold(`
+  A local file or directory named ${name} already exists - remove it and try again.`));
+        return false;
+      }
+
+      return true;
+    };
+    /**
+     * The questions that we need to ask about this git build.
+     */
+
+
+    const gitterQs = [{
+      type: 'input',
+      name: 'git.name',
+      message: 'What is the desired name of the git repository?',
+      validate: value => {
+        return verifyRepositoryName(value);
+      }
+    }, {
+      type: 'list',
+      name: 'git.host',
+      message: 'Where will the repository be hosted?',
+      choices: ['bitbucket', 'github', 'local']
+    }, {
+      type: 'list',
+      name: 'git.owner',
+      message: 'Who is the owner of the git repository?',
+      choices: ['leverege', 'cox2m'],
+      when: answer => {
+        return answer.git.host !== 'local';
+      }
+    }, {
+      type: 'list',
+      name: 'git.createRemote',
+      message: 'Let repo-init create the remote git repository?',
+      choices: ['yes', 'skip'],
+      when: answer => {
+        return answer.git.host !== 'local';
+      }
+    }];
+    return inquirer.prompt(gitterQs);
+  }
+
+  async build(buildSpec) {
+    if (!fs.existsSync(buildSpec.git.name)) {
+      console.log(chalk.yellow.bold(`
+  ${chalk.red.bold('***ERROR: source directory does not exist')}
+            Did the template generation for ${chalk.red.bold(buildSpec.git.name)} fail?
+`));
+    }
+
+    const initialCommit = `repo-init => bootstrapped ${buildSpec.template.type} ${buildSpec.template.subType}`;
+    /**
+     * We need to have an initialized git repo before attempting to do an
+     * npm install since there are husky rules and it needs git.
+     */
+
+    const git = SimpleGit(buildSpec.git.name);
+
+    try {
+      await git.init().add(['--all', '--force']); // we want it all!
+    } catch (initErr) {
+      console.log(initErr);
+      process.exit(1);
+    }
+    /**
+     * Keep in mind that all of the git commands will be relevant to the cwd
+     * at the time the SimpleGit interface was instantiated. That has nothing
+     * to do with the set of commands that are about to execute.
+     */
+
+
+    Shell.pushd(buildSpec.git.name);
+    const spinner = new Ora();
+
+    if (buildSpec.config.npmCheck) {
+      console.log(chalk.keyword('orange').bold(`
+  Running npm-check-updates interactively to verify all of the package
+  versions in package.json are up to date prior to committing everything.`), chalk.yellow.bold(`
+
+  Pay attention! You may be asked to answer Y/n if any are out of date!`));
+      spinner.start('Preparing for dependency checks prior to install.');
+      await pause(3000);
+      spinner.succeed();
+      await execa('npm', ['install', 'npm-check-updates'], {
+        stdio: 'inherit'
+      });
+      await execa('npm', ['run', 'npm-check-updates'], {
+        stdio: 'inherit'
+      });
+    }
+
+    try {
+      for (let i = 0; i < buildSpec.npmActions.length; i++) {
+        const npmAction = buildSpec.npmActions[i];
+        spinner.start(`Running npm ${npmAction}`);
+        await pause(2000); // eslint-disable-line
+
+        spinner.stop();
+        await execa('npm', npmAction.split(' '), {
+          stdio: 'inherit'
+        }); // eslint-disable-line
+
+        spinner.succeed();
+        await pause(1000); // eslint-disable-line
+      }
+    } catch (err) {
+      console.error(`${chalk.red.bold(err)}\n\n`);
+      spinner.fail('Running npm install');
+      process.exit(1);
+    }
+
+    if (buildSpec.template.helmify) {
+      try {
+        await execa('helmify', {
+          stdio: 'inherit'
+        });
+      } catch (err) {
+        console.log(err);
+        process.exit(1);
+      }
+    }
+
+    Shell.popd();
+    /**
+     * Complete the standard git repo setup by adding all,
+     * to push to host unless the repo already exists.
+     */
+
+    try {
+      spinner.start('Adding all source to the git repository');
+      await git.add(['--all']).commit(initialCommit).branch(['development']).checkout(['development']);
+      spinner.succeed();
+    } catch (err) {
+      console.log(err);
+      spinner.fail('Repository initialization failed - this is very bad');
+      process.exit(1);
+    }
+
+    if (buildSpec.template.type === 'ingestor') {
+      /**
+       * Drop back down into the newly created git repo before creating the
+       * .env file in the repository. This file will not be tracked. Note that
+       * the pause here is an artificial delay to make this step noticable to
+       * the user.
+       */
+      Shell.pushd(buildSpec.git.name);
+      const makeDot = 'scripts/make-dot';
+      spinner.start(`Executing ${chalk.green.bold(makeDot)} to generate a simple .env file.`);
+      await execa('bash', [makeDot]);
+      await pause(1500); // eslint-disable-line
+
+      spinner.succeed();
+      Shell.popd();
+    }
+
+    if (buildSpec.git.host === 'local' || buildSpec.git.createRemote === 'skip') {
+      console.log(chalk.keyword('orange').bold(`
+  The repository is now configured with the initial commit and a development
+  branch. Since you selected to skip the creation of the remote hosted repository
+  it is up to you to complete those step manually.`));
+      return;
+    }
+
+    await repoHosting.build(buildSpec);
+    console.log(chalk.keyword('orange').bold(`
+  The repository is now configured with the initial commit and a development
+  branch. The upstream push may take up to 30 seconds to complete.
+`));
+
+    try {
+      spinner.start(`Pushing ${buildSpec.git.name} repository upstream`);
+      await git.addRemote('origin', repoHosting.getGitURL('remote', buildSpec)).push(['--set-upstream', 'origin', 'master']).push(['--set-upstream', 'origin', 'development']).checkout(['development']);
+      spinner.succeed();
+    } catch (err) {
+      console.log(err);
+      spinner.fail(`git push ${buildSpec.git.name}`);
+      process.exit(1);
+    }
+
+    await repoHosting.openAdmin(buildSpec);
+  }
+
+}
+
+module.exports = {
+  Gitter
+};

package/lib/server/repo-init/gitter/RepoHosting.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const chalk = require('chalk');
+
+const clipboardy = require('clipboardy');
+
+const open = require('open');
+
+const {
+  clear,
+  proceed
+} = require('../utils');
+
+const greet = async () => {
+  console.log(chalk.keyword('orange').bold(`
+  Setting up the initial repository on the git hosting service is a manual
+  process which will require the setting of a handful of fields via the UI.
+  Proceeding forward with this step will result in a browser window being
+  opened at the repository creation page.
+`));
+  await proceed('Do you wish to continue to the repo creation page?');
+  clear();
+};
+/**
+ * This could come from a config file but we're keeping it simple, for now.
+ */
+
+
+const getGitURL = (type, buildSpec) => {
+  const gitHostURLs = {
+    control: {
+      admin: 'admin',
+      create: 'create',
+      remote: 'remote'
+    },
+    bitbucket: {
+      admin: `https://bitbucket.org/${buildSpec.git.owner}/${buildSpec.git.name}/admin`,
+      create: `https://bitbucket.org/repo/create?owner=${buildSpec.git.owner}`,
+      remote: `git@bitbucket-leverege:${buildSpec.git.owner}/${buildSpec.git.name}.git`
+    },
+    github: {
+      admin: `https://github.com/${buildSpec.git.owner}/${buildSpec.git.name}/settings/branches`,
+      create: `https://github.com/organizations/${buildSpec.git.owner}/repositories/new`,
+      remote: `git@github.com:${buildSpec.git.owner}/${buildSpec.git.name}.git`
+    }
+  };
+
+  if (!Object.keys(gitHostURLs.control).includes(type)) {
+    throw new Error(`Unknown git URL type of ${type}`);
+  }
+
+  return gitHostURLs[buildSpec.git.host][type];
+};
+/**
+ */
+
+
+const build = async buildSpec => {
+  await greet();
+  console.log(`${chalk.keyword('orange').bold(`
+  Before proceeding you will want to verify that your browser has access to the
+  git hosting service you are about to use. The easiest way to do this is to
+  simply open a browser window on bitbuck or github with the desired account.
+
+  Once you proceed from this step a browser window will be opened and you will
+  enter the relevant information into the repository creation page. Click the
+  ${chalk.blue.bold('Create repository')} button to complete the process.
+    ${chalk.keyword('green').bold(`
+  Git Host        => ${chalk.yellow.bold(buildSpec.git.host)}
+  Project         => ${chalk.yellow.bold('Testing or something appropriate')}
+  Repository name => ${chalk.yellow.bold(buildSpec.git.name)} <= copied to clipboard`)}
+
+  ${chalk.red.bold('DO NOT initialize a README, gitignore or License file')}
+
+  This window may be covered by the browser window so be sure to come back here
+  after you ${chalk.blue.bold('create the repository')}.`)}
+`);
+  await proceed(`You at least read the ${chalk.red.bold('red')} line above and are ready to proceed?`);
+  clipboardy.writeSync(buildSpec.git.name);
+  await open(getGitURL('create', buildSpec));
+  console.log(`${chalk.keyword('orange').bold('Waiting on repo creation to complete...')}`);
+  await proceed('Continue after the initial repository has been created?');
+};
+/**
+ */
+
+
+const openAdmin = async buildSpec => {
+  console.log(chalk.keyword('orange').bold(`
+  The admin page for the repository will now be opened in the browser. Please
+  take a moment to tweak the following settings:
+
+    ${chalk.keyword('green')('Project')}     - adjust if the original selection was slightly off
+    ${chalk.keyword('green').bold('Description')} - a few words here wouldn't hurt
+    ${chalk.keyword('green').bold('Language')}    - set this to Node.js or Javascript?
+    ${chalk.keyword('green').bold('Main branch')} - set that to ${chalk.keyword('red').bold('development')}, ok?
+    `));
+  await open(getGitURL('admin', buildSpec));
+  await proceed('Please take a moment to at least set the Language and Main branch?');
+};
+
+module.exports = {
+  build,
+  getGitURL,
+  openAdmin
+};

package/lib/server/repo-init/gitter/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const {
+  Gitter
+} = require('./Gitter');
+
+module.exports = {
+  Gitter
+};

package/lib/server/repo-init/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+
+const RepoInit = require('./RepoInit');
+
+RepoInit.start();