@semantic-release/github 8.0.9 → 9.0.0-beta.1

package/lib/success.js

@@ -1,20 +1,23 @@
-const {isNil, uniqBy, template, flatten, isEmpty} = require('lodash');
-const pFilter = require('p-filter');
-const AggregateError = require('aggregate-error');
-const issueParser = require('issue-parser');
-const debug = require('debug')('semantic-release:github');
-const parseGithubUrl = require('./parse-github-url');
-const resolveConfig = require('./resolve-config');
-const getClient = require('./get-client');
-const getSearchQueries = require('./get-search-queries');
-const getSuccessComment = require('./get-success-comment');
-const findSRIssues = require('./find-sr-issues');
-const {RELEASE_NAME} = require('./definitions/constants');
-const getReleaseLinks = require('./get-release-links');
-
-module.exports = async (pluginConfig, context) => {
+import { isNil, uniqBy, template, flatten, isEmpty } from "lodash-es";
+import pFilter from "p-filter";
+import AggregateError from "aggregate-error";
+import issueParser from "issue-parser";
+import debugFactory from "debug";
+
+import parseGithubUrl from "./parse-github-url.js";
+import resolveConfig from "./resolve-config.js";
+import { toOctokitOptions, SemanticReleaseOctokit } from "./octokit.js";
+import getSearchQueries from "./get-search-queries.js";
+import getSuccessComment from "./get-success-comment.js";
+import findSRIssues from "./find-sr-issues.js";
+import { RELEASE_NAME } from "./definitions/constants.js";
+import getReleaseLinks from "./get-release-links.js";
+
+const debug = debugFactory("semantic-release:github");
+
+export default async function success(pluginConfig, context, { Octokit }) {
   const {
-    options: {repositoryUrl},
+    options: { repositoryUrl },
     commits,
     nextRelease,
     releases,
@@ -32,95 +35,144 @@ module.exports = async (pluginConfig, context) => {
     addReleases,
   } = resolveConfig(pluginConfig, context);
 
-  const octokit = getClient({githubToken, githubUrl, githubApiPathPrefix, proxy});
+  const octokit = new Octokit(
+    toOctokitOptions({ githubToken, githubUrl, githubApiPathPrefix, proxy })
+  );
+
   // In case the repo changed name, get the new `repo`/`owner` as the search API will not follow redirects
-  const {data: repoData} = await octokit.request('GET /repos/{owner}/{repo}', parseGithubUrl(repositoryUrl));
-  const [owner, repo] = repoData.full_name.split('/');
+  const { data: repoData } = await octokit.request(
+    "GET /repos/{owner}/{repo}",
+    parseGithubUrl(repositoryUrl)
+  );
+  const [owner, repo] = repoData.full_name.split("/");
 
   const errors = [];
 
   if (successComment === false) {
-    logger.log('Skip commenting on issues and pull requests.');
+    logger.log("Skip commenting on issues and pull requests.");
   } else {
-    const parser = issueParser('github', githubUrl ? {hosts: [githubUrl]} : {});
+    const parser = issueParser(
+      "github",
+      githubUrl ? { hosts: [githubUrl] } : {}
+    );
     const releaseInfos = releases.filter((release) => Boolean(release.name));
-    const shas = commits.map(({hash}) => hash);
-
-    const searchQueries = getSearchQueries(`repo:${owner}/${repo}+type:pr+is:merged`, shas).map(
-      async (q) => (await octokit.request('GET /search/issues', {q})).data.items
+    const shas = commits.map(({ hash }) => hash);
+
+    const searchQueries = getSearchQueries(
+      `repo:${owner}/${repo}+type:pr+is:merged`,
+      shas
+    ).map(
+      async (q) =>
+        (await octokit.request("GET /search/issues", { q })).data.items
     );
 
     const searchQueriesResults = await Promise.all(searchQueries);
-    const uniqueSearchQueriesResults = uniqBy(flatten(searchQueriesResults), 'number');
-    const prs = await pFilter(uniqueSearchQueriesResults, async ({number}) => {
-      const commits = await octokit.paginate('GET /repos/{owner}/{repo}/pulls/{pull_number}/commits', {
-        owner,
-        repo,
-        pull_number: number,
-      });
-      const matchingCommit = commits.find(({sha}) => shas.includes(sha));
-      if (matchingCommit) return matchingCommit;
-
-      const {data: pullRequest} = await octokit.request('GET /repos/{owner}/{repo}/pulls/{pull_number}', {
-        owner,
-        repo,
-        pull_number: number,
-      });
-      return shas.includes(pullRequest.merge_commit_sha);
-    });
+    const uniqueSearchQueriesResults = uniqBy(
+      flatten(searchQueriesResults),
+      "number"
+    );
+    const prs = await pFilter(
+      uniqueSearchQueriesResults,
+      async ({ number }) => {
+        const commits = await octokit.paginate(
+          "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits",
+          {
+            owner,
+            repo,
+            pull_number: number,
+          }
+        );
+        const matchingCommit = commits.find(({ sha }) => shas.includes(sha));
+        if (matchingCommit) return matchingCommit;
+
+        const { data: pullRequest } = await octokit.request(
+          "GET /repos/{owner}/{repo}/pulls/{pull_number}",
+          {
+            owner,
+            repo,
+            pull_number: number,
+          }
+        );
+        return shas.includes(pullRequest.merge_commit_sha);
+      }
+    );
 
     debug(
-      'found pull requests: %O',
+      "found pull requests: %O",
       prs.map((pr) => pr.number)
     );
 
     // Parse the release commits message and PRs body to find resolved issues/PRs via comment keyworkds
-    const issues = [...prs.map((pr) => pr.body), ...commits.map((commit) => commit.message)].reduce(
-      (issues, message) => {
-        return message
+    const issues = [
+      ...prs.map((pr) => pr.body),
+      ...commits.map((commit) => commit.message),
+    ].reduce(
+      (issues, message) =>
+        message
           ? issues.concat(
               parser(message)
-                .actions.close.filter((action) => isNil(action.slug) || action.slug === `${owner}/${repo}`)
-                .map((action) => ({number: Number.parseInt(action.issue, 10)}))
+                .actions.close.filter(
+                  (action) =>
+                    isNil(action.slug) || action.slug === `${owner}/${repo}`
+                )
+                .map((action) => ({
+                  number: Number.parseInt(action.issue, 10),
+                }))
             )
-          : issues;
-      },
+          : issues,
       []
     );
 
-    debug('found issues via comments: %O', issues);
+    debug("found issues via comments: %O", issues);
 
     await Promise.all(
-      uniqBy([...prs, ...issues], 'number').map(async (issue) => {
+      uniqBy([...prs, ...issues], "number").map(async (issue) => {
         const body = successComment
-          ? template(successComment)({...context, issue})
+          ? template(successComment)({ ...context, issue })
           : getSuccessComment(issue, releaseInfos, nextRelease);
         try {
-          const comment = {owner, repo, issue_number: issue.number, body};
-          debug('create comment: %O', comment);
+          const comment = { owner, repo, issue_number: issue.number, body };
+          debug("create comment: %O", comment);
           const {
-            data: {html_url: url},
-          } = await octokit.request('POST /repos/{owner}/{repo}/issues/{issue_number}/comments', comment);
-          logger.log('Added comment to issue #%d: %s', issue.number, url);
+            data: { html_url: url },
+          } = await octokit.request(
+            "POST /repos/{owner}/{repo}/issues/{issue_number}/comments",
+            comment
+          );
+          logger.log("Added comment to issue #%d: %s", issue.number, url);
 
           if (releasedLabels) {
-            const labels = releasedLabels.map((label) => template(label)(context));
-            await octokit.request('POST /repos/{owner}/{repo}/issues/{issue_number}/labels', {
-              owner,
-              repo,
-              issue_number: issue.number,
-              data: labels,
-            });
-            logger.log('Added labels %O to issue #%d', labels, issue.number);
+            const labels = releasedLabels.map((label) =>
+              template(label)(context)
+            );
+            await octokit.request(
+              "POST /repos/{owner}/{repo}/issues/{issue_number}/labels",
+              {
+                owner,
+                repo,
+                issue_number: issue.number,
+                data: labels,
+              }
+            );
+            logger.log("Added labels %O to issue #%d", labels, issue.number);
           }
         } catch (error) {
           if (error.status === 403) {
-            logger.error('Not allowed to add a comment to the issue #%d.', issue.number);
+            logger.error(
+              "Not allowed to add a comment to the issue #%d.",
+              issue.number
+            );
           } else if (error.status === 404) {
-            logger.error("Failed to add a comment to the issue #%d as it doesn't exist.", issue.number);
+            logger.error(
+              "Failed to add a comment to the issue #%d as it doesn't exist.",
+              issue.number
+            );
           } else {
             errors.push(error);
-            logger.error('Failed to add a comment to the issue #%d.', issue.number);
+            logger.error(
+              "Failed to add a comment to the issue #%d.",
+              issue.number
+            );
             // Don't throw right away and continue to update other issues
           }
         }
@@ -129,25 +181,33 @@ module.exports = async (pluginConfig, context) => {
   }
 
   if (failComment === false || failTitle === false) {
-    logger.log('Skip closing issue.');
+    logger.log("Skip closing issue.");
   } else {
     const srIssues = await findSRIssues(octokit, failTitle, owner, repo);
 
-    debug('found semantic-release issues: %O', srIssues);
+    debug("found semantic-release issues: %O", srIssues);
 
     await Promise.all(
       srIssues.map(async (issue) => {
-        debug('close issue: %O', issue);
+        debug("close issue: %O", issue);
         try {
-          const updateIssue = {owner, repo, issue_number: issue.number, state: 'closed'};
-          debug('closing issue: %O', updateIssue);
+          const updateIssue = {
+            owner,
+            repo,
+            issue_number: issue.number,
+            state: "closed",
+          };
+          debug("closing issue: %O", updateIssue);
           const {
-            data: {html_url: url},
-          } = await octokit.request('PATCH /repos/{owner}/{repo}/issues/{issue_number}', updateIssue);
-          logger.log('Closed issue #%d: %s.', issue.number, url);
+            data: { html_url: url },
+          } = await octokit.request(
+            "PATCH /repos/{owner}/{repo}/issues/{issue_number}",
+            updateIssue
+          );
+          logger.log("Closed issue #%d: %s.", issue.number, url);
         } catch (error) {
           errors.push(error);
-          logger.error('Failed to close the issue #%d.', issue.number);
+          logger.error("Failed to close the issue #%d.", issue.number);
           // Don't throw right away and continue to close other issues
         }
       })
@@ -155,21 +215,26 @@ module.exports = async (pluginConfig, context) => {
   }
 
   if (addReleases !== false && errors.length === 0) {
-    const ghRelease = releases.find((release) => release.name && release.name === RELEASE_NAME);
+    const ghRelease = releases.find(
+      (release) => release.name && release.name === RELEASE_NAME
+    );
     if (!isNil(ghRelease)) {
       const ghRelaseId = ghRelease.id;
       const additionalReleases = getReleaseLinks(releases);
       if (!isEmpty(additionalReleases) && !isNil(ghRelaseId)) {
         const newBody =
-          addReleases === 'top'
-            ? additionalReleases.concat('\n---\n', nextRelease.notes)
-            : nextRelease.notes.concat('\n---\n', additionalReleases);
-        await octokit.request('PATCH /repos/{owner}/{repo}/releases/{release_id}', {
-          owner,
-          repo,
-          release_id: ghRelaseId,
-          body: newBody,
-        });
+          addReleases === "top"
+            ? additionalReleases.concat("\n---\n", nextRelease.notes)
+            : nextRelease.notes.concat("\n---\n", additionalReleases);
+        await octokit.request(
+          "PATCH /repos/{owner}/{repo}/releases/{release_id}",
+          {
+            owner,
+            repo,
+            release_id: ghRelaseId,
+            body: newBody,
+          }
+        );
       }
     }
   }
@@ -177,4 +242,4 @@ module.exports = async (pluginConfig, context) => {
   if (errors.length > 0) {
     throw new AggregateError(errors);
   }
-};
+}

package/lib/verify.js

@@ -1,24 +1,41 @@
-const {isString, isPlainObject, isNil, isArray, isNumber} = require('lodash');
-const urlJoin = require('url-join');
-const AggregateError = require('aggregate-error');
-const parseGithubUrl = require('./parse-github-url');
-const resolveConfig = require('./resolve-config');
-const getClient = require('./get-client');
-const getError = require('./get-error');
+import {
+  isString,
+  isPlainObject,
+  isNil,
+  isArray,
+  isNumber,
+  isBoolean,
+} from "lodash-es";
+import urlJoin from "url-join";
+import AggregateError from "aggregate-error";
+
+import parseGithubUrl from "./parse-github-url.js";
+import resolveConfig from "./resolve-config.js";
+import { toOctokitOptions, SemanticReleaseOctokit } from "./octokit.js";
+import getError from "./get-error.js";
 
 const isNonEmptyString = (value) => isString(value) && value.trim();
-const oneOf = (enumArray) => (value) => enumArray.some((element) => element === value);
+const oneOf = (enumArray) => (value) => enumArray.includes(value);
 const isStringOrStringArray = (value) =>
-  isNonEmptyString(value) || (isArray(value) && value.every((string) => isNonEmptyString(string)));
-const isArrayOf = (validator) => (array) => isArray(array) && array.every((value) => validator(value));
-const canBeDisabled = (validator) => (value) => value === false || validator(value);
+  isNonEmptyString(value) ||
+  (isArray(value) && value.every((string) => isNonEmptyString(string)));
+const isArrayOf = (validator) => (array) =>
+  isArray(array) && array.every((value) => validator(value));
+const canBeDisabled = (validator) => (value) =>
+  value === false || validator(value);
 
 const VALIDATORS = {
   proxy: canBeDisabled(
-    (proxy) => isNonEmptyString(proxy) || (isPlainObject(proxy) && isNonEmptyString(proxy.host) && isNumber(proxy.port))
+    (proxy) =>
+      isNonEmptyString(proxy) ||
+      (isPlainObject(proxy) &&
+        isNonEmptyString(proxy.host) &&
+        isNumber(proxy.port))
   ),
   assets: isArrayOf(
-    (asset) => isStringOrStringArray(asset) || (isPlainObject(asset) && isStringOrStringArray(asset.path))
+    (asset) =>
+      isStringOrStringArray(asset) ||
+      (isPlainObject(asset) && isStringOrStringArray(asset.path))
   ),
   successComment: canBeDisabled(isNonEmptyString),
   failTitle: canBeDisabled(isNonEmptyString),
@@ -26,36 +43,49 @@ const VALIDATORS = {
   labels: canBeDisabled(isArrayOf(isNonEmptyString)),
   assignees: isArrayOf(isNonEmptyString),
   releasedLabels: canBeDisabled(isArrayOf(isNonEmptyString)),
-  addReleases: canBeDisabled(oneOf(['bottom', 'top'])),
+  addReleases: canBeDisabled(oneOf(["bottom", "top"])),
+  draftRelease: isBoolean,
 };
 
-module.exports = async (pluginConfig, context) => {
+export default async function verify(pluginConfig, context, { Octokit }) {
   const {
     env,
-    options: {repositoryUrl},
+    options: { repositoryUrl },
     logger,
   } = context;
-  const {githubToken, githubUrl, githubApiPathPrefix, proxy, ...options} = resolveConfig(pluginConfig, context);
+  const { githubToken, githubUrl, githubApiPathPrefix, proxy, ...options } =
+    resolveConfig(pluginConfig, context);
 
-  const errors = Object.entries({...options, proxy}).reduce(
+  const errors = Object.entries({ ...options, proxy }).reduce(
     (errors, [option, value]) =>
       !isNil(value) && !VALIDATORS[option](value)
-        ? [...errors, getError(`EINVALID${option.toUpperCase()}`, {[option]: value})]
+        ? [
+            ...errors,
+            getError(`EINVALID${option.toUpperCase()}`, { [option]: value }),
+          ]
         : errors,
     []
   );
 
   if (githubUrl) {
-    logger.log('Verify GitHub authentication (%s)', urlJoin(githubUrl, githubApiPathPrefix));
+    logger.log(
+      "Verify GitHub authentication (%s)",
+      urlJoin(githubUrl, githubApiPathPrefix)
+    );
   } else {
-    logger.log('Verify GitHub authentication');
+    logger.log("Verify GitHub authentication");
   }
 
-  const {repo, owner} = parseGithubUrl(repositoryUrl);
+  const { repo, owner } = parseGithubUrl(repositoryUrl);
   if (!owner || !repo) {
-    errors.push(getError('EINVALIDGITHUBURL'));
-  } else if (githubToken && !errors.find(({code}) => code === 'EINVALIDPROXY')) {
-    const octokit = getClient({githubToken, githubUrl, githubApiPathPrefix, proxy});
+    errors.push(getError("EINVALIDGITHUBURL"));
+  } else if (
+    githubToken &&
+    !errors.find(({ code }) => code === "EINVALIDPROXY")
+  ) {
+    const octokit = new Octokit(
+      toOctokitOptions({ githubToken, githubUrl, githubApiPathPrefix, proxy })
+    );
 
     // https://github.com/semantic-release/github/issues/182
     // Do not check for permissions in GitHub actions, as the provided token is an installation access token.
@@ -68,25 +98,29 @@ module.exports = async (pluginConfig, context) => {
     try {
       const {
         data: {
-          permissions: {push},
+          permissions: { push },
         },
-      } = await octokit.request('GET /repos/{owner}/{repo}', {repo, owner});
+      } = await octokit.request("GET /repos/{owner}/{repo}", { repo, owner });
       if (!push) {
         // If authenticated as GitHub App installation, `push` will always be false.
         // We send another request to check if current authentication is an installation.
         // Note: we cannot check if the installation has all required permissions, it's
         // up to the user to make sure it has
-        if (await octokit.request('HEAD /installation/repositories', {per_page: 1}).catch(() => false)) {
+        if (
+          await octokit
+            .request("HEAD /installation/repositories", { per_page: 1 })
+            .catch(() => false)
+        ) {
           return;
         }
 
-        errors.push(getError('EGHNOPERMISSION', {owner, repo}));
+        errors.push(getError("EGHNOPERMISSION", { owner, repo }));
       }
     } catch (error) {
       if (error.status === 401) {
-        errors.push(getError('EINVALIDGHTOKEN', {owner, repo}));
+        errors.push(getError("EINVALIDGHTOKEN", { owner, repo }));
       } else if (error.status === 404) {
-        errors.push(getError('EMISSINGREPO', {owner, repo}));
+        errors.push(getError("EMISSINGREPO", { owner, repo }));
       } else {
         throw error;
       }
@@ -94,10 +128,10 @@ module.exports = async (pluginConfig, context) => {
   }
 
   if (!githubToken) {
-    errors.push(getError('ENOGHTOKEN', {owner, repo}));
+    errors.push(getError("ENOGHTOKEN", { owner, repo }));
   }
 
   if (errors.length > 0) {
     throw new AggregateError(errors);
   }
-};
+}

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@semantic-release/github",
   "description": "semantic-release plugin to publish a GitHub release and comment on released Pull Requests/Issues",
-  "version": "8.0.9",
+  "version": "9.0.0-beta.1",
+  "type": "module",
   "author": "Pierre Vanduynslager (https://twitter.com/@pvdlg_)",
   "ava": {
     "files": [
       "test/**/*.test.js"
+    ],
+    "nodeArguments": [
+      "--no-warnings"
     ]
   },
   "bugs": {
@@ -19,37 +23,32 @@
     "@octokit/core": "^4.2.1",
     "@octokit/plugin-paginate-rest": "^6.1.2",
     "@octokit/plugin-retry": "^4.1.3",
-    "@octokit/plugin-throttling": "^5.2.3",
+    "@octokit/plugin-throttling": "^6.0.0",
     "@semantic-release/error": "^3.0.0",
-    "aggregate-error": "^3.0.0",
-    "debug": "^4.0.0",
-    "dir-glob": "^3.0.0",
-    "fs-extra": "^11.0.0",
-    "globby": "^11.0.0",
+    "aggregate-error": "^4.0.1",
+    "debug": "^4.3.4",
+    "dir-glob": "^3.0.1",
+    "globby": "^13.1.4",
     "http-proxy-agent": "^7.0.0",
     "https-proxy-agent": "^7.0.0",
     "issue-parser": "^6.0.0",
-    "lodash": "^4.17.4",
+    "lodash-es": "^4.17.21",
     "mime": "^3.0.0",
-    "p-filter": "^2.0.0",
-    "url-join": "^4.0.0"
+    "p-filter": "^3.0.0",
+    "url-join": "^5.0.0"
   },
   "devDependencies": {
-    "ava": "5.1.0",
-    "clear-module": "4.1.2",
-    "codecov": "3.8.3",
-    "nock": "13.3.1",
-    "nyc": "15.1.0",
-    "proxy": "1.0.2",
-    "proxyquire": "2.1.3",
+    "ava": "5.3.0",
+    "c8": "7.14.0",
+    "cpy": "10.1.0",
+    "fetch-mock": "npm:@gr2m/fetch-mock@9.11.0-pull-request-644.1",
+    "prettier": "2.8.8",
     "semantic-release": "21.0.2",
-    "server-destroy": "1.0.1",
     "sinon": "15.1.0",
-    "tempy": "1.0.1",
-    "xo": "0.36.1"
+    "tempy": "3.0.0"
   },
   "engines": {
-    "node": ">=14.17"
+    "node": ">=18"
   },
   "files": [
     "lib",
@@ -68,8 +67,8 @@
     "version"
   ],
   "license": "MIT",
-  "main": "index.js",
-  "nyc": {
+  "exports": "./index.js",
+  "c8": {
     "include": [
       "lib/**/*.js",
       "index.js"
@@ -82,11 +81,7 @@
     "all": true
   },
   "peerDependencies": {
-    "semantic-release": ">=18.0.0-beta.1"
-  },
-  "prettier": {
-    "printWidth": 120,
-    "trailingComma": "es5"
+    "semantic-release": ">=20.1.0"
   },
   "publishConfig": {
     "access": "public",
@@ -98,25 +93,10 @@
   },
   "scripts": {
     "codecov": "codecov -f coverage/coverage-final.json",
-    "lint": "xo",
-    "pretest": "npm run lint",
+    "lint": "prettier --check \"{lib,test}/**/*.{js,json,ts}\" \"*.{js,md,json}\" \".github/**/*.yml\"",
+    "lint:fix": "prettier --write \"{lib,test}/**/*.{js,json,ts}\" \"*.{js,md,json}\" \".github/**/*.yml\"",
     "semantic-release": "semantic-release",
-    "test": "nyc ava -v",
-    "test:ci": "nyc ava -v"
-  },
-  "xo": {
-    "prettier": true,
-    "space": true,
-    "rules": {
-      "camelcase": [
-        "error",
-        {
-          "properties": "never"
-        }
-      ],
-      "unicorn/string-content": "off",
-      "unicorn/no-reduce": "off"
-    }
+    "test": "c8 ava -v"
   },
   "renovate": {
     "extends": [

package/lib/get-client.js

@@ -1,24 +0,0 @@
-const urljoin = require('url-join');
-const {HttpProxyAgent} = require('http-proxy-agent');
-const {HttpsProxyAgent} = require('https-proxy-agent');
-
-const SemanticReleaseOctokit = require('./semantic-release-octokit');
-
-module.exports = ({githubToken, githubUrl, githubApiPathPrefix, proxy}) => {
-  const baseUrl = githubUrl && urljoin(githubUrl, githubApiPathPrefix);
-  const octokit = new SemanticReleaseOctokit({
-    auth: `token ${githubToken}`,
-    baseUrl,
-    request: {
-      agent: proxy
-        ? baseUrl && new URL(baseUrl).protocol.replace(':', '') === 'http'
-          ? // Some `proxy.headers` need to be passed as second arguments since version 6 or 7
-            // For simplicity, we just pass the same proxy object twice. It works 🤷🏻
-            new HttpProxyAgent(proxy, proxy)
-          : new HttpsProxyAgent(proxy, proxy)
-        : undefined,
-    },
-  });
-
-  return octokit;
-};