feat: add success and fail notification plugins

- Allow `publish` plugins to return an `Object` with information related to the releases
- Add the `success` plugin hook, called when all `publish` are successful, receiving a list of release
- Add the `fail` plugin hook, called when an error happens at any point, receiving a list of errors
- Add detailed message for each error

index.js

@@ -1,4 +1,4 @@
-const {template, isFunction} = require('lodash');
+const {template, isPlainObject, castArray} = require('lodash');
 const marked = require('marked');
 const TerminalRenderer = require('marked-terminal');
 const envCi = require('env-ci');
@@ -9,13 +9,14 @@ const verify = require('./lib/verify');
 const getNextVersion = require('./lib/get-next-version');
 const getCommits = require('./lib/get-commits');
 const getLastRelease = require('./lib/get-last-release');
+const {extractErrors} = require('./lib/utils');
 const logger = require('./lib/logger');
 const {unshallow, gitHead: getGitHead, tag, push, deleteTag} = require('./lib/git');
 
-async function run(opts) {
+marked.setOptions({renderer: new TerminalRenderer()});
+
+async function run(options, plugins) {
   const {isCi, branch, isPr} = envCi();
-  const config = await getConfig(opts, logger);
-  const {plugins, options} = config;
 
   if (!isCi && !options.dryRun && !options.noCi) {
     logger.log('This run was not triggered in a known CI environment, running in dry-run mode.');
@@ -34,7 +35,7 @@ async function run(opts) {
   logger.log('Run automated release from branch %s', options.branch);
 
   logger.log('Call plugin %s', 'verify-conditions');
-  await plugins.verifyConditions({options, logger}, true);
+  await plugins.verifyConditions({options, logger}, {settleAll: true});
 
   // Unshallow the repo in order to get all the tags
   await unshallow();
@@ -57,14 +58,13 @@ async function run(opts) {
   const nextRelease = {type, version, gitHead: await getGitHead(), gitTag: template(options.tagFormat)({version})};
 
   logger.log('Call plugin %s', 'verify-release');
-  await plugins.verifyRelease({options, logger, lastRelease, commits, nextRelease}, true);
+  await plugins.verifyRelease({options, logger, lastRelease, commits, nextRelease}, {settleAll: true});
 
   const generateNotesParam = {options, logger, lastRelease, commits, nextRelease};
 
   if (options.dryRun) {
     logger.log('Call plugin %s', 'generate-notes');
     const notes = await plugins.generateNotes(generateNotesParam);
-    marked.setOptions({renderer: new TerminalRenderer()});
     logger.log('Release note for version %s:\n', nextRelease.version);
     process.stdout.write(`${marked(notes)}\n`);
   } else {
@@ -77,45 +77,85 @@ async function run(opts) {
     await push(options.repositoryUrl, branch);
 
     logger.log('Call plugin %s', 'publish');
-    await plugins.publish({options, logger, lastRelease, commits, nextRelease}, false, async prevInput => {
-      const newGitHead = await getGitHead();
-      // If previous publish plugin has created a commit (gitHead changed)
-      if (prevInput.nextRelease.gitHead !== newGitHead) {
-        // Delete the previously created tag
-        await deleteTag(options.repositoryUrl, nextRelease.gitTag);
-        // Recreate the tag, referencing the new gitHead
-        logger.log('Create tag %s', nextRelease.gitTag);
-        await tag(nextRelease.gitTag);
-        await push(options.repositoryUrl, branch);
+    const releases = await plugins.publish(
+      {options, logger, lastRelease, commits, nextRelease},
+      {
+        getNextInput: async lastResult => {
+          const newGitHead = await getGitHead();
+          // If previous publish plugin has created a commit (gitHead changed)
+          if (lastResult.nextRelease.gitHead !== newGitHead) {
+            // Delete the previously created tag
+            await deleteTag(options.repositoryUrl, nextRelease.gitTag);
+            // Recreate the tag, referencing the new gitHead
+            logger.log('Create tag %s', nextRelease.gitTag);
+            await tag(nextRelease.gitTag);
+            await push(options.repositoryUrl, branch);
 
-        nextRelease.gitHead = newGitHead;
-        // Regenerate the release notes
-        logger.log('Call plugin %s', 'generateNotes');
-        nextRelease.notes = await plugins.generateNotes(generateNotesParam);
+            nextRelease.gitHead = newGitHead;
+            // Regenerate the release notes
+            logger.log('Call plugin %s', 'generateNotes');
+            nextRelease.notes = await plugins.generateNotes(generateNotesParam);
+          }
+          // Call the next publish plugin with the updated `nextRelease`
+          return {options, logger, lastRelease, commits, nextRelease};
+        },
+        // Add nextRelease and plugin properties to published release
+        transform: (release, step) => ({...(isPlainObject(release) ? release : {}), ...nextRelease, ...step}),
       }
-      // Call the next publish plugin with the updated `nextRelease`
-      return {options, logger, lastRelease, commits, nextRelease};
-    });
+    );
+
+    await plugins.success(
+      {options, logger, lastRelease, commits, nextRelease, releases: castArray(releases)},
+      {settleAll: true}
+    );
+
     logger.log('Published release: %s', nextRelease.version);
   }
   return true;
 }
 
+function logErrors(err) {
+  const errors = extractErrors(err).sort(error => (error.semanticRelease ? -1 : 0));
+  for (const error of errors) {
+    if (error.semanticRelease) {
+      logger.log(`%s ${error.message}`, error.code);
+      if (error.details) {
+        process.stdout.write(`${marked(error.details)}\n`);
+      }
+    } else {
+      logger.error('An error occurred while running semantic-release: %O', error);
+    }
+  }
+}
+
+async function callFail(plugins, options, error) {
+  const errors = extractErrors(error).filter(error => error.semanticRelease);
+  if (errors.length > 0) {
+    try {
+      await plugins.fail({options, logger, errors}, {settleAll: true});
+    } catch (err) {
+      logErrors(err);
+    }
+  }
+}
+
 module.exports = async opts => {
   const unhook = hookStd({silent: false}, hideSensitive);
   try {
-    const result = await run(opts);
-    unhook();
-    return result;
-  } catch (err) {
-    const errors = err && isFunction(err[Symbol.iterator]) ? [...err].sort(error => !error.semanticRelease) : [err];
-    for (const error of errors) {
-      if (error.semanticRelease) {
-        logger.log(`%s ${error.message}`, error.code);
-      } else {
-        logger.error('An error occurred while running semantic-release: %O', error);
+    const config = await getConfig(opts, logger);
+    const {plugins, options} = config;
+    try {
+      const result = await run(options, plugins);
+      unhook();
+      return result;
+    } catch (err) {
+      if (!options.dryRun) {
+        await callFail(plugins, options, err);
       }
+      throw err;
     }
+  } catch (err) {
+    logErrors(err);
     unhook();
     throw err;
   }