@semantic-release/github 8.1.0 → 9.0.0-beta.2

package/lib/glob-assets.js

@@ -1,65 +1,76 @@
-const path = require('path');
-const {isPlainObject, castArray, uniqWith, uniq} = require('lodash');
-const dirGlob = require('dir-glob');
-const globby = require('globby');
-const debug = require('debug')('semantic-release:github');
+import { basename, resolve } from "node:path";
 
-module.exports = async ({cwd}, assets) =>
-  uniqWith(
-    []
-      .concat(
-        ...(await Promise.all(
-          assets.map(async (asset) => {
-            // Wrap single glob definition in Array
-            let glob = castArray(isPlainObject(asset) ? asset.path : asset);
-            // TODO Temporary workaround for https://github.com/mrmlnc/fast-glob/issues/47
-            glob = uniq([...(await dirGlob(glob, {cwd})), ...glob]);
+import { isPlainObject, castArray, uniqWith, uniq } from "lodash-es";
+import dirGlob from "dir-glob";
+import { globby } from "globby";
+import debugFactory from "debug";
 
-            // Skip solo negated pattern (avoid to include every non js file with `!**/*.js`)
-            if (glob.length <= 1 && glob[0].startsWith('!')) {
-              debug(
-                'skipping the negated glob %o as its alone in its group and would retrieve a large amount of files',
-                glob[0]
-              );
-              return [];
-            }
+const debug = debugFactory("semantic-release:github");
+
+export default async function globAssets({ cwd }, assets) {
+  return uniqWith(
+    (
+      await Promise.all(
+        assets.map(async (asset) => {
+          // Wrap single glob definition in Array
+          let glob = castArray(isPlainObject(asset) ? asset.path : asset);
+
+          // TODO Temporary workaround for https://github.com/mrmlnc/fast-glob/issues/47
+          glob = uniq([...(await dirGlob(glob, { cwd })), ...glob]);
 
-            const globbed = await globby(glob, {
-              cwd,
-              expandDirectories: false, // TODO Temporary workaround for https://github.com/mrmlnc/fast-glob/issues/47
-              gitignore: false,
-              dot: true,
-              onlyFiles: false,
-            });
+          // Skip solo negated pattern (avoid to include every non js file with `!**/*.js`)
+          if (glob.length <= 1 && glob[0].startsWith("!")) {
+            debug(
+              "skipping the negated glob %o as its alone in its group and would retrieve a large amount of files",
+              glob[0]
+            );
+            return [];
+          }
 
-            if (isPlainObject(asset)) {
-              if (globbed.length > 1) {
-                // If asset is an Object with a glob the `path` property that resolve to multiple files,
-                // Output an Object definition for each file matched and set each one with:
-                // - `path` of the matched file
-                // - `name` based on the actual file name (to avoid assets with duplicate `name`)
-                // - other properties of the original asset definition
-                return globbed.map((file) => ({...asset, path: file, name: path.basename(file)}));
-              }
+          const globbed = await globby(glob, {
+            cwd,
+            expandDirectories: false, // TODO Temporary workaround for https://github.com/mrmlnc/fast-glob/issues/47
+            gitignore: false,
+            dot: true,
+            onlyFiles: false,
+          });
 
-              // If asset is an Object, output an Object definition with:
-              // - `path` of the matched file if there is one, or the original `path` definition (will be considered as a missing file)
+          if (isPlainObject(asset)) {
+            if (globbed.length > 1) {
+              // If asset is an Object with a glob the `path` property that resolve to multiple files,
+              // Output an Object definition for each file matched and set each one with:
+              // - `path` of the matched file
+              // - `name` based on the actual file name (to avoid assets with duplicate `name`)
               // - other properties of the original asset definition
-              return {...asset, path: globbed[0] || asset.path};
+              return globbed.map((file) => ({
+                ...asset,
+                path: file,
+                name: basename(file),
+              }));
             }
 
-            if (globbed.length > 0) {
-              // If asset is a String definition, output each files matched
-              return globbed;
-            }
+            // If asset is an Object, output an Object definition with:
+            // - `path` of the matched file if there is one, or the original `path` definition (will be considered as a missing file)
+            // - other properties of the original asset definition
+            return { ...asset, path: globbed[0] || asset.path };
+          }
+
+          if (globbed.length > 0) {
+            // If asset is a String definition, output each files matched
+            return globbed;
+          }
 
-            // If asset is a String definition but no match is found, output the elements of the original glob (each one will be considered as a missing file)
-            return glob;
-          })
-          // Sort with Object first, to prioritize Object definition over Strings in dedup
-        ))
+          // If asset is a String definition but no match is found, output the elements of the original glob (each one will be considered as a missing file)
+          return glob;
+        })
+        // Sort with Object first, to prioritize Object definition over Strings in dedup
       )
+    )
+      .flat()
       .sort((asset) => (isPlainObject(asset) ? -1 : 1)),
     // Compare `path` property if Object definition, value itself if String
-    (a, b) => path.resolve(cwd, isPlainObject(a) ? a.path : a) === path.resolve(cwd, isPlainObject(b) ? b.path : b)
+    (a, b) =>
+      resolve(cwd, isPlainObject(a) ? a.path : a) ===
+      resolve(cwd, isPlainObject(b) ? b.path : b)
   );
+}

package/lib/is-prerelease.js

@@ -1 +1,3 @@
-module.exports = ({type, main}) => type === 'prerelease' || (type === 'release' && !main);
+export default function isPrerelease({ type, main }) {
+  return type === "prerelease" || (type === "release" && !main);
+}

package/lib/octokit.js

@@ -0,0 +1,76 @@
+/* c8 ignore start */
+// @ts-check
+
+import { createRequire } from "node:module";
+
+// If maintaining @octokit/core and the separate plugins gets to cumbersome
+// then the `octokit` package can be used which has all these plugins included.
+// However the `octokit` package has a lot of other things we don't care about.
+// We use only the bits we need to minimize the size of the package.
+import { Octokit } from "@octokit/core";
+import { paginateRest } from "@octokit/plugin-paginate-rest";
+import { retry } from "@octokit/plugin-retry";
+import { throttling } from "@octokit/plugin-throttling";
+import urljoin from "url-join";
+import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+
+import { RETRY_CONF } from "./definitions/retry.js";
+import { THROTTLE_CONF } from "./definitions/throttle.js";
+
+// NOTE: replace with import ... assert { type: 'json' } once supported
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+
+const onRetry = (retryAfter, options, octokit, retryCount) => {
+  octokit.log.warn(
+    `Request quota exhausted for request ${options.method} ${options.url}`
+  );
+
+  if (retryCount <= RETRY_CONF.retries) {
+    octokit.log.debug(`Will retry after ${retryAfter}.`);
+    return true;
+  }
+};
+
+export const SemanticReleaseOctokit = Octokit.plugin(
+  paginateRest,
+  retry,
+  throttling
+).defaults({
+  userAgent: `@semantic-release/github v${pkg.version}`,
+  retry: RETRY_CONF,
+  throttle: {
+    ...THROTTLE_CONF,
+    onRateLimit: onRetry,
+    onSecondaryRateLimit: onRetry,
+  },
+});
+/* c8 ignore stop */
+
+/**
+ * @param {{githubToken: string, proxy: any} | {githubUrl: string, githubApiPathPrefix: string, githubToken: string, proxy: any}} options
+ * @returns {{ auth: string, baseUrl?: string, request: { agent?: any } }}
+ */
+export function toOctokitOptions(options) {
+  const baseUrl =
+    "githubUrl" in options && options.githubUrl
+      ? urljoin(options.githubUrl, options.githubApiPathPrefix)
+      : undefined;
+
+  const agent = options.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(options.proxy, options.proxy)
+      : new HttpsProxyAgent(options.proxy, options.proxy)
+    : undefined;
+
+  return {
+    ...(baseUrl ? { baseUrl } : {}),
+    auth: options.githubToken,
+    request: {
+      agent,
+    },
+  };
+}

package/lib/parse-github-url.js

@@ -1,11 +1,19 @@
-module.exports = (repositoryUrl) => {
-  const [match, auth, host, path] = /^(?!.+:\/\/)(?:(?<auth>.*)@)?(?<host>.*?):(?<path>.*)$/.exec(repositoryUrl) || [];
+export default function parseGitHubUrl(repositoryUrl) {
+  const [match, auth, host, path] =
+    /^(?!.+:\/\/)(?:(?<auth>.*)@)?(?<host>.*?):(?<path>.*)$/.exec(
+      repositoryUrl
+    ) || [];
   try {
-    const [, owner, repo] = /^\/(?<owner>[^/]+)?\/?(?<repo>.+?)(?:\.git)?$/.exec(
-      new URL(match ? `ssh://${auth ? `${auth}@` : ''}${host}/${path}` : repositoryUrl).pathname
-    );
-    return {owner, repo};
+    const [, owner, repo] =
+      /^\/(?<owner>[^/]+)?\/?(?<repo>.+?)(?:\.git)?$/.exec(
+        new URL(
+          match
+            ? `ssh://${auth ? `${auth}@` : ""}${host}/${path}`
+            : repositoryUrl
+        ).pathname
+      );
+    return { owner, repo };
   } catch {
     return {};
   }
-};
+}

package/lib/publish.js

@@ -1,29 +1,44 @@
-const path = require('path');
-const {stat, readFile} = require('fs-extra');
-const {isPlainObject, template} = require('lodash');
-const mime = require('mime');
-const debug = require('debug')('semantic-release:github');
-const {RELEASE_NAME} = require('./definitions/constants');
-const parseGithubUrl = require('./parse-github-url');
-const globAssets = require('./glob-assets');
-const resolveConfig = require('./resolve-config');
-const getClient = require('./get-client');
-const isPrerelease = require('./is-prerelease');
-
-module.exports = async (pluginConfig, context) => {
+import { resolve, basename, extname } from "node:path";
+import { stat, readFile } from "node:fs/promises";
+
+import { isPlainObject, template } from "lodash-es";
+import mime from "mime";
+import debugFactory from "debug";
+
+import { RELEASE_NAME } from "./definitions/constants.js";
+import parseGithubUrl from "./parse-github-url.js";
+import globAssets from "./glob-assets.js";
+import resolveConfig from "./resolve-config.js";
+import { toOctokitOptions } from "./octokit.js";
+import isPrerelease from "./is-prerelease.js";
+
+const debug = debugFactory("semantic-release:github");
+
+export default async function publish(pluginConfig, context, { Octokit }) {
   const {
     cwd,
-    options: {repositoryUrl},
+    options: { repositoryUrl },
     branch,
-    nextRelease: {name, gitTag, notes},
+    nextRelease: { name, gitTag, notes },
     logger,
   } = context;
-  const {githubToken, githubUrl, githubApiPathPrefix, proxy, assets, draftRelease} = resolveConfig(
-    pluginConfig,
-    context
+  const {
+    githubToken,
+    githubUrl,
+    githubApiPathPrefix,
+    proxy,
+    assets,
+    draftRelease,
+  } = resolveConfig(pluginConfig, context);
+  const { owner, repo } = parseGithubUrl(repositoryUrl);
+  const octokit = new Octokit(
+    toOctokitOptions({
+      githubToken,
+      githubUrl,
+      githubApiPathPrefix,
+      proxy,
+    })
   );
-  const {owner, repo} = parseGithubUrl(repositoryUrl);
-  const octokit = getClient({githubToken, githubUrl, githubApiPathPrefix, proxy});
   const release = {
     owner,
     repo,
@@ -34,39 +49,45 @@ module.exports = async (pluginConfig, context) => {
     prerelease: isPrerelease(branch),
   };
 
-  debug('release object: %O', release);
+  debug("release object: %O", release);
 
-  const draftReleaseOptions = {...release, draft: true};
+  const draftReleaseOptions = { ...release, draft: true };
 
   // When there are no assets, we publish a release directly.
   if (!assets || assets.length === 0) {
     // If draftRelease is true we create a draft release instead.
     if (draftRelease) {
       const {
-        data: {html_url: url, id: releaseId},
-      } = await octokit.request('POST /repos/{owner}/{repo}/releases', draftReleaseOptions);
-
-      logger.log('Created GitHub draft release: %s', url);
-      return {url, name: RELEASE_NAME, id: releaseId};
+        data: { html_url: url, id: releaseId },
+      } = await octokit.request(
+        "POST /repos/{owner}/{repo}/releases",
+        draftReleaseOptions
+      );
+
+      logger.log("Created GitHub draft release: %s", url);
+      return { url, name: RELEASE_NAME, id: releaseId };
     }
 
     const {
-      data: {html_url: url, id: releaseId},
-    } = await octokit.request('POST /repos/{owner}/{repo}/releases', release);
+      data: { html_url: url, id: releaseId },
+    } = await octokit.request("POST /repos/{owner}/{repo}/releases", release);
 
-    logger.log('Published GitHub release: %s', url);
-    return {url, name: RELEASE_NAME, id: releaseId};
+    logger.log("Published GitHub release: %s", url);
+    return { url, name: RELEASE_NAME, id: releaseId };
   }
 
   // We'll create a draft release, append the assets to it, and then publish it.
   // This is so that the assets are available when we get a Github release event.
   const {
-    data: {upload_url: uploadUrl, html_url: draftUrl, id: releaseId},
-  } = await octokit.request('POST /repos/{owner}/{repo}/releases', draftReleaseOptions);
+    data: { upload_url: uploadUrl, html_url: draftUrl, id: releaseId },
+  } = await octokit.request(
+    "POST /repos/{owner}/{repo}/releases",
+    draftReleaseOptions
+  );
 
   // Append assets to the release
   const globbedAssets = await globAssets(context, assets);
-  debug('globed assets: %o', globbedAssets);
+  debug("globed assets: %o", globbedAssets);
 
   await Promise.all(
     globbedAssets.map(async (asset) => {
@@ -74,58 +95,67 @@ module.exports = async (pluginConfig, context) => {
       let file;
 
       try {
-        file = await stat(path.resolve(cwd, filePath));
+        file = await stat(resolve(cwd, filePath));
       } catch {
-        logger.error('The asset %s cannot be read, and will be ignored.', filePath);
+        logger.error(
+          "The asset %s cannot be read, and will be ignored.",
+          filePath
+        );
         return;
       }
 
       if (!file || !file.isFile()) {
-        logger.error('The asset %s is not a file, and will be ignored.', filePath);
+        logger.error(
+          "The asset %s is not a file, and will be ignored.",
+          filePath
+        );
         return;
       }
 
-      const fileName = template(asset.name || path.basename(filePath))(context);
+      const fileName = template(asset.name || basename(filePath))(context);
       const upload = {
-        method: 'POST',
+        method: "POST",
         url: uploadUrl,
-        data: await readFile(path.resolve(cwd, filePath)),
+        data: await readFile(resolve(cwd, filePath)),
         name: fileName,
         headers: {
-          'content-type': mime.getType(path.extname(fileName)) || 'text/plain',
-          'content-length': file.size,
+          "content-type": mime.getType(extname(fileName)) || "text/plain",
+          "content-length": file.size,
         },
       };
 
-      debug('file path: %o', filePath);
-      debug('file name: %o', fileName);
+      debug("file path: %o", filePath);
+      debug("file name: %o", fileName);
 
       if (isPlainObject(asset) && asset.label) {
         upload.label = template(asset.label)(context);
       }
 
       const {
-        data: {browser_download_url: downloadUrl},
+        data: { browser_download_url: downloadUrl },
       } = await octokit.request(upload);
-      logger.log('Published file %s', downloadUrl);
+      logger.log("Published file %s", downloadUrl);
     })
   );
 
   // If we want to create a draft we don't need to update the release again
   if (draftRelease) {
-    logger.log('Created GitHub draft release: %s', draftUrl);
-    return {url: draftUrl, name: RELEASE_NAME, id: releaseId};
+    logger.log("Created GitHub draft release: %s", draftUrl);
+    return { url: draftUrl, name: RELEASE_NAME, id: releaseId };
   }
 
   const {
-    data: {html_url: url},
-  } = await octokit.request('PATCH /repos/{owner}/{repo}/releases/{release_id}', {
-    owner,
-    repo,
-    release_id: releaseId,
-    draft: false,
-  });
+    data: { html_url: url },
+  } = await octokit.request(
+    "PATCH /repos/{owner}/{repo}/releases/{release_id}",
+    {
+      owner,
+      repo,
+      release_id: releaseId,
+      draft: false,
+    }
+  );
 
-  logger.log('Published GitHub release: %s', url);
-  return {url, name: RELEASE_NAME, id: releaseId};
-};
+  logger.log("Published GitHub release: %s", url);
+  return { url, name: RELEASE_NAME, id: releaseId };
+}

package/lib/resolve-config.js

@@ -1,6 +1,6 @@
-const {isNil, castArray} = require('lodash');
+import { isNil, castArray } from "lodash-es";
 
-module.exports = (
+export default function resolveConfig(
   {
     githubUrl,
     githubApiPathPrefix,
@@ -15,23 +15,34 @@ module.exports = (
     addReleases,
     draftRelease,
   },
-  {env}
-) => ({
-  githubToken: env.GH_TOKEN || env.GITHUB_TOKEN,
-  githubUrl: githubUrl || env.GITHUB_API_URL || env.GH_URL || env.GITHUB_URL,
-  githubApiPathPrefix: githubApiPathPrefix || env.GH_PREFIX || env.GITHUB_PREFIX || '',
-  proxy: isNil(proxy) ? env.http_proxy || env.HTTP_PROXY || false : proxy,
-  assets: assets ? castArray(assets) : assets,
-  successComment,
-  failTitle: isNil(failTitle) ? 'The automated release is failing 🚨' : failTitle,
-  failComment,
-  labels: isNil(labels) ? ['semantic-release'] : labels === false ? false : castArray(labels),
-  assignees: assignees ? castArray(assignees) : assignees,
-  releasedLabels: isNil(releasedLabels)
-    ? [`released<%= nextRelease.channel ? \` on @\${nextRelease.channel}\` : "" %>`]
-    : releasedLabels === false
-    ? false
-    : castArray(releasedLabels),
-  addReleases: isNil(addReleases) ? false : addReleases,
-  draftRelease: isNil(draftRelease) ? false : draftRelease,
-});
+  { env }
+) {
+  return {
+    githubToken: env.GH_TOKEN || env.GITHUB_TOKEN,
+    githubUrl: githubUrl || env.GITHUB_API_URL || env.GH_URL || env.GITHUB_URL,
+    githubApiPathPrefix:
+      githubApiPathPrefix || env.GH_PREFIX || env.GITHUB_PREFIX || "",
+    proxy: isNil(proxy) ? env.http_proxy || env.HTTP_PROXY || false : proxy,
+    assets: assets ? castArray(assets) : assets,
+    successComment,
+    failTitle: isNil(failTitle)
+      ? "The automated release is failing 🚨"
+      : failTitle,
+    failComment,
+    labels: isNil(labels)
+      ? ["semantic-release"]
+      : labels === false
+      ? false
+      : castArray(labels),
+    assignees: assignees ? castArray(assignees) : assignees,
+    releasedLabels: isNil(releasedLabels)
+      ? [
+          `released<%= nextRelease.channel ? \` on @\${nextRelease.channel}\` : "" %>`,
+        ]
+      : releasedLabels === false
+      ? false
+      : castArray(releasedLabels),
+    addReleases: isNil(addReleases) ? false : addReleases,
+    draftRelease: isNil(draftRelease) ? false : draftRelease,
+  };
+}