@semantic-release/github 4.4.0 → 5.0.1

package/lib/definitions/rate-limit.js

@@ -0,0 +1,27 @@
+/**
+ * Default exponential backoff configuration for retries.
+ */
+const RETRY_CONF = {retries: 3, factor: 2, minTimeout: 1000};
+
+/**
+ * Rate limit per API endpoints.
+ *
+ * See {@link https://developer.github.com/v3/search/#rate-limit|Search API rate limit}.
+ * See {@link https://developer.github.com/v3/#rate-limiting|Rate limiting}.
+ */
+const RATE_LIMITS = {
+  search: ((60 * 1000) / 30) * 1.1, // 30 calls per minutes => 1 call every 2s + 10% safety margin
+  core: {
+    read: ((60 * 60 * 1000) / 5000) * 1.1, // 5000 calls per hour => 1 call per 720ms + 10% safety margin
+    write: 3000, // 1 call every 3 seconds
+  },
+};
+
+/**
+ * Global rate limit to prevent abuse.
+ *
+ * See {@link https://developer.github.com/v3/guides/best-practices-for-integrators/#dealing-with-abuse-rate-limits|Dealing with abuse rate limits}
+ */
+const GLOBAL_RATE_LIMIT = 1000;
+
+module.exports = {RETRY_CONF, RATE_LIMITS, GLOBAL_RATE_LIMIT};

package/lib/fail.js

@@ -7,9 +7,15 @@ const getClient = require('./get-client');
 const findSRIssues = require('./find-sr-issues');
 const getFailComment = require('./get-fail-comment');
 
-module.exports = async (pluginConfig, {options: {branch, repositoryUrl}, errors, logger}) => {
+module.exports = async (pluginConfig, context) => {
+  const {
+    options: {branch, repositoryUrl},
+    errors,
+    logger,
+  } = context;
   const {githubToken, githubUrl, githubApiPathPrefix, proxy, failComment, failTitle, labels, assignees} = resolveConfig(
-    pluginConfig
+    pluginConfig,
+    context
   );
   const {name: repo, owner} = parseGithubUrl(repositoryUrl);
   const github = getClient({githubToken, githubUrl, githubApiPathPrefix, proxy});

package/lib/get-client.js

@@ -1,5 +1,5 @@
 const url = require('url');
-const {memoize} = require('lodash');
+const {memoize, get} = require('lodash');
 const Octokit = require('@octokit/rest');
 const pRetry = require('p-retry');
 const Bottleneck = require('bottleneck');
@@ -7,28 +7,8 @@ const urljoin = require('url-join');
 const HttpProxyAgent = require('http-proxy-agent');
 const HttpsProxyAgent = require('https-proxy-agent');
 
-/**
- * Default exponential backoff configuration for retries.
- */
-const DEFAULT_RETRY = {retries: 3, factor: 2, minTimeout: 1000};
-
-/**
- * Rate limit per API endpoints.
- *
- * See {@link https://developer.github.com/v3/search/#rate-limit|Search API rate limit}.
- * See {@link https://developer.github.com/v3/#rate-limiting|Rate limiting}.
- */
-const RATE_LIMITS = {
-  search: (60 * 1000) / 30, // 30 calls per minutes => 1 call per 2s
-  core: (60 * 60 * 1000) / 5000, // 5000 calls per hour => 1 call per 720ms
-};
-
-/**
- * Global rate limit to prevent abuse.
- *
- * See {@link https://developer.github.com/v3/guides/best-practices-for-integrators/#dealing-with-abuse-rate-limits|Dealing with abuse rate limits}
- */
-const GLOBAL_RATE_LIMIT = 1000;
+const GH_ROUTES = require('@octokit/rest/lib/routes');
+const {RETRY_CONF, RATE_LIMITS, GLOBAL_RATE_LIMIT} = require('./definitions/rate-limit');
 
 /**
  * Http error codes for which to not retry.
@@ -41,35 +21,66 @@ const SKIP_RETRY_CODES = [400, 401, 403];
  * @param {Array} rate The rate limit group.
  * @param {String} limit The rate limits per API endpoints.
  * @param {Bottleneck} globalThrottler The global throttler.
+ *
  * @return {Bottleneck} The throller function for the given rate limit group.
  */
-const getThrottler = memoize((rate, limit, globalThrottler) =>
-  new Bottleneck({minTime: limit[rate]}).chain(globalThrottler)
+const getThrottler = memoize((rate, globalThrottler) =>
+  new Bottleneck({minTime: get(RATE_LIMITS, rate)}).chain(globalThrottler)
 );
 
+/**
+ * Determine if a call to a client function will trigger a read (`GET`) or a write (`POST`, `PATCH`, etc...) request.
+ *
+ * @param {String} endpoint The client API enpoint (for example the endpoint for a call to `github.repos.get` is `repos`).
+ * @param {String} command The client API command (for example the command for a call to `github.repos.get` is `get`).
+ *
+ * @return {String} `write` or `read` if there is rate limit configuration for this `endpoint` and `command`, `undefined` otherwise.
+ */
+const getAccess = (endpoint, command) => {
+  const method = GH_ROUTES[endpoint] && GH_ROUTES[endpoint][command] && GH_ROUTES[endpoint][command].method;
+  const access = method && method === 'GET' ? 'read' : 'write';
+  return RATE_LIMITS[endpoint][access] && access;
+};
+
+/**
+ * Get the limiter identifier associated with a client API call.
+ *
+ * @param {String} endpoint The client API enpoint (for example the endpoint for a call to `github.repos.get` is `repos`).
+ * @param {String} command The client API command (for example the command for a call to `github.repos.get` is `get`).
+ *
+ * @return {String} A string identifying the limiter to use for this `endpoint` and `command` (e.g. `search` or `core.write`).
+ */
+const getLimitKey = (endpoint, command) => {
+  return endpoint
+    ? [endpoint, RATE_LIMITS[endpoint] && getAccess(endpoint, command)].filter(Boolean).join('.')
+    : RATE_LIMITS[command]
+      ? command
+      : 'core';
+};
+
 /**
  * Create a`handler` for a `Proxy` wrapping an Octokit instance to:
  * - Recursively wrap the child objects of the Octokit instance in a `Proxy`
  * - Throttle and retry the Octokit instance functions
  *
- * @param {Object} retry The configuration to pass to `p-retry`.
- * @param {Array} limit The rate limits per API endpoints.
  * @param {Throttler} globalThrottler The throller function for the global rate limit.
- * @param {String} endpoint The API endpoint to handle.
+ * @param {String} limitKey The key to find the limit rate for the  API endpoint and method.
+ *
  * @return {Function} The `handler` for a `Proxy` wrapping an Octokit instance.
  */
-const handler = (retry, limit, globalThrottler, endpoint) => ({
+const handler = (globalThrottler, limitKey) => ({
   /**
    * If the target has the property as own, determine the rate limit based on the property name and recursively wrap the value in a `Proxy`. Otherwise returns the property value.
    *
    * @param {Object} target The target object.
    * @param {String} name The name of the property to get.
    * @param {Any} receiver The `Proxy` object.
+   *
    * @return {Any} The property value or a `Proxy` of the property value.
    */
   get: (target, name, receiver) =>
     Reflect.apply(Object.prototype.hasOwnProperty, target, [name])
-      ? new Proxy(target[name], handler(retry, limit, globalThrottler, endpoint || name))
+      ? new Proxy(target[name], handler(globalThrottler, getLimitKey(limitKey, name)))
       : Reflect.get(target, name, receiver),
 
   /**
@@ -78,11 +89,11 @@ const handler = (retry, limit, globalThrottler, endpoint) => ({
    * @param {Function} func The target function.
    * @param {Any} that The this argument for the call.
    * @param {Array} args The list of arguments for the call.
+   *
    * @return {Promise<Any>} The result of the function called.
    */
   apply: (func, that, args) => {
-    const throttler = getThrottler(limit[endpoint] ? endpoint : 'core', limit, globalThrottler);
-
+    const throttler = getThrottler(limitKey, globalThrottler);
     return pRetry(async () => {
       try {
         return await throttler.wrap(func)(...args);
@@ -92,19 +103,11 @@ const handler = (retry, limit, globalThrottler, endpoint) => ({
         }
         throw err;
       }
-    }, retry);
+    }, RETRY_CONF);
   },
 });
 
-module.exports = ({
-  githubToken,
-  githubUrl,
-  githubApiPathPrefix,
-  proxy,
-  retry = DEFAULT_RETRY,
-  limit = RATE_LIMITS,
-  globalLimit = GLOBAL_RATE_LIMIT,
-}) => {
+module.exports = ({githubToken, githubUrl, githubApiPathPrefix, proxy} = {}) => {
   const baseUrl = githubUrl && urljoin(githubUrl, githubApiPathPrefix);
   const github = new Octokit({
     baseUrl,
@@ -115,5 +118,5 @@ module.exports = ({
       : undefined,
   });
   github.authenticate({type: 'token', token: githubToken});
-  return new Proxy(github, handler(retry, limit, new Bottleneck({minTime: globalLimit})));
+  return new Proxy(github, handler(new Bottleneck({minTime: GLOBAL_RATE_LIMIT})));
 };

package/lib/glob-assets.js

@@ -1,25 +1,44 @@
+const path = require('path');
 const {basename} = require('path');
-const {isPlainObject, castArray, uniqWith} = require('lodash');
+const {isPlainObject, castArray, uniqWith, uniq} = require('lodash');
+const dirGlob = require('dir-glob');
 const globby = require('globby');
 const debug = require('debug')('semantic-release:github');
 
-module.exports = async assets =>
+const filesTransform = (files, cwd, transform) =>
+  files.map(file => `${file.startsWith('!') ? '!' : ''}${transform(cwd, file.startsWith('!') ? file.slice(1) : file)}`);
+
+module.exports = async ({cwd}, assets) =>
   uniqWith(
     []
       .concat(
         ...(await Promise.all(
           assets.map(async asset => {
             // Wrap single glob definition in Array
-            const glob = castArray(isPlainObject(asset) ? asset.path : asset);
+            let glob = castArray(isPlainObject(asset) ? asset.path : asset);
+            // TODO Temporary workaround for https://github.com/kevva/dir-glob/issues/7 and https://github.com/mrmlnc/fast-glob/issues/47
+            glob = uniq([
+              ...filesTransform(await dirGlob(filesTransform(glob, cwd, path.resolve)), cwd, path.relative),
+              ...glob,
+            ]);
+
             // 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 ',
+                'skipping the negated glob %o as its alone in its group and would retrieve a large amount of files',
                 glob[0]
               );
               return [];
             }
-            const globbed = await globby(glob, {expandDirectories: true, gitignore: false, dot: true});
+
+            const globbed = await globby(glob, {
+              cwd,
+              expandDirectories: true,
+              gitignore: false,
+              dot: true,
+              onlyFiles: false,
+            });
+
             if (isPlainObject(asset)) {
               if (globbed.length > 1) {
                 // If asset is an Object with a glob the `path` property that resolve to multiple files,
@@ -27,17 +46,19 @@ module.exports = async assets =>
                 // - `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 => Object.assign({}, asset, {path: file, name: basename(file)}));
+                return globbed.map(file => ({...asset, path: file, name: basename(file)}));
               }
               // 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 Object.assign({}, asset, {path: globbed[0] || asset.path});
+              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;
           })

package/lib/publish.js

@@ -1,4 +1,4 @@
-const {basename, extname} = require('path');
+const {basename, extname, resolve} = require('path');
 const {stat, readFile} = require('fs-extra');
 const {isPlainObject} = require('lodash');
 const parseGithubUrl = require('parse-github-url');
@@ -8,8 +8,14 @@ const globAssets = require('./glob-assets.js');
 const resolveConfig = require('./resolve-config');
 const getClient = require('./get-client');
 
-module.exports = async (pluginConfig, {options: {branch, repositoryUrl}, nextRelease: {gitTag, notes}, logger}) => {
-  const {githubToken, githubUrl, githubApiPathPrefix, proxy, assets} = resolveConfig(pluginConfig);
+module.exports = async (pluginConfig, context) => {
+  const {
+    cwd,
+    options: {branch, repositoryUrl},
+    nextRelease: {gitTag, notes},
+    logger,
+  } = context;
+  const {githubToken, githubUrl, githubApiPathPrefix, proxy, assets} = resolveConfig(pluginConfig, context);
   const {name: repo, owner} = parseGithubUrl(repositoryUrl);
   const github = getClient({githubToken, githubUrl, githubApiPathPrefix, proxy});
   const release = {owner, repo, tag_name: gitTag, name: gitTag, target_commitish: branch, body: notes}; // eslint-disable-line camelcase
@@ -25,7 +31,7 @@ module.exports = async (pluginConfig, {options: {branch, repositoryUrl}, nextRel
   logger.log('Published GitHub release: %s', url);
 
   if (assets && assets.length > 0) {
-    const globbedAssets = await globAssets(assets);
+    const globbedAssets = await globAssets(context, assets);
     debug('globed assets: %o', globbedAssets);
 
     await Promise.all(
@@ -34,7 +40,7 @@ module.exports = async (pluginConfig, {options: {branch, repositoryUrl}, nextRel
         let file;
 
         try {
-          file = await stat(filePath);
+          file = await stat(resolve(cwd, filePath));
         } catch (err) {
           logger.error('The asset %s cannot be read, and will be ignored.', filePath);
           return;
@@ -47,7 +53,7 @@ module.exports = async (pluginConfig, {options: {branch, repositoryUrl}, nextRel
         const fileName = asset.name || basename(filePath);
         const upload = {
           url: uploadUrl,
-          file: await readFile(filePath),
+          file: await readFile(resolve(cwd, filePath)),
           contentType: mime.getType(extname(fileName)) || 'text/plain',
           contentLength: file.size,
           name: fileName,

package/lib/resolve-config.js

@@ -1,20 +1,13 @@
 const {isUndefined, castArray} = require('lodash');
 
-module.exports = ({
-  githubUrl,
-  githubApiPathPrefix,
-  proxy,
-  assets,
-  successComment,
-  failTitle,
-  failComment,
-  labels,
-  assignees,
-}) => ({
-  githubToken: process.env.GH_TOKEN || process.env.GITHUB_TOKEN,
-  githubUrl: githubUrl || process.env.GH_URL || process.env.GITHUB_URL,
-  githubApiPathPrefix: githubApiPathPrefix || process.env.GH_PREFIX || process.env.GITHUB_PREFIX || '',
-  proxy: proxy || process.env.HTTP_PROXY,
+module.exports = (
+  {githubUrl, githubApiPathPrefix, proxy, assets, successComment, failTitle, failComment, labels, assignees},
+  {env}
+) => ({
+  githubToken: env.GH_TOKEN || env.GITHUB_TOKEN,
+  githubUrl: githubUrl || env.GH_URL || env.GITHUB_URL,
+  githubApiPathPrefix: githubApiPathPrefix || env.GH_PREFIX || env.GITHUB_PREFIX || '',
+  proxy: proxy || env.HTTP_PROXY,
   assets: assets ? castArray(assets) : assets,
   successComment,
   failTitle: isUndefined(failTitle) || failTitle === false ? 'The automated release is failing 🚨' : failTitle,

package/lib/success.js

@@ -10,11 +10,19 @@ const getSearchQueries = require('./get-search-queries');
 const getSuccessComment = require('./get-success-comment');
 const findSRIssues = require('./find-sr-issues');
 
-module.exports = async (
-  pluginConfig,
-  {options: {branch, repositoryUrl}, lastRelease, commits, nextRelease, releases, logger}
-) => {
-  const {githubToken, githubUrl, githubApiPathPrefix, proxy, successComment, failTitle} = resolveConfig(pluginConfig);
+module.exports = async (pluginConfig, context) => {
+  const {
+    options: {branch, repositoryUrl},
+    lastRelease,
+    commits,
+    nextRelease,
+    releases,
+    logger,
+  } = context;
+  const {githubToken, githubUrl, githubApiPathPrefix, proxy, successComment, failTitle} = resolveConfig(
+    pluginConfig,
+    context
+  );
   const {name: repo, owner} = parseGithubUrl(repositoryUrl);
   const github = getClient({githubToken, githubUrl, githubApiPathPrefix, proxy});
   const parser = issueParser('github', githubUrl ? {hosts: [githubUrl]} : {});

package/lib/verify.js

@@ -23,8 +23,12 @@ const VALIDATORS = {
   assignees: isArrayOf(isStringOrStringArray),
 };
 
-module.exports = async (pluginConfig, {options: {repositoryUrl}, logger}) => {
-  const {githubToken, githubUrl, githubApiPathPrefix, proxy, ...options} = resolveConfig(pluginConfig);
+module.exports = async (pluginConfig, context) => {
+  const {
+    options: {repositoryUrl},
+    logger,
+  } = context;
+  const {githubToken, githubUrl, githubApiPathPrefix, proxy, ...options} = resolveConfig(pluginConfig, context);
 
   const errors = Object.entries({...options, proxy}).reduce(
     (errors, [option, value]) =>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@semantic-release/github",
   "description": "Set of semantic-release plugins for publishing a GitHub release",
-  "version": "4.4.0",
+  "version": "5.0.1",
   "author": "Pierre Vanduynslager (https://twitter.com/@pvdlg_)",
   "bugs": {
     "url": "https://github.com/semantic-release/github/issues"
@@ -21,7 +21,8 @@
     "aggregate-error": "^1.0.0",
     "bottleneck": "^2.0.1",
     "debug": "^3.1.0",
-    "fs-extra": "^6.0.0",
+    "dir-glob": "^2.0.0",
+    "fs-extra": "^7.0.0",
     "globby": "^8.0.0",
     "http-proxy-agent": "^2.1.0",
     "https-proxy-agent": "^2.2.1",
@@ -35,7 +36,7 @@
   },
   "devDependencies": {
     "ava": "^0.25.0",
-    "clear-module": "^2.1.0",
+    "clear-module": "^3.0.0",
     "codecov": "^3.0.0",
     "commitizen": "^2.9.6",
     "cz-conventional-changelog": "^2.0.0",
@@ -82,6 +83,9 @@
     ],
     "all": true
   },
+  "peerDependencies": {
+    "semantic-release": ">=15.8.0 <16.0.0"
+  },
   "prettier": {
     "printWidth": 120,
     "trailingComma": "es5"