feat: Throw regular Error for unexpected errors

BREAKING CHANGE: Do not wrap unexpected errors in a `@semantic-release/error`. This way, in case of unexpected error (wrong release rule for example) `semantic-release` will fail and return with an exit code

Author: pvdlg

lib/index.js

@@ -1,6 +1,5 @@
 const loadParserConfig = require('./load/parser-config');
 const loadReleaseRules = require('./load/release-rules');
-const parse = require('./parse');
 const analyzeCommit = require('./analyze-commit');
 const compareReleaseTypes = require('./compare-release-types');
 const RELEASE_TYPES = require('./default/release-types');
@@ -31,8 +30,8 @@ module.exports = async (pluginConfig = {}, {commits}, callback) => {
     let releaseType = null;
 
     commits.every(rawCommit => {
-      const commit = parse(rawCommit.message, config);
       let commitReleaseType;
+    const commit = parser(rawCommit.message, config);
 
       // Determine release type based on custom releaseRules
       if (releaseRules) {

lib/load/parser-config.js

@@ -1,7 +1,6 @@
 const {promisify} = require('util');
 const importFrom = require('import-from');
 const {mergeWith} = require('lodash');
-const SemanticReleaseError = require('@semantic-release/error');
 const conventionalChangelogAngular = require('conventional-changelog-angular');
 
 /**
@@ -17,17 +16,9 @@ module.exports = async ({preset, config, parserOpts}) => {
 
   if (preset) {
     const presetPackage = `conventional-changelog-${preset.toLowerCase()}`;
-    try {
-      loadedConfig = importFrom.silent(__dirname, presetPackage) || importFrom(process.cwd(), presetPackage);
-    } catch (err) {
-      throw new SemanticReleaseError(`Preset: "${preset}" does not exist: ${err.message}`, err.code);
-    }
+    loadedConfig = importFrom.silent(__dirname, presetPackage) || importFrom(process.cwd(), presetPackage);
   } else if (config) {
-    try {
-      loadedConfig = importFrom.silent(__dirname, config) || importFrom(process.cwd(), config);
-    } catch (err) {
-      throw new SemanticReleaseError(`Config: "${config}" does not exist: ${err.message}`, err.code);
-    }
+    loadedConfig = importFrom.silent(__dirname, config) || importFrom(process.cwd(), config);
   } else if (!parserOpts) {
     loadedConfig = conventionalChangelogAngular;
   }

lib/load/release-rules.js

@@ -1,5 +1,4 @@
 const importFrom = require('import-from');
-const SemanticReleaseError = require('@semantic-release/error');
 const RELEASE_TYPES = require('../default/release-types');
 
 /**
@@ -21,19 +20,15 @@ module.exports = ({releaseRules}) => {
         : releaseRules;
 
     if (!Array.isArray(loadedReleaseRules)) {
-      throw new SemanticReleaseError(
-        'Error in commit-analyzer configuration: "releaseRules" must be an array of rules',
-        'EINVALIDCONFIG'
-      );
+      throw new Error('Error in commit-analyzer configuration: "releaseRules" must be an array of rules');
     }
 
     loadedReleaseRules.forEach(rule => {
       if (RELEASE_TYPES.indexOf(rule.release) === -1) {
-        throw new SemanticReleaseError(
+        throw new Error(
           `Error in commit-analyzer configuration: "${rule.release}" is not a valid release type. Valid values are: ${JSON.stringify(
             RELEASE_TYPES
-          )}`,
-          'EINVALIDRELEASE'
+          )}`
         );
       }
     });

lib/parse.js

@@ -12,7 +12,6 @@
     }
   },
   "dependencies": {
-    "@semantic-release/error": "^2.0.0",
     "conventional-changelog-angular": "^1.4.0",
     "conventional-commits-parser": "^2.0.0",
     "import-from": "^2.1.0",

package.json

@@ -1,6 +1,5 @@
 import {promisify} from 'util';
 import test from 'ava';
-import SemanticReleaseError from '@semantic-release/error';
 import commitAnalyzer from '../lib/index';
 
 test('Parse with "conventional-changelog-angular" by default', async t => {
@@ -134,65 +133,43 @@ test('Ignore malformatted commits and process valid ones', async t => {
   t.is(releaseType, 'patch');
 });
 
-test('Throw "SemanticReleaseError" if "preset" doesn`t exist', async t => {
-  const error = await t.throws(
-    promisify(commitAnalyzer)({preset: 'unknown-preset'}, {}),
-    /Preset: "unknown-preset" does not exist:/
-  );
+test('Throw error if "preset" doesn`t exist', async t => {
+  const error = await t.throws(promisify(commitAnalyzer)({preset: 'unknown-preset'}, {}));
 
-  t.true(error instanceof SemanticReleaseError);
   t.is(error.code, 'MODULE_NOT_FOUND');
 });
 
-test('Throw "SemanticReleaseError" if "releaseRules" is not an Array or a String', async t => {
-  const error = await t.throws(
+test('Throw error if "releaseRules" is not an Array or a String', async t => {
+  await t.throws(
     promisify(commitAnalyzer)({releaseRules: {}}, {}),
     /Error in commit-analyzer configuration: "releaseRules" must be an array of rules/
   );
-
-  t.true(error instanceof SemanticReleaseError);
-  t.is(error.code, 'EINVALIDCONFIG');
 });
 
-test('Throw "SemanticReleaseError" if "releaseRules" option reference a requierable module that is not an Array or a String', async t => {
-  const error = await t.throws(
+test('Throw error if "releaseRules" option reference a requierable module that is not an Array or a String', async t => {
+  await t.throws(
     promisify(commitAnalyzer)({releaseRules: './test/fixtures/release-rules-invalid'}, {}),
     /Error in commit-analyzer configuration: "releaseRules" must be an array of rules/
   );
-
-  t.true(error instanceof SemanticReleaseError);
-  t.is(error.code, 'EINVALIDCONFIG');
 });
 
-test('Throw "SemanticReleaseError" if "config" doesn`t exist', async t => {
+test('Throw error if "config" doesn`t exist', async t => {
   const commits = [{message: 'Fix: First fix (fixes #123)'}, {message: 'Update: Second feature (fixes #456)'}];
-  const error = await t.throws(
-    promisify(commitAnalyzer)({config: 'unknown-config'}, {commits}),
-    /Config: "unknown-config" does not exist:/
-  );
+  const error = await t.throws(promisify(commitAnalyzer)({config: 'unknown-config'}, {commits}));
 
-  t.true(error instanceof SemanticReleaseError);
   t.is(error.code, 'MODULE_NOT_FOUND');
 });
 
-test('Throw "SemanticReleaseError" if "releaseRules" reference invalid commit type', async t => {
-  const error = await t.throws(
+test('Throw error if "releaseRules" reference invalid commit type', async t => {
+  await t.throws(
     promisify(commitAnalyzer)({preset: 'eslint', releaseRules: [{tag: 'Update', release: 'invalid'}]}, {}),
     /Error in commit-analyzer configuration: "invalid" is not a valid release type\. Valid values are:\[?.*\]/
   );
-
-  t.is(error.code, 'EINVALIDRELEASE');
-  t.true(error instanceof SemanticReleaseError);
 });
 
-test('Handle error in "conventional-changelog-parser" and wrap in "SemanticReleaseError"', async t => {
+test('Re-Throw error from "conventional-changelog-parser"', async t => {
   const commits = [{message: 'Fix: First fix (fixes #123)'}, {message: 'Update: Second feature (fixes #456)'}];
-  const error = await t.throws(
-    promisify(commitAnalyzer)({parserOpts: {headerPattern: '\\'}}, {commits}),
-    /Error in conventional-changelog-parser: Invalid regular expression:/
-  );
-
-  t.true(error instanceof SemanticReleaseError);
+  await t.throws(promisify(commitAnalyzer)({parserOpts: {headerPattern: '\\'}}, {commits, logger: t.context.logger}));
 });
 
 test('Accept an undefined "pluginConfig"', async t => {

test/integration.test.js

@@ -1,5 +1,4 @@
 import test from 'ava';
-import SemanticReleaseError from '@semantic-release/error';
 import loadParserConfig from './../lib/load/parser-config';
 
 /**
@@ -70,22 +69,14 @@ test(loadConfig, 'express');
 test(loadPreset, 'jshint');
 test(loadConfig, 'jshint');
 
-test('Throw "SemanticReleaseError" if "config" doesn`t exist', async t => {
-  const error = await t.throws(
-    loadParserConfig({config: 'unknown-config'}),
-    /Config: "unknown-config" does not exist:/
-  );
+test('Throw error if "config" doesn`t exist', async t => {
+  const error = await t.throws(loadParserConfig({config: 'unknown-config'}));
 
-  t.true(error instanceof SemanticReleaseError);
   t.is(error.code, 'MODULE_NOT_FOUND');
 });
 
-test('Throw "SemanticReleaseError" if "preset" doesn`t exist', async t => {
-  const error = await t.throws(
-    loadParserConfig({preset: 'unknown-preset'}),
-    /Preset: "unknown-preset" does not exist:/
-  );
+test('Throw error if "preset" doesn`t exist', async t => {
+  const error = await t.throws(loadParserConfig({preset: 'unknown-preset'}));
 
-  t.true(error instanceof SemanticReleaseError);
   t.is(error.code, 'MODULE_NOT_FOUND');
 });

test/load-parser-config.test.js

@@ -1,5 +1,4 @@
 import test from 'ava';
-import SemanticReleaseError from '@semantic-release/error';
 import loadReleaseRules from './../lib/load/release-rules';
 import testReleaseRules from './fixtures/release-rules';
 
@@ -21,32 +20,25 @@ test('Return undefined if "releaseRules" not set', t => {
   t.is(releaseRules, undefined);
 });
 
-test('Throw "SemanticReleaseError" if "releaseRules" reference invalid commit type', t => {
-  const error = t.throws(
+test('Throw error if "releaseRules" reference invalid commit type', t => {
+  t.throws(
     () => loadReleaseRules({releaseRules: [{tag: 'Update', release: 'invalid'}]}),
     /Error in commit-analyzer configuration: "invalid" is not a valid release type\. Valid values are:\[?.*\]/
   );
 
-  t.is(error.code, 'EINVALIDRELEASE');
-  t.true(error instanceof SemanticReleaseError);
 });
 
-test('Throw "SemanticReleaseError" if "releaseRules" is not an Array or a String', t => {
-  const error = t.throws(
+test('Throw error if "releaseRules" is not an Array or a String', t => {
+  t.throws(
     () => loadReleaseRules({releaseRules: {}}, {}),
     /Error in commit-analyzer configuration: "releaseRules" must be an array of rules/
   );
-
-  t.true(error instanceof SemanticReleaseError);
-  t.is(error.code, 'EINVALIDCONFIG');
 });
 
-test('Throw "SemanticReleaseError" if "releaseRules" option reference a requierable module that is not an Array or a String', t => {
-  const error = t.throws(
+test('Throw error if "releaseRules" option reference a requierable module that is not an Array or a String', t => {
+  t.throws(
     () => loadReleaseRules({releaseRules: './test/fixtures/release-rules-invalid'}),
     /Error in commit-analyzer configuration: "releaseRules" must be an array of rules/
   );
 
-  t.true(error instanceof SemanticReleaseError);
-  t.is(error.code, 'EINVALIDCONFIG');
 });