semantic-release 19.0.5 → 20.0.0-beta.2

package/lib/git.js

@@ -1,8 +1,10 @@
-const gitLogParser = require('git-log-parser');
-const getStream = require('get-stream');
-const execa = require('execa');
-const debug = require('debug')('semantic-release:git');
-const {GIT_NOTE_REF} = require('./definitions/constants');
+import gitLogParser from 'git-log-parser';
+import getStream from 'get-stream';
+import {execa} from 'execa';
+import debugGit from 'debug';
+import {GIT_NOTE_REF} from './definitions/constants.js';
+
+const debug = debugGit('semantic-release:git');
 
 Object.assign(gitLogParser.fields, {hash: 'H', message: 'B', gitTags: 'd', committerDate: {key: 'ci', type: Date}});
 
@@ -14,7 +16,7 @@ Object.assign(gitLogParser.fields, {hash: 'H', message: 'B', gitTags: 'd', commi
  *
  * @return {String} The commit sha of the tag in parameter or `null`.
  */
-async function getTagHead(tagName, execaOptions) {
+export async function getTagHead(tagName, execaOptions) {
   return (await execa('git', ['rev-list', '-1', tagName], execaOptions)).stdout;
 }
 
@@ -27,7 +29,7 @@ async function getTagHead(tagName, execaOptions) {
  * @return {Array<String>} List of git tags.
  * @throws {Error} If the `git` command fails.
  */
-async function getTags(branch, execaOptions) {
+export async function getTags(branch, execaOptions) {
   return (await execa('git', ['tag', '--merged', branch], execaOptions)).stdout
     .split('\n')
     .map((tag) => tag.trim())
@@ -42,7 +44,7 @@ async function getTags(branch, execaOptions) {
  * @param {Object} [execaOpts] Options to pass to `execa`.
  * @return {Promise<Array<Object>>} The list of commits between `from` and `to`.
  */
-async function getCommits(from, to, execaOptions) {
+export async function getCommits(from, to, execaOptions) {
   return (
     await getStream.array(
       gitLogParser.parse(
@@ -62,7 +64,7 @@ async function getCommits(from, to, execaOptions) {
  * @return {Array<String>} List of git branches.
  * @throws {Error} If the `git` command fails.
  */
-async function getBranches(repositoryUrl, execaOptions) {
+export async function getBranches(repositoryUrl, execaOptions) {
   return (await execa('git', ['ls-remote', '--heads', repositoryUrl], execaOptions)).stdout
     .split('\n')
     .filter(Boolean)
@@ -77,7 +79,7 @@ async function getBranches(repositoryUrl, execaOptions) {
  *
  * @return {Boolean} `true` if the reference exists, falsy otherwise.
  */
-async function isRefExists(ref, execaOptions) {
+export async function isRefExists(ref, execaOptions) {
   try {
     return (await execa('git', ['rev-parse', '--verify', ref], execaOptions)).exitCode === 0;
   } catch (error) {
@@ -99,7 +101,7 @@ async function isRefExists(ref, execaOptions) {
  * @param {String} branch The repository branch to fetch.
  * @param {Object} [execaOpts] Options to pass to `execa`.
  */
-async function fetch(repositoryUrl, branch, ciBranch, execaOptions) {
+export async function fetch(repositoryUrl, branch, ciBranch, execaOptions) {
   const isDetachedHead =
     (await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {...execaOptions, reject: false})).stdout === 'HEAD';
 
@@ -137,7 +139,7 @@ async function fetch(repositoryUrl, branch, ciBranch, execaOptions) {
  * @param {String} repositoryUrl The remote repository URL.
  * @param {Object} [execaOpts] Options to pass to `execa`.
  */
-async function fetchNotes(repositoryUrl, execaOptions) {
+export async function fetchNotes(repositoryUrl, execaOptions) {
   try {
     await execa(
       'git',
@@ -159,7 +161,7 @@ async function fetchNotes(repositoryUrl, execaOptions) {
  *
  * @return {String} the sha of the HEAD commit.
  */
-async function getGitHead(execaOptions) {
+export async function getGitHead(execaOptions) {
   return (await execa('git', ['rev-parse', 'HEAD'], execaOptions)).stdout;
 }
 
@@ -170,7 +172,7 @@ async function getGitHead(execaOptions) {
  *
  * @return {string} The value of the remote git URL.
  */
-async function repoUrl(execaOptions) {
+export async function repoUrl(execaOptions) {
   try {
     return (await execa('git', ['config', '--get', 'remote.origin.url'], execaOptions)).stdout;
   } catch (error) {
@@ -185,7 +187,7 @@ async function repoUrl(execaOptions) {
  *
  * @return {Boolean} `true` if the current working directory is in a git repository, falsy otherwise.
  */
-async function isGitRepo(execaOptions) {
+export async function isGitRepo(execaOptions) {
   try {
     return (await execa('git', ['rev-parse', '--git-dir'], execaOptions)).exitCode === 0;
   } catch (error) {
@@ -202,7 +204,7 @@ async function isGitRepo(execaOptions) {
  *
  * @throws {Error} if not authorized to push.
  */
-async function verifyAuth(repositoryUrl, branch, execaOptions) {
+export async function verifyAuth(repositoryUrl, branch, execaOptions) {
   try {
     await execa('git', ['push', '--dry-run', '--no-verify', repositoryUrl, `HEAD:${branch}`], execaOptions);
   } catch (error) {
@@ -220,7 +222,7 @@ async function verifyAuth(repositoryUrl, branch, execaOptions) {
  *
  * @throws {Error} if the tag creation failed.
  */
-async function tag(tagName, ref, execaOptions) {
+export async function tag(tagName, ref, execaOptions) {
   await execa('git', ['tag', tagName, ref], execaOptions);
 }
 
@@ -232,7 +234,7 @@ async function tag(tagName, ref, execaOptions) {
  *
  * @throws {Error} if the push failed.
  */
-async function push(repositoryUrl, execaOptions) {
+export async function push(repositoryUrl, execaOptions) {
   await execa('git', ['push', '--tags', repositoryUrl], execaOptions);
 }
 
@@ -244,7 +246,7 @@ async function push(repositoryUrl, execaOptions) {
  *
  * @throws {Error} if the push failed.
  */
-async function pushNotes(repositoryUrl, execaOptions) {
+export async function pushNotes(repositoryUrl, execaOptions) {
   await execa('git', ['push', repositoryUrl, `refs/notes/${GIT_NOTE_REF}`], execaOptions);
 }
 
@@ -256,7 +258,7 @@ async function pushNotes(repositoryUrl, execaOptions) {
  *
  * @return {Boolean} `true` if valid, falsy otherwise.
  */
-async function verifyTagName(tagName, execaOptions) {
+export async function verifyTagName(tagName, execaOptions) {
   try {
     return (await execa('git', ['check-ref-format', `refs/tags/${tagName}`], execaOptions)).exitCode === 0;
   } catch (error) {
@@ -272,7 +274,7 @@ async function verifyTagName(tagName, execaOptions) {
  *
  * @return {Boolean} `true` if valid, falsy otherwise.
  */
-async function verifyBranchName(branch, execaOptions) {
+export async function verifyBranchName(branch, execaOptions) {
   try {
     return (await execa('git', ['check-ref-format', `refs/heads/${branch}`], execaOptions)).exitCode === 0;
   } catch (error) {
@@ -289,7 +291,7 @@ async function verifyBranchName(branch, execaOptions) {
  *
  * @return {Boolean} `true` is the HEAD of the current local branch is the same as the HEAD of the remote branch, falsy otherwise.
  */
-async function isBranchUpToDate(repositoryUrl, branch, execaOptions) {
+export async function isBranchUpToDate(repositoryUrl, branch, execaOptions) {
   return (
     (await getGitHead(execaOptions)) ===
     (await execa('git', ['ls-remote', '--heads', repositoryUrl, branch], execaOptions)).stdout.match(/^(?<ref>\w+)?/)[1]
@@ -304,7 +306,7 @@ async function isBranchUpToDate(repositoryUrl, branch, execaOptions) {
  *
  * @return {Object} the parsed JSON note if there is one, an empty object otherwise.
  */
-async function getNote(ref, execaOptions) {
+export async function getNote(ref, execaOptions) {
   try {
     return JSON.parse((await execa('git', ['notes', '--ref', GIT_NOTE_REF, 'show', ref], execaOptions)).stdout);
   } catch (error) {
@@ -324,28 +326,6 @@ async function getNote(ref, execaOptions) {
  * @param {String} ref The Git reference to add the note to.
  * @param {Object} [execaOpts] Options to pass to `execa`.
  */
-async function addNote(note, ref, execaOptions) {
+export async function addNote(note, ref, execaOptions) {
   await execa('git', ['notes', '--ref', GIT_NOTE_REF, 'add', '-f', '-m', JSON.stringify(note), ref], execaOptions);
 }
-
-module.exports = {
-  getTagHead,
-  getTags,
-  getCommits,
-  getBranches,
-  isRefExists,
-  fetch,
-  fetchNotes,
-  getGitHead,
-  repoUrl,
-  isGitRepo,
-  verifyAuth,
-  tag,
-  push,
-  pushNotes,
-  verifyTagName,
-  isBranchUpToDate,
-  verifyBranchName,
-  getNote,
-  addNote,
-};

package/lib/hide-sensitive.js

@@ -1,7 +1,7 @@
-const {escapeRegExp, size, isString} = require('lodash');
-const {SECRET_REPLACEMENT, SECRET_MIN_SIZE} = require('./definitions/constants');
+import {escapeRegExp, isString, size} from 'lodash-es';
+import {SECRET_MIN_SIZE, SECRET_REPLACEMENT} from './definitions/constants.js';
 
-module.exports = (env) => {
+export default (env) => {
   const toReplace = Object.keys(env).filter((envVar) => {
     // https://github.com/semantic-release/semantic-release/issues/1558
     if (envVar === 'GOPRIVATE') {
@@ -17,4 +17,4 @@ module.exports = (env) => {
   );
   return (output) =>
     output && isString(output) && toReplace.length > 0 ? output.toString().replace(regexp, SECRET_REPLACEMENT) : output;
-};
+}

package/lib/plugins/index.js

@@ -1,20 +1,21 @@
-const {identity, isPlainObject, omit, castArray, isNil, isString} = require('lodash');
-const AggregateError = require('aggregate-error');
-const getError = require('../get-error');
-const PLUGINS_DEFINITIONS = require('../definitions/plugins');
-const {validatePlugin, validateStep, loadPlugin, parseConfig} = require('./utils');
-const pipeline = require('./pipeline');
-const normalize = require('./normalize');
+import {castArray, identity, isNil, isPlainObject, isString, omit} from 'lodash-es';
+import AggregateError from 'aggregate-error';
+import getError from '../get-error.js';
+import PLUGINS_DEFINITIONS from '../definitions/plugins.js';
+import {loadPlugin, parseConfig, validatePlugin, validateStep} from './utils.js';
+import pipeline from './pipeline.js';
+import normalize from './normalize.js';
 
-module.exports = (context, pluginsPath) => {
+export default async (context, pluginsPath) => {
   let {options, logger} = context;
   const errors = [];
 
   const plugins = options.plugins
-    ? castArray(options.plugins).reduce((plugins, plugin) => {
+    ? await castArray(options.plugins).reduce(async (eventualPluginsList, plugin) => {
+        const pluginsList = await eventualPluginsList;
         if (validatePlugin(plugin)) {
           const [name, config] = parseConfig(plugin);
-          plugin = isString(name) ? loadPlugin(context, name, pluginsPath) : name;
+          plugin = isString(name) ? await loadPlugin(context, name, pluginsPath) : name;
 
           if (isPlainObject(plugin)) {
             Object.entries(plugin).forEach(([type, func]) => {
@@ -24,7 +25,7 @@ module.exports = (context, pluginsPath) => {
                   writable: false,
                   enumerable: true,
                 });
-                plugins[type] = [...(plugins[type] || []), [func, config]];
+                pluginsList[type] = [...(pluginsList[type] || []), [func, config]];
               }
             });
           } else {
@@ -34,7 +35,7 @@ module.exports = (context, pluginsPath) => {
           errors.push(getError('EPLUGINSCONF', {plugin}));
         }
 
-        return plugins;
+        return pluginsList;
       }, {})
     : [];
 
@@ -44,9 +45,13 @@ module.exports = (context, pluginsPath) => {
 
   options = {...plugins, ...options};
 
-  const pluginsConf = Object.entries(PLUGINS_DEFINITIONS).reduce(
-    (pluginsConf, [type, {required, default: def, pipelineConfig, postprocess = identity, preprocess = identity}]) => {
+  const pluginsConfig = await Object.entries(PLUGINS_DEFINITIONS).reduce(
+    async (
+      eventualPluginsConfigAccumulator,
+      [type, {required, default: def, pipelineConfig, postprocess = identity, preprocess = identity}]
+    ) => {
       let pluginOptions;
+      const pluginsConfigAccumulator = await eventualPluginsConfigAccumulator;
 
       if (isNil(options[type]) && def) {
         pluginOptions = def;
@@ -60,28 +65,33 @@ module.exports = (context, pluginsPath) => {
 
         if (!validateStep({required}, options[type])) {
           errors.push(getError('EPLUGINCONF', {type, required, pluginConf: options[type]}));
-          return pluginsConf;
+          return pluginsConfigAccumulator;
         }
 
         pluginOptions = options[type];
       }
 
-      const steps = castArray(pluginOptions).map((pluginOpt) =>
-        normalize(
-          {...context, options: omit(options, Object.keys(PLUGINS_DEFINITIONS), 'plugins')},
-          type,
-          pluginOpt,
-          pluginsPath
+      const steps = await Promise.all(
+        castArray(pluginOptions).map(async (pluginOpt) =>
+          normalize(
+            {...context, options: omit(options, Object.keys(PLUGINS_DEFINITIONS), 'plugins')},
+            type,
+            pluginOpt,
+            pluginsPath
+          )
         )
       );
 
-      pluginsConf[type] = async (input) =>
+      pluginsConfigAccumulator[type] = async (input) =>
         postprocess(
-          await pipeline(steps, pipelineConfig && pipelineConfig(pluginsConf, logger))(await preprocess(input)),
+          await pipeline(
+            steps,
+            pipelineConfig && pipelineConfig(pluginsConfigAccumulator, logger)
+          )(await preprocess(input)),
           input
         );
 
-      return pluginsConf;
+      return pluginsConfigAccumulator;
     },
     plugins
   );
@@ -89,5 +99,5 @@ module.exports = (context, pluginsPath) => {
     throw new AggregateError(errors);
   }
 
-  return pluginsConf;
-};
+  return pluginsConfig;
+}

package/lib/plugins/normalize.js

@@ -1,11 +1,13 @@
-const {isPlainObject, isFunction, noop, cloneDeep, omit} = require('lodash');
-const debug = require('debug')('semantic-release:plugins');
-const getError = require('../get-error');
-const {extractErrors} = require('../utils');
-const PLUGINS_DEFINITIONS = require('../definitions/plugins');
-const {loadPlugin, parseConfig} = require('./utils');
+import {cloneDeep, isFunction, isPlainObject, noop, omit} from 'lodash-es';
+import debugPlugins from 'debug';
+import getError from '../get-error.js';
+import {extractErrors} from '../utils.js';
+import PLUGINS_DEFINITIONS from '../definitions/plugins.js';
+import {loadPlugin, parseConfig} from './utils.js';
 
-module.exports = (context, type, pluginOpt, pluginsPath) => {
+const debug = debugPlugins('semantic-release:plugins');
+
+export default async (context, type, pluginOpt, pluginsPath) => {
   const {stdout, stderr, options, logger} = context;
   if (!pluginOpt) {
     return noop;
@@ -13,7 +15,7 @@ module.exports = (context, type, pluginOpt, pluginsPath) => {
 
   const [name, config] = parseConfig(pluginOpt);
   const pluginName = name.pluginName ? name.pluginName : isFunction(name) ? `[Function: ${name.name}]` : name;
-  const plugin = loadPlugin(context, name, pluginsPath);
+  const plugin = await loadPlugin(context, name, pluginsPath);
 
   debug(`options for ${pluginName}/${type}: %O`, config);
 
@@ -64,4 +66,4 @@ module.exports = (context, type, pluginOpt, pluginsPath) => {
   }
 
   return validator;
-};
+}

package/lib/plugins/pipeline.js

@@ -1,7 +1,7 @@
-const {identity} = require('lodash');
-const pReduce = require('p-reduce');
-const AggregateError = require('aggregate-error');
-const {extractErrors} = require('../utils');
+import {identity} from 'lodash-es';
+import pReduce from 'p-reduce';
+import AggregateError from 'aggregate-error';
+import {extractErrors} from '../utils.js';
 
 /**
  * A Function that execute a list of function sequencially. If at least one Function ins the pipeline throws an Error or rejects, the pipeline function rejects as well.
@@ -23,9 +23,9 @@ const {extractErrors} = require('../utils');
  * @param {Function} [options.getNextInput=identity] Function called after each step is executed, with the last step input and the current current step result; the returned value will be used as the input of the next step.
  * @param {Function} [options.transform=identity] Function called after each step is executed, with the current step result, the step function and the last step input; the returned value will be saved in the pipeline results.
  *
- * @return {Pipeline} A Function that execute the `steps` sequencially
+ * @return {Pipeline} A Function that execute the `steps` sequentially
  */
-module.exports = (steps, {settleAll = false, getNextInput = identity, transform = identity} = {}) => async (input) => {
+export default (steps, {settleAll = false, getNextInput = identity, transform = identity} = {}) => async (input) => {
   const results = [];
   const errors = [];
   await pReduce(
@@ -55,4 +55,4 @@ module.exports = (steps, {settleAll = false, getNextInput = identity, transform
   }
 
   return results;
-};
+}

package/lib/plugins/utils.js

@@ -1,6 +1,9 @@
-const {dirname} = require('path');
-const {isString, isFunction, castArray, isArray, isPlainObject, isNil} = require('lodash');
-const resolveFrom = require('resolve-from');
+import {dirname} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {castArray, isArray, isFunction, isNil, isPlainObject, isString} from 'lodash-es';
+import resolveFrom from 'resolve-from';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const validateSteps = (conf) => {
   return conf.every((conf) => {
@@ -24,7 +27,7 @@ const validateSteps = (conf) => {
   });
 };
 
-function validatePlugin(conf) {
+export function validatePlugin(conf) {
   return (
     isString(conf) ||
     (isArray(conf) &&
@@ -35,7 +38,7 @@ function validatePlugin(conf) {
   );
 }
 
-function validateStep({required}, conf) {
+export function validateStep({required}, conf) {
   conf = castArray(conf).filter(Boolean);
   if (required) {
     return conf.length >= 1 && validateSteps(conf);
@@ -44,14 +47,17 @@ function validateStep({required}, conf) {
   return conf.length === 0 || validateSteps(conf);
 }
 
-function loadPlugin({cwd}, name, pluginsPath) {
+export async function loadPlugin({cwd}, name, pluginsPath) {
   const basePath = pluginsPath[name]
     ? dirname(resolveFrom.silent(__dirname, pluginsPath[name]) || resolveFrom(cwd, pluginsPath[name]))
     : __dirname;
-  return isFunction(name) ? name : require(resolveFrom.silent(basePath, name) || resolveFrom(cwd, name));
+
+  // See https://github.com/mysticatea/eslint-plugin-node/issues/250
+  // eslint-disable-next-line node/no-unsupported-features/es-syntax
+  return isFunction(name) ? name : (await import(resolveFrom.silent(basePath, name) || resolveFrom(cwd, name))).default;
 }
 
-function parseConfig(plugin) {
+export function parseConfig(plugin) {
   let path;
   let config;
   if (isArray(plugin)) {
@@ -64,5 +70,3 @@ function parseConfig(plugin) {
 
   return [path, config || {}];
 }
-
-module.exports = {validatePlugin, validateStep, loadPlugin, parseConfig};

package/lib/utils.js

@@ -1,12 +1,12 @@
-const {isFunction, union, template} = require('lodash');
-const semver = require('semver');
-const hideSensitive = require('./hide-sensitive');
+import {isFunction, template, union} from 'lodash-es';
+import semver from 'semver';
+import hideSensitive from './hide-sensitive.js';
 
-function extractErrors(err) {
-  return err && isFunction(err[Symbol.iterator]) ? [...err] : [err];
+export function extractErrors(err) {
+  return err && err.errors ? [...err.errors] : [err];
 }
 
-function hideSensitiveValues(env, objs) {
+export function hideSensitiveValues(env, objs) {
   const hideFunction = hideSensitive(env);
   return objs.map((object) => {
     Object.getOwnPropertyNames(object).forEach((prop) => {
@@ -18,19 +18,19 @@ function hideSensitiveValues(env, objs) {
   });
 }
 
-function tagsToVersions(tags) {
+export function tagsToVersions(tags) {
   return tags.map(({version}) => version);
 }
 
-function isMajorRange(range) {
+export function isMajorRange(range) {
   return /^\d+\.x(?:\.x)?$/i.test(range);
 }
 
-function isMaintenanceRange(range) {
+export function isMaintenanceRange(range) {
   return /^\d+\.(?:\d+|x)(?:\.x)?$/i.test(range);
 }
 
-function getUpperBound(range) {
+export function getUpperBound(range) {
   const result = semver.valid(range)
     ? range
     : ((semver.validRange(range) || '').match(/<(?<upperBound>\d+\.\d+\.\d+(-\d+)?)$/) || [])[1];
@@ -41,27 +41,27 @@ function getUpperBound(range) {
     : result;
 }
 
-function getLowerBound(range) {
+export function getLowerBound(range) {
   return ((semver.validRange(range) || '').match(/(?<lowerBound>\d+\.\d+\.\d+)/) || [])[1];
 }
 
-function highest(version1, version2) {
+export function highest(version1, version2) {
   return version1 && version2 ? (semver.gt(version1, version2) ? version1 : version2) : version1 || version2;
 }
 
-function lowest(version1, version2) {
+export function lowest(version1, version2) {
   return version1 && version2 ? (semver.lt(version1, version2) ? version1 : version2) : version1 || version2;
 }
 
-function getLatestVersion(versions, {withPrerelease} = {}) {
+export function getLatestVersion(versions, {withPrerelease} = {}) {
   return versions.filter((version) => withPrerelease || !semver.prerelease(version)).sort(semver.rcompare)[0];
 }
 
-function getEarliestVersion(versions, {withPrerelease} = {}) {
+export function getEarliestVersion(versions, {withPrerelease} = {}) {
   return versions.filter((version) => withPrerelease || !semver.prerelease(version)).sort(semver.compare)[0];
 }
 
-function getFirstVersion(versions, lowerBranches) {
+export function getFirstVersion(versions, lowerBranches) {
   const lowerVersion = union(...lowerBranches.map(({tags}) => tagsToVersions(tags))).sort(semver.rcompare);
   if (lowerVersion[0]) {
     return versions.sort(semver.compare).find((version) => semver.gt(version, lowerVersion[0]));
@@ -70,32 +70,14 @@ function getFirstVersion(versions, lowerBranches) {
   return getEarliestVersion(versions);
 }
 
-function getRange(min, max) {
+export function getRange(min, max) {
   return `>=${min}${max ? ` <${max}` : ''}`;
 }
 
-function makeTag(tagFormat, version) {
+export function makeTag(tagFormat, version) {
   return template(tagFormat)({version});
 }
 
-function isSameChannel(channel, otherChannel) {
+export function isSameChannel(channel, otherChannel) {
   return channel === otherChannel || (!channel && !otherChannel);
 }
-
-module.exports = {
-  extractErrors,
-  hideSensitiveValues,
-  tagsToVersions,
-  isMajorRange,
-  isMaintenanceRange,
-  getUpperBound,
-  getLowerBound,
-  highest,
-  lowest,
-  getLatestVersion,
-  getEarliestVersion,
-  getFirstVersion,
-  getRange,
-  makeTag,
-  isSameChannel,
-};

package/lib/verify.js

@@ -1,9 +1,9 @@
-const {template, isString, isPlainObject} = require('lodash');
-const AggregateError = require('aggregate-error');
-const {isGitRepo, verifyTagName} = require('./git');
-const getError = require('./get-error');
+import {isPlainObject, isString, template} from 'lodash-es';
+import AggregateError from 'aggregate-error';
+import {isGitRepo, verifyTagName} from './git.js';
+import getError from './get-error.js';
 
-module.exports = async (context) => {
+export default async (context) => {
   const {
     cwd,
     env,
@@ -40,4 +40,4 @@ module.exports = async (context) => {
   if (errors.length > 0) {
     throw new AggregateError(errors);
   }
-};
+}