Complete publish release script

Author: devversion

tools/release/git-release-task.ts renamed to tools/release/base-release-task.ts

@@ -1,9 +1,14 @@
 import {green, italic, red, yellow} from 'chalk';
+import {prompt} from 'inquirer';
 import {GitClient} from './git/git-client';
 import {Version} from './version-name/parse-version';
 import {getAllowedPublishBranches} from './version-name/publish-branches';
 
-export class GitReleaseTask {
+/**
+ * Base release task class that contains shared methods that are commonly used across
+ * the staging and publish script.
+ */
+export class BaseReleaseTask {
 
   constructor(public git: GitClient) {}
 
@@ -64,4 +69,13 @@ export class GitReleaseTask {
       process.exit(1);
     }
   }
+
+  /** Prompts the user with a confirmation question and a specified message. */
+  protected async promptConfirm(message: string): Promise<boolean> {
+    return (await prompt<{result: boolean}>({
+      type: 'confirm',
+      name: 'result',
+      message: message,
+    })).result;
+  }
 }

tools/release/git/git-client.ts

@@ -53,10 +53,15 @@ export class GitClient {
     return spawnSync('git', ['commit', '-m', message], {cwd: this.projectDir}).status === 0;
   }
 
-  /** Gets the title of a specified commit. */
-  getCommitTitle(commitSha: string): string {
-    return spawnSync('git', ['log', '-n1', '--format', '%s', commitSha], {cwd: this.projectDir})
+  /** Gets the title of a specified commit reference. */
+  getCommitTitle(commitRef: string): string {
+    return spawnSync('git', ['log', '-n1', '--format', '%s', commitRef], {cwd: this.projectDir})
       .stdout.toString().trim();
   }
+
+  /** Creates a tag for the specified commit reference. */
+  createTag(commitRef: string, tagName: string, message: string): boolean {
+    return spawnSync('git', ['tag', tagName, '-m', message], {cwd: this.projectDir}).status === 0;
+  }
 }
 

tools/release/git/github-urls.ts

@@ -2,3 +2,8 @@
 export function getGithubBranchCommitsUrl(owner: string, repository: string, branchName: string) {
   return `https://github.com/${owner}/${repository}/commits/${branchName}`;
 }
+
+/** Gets a Github URL that refers list of releases within the specified repository. */
+export function getGithubReleasesUrl(owner: string, repository: string) {
+  return `https://github.com/${owner}/${repository}/releases`;
+}

tools/release/npm/npm-client.ts

@@ -0,0 +1,44 @@
+import {spawnSync} from 'child_process';
+
+/**
+ * Process environment that does not refer to Yarn's package registry. Since the scripts are
+ * usually run through Yarn, we need to update the "npm_config_registry" so that NPM is able to
+ * properly run "npm login" and "npm publish".
+ */
+const npmClientEnvironment = {
+  ...process.env,
+  // See https://docs.npmjs.com/misc/registry for the official documentation of the NPM registry.
+  npm_config_registry: 'https://registry.npmjs.org',
+};
+
+/** Checks whether NPM is currently authenticated. */
+export function isNpmAuthenticated(): boolean {
+  return spawnSync('npm', ['whoami'], {
+    shell: true,
+    env: npmClientEnvironment,
+  }).stdout.toString() !== '';
+}
+
+/** Runs "npm login" interactively by piping stdin/stderr/stdout to the current tty. */
+export function runInteractiveNpmLogin(): boolean {
+  return spawnSync('npm', ['login'], {
+    stdio: 'inherit',
+    shell: true,
+    env: npmClientEnvironment,
+  }).status === 0;
+}
+
+/** Runs NPM publish within a specified directory */
+export function runNpmPublish(packagePath: string, distTag: string): string | null {
+  const result = spawnSync('npm', ['publish', '--access', 'public', '--tag', distTag, '--dry-run'], {
+    cwd: packagePath,
+    shell: true,
+    env: npmClientEnvironment,
+  });
+
+  // We only want to return an error if the exit code is not zero. NPM by default prints the
+  // logging messages to "stdout" and therefore just checking for "stdout" is not reliable.
+  if (result.status !== 0) {
+    return result.stderr.toString();
+  }
+}

tools/release/publish-release.ts

@@ -1,21 +1,24 @@
-import * as OctokitApi from '@octokit/rest';
 import {bold, green, italic, red, yellow} from 'chalk';
-import {existsSync, readFileSync} from 'fs';
-import {prompt} from 'inquirer';
+import {execSync} from 'child_process';
+import {readFileSync} from 'fs';
 import {join} from 'path';
-import {GitReleaseTask} from './git-release-task';
+import {BaseReleaseTask} from './base-release-task';
 import {GitClient} from './git/git-client';
+import {getGithubReleasesUrl} from './git/github-urls';
+import {isNpmAuthenticated, runInteractiveNpmLogin, runNpmPublish} from './npm/npm-client';
 import {promptForNpmDistTag} from './prompt/npm-dist-tag-prompt';
 import {checkReleasePackage} from './release-output/check-packages';
 import {releasePackages} from './release-output/release-packages';
 import {parseVersionName, Version} from './version-name/parse-version';
-import {execSync} from 'child_process';
+
+/** Maximum allowed tries to authenticate NPM. */
+const MAX_NPM_LOGIN_TRIES = 2;
 
 /**
  * Class that can be instantiated in order to create a new release. The tasks requires user
  * interaction/input through command line prompts.
  */
-class PublishReleaseTask extends GitReleaseTask {
+class PublishReleaseTask extends BaseReleaseTask {
 
   /** Path to the project package JSON. */
   packageJsonPath: string;
@@ -26,27 +29,20 @@ class PublishReleaseTask extends GitReleaseTask {
   /** Parsed current version of the project. */
   currentVersion: Version;
 
+  /** Path to the release output of the project. */
+  releaseOutputPath: string;
+
   /** Instance of a wrapper that can execute Git commands. */
   git: GitClient;
 
-  /** Octokit API instance that can be used to make Github API calls. */
-  githubApi: OctokitApi;
-
   constructor(public projectDir: string,
               public repositoryOwner: string,
               public repositoryName: string) {
     super(new GitClient(projectDir,
       `https://github.com/${repositoryOwner}/${repositoryName}.git`));
 
     this.packageJsonPath = join(projectDir, 'package.json');
-
-    console.log(this.projectDir);
-
-    if (!existsSync(this.packageJsonPath)) {
-      console.error(red(`The specified directory is not referring to a project directory. ` +
-        `There must be a ${italic('package.json')} file in the project directory.`));
-      process.exit(1);
-    }
+    this.releaseOutputPath = join(projectDir, 'dist/releases');
 
     this.packageJson = JSON.parse(readFileSync(this.packageJsonPath, 'utf-8'));
     this.currentVersion = parseVersionName(this.packageJson.version);
@@ -56,8 +52,6 @@ class PublishReleaseTask extends GitReleaseTask {
         `make sure "${this.packageJson.version}" is a valid Semver version.`));
       process.exit(1);
     }
-
-    this.githubApi = new OctokitApi();
   }
 
   async run() {
@@ -67,26 +61,54 @@ class PublishReleaseTask extends GitReleaseTask {
     console.log(green('-----------------------------------------'));
     console.log();
 
+    const newVersion = this.currentVersion;
+    const newVersionName = this.currentVersion.format();
+
     // Ensure there are no uncommitted changes. Checking this before switching to a
     // publish branch is sufficient as unstaged changes are not specific to Git branches.
     this.verifyNoUncommittedChanges();
 
     // Branch that will be used to build the output for the release of the current version.
-    const publishBranch = this.switchToPublishBranch(this.currentVersion);
+    const publishBranch = this.switchToPublishBranch(newVersion);
 
     this.verifyLastCommitVersionBump();
     this.verifyLocalCommitsMatchUpstream(publishBranch);
 
-    const npmDistTag = await promptForNpmDistTag(this.currentVersion);
+    const npmDistTag = await promptForNpmDistTag(newVersion);
 
     // In case the user wants to publish a stable version to the "next" npm tag, we want
     // to double-check because usually only pre-release's are pushed to that tag.
-    if (npmDistTag === 'next' && !this.currentVersion.prereleaseLabel) {
+    if (npmDistTag === 'next' && !newVersion.prereleaseLabel) {
       await this.promptStableVersionForNextTag();
     }
 
     this.buildReleasePackages();
+    console.info(green(`  ✓   Built the release output.`));
+
     this.checkReleaseOutput();
+    console.info(green(`  ✓   Release output passed validation checks.`));
+
+    // TODO(devversion): find a way to extract the changelog part just for this version.
+    this.git.createTag('HEAD', newVersionName, '');
+    console.info(green(`  ✓   Created release tag: "${italic(newVersionName)}"`));
+
+    // Ensure that we are authenticated before running "npm publish" for each package.
+    this.checkNpmAuthentication();
+
+    // Just in order to double-check that the user is sure to publish to NPM, we want
+    // the user to interactively confirm that the script should continue.
+    await this.promptConfirmReleasePublish();
+
+    for (let packageName of releasePackages) {
+      this.publishPackageToNpm(packageName, npmDistTag);
+    }
+
+    console.log();
+    console.info(green(bold(`  ✓   Published all packages successfully`)));
+    console.info(yellow(`  ⚠   Please push the newly created tag to Github and draft a new ` +
+      `release.`));
+    console.info(yellow(
+      `      ${getGithubReleasesUrl(this.repositoryOwner, this.repositoryName)}`));
   }
 
   /**
@@ -116,11 +138,10 @@ class PublishReleaseTask extends GitReleaseTask {
 
   /** Checks the release output by running the release-output validations. */
   private checkReleaseOutput() {
-    const releasesPath = join(this.projectDir, 'dist/releases');
     let hasFailed = false;
 
     releasePackages.forEach(packageName => {
-      if (!checkReleasePackage(releasesPath, packageName)) {
+      if (!checkReleasePackage(this.releaseOutputPath, packageName)) {
         hasFailed = true;
       }
     });
@@ -135,22 +156,80 @@ class PublishReleaseTask extends GitReleaseTask {
   }
 
   /**
-   * Prompts the user whether he is sure that the current stable version should be
+   * Prompts the user whether they are sure that the current stable version should be
    * released to the "next" NPM dist-tag.
    */
   private async promptStableVersionForNextTag() {
-    const {shouldContinue} = await prompt<{shouldContinue: boolean}>({
-      type: 'confirm',
-      name: 'shouldContinue',
-      message: 'Are you sure that you want to release a stable version to the "next" tag?'
-    });
+    if (!await this.promptConfirm(
+        'Are you sure that you want to release a stable version to the "next" tag?')) {
+      console.log();
+      console.log(yellow('Aborting publish...'));
+      process.exit(0);
+    }
+  }
 
-    if (!shouldContinue) {
+
+  /**
+   * Prompts the user whether he is sure that the script should continue publishing
+   * the release to NPM.
+   */
+  private async promptConfirmReleasePublish() {
+    if (!await this.promptConfirm('Are you sure that you want to release now?')) {
       console.log();
       console.log(yellow('Aborting publish...'));
       process.exit(0);
     }
   }
+
+  /**
+   * Checks whether NPM is currently authenticated. If not, the user will be prompted to enter
+   * the NPM credentials that are necessary to publish the release. We achieve this by basically
+   * running "npm login" as a child process and piping stdin/stdout/stderr to the current tty.
+   */
+  private checkNpmAuthentication() {
+    if (isNpmAuthenticated()) {
+      console.info(green(`  ✓   NPM is authenticated.`));
+      return;
+    }
+
+    let failedAuthentication = false;
+    console.log(yellow(`  ⚠   NPM is currently not authenticated. Running "npm login"..`));
+
+    for (let i = 0;  i < MAX_NPM_LOGIN_TRIES; i++) {
+      if (runInteractiveNpmLogin()) {
+        // In case the user was able to login properly, we want to exit the loop as we
+        // don't need to ask for authentication again.
+        break;
+      }
+
+      failedAuthentication = true;
+      console.error(red(`  ✘   Could not authenticate successfully. Please try again.`));
+    }
+
+    if (failedAuthentication) {
+      console.error(red(`  ✘   Could not authenticate after ${MAX_NPM_LOGIN_TRIES} tries. ` +
+        `Exiting..`));
+      process.exit(1);
+    }
+
+    console.info(green(`  ✓   Successfully authenticated NPM.`));
+  }
+
+  /** Publishes the specified package within the given NPM dist tag. */
+  private publishPackageToNpm(packageName: string, npmDistTag: string) {
+    console.info(green(`  ⭮   Publishing "${packageName}"..`));
+
+    const errorOutput = runNpmPublish(join(this.releaseOutputPath, packageName), npmDistTag);
+
+    if (errorOutput) {
+      console.error(red(`  ✘   An error occurred while publishing "${packageName}".`));
+      console.error(red(`      Please check the terminal output and reach out to the team.`));
+      console.error(red(`\n${errorOutput}`));
+      process.exit(1);
+    }
+
+    console.info(green(`  ✓   Successfully published "${packageName}"`));
+  }
 }
 
 /** Entry-point for the create release script. */