@taskcluster/client 100.4.0 → 101.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taskcluster/client",
-  "version": "100.4.0",
+  "version": "101.0.0",
   "author": "Jonas Finnemann Jensen <jopsen@gmail.com>",
   "description": "Client for interfacing taskcluster components",
   "license": "MPL-2.0",
@@ -23,7 +23,7 @@
     "nock": "^14.0.13"
   },
   "engines": {
-    "node": "24.16.0"
+    "node": "^24"
   },
   "type": "module",
   "files": [

package/src/apis.js

@@ -1,4 +1,3 @@
-/* eslint-disable */
 export default {
   "Auth": {
     "reference": {

package/src/client.js

@@ -7,19 +7,19 @@ import got, { TimeoutError } from 'got';
 import debugFactory from 'debug';
 const debug = debugFactory('@taskcluster/client');
 import _ from 'lodash';
-import assert from 'assert';
+import assert from 'node:assert';
 import hawk from 'hawk';
-import url from 'url';
-import crypto from 'crypto';
+import url from 'node:url';
+import crypto from 'node:crypto';
 import slugid from 'slugid';
-import http from 'http';
-import https from 'https';
-import querystring from 'querystring';
+import http from 'node:http';
+import https from 'node:https';
+import querystring from 'node:querystring';
 import tcUrl from 'taskcluster-lib-urls';
 import retry from './retry.js';
 
 /** Default options for our http/https global agents */
-let AGENT_OPTIONS = {
+const AGENT_OPTIONS = {
   maxSockets: 50,
   maxFreeSockets: 0,
   keepAlive: false,
@@ -30,7 +30,7 @@ let AGENT_OPTIONS = {
  * defaulting to the global node agents primarily so we can tweak this across
  * all our components if needed...
  */
-let DEFAULT_AGENTS = {
+const DEFAULT_AGENTS = {
   http: new http.Agent(AGENT_OPTIONS),
   https: new https.Agent(AGENT_OPTIONS),
 };
@@ -93,12 +93,12 @@ let _defaultOptions = {
 };
 
 /** Make a request for a Client instance */
-export const makeRequest = async function(client, method, url, payload, query) {
+export const makeRequest = async (client, method, url, payload, query) => {
   // Add query to url if present
   if (query) {
     query = querystring.stringify(query);
     if (query.length > 0) {
-      url += '?' + query;
+      url += `?${query}`;
     }
   }
 
@@ -115,13 +115,15 @@ export const makeRequest = async function(client, method, url, payload, query) {
       limit: 0,
     },
     hooks: {
-      afterResponse: [res => {
-        // parse the body, if one was given (Got's `responseType: json` fails to check content-type)
-        if (res.body && (res.headers['content-type'] || '').startsWith('application/json')) {
-          res.body = JSON.parse(res.body);
-        }
-        return res;
-      }],
+      afterResponse: [
+        res => {
+          // parse the body, if one was given (Got's `responseType: json` fails to check content-type)
+          if (res.body && (res.headers['content-type'] || '').startsWith('application/json')) {
+            res.body = JSON.parse(res.body);
+          }
+          return res;
+        },
+      ],
     },
   };
 
@@ -130,11 +132,9 @@ export const makeRequest = async function(client, method, url, payload, query) {
   }
 
   // Authenticate, if credentials are provided
-  if (client._options.credentials &&
-      client._options.credentials.clientId &&
-      client._options.credentials.accessToken) {
+  if (client._options.credentials?.clientId && client._options.credentials.accessToken) {
     // Create hawk authentication header
-    let header = hawk.client.header(url, method.toUpperCase(), {
+    const header = hawk.client.header(url, method.toUpperCase(), {
       credentials: {
         id: client._options.credentials.clientId,
         key: client._options.credentials.accessToken,
@@ -142,7 +142,7 @@ export const makeRequest = async function(client, method, url, payload, query) {
       },
       ext: client._extData,
     });
-    options.headers['Authorization'] = header.header;
+    options.headers.Authorization = header.header;
   }
 
   // Send payload if defined
@@ -190,17 +190,17 @@ export const makeRequest = async function(client, method, url, payload, query) {
  *
  * `rootUrl` and `baseUrl` are mutually exclusive.
  */
-export const createClient = function(reference, name) {
+export const createClient = (reference, name) => {
   if (!name || typeof name !== 'string') {
     name = 'Unknown';
   }
 
   // Client class constructor
-  let Client = function(options) {
-    if (options && options.baseUrl) {
+  const Client = function (options) {
+    if (options?.baseUrl) {
       throw new Error('baseUrl has been deprecated!');
     }
-    if (options && options.exchangePrefix) {
+    if (options?.exchangePrefix) {
       throw new Error('exchangePrefix has been deprecated!');
     }
     let serviceName = reference.serviceName;
@@ -216,11 +216,16 @@ export const createClient = function(reference, name) {
         serviceName = reference.exchangePrefix.split('/')[1].replace('taskcluster-', '');
       }
     }
-    this._options = _.defaults({}, options || {}, {
-      exchangePrefix: reference.exchangePrefix,
-      serviceName,
-      serviceVersion: 'v1',
-    }, _defaultOptions);
+    this._options = _.defaults(
+      {},
+      options || {},
+      {
+        exchangePrefix: reference.exchangePrefix,
+        serviceName,
+        serviceVersion: 'v1',
+      },
+      _defaultOptions
+    );
     assert(this._options.rootUrl, 'Must provide a rootUrl'); // We always assert this even with service discovery
     this._options.rootUrl = this._options.rootUrl.replace(/\/$/, '');
     this._options._trueRootUrl = this._options.rootUrl.replace(/\/$/, ''); // Useful for buildUrl/buildSignedUrl in certain cases
@@ -238,8 +243,7 @@ export const createClient = function(reference, name) {
       throw new Error('monitoring client calls is no longer supported');
     }
 
-    if (this._options.randomizationFactor < 0 ||
-        this._options.randomizationFactor >= 1) {
+    if (this._options.randomizationFactor < 0 || this._options.randomizationFactor >= 1) {
       throw new Error('options.randomizationFactor must be between 0 and 1!');
     }
 
@@ -262,10 +266,8 @@ export const createClient = function(reference, name) {
 
     // Build ext for hawk requests
     this._extData = undefined;
-    if (this._options.credentials &&
-        this._options.credentials.clientId &&
-        this._options.credentials.accessToken) {
-      let ext = {};
+    if (this._options.credentials?.clientId && this._options.credentials.accessToken) {
+      const ext = {};
 
       // If there is a certificate we have temporary credentials, and we
       // must provide the certificate
@@ -276,8 +278,7 @@ export const createClient = function(reference, name) {
           try {
             ext.certificate = JSON.parse(ext.certificate);
           } catch (err) {
-            debug('Failed to parse credentials.certificate, err: %s, JSON: %j',
-              err, err);
+            debug('Failed to parse credentials.certificate, err: %s, JSON: %j', err, err);
             throw new Error('JSON.parse(): Failed for configured certificate');
           }
         }
@@ -285,7 +286,7 @@ export const createClient = function(reference, name) {
 
       // If set of authorized scopes is provided, we'll restrict the request
       // to only use these scopes
-      if (this._options.authorizedScopes instanceof Array) {
+      if (Array.isArray(this._options.authorizedScopes)) {
         ext.authorizedScopes = this._options.authorizedScopes;
       }
 
@@ -299,7 +300,11 @@ export const createClient = function(reference, name) {
     if (this._options.fake) {
       debug('Creating @taskcluster/client object in "fake" mode');
       this.fakeCalls = {};
-      reference.entries.filter(e => e.type === 'function').forEach(e => this.fakeCalls[e.name] = []);
+      reference.entries
+        .filter(e => e.type === 'function')
+        .forEach(e => {
+          this.fakeCalls[e.name] = [];
+        });
       // Throw an error if creating fakes in production
       if (process.env.NODE_ENV === 'production') {
         throw new Error('@taskcluster/client object created in "fake" mode, when NODE_ENV == "production"');
@@ -307,240 +312,241 @@ export const createClient = function(reference, name) {
     }
   };
 
-  Client.prototype.use = function(optionsUpdates) {
-    let options = _.defaults({}, optionsUpdates, { rootUrl: this._options._trueRootUrl }, this._options);
+  Client.prototype.use = function (optionsUpdates) {
+    const options = _.defaults({}, optionsUpdates, { rootUrl: this._options._trueRootUrl }, this._options);
     return new Client(options);
   };
 
-  Client.prototype.taskclusterPerRequestInstance = function({ requestId, traceId }) {
+  Client.prototype.taskclusterPerRequestInstance = function ({ traceId }) {
     return this.use({ traceId });
   };
 
   // For each function entry create a method on the Client class
-  reference.entries.filter(function(entry) {
-    return entry.type === 'function';
-  }).forEach(function(entry) {
-    // Get number of arguments
-    let nb_args = entry.args.length;
-    if (entry.input) {
-      nb_args += 1;
-    }
-    // Get the query-string options taken
-    let optKeys = entry.query || [];
-
-    // Create method on prototype
-    Client.prototype[entry.name] = function() {
-      // Convert arguments to actual array
-      let args = Array.prototype.slice.call(arguments);
-      // Validate number of arguments
-      let N = args.length;
-      if (N !== nb_args && (optKeys.length === 0 || N !== nb_args + 1)) {
-        throw new Error('Function ' + entry.name + ' takes ' + nb_args +
-                        ' arguments, but was given ' + N +
-                        ' arguments');
-      }
-      // Substitute parameters into route
-      let endpoint = entry.route.replace(/<([^<>]+)>/g, function(text, arg) {
-        let index = entry.args.indexOf(arg);
-        if (index !== -1) {
-          let param = args[index];
-          if (typeof param !== 'string' && typeof param !== 'number') {
-            throw new Error('URL parameter ' + arg + ' must be a string, but ' +
-                            'we received a: ' + typeof param);
-          }
-          return encodeURIComponent(param);
-        }
-        return text; // Preserve original
-      });
-      // Create url for the request
-      let url = tcUrl.api(this._options.rootUrl, this._options.serviceName, this._options.serviceVersion, endpoint);
-      // Add payload if one is given
-      let payload = undefined;
+  reference.entries
+    .filter(entry => entry.type === 'function')
+    .forEach(entry => {
+      // Get number of arguments
+      let nb_args = entry.args.length;
       if (entry.input) {
-        payload = args[nb_args - 1];
+        nb_args += 1;
       }
-      // Find query string options (if present)
-      let query = args[nb_args] || null;
-      if (query) {
-        _.keys(query).forEach(function(key) {
-          if (!_.includes(optKeys, key)) {
-            throw new Error('Function ' + entry.name + ' takes options: ' +
-                            optKeys.join(', ') + ' but was given ' + key);
+      // Get the query-string options taken
+      const optKeys = entry.query || [];
+
+      // Create method on prototype
+      Client.prototype[entry.name] = function (...args) {
+        // Validate number of arguments
+        const N = args.length;
+        if (N !== nb_args && (optKeys.length === 0 || N !== nb_args + 1)) {
+          throw new Error(`Function ${entry.name} takes ${nb_args} arguments, but was given ${N} arguments`);
+        }
+        // Substitute parameters into route
+        const endpoint = entry.route.replace(/<([^<>]+)>/g, (text, arg) => {
+          const index = entry.args.indexOf(arg);
+          if (index !== -1) {
+            const param = args[index];
+            if (typeof param !== 'string' && typeof param !== 'number') {
+              throw new Error(`URL parameter ${arg} must be a string, but we received a: ${typeof param}`);
+            }
+            return encodeURIComponent(param);
           }
+          return text; // Preserve original
         });
-      }
-
-      // call out to the fake version, if set
-      if (this._options.fake) {
-        debug('Faking call to %s(%s)', entry.name, args.map(a => JSON.stringify(a, null, 2)).join(', '));
-        // Add a call record to fakeCalls[<method>]
-        let record = {};
-        if (payload !== undefined) {
-          record.payload = _.cloneDeep(payload);
-        }
-        if (query !== null) {
-          record.query = _.cloneDeep(query);
+        // Create url for the request
+        const url = tcUrl.api(this._options.rootUrl, this._options.serviceName, this._options.serviceVersion, endpoint);
+        // Add payload if one is given
+        let payload;
+        if (entry.input) {
+          payload = args[nb_args - 1];
         }
-        entry.args.forEach((k, i) => record[k] = _.cloneDeep(args[i]));
-        this.fakeCalls[entry.name].push(record);
-        // Call fake[<method>]
-        if (!this._options.fake[entry.name]) {
-          return Promise.reject(new Error(
-            `Faked ${this._options.serviceName} object does not have an implementation of ${entry.name}`,
-          ));
+        // Find query string options (if present)
+        const query = args[nb_args] || null;
+        if (query) {
+          _.keys(query).forEach(key => {
+            if (!_.includes(optKeys, key)) {
+              throw new Error(`Function ${entry.name} takes options: ${optKeys.join(', ')} but was given ${key}`);
+            }
+          });
         }
-        return this._options.fake[entry.name].apply(this, args);
-      }
 
-      return retry(this._options, (retriableError, attempt) => {
-        debug('Calling: %s, retry: %s', entry.name, attempt);
-        // Make request and handle response or error
-        return makeRequest(
-          this,
-          entry.method,
-          url,
-          payload,
-          query,
-        ).then(function(res) {
-          // If request was successful, accept the result
-          debug('Success calling: %s, (%s retries)', entry.name, attempt);
-          if (!_.includes(res.headers['content-type'], 'application/json') || !res.body) {
-            debug('Empty response from server: call: %s, method: %s', entry.name, entry.method);
-            return undefined;
+        // call out to the fake version, if set
+        if (this._options.fake) {
+          debug('Faking call to %s(%s)', entry.name, args.map(a => JSON.stringify(a, null, 2)).join(', '));
+          // Add a call record to fakeCalls[<method>]
+          const record = {};
+          if (payload !== undefined) {
+            record.payload = _.cloneDeep(payload);
           }
-          return res.body;
-        }, function(err) {
-          // If we got a response we read the error code from the response
-          let res = err.response;
-          if (res) {
-            let message = 'Unknown Server Error';
-            if (res.statusCode === 401) {
-              message = 'Authentication Error';
-            }
-            if (res.statusCode === 500) {
-              message = 'Internal Server Error';
-            }
-            if (res.statusCode >= 300 && res.statusCode < 400) {
-              message = 'Unexpected Redirect';
-            }
-            err = new Error(res.body.message || message);
-            err.body = res.body;
-            err.code = res.body.code || 'UnknownError';
-            err.statusCode = res.statusCode;
-
-            // Decide if we should retry or just throw
-            if (res.statusCode >= 500 && // Check if it's a 5xx error
-                res.statusCode < 600) {
-              debug('Error calling: %s now retrying, info: %j',
-                entry.name, res.body);
-              return retriableError(err);
-            } else {
-              debug('Error calling: %s NOT retrying!, info: %j',
-                entry.name, res.body);
-              throw err;
-            }
+          if (query !== null) {
+            record.query = _.cloneDeep(query);
+          }
+          entry.args.forEach((k, i) => {
+            record[k] = _.cloneDeep(args[i]);
+          });
+          this.fakeCalls[entry.name].push(record);
+          // Call fake[<method>]
+          if (!this._options.fake[entry.name]) {
+            return Promise.reject(
+              new Error(`Faked ${this._options.serviceName} object does not have an implementation of ${entry.name}`)
+            );
           }
+          return this._options.fake[entry.name].apply(this, args);
+        }
 
-          // All errors without a response are treated as retriable
-          debug('Request error calling %s (retrying), err: %s, JSON: %s',
-            entry.name, err, err);
-          return retriableError(err);
+        return retry(this._options, (retriableError, attempt) => {
+          debug('Calling: %s, retry: %s', entry.name, attempt);
+          // Make request and handle response or error
+          return makeRequest(this, entry.method, url, payload, query).then(
+            res => {
+              // If request was successful, accept the result
+              debug('Success calling: %s, (%s retries)', entry.name, attempt);
+              if (!_.includes(res.headers['content-type'], 'application/json') || !res.body) {
+                debug('Empty response from server: call: %s, method: %s', entry.name, entry.method);
+                return undefined;
+              }
+              return res.body;
+            },
+            err => {
+              // If we got a response we read the error code from the response
+              const res = err.response;
+              if (res) {
+                let message = 'Unknown Server Error';
+                if (res.statusCode === 401) {
+                  message = 'Authentication Error';
+                }
+                if (res.statusCode === 500) {
+                  message = 'Internal Server Error';
+                }
+                if (res.statusCode >= 300 && res.statusCode < 400) {
+                  message = 'Unexpected Redirect';
+                }
+                err = new Error(res.body.message || message);
+                err.body = res.body;
+                err.code = res.body.code || 'UnknownError';
+                err.statusCode = res.statusCode;
+
+                // Decide if we should retry or just throw
+                if (
+                  res.statusCode >= 500 && // Check if it's a 5xx error
+                  res.statusCode < 600
+                ) {
+                  debug('Error calling: %s now retrying, info: %j', entry.name, res.body);
+                  return retriableError(err);
+                } else {
+                  debug('Error calling: %s NOT retrying!, info: %j', entry.name, res.body);
+                  throw err;
+                }
+              }
+
+              // All errors without a response are treated as retriable
+              debug('Request error calling %s (retrying), err: %s, JSON: %s', entry.name, err, err);
+              return retriableError(err);
+            }
+          );
         });
-      });
-    };
-    // Add reference for buildUrl and signUrl
-    Client.prototype[entry.name].entryReference = entry;
-  });
+      };
+      // Add reference for buildUrl and signUrl
+      Client.prototype[entry.name].entryReference = entry;
+    });
 
   // For each topic-exchange entry
-  reference.entries.filter(function(entry) {
-    return entry.type === 'topic-exchange';
-  }).forEach(function(entry) {
-    // Create function for routing-key pattern construction
-    Client.prototype[entry.name] = function(routingKeyPattern) {
-      if (typeof routingKeyPattern !== 'string') {
-        // Allow for empty routing key patterns
-        if (routingKeyPattern === undefined ||
-            routingKeyPattern === null) {
-          routingKeyPattern = {};
-        }
-
-        // Check that the routing key pattern is an object
-        assert(routingKeyPattern instanceof Object,
-          'routingKeyPattern must be an object');
-
-        // Construct routingkey pattern as string from reference
-        routingKeyPattern = entry.routingKey.map(function(key) {
-          // Get value for key
-          let value = routingKeyPattern[key.name];
-          // Routing key constant entries cannot be modified
-          if (key.constant) {
-            value = key.constant;
-          }
-          // If number convert to string
-          if (typeof value === 'number') {
-            return '' + value;
+  reference.entries
+    .filter(entry => entry.type === 'topic-exchange')
+    .forEach(entry => {
+      // Create function for routing-key pattern construction
+      Client.prototype[entry.name] = function (routingKeyPattern) {
+        if (typeof routingKeyPattern !== 'string') {
+          // Allow for empty routing key patterns
+          if (routingKeyPattern === undefined || routingKeyPattern === null) {
+            routingKeyPattern = {};
           }
-          // Validate string and return
-          if (typeof value === 'string') {
-            // Check for multiple words
-            assert(key.multipleWords || value.indexOf('.') === -1,
-              'routingKey pattern \'' + value + '\' for ' + key.name +
-                   ' cannot contain dots as it does not hold multiple words');
-            return value;
-          }
-          // Check that we haven't got an invalid value
-          assert(value === null || value === undefined,
-            'Value: \'' + value + '\' is not supported as routingKey ' +
-                'pattern for ' + key.name);
-          // Return default pattern for entry not being matched
-          return key.multipleWords ? '#' : '*';
-        }).join('.');
-      }
 
-      // Return values necessary to bind with EventHandler
-      return {
-        exchange: this._options.exchangePrefix + entry.exchange,
-        routingKeyPattern: routingKeyPattern,
-        routingKeyReference: _.cloneDeep(entry.routingKey),
+          // Check that the routing key pattern is an object
+          assert(routingKeyPattern instanceof Object, 'routingKeyPattern must be an object');
+
+          // Construct routingkey pattern as string from reference
+          routingKeyPattern = entry.routingKey
+            .map(key => {
+              // Get value for key
+              let value = routingKeyPattern[key.name];
+              // Routing key constant entries cannot be modified
+              if (key.constant) {
+                value = key.constant;
+              }
+              // If number convert to string
+              if (typeof value === 'number') {
+                return `${value}`;
+              }
+              // Validate string and return
+              if (typeof value === 'string') {
+                // Check for multiple words
+                assert(
+                  key.multipleWords || value.indexOf('.') === -1,
+                  "routingKey pattern '" +
+                    value +
+                    "' for " +
+                    key.name +
+                    ' cannot contain dots as it does not hold multiple words'
+                );
+                return value;
+              }
+              // Check that we haven't got an invalid value
+              assert(
+                value === null || value === undefined,
+                `Value: '${value}' is not supported as routingKey pattern for ${key.name}`
+              );
+              // Return default pattern for entry not being matched
+              return key.multipleWords ? '#' : '*';
+            })
+            .join('.');
+        }
+
+        // Return values necessary to bind with EventHandler
+        return {
+          exchange: this._options.exchangePrefix + entry.exchange,
+          routingKeyPattern: routingKeyPattern,
+          routingKeyReference: _.cloneDeep(entry.routingKey),
+        };
       };
-    };
-  });
+    });
 
-  Client.prototype._buildUrl = function(rootUrl, args) {
+  Client.prototype._buildUrl = function (rootUrl, args) {
     if (args.length === 0) {
-      throw new Error('buildUrl(method, arg1, arg2, ...) takes a least one ' +
-                        'argument!');
+      throw new Error('buildUrl(method, arg1, arg2, ...) takes a least one ' + 'argument!');
     }
     // Find the method
-    let method = args.shift();
-    let entry = method.entryReference;
-    if (!entry || entry.type !== 'function') {
-      throw new Error('method in buildUrl(method, arg1, arg2, ...) must be ' +
-                        'an API method from the same object!');
+    const method = args.shift();
+    const entry = method.entryReference;
+    if (entry?.type !== 'function') {
+      throw new Error('method in buildUrl(method, arg1, arg2, ...) must be ' + 'an API method from the same object!');
     }
 
     // Get the query-string options taken
-    let optKeys = entry.query || [];
-    let supportsOpts = optKeys.length !== 0;
+    const optKeys = entry.query || [];
+    const supportsOpts = optKeys.length !== 0;
 
-    debug('build url for: ' + entry.name);
+    debug(`build url for: ${entry.name}`);
     // Validate number of arguments
-    let N = entry.args.length;
+    const N = entry.args.length;
     if (args.length !== N && (!supportsOpts || args.length !== N + 1)) {
-      throw new Error('Function ' + entry.name + 'buildUrl() takes ' +
-                        (N + 1) + ' arguments, but was given ' +
-                        (args.length + 1) + ' arguments');
+      throw new Error(
+        'Function ' +
+          entry.name +
+          'buildUrl() takes ' +
+          (N + 1) +
+          ' arguments, but was given ' +
+          (args.length + 1) +
+          ' arguments'
+      );
     }
 
     // Substitute parameters into route
-    let endpoint = entry.route.replace(/<([^<>]+)>/g, function(text, arg) {
-      let index = entry.args.indexOf(arg);
+    const endpoint = entry.route.replace(/<([^<>]+)>/g, (text, arg) => {
+      const index = entry.args.indexOf(arg);
       if (index !== -1) {
-        let param = args[index];
+        const param = args[index];
         if (typeof param !== 'string' && typeof param !== 'number') {
-          throw new Error('URL parameter ' + arg + ' must be a string, but ' +
-                            'we received a: ' + typeof param);
+          throw new Error(`URL parameter ${arg} must be a string, but we received a: ${typeof param}`);
         }
         return encodeURIComponent(param);
       }
@@ -550,16 +556,15 @@ export const createClient = function(reference, name) {
     // Find query string options (if present)
     let query = args[N] || '';
     if (query) {
-      _.keys(query).forEach(function(key) {
+      _.keys(query).forEach(key => {
         if (!_.includes(optKeys, key)) {
-          throw new Error('Function ' + entry.name + ' takes options: ' +
-                            optKeys.join(', ') + ' but was given ' + key);
+          throw new Error(`Function ${entry.name} takes options: ${optKeys.join(', ')} but was given ${key}`);
         }
       });
 
       query = querystring.stringify(query);
       if (query.length > 0) {
-        query = '?' + query;
+        query = `?${query}`;
       }
     }
 
@@ -569,22 +574,21 @@ export const createClient = function(reference, name) {
   // Utility functions to build the request URL for given method and
   // input parameters. The first builds with whatever rootUrl currently
   // is while the latter builds with trueRootUrl for sending to users
-  Client.prototype.buildUrl = function() {
-    return this._buildUrl(this._options.rootUrl, Array.prototype.slice.call(arguments));
+  Client.prototype.buildUrl = function (...args) {
+    return this._buildUrl(this._options.rootUrl, args);
   };
-  Client.prototype.externalBuildUrl = function() {
-    return this._buildUrl(this._options._trueRootUrl, Array.prototype.slice.call(arguments));
+  Client.prototype.externalBuildUrl = function (...args) {
+    return this._buildUrl(this._options._trueRootUrl, args);
   };
 
-  Client.prototype._buildSignedUrl = function(builder, args) {
+  Client.prototype._buildSignedUrl = function (builder, args) {
     if (args.length === 0) {
-      throw new Error('buildSignedUrl(method, arg1, arg2, ..., [options]) ' +
-                        'takes a least one argument!');
+      throw new Error('buildSignedUrl(method, arg1, arg2, ..., [options]) ' + 'takes a least one argument!');
     }
 
     // Find method and reference entry
-    let method = args[0];
-    let entry = method.entryReference;
+    const method = args[0];
+    const entry = method.entryReference;
     if (entry.method !== 'get') {
       throw new Error('buildSignedUrl only works for GET requests');
     }
@@ -593,7 +597,7 @@ export const createClient = function(reference, name) {
     let expiration = 15 * 60;
 
     // Check if method supports query-string options
-    let supportsOpts = (entry.query || []).length !== 0;
+    const supportsOpts = (entry.query || []).length !== 0;
 
     // if longer than method + args, then we have options too
     let N = entry.args.length + 1;
@@ -602,7 +606,7 @@ export const createClient = function(reference, name) {
     }
     if (args.length > N) {
       // Get request options
-      let options = args.pop();
+      const options = args.pop();
 
       // Get expiration from options
       expiration = options.expiration || expiration;
@@ -614,7 +618,7 @@ export const createClient = function(reference, name) {
     }
 
     // Build URL
-    let requestUrl = builder.apply(this, args);
+    const requestUrl = builder.apply(this, args);
 
     // Check that we have credentials
     if (!this._options.credentials.clientId) {
@@ -625,7 +629,7 @@ export const createClient = function(reference, name) {
     }
 
     // Create bewit
-    let bewit = hawk.client.getBewit(requestUrl, {
+    const bewit = hawk.client.getBewit(requestUrl, {
       credentials: {
         id: this._options.credentials.clientId,
         key: this._options.credentials.accessToken,
@@ -636,11 +640,11 @@ export const createClient = function(reference, name) {
     });
 
     // Add bewit to requestUrl
-    let urlParts = url.parse(requestUrl);
+    const urlParts = url.parse(requestUrl);
     if (urlParts.search) {
-      urlParts.search += '&bewit=' + bewit;
+      urlParts.search += `&bewit=${bewit}`;
     } else {
-      urlParts.search = '?bewit=' + bewit;
+      urlParts.search = `?bewit=${bewit}`;
     }
 
     // Return formatted URL
@@ -649,11 +653,11 @@ export const createClient = function(reference, name) {
 
   // Utility function to construct a bewit URL for GET requests. Same convention
   // as unsigned buildUrl applies here too
-  Client.prototype.buildSignedUrl = function() {
-    return this._buildSignedUrl(this.buildUrl, Array.prototype.slice.call(arguments));
+  Client.prototype.buildSignedUrl = function (...args) {
+    return this._buildSignedUrl(this.buildUrl, args);
   };
-  Client.prototype.externalBuildSignedUrl = function() {
-    return this._buildSignedUrl(this.externalBuildUrl, Array.prototype.slice.call(arguments));
+  Client.prototype.externalBuildSignedUrl = function (...args) {
+    return this._buildSignedUrl(this.externalBuildUrl, args);
   };
 
   // Return client class
@@ -664,23 +668,23 @@ export const createClient = function(reference, name) {
 import apis from './apis.js';
 
 export const clients = {
-  Auth: createClient(apis.Auth.reference, "Auth"),
-  AuthEvents: createClient(apis.AuthEvents.reference, "AuthEvents"),
-  Github: createClient(apis.Github.reference, "Github"),
-  GithubEvents: createClient(apis.GithubEvents.reference, "GithubEvents"),
-  Hooks: createClient(apis.Hooks.reference, "Hooks"),
-  HooksEvents: createClient(apis.HooksEvents.reference, "HooksEvents"),
-  Index: createClient(apis.Index.reference, "Index"),
-  Notify: createClient(apis.Notify.reference, "Notify"),
-  NotifyEvents: createClient(apis.NotifyEvents.reference, "NotifyEvents"),
-  Object: createClient(apis.Object.reference, "Object"),
-  PurgeCache: createClient(apis.PurgeCache.reference, "PurgeCache"),
-  Queue: createClient(apis.Queue.reference, "Queue"),
-  QueueEvents: createClient(apis.QueueEvents.reference, "QueueEvents"),
-  Secrets: createClient(apis.Secrets.reference, "Secrets"),
-  WebServer: createClient(apis.WebServer.reference, "WebServer"),
-  WorkerManager: createClient(apis.WorkerManager.reference, "WorkerManager"),
-  WorkerManagerEvents: createClient(apis.WorkerManagerEvents.reference, "WorkerManagerEvents"),
+  Auth: createClient(apis.Auth.reference, 'Auth'),
+  AuthEvents: createClient(apis.AuthEvents.reference, 'AuthEvents'),
+  Github: createClient(apis.Github.reference, 'Github'),
+  GithubEvents: createClient(apis.GithubEvents.reference, 'GithubEvents'),
+  Hooks: createClient(apis.Hooks.reference, 'Hooks'),
+  HooksEvents: createClient(apis.HooksEvents.reference, 'HooksEvents'),
+  Index: createClient(apis.Index.reference, 'Index'),
+  Notify: createClient(apis.Notify.reference, 'Notify'),
+  NotifyEvents: createClient(apis.NotifyEvents.reference, 'NotifyEvents'),
+  Object: createClient(apis.Object.reference, 'Object'),
+  PurgeCache: createClient(apis.PurgeCache.reference, 'PurgeCache'),
+  Queue: createClient(apis.Queue.reference, 'Queue'),
+  QueueEvents: createClient(apis.QueueEvents.reference, 'QueueEvents'),
+  Secrets: createClient(apis.Secrets.reference, 'Secrets'),
+  WebServer: createClient(apis.WebServer.reference, 'WebServer'),
+  WorkerManager: createClient(apis.WorkerManager.reference, 'WorkerManager'),
+  WorkerManagerEvents: createClient(apis.WorkerManagerEvents.reference, 'WorkerManagerEvents'),
 };
 
 /**
@@ -688,13 +692,13 @@ export const clients = {
  *
  * Example: `Client.config({credentials: {...}});`
  */
-export const config = function(options) {
+export const config = options => {
   _defaultOptions = _.defaults({}, options, _defaultOptions);
 };
 
-export const fromEnvVars = function() {
-  let results = {};
-  for (let { env, path } of [
+export const fromEnvVars = () => {
+  const results = {};
+  for (const { env, path } of [
     { env: 'TASKCLUSTER_ROOT_URL', path: 'rootUrl' },
     { env: 'TASKCLUSTER_CLIENT_ID', path: 'credentials.clientId' },
     { env: 'TASKCLUSTER_ACCESS_TOKEN', path: 'credentials.accessToken' },
@@ -728,48 +732,52 @@ export const fromEnvVars = function() {
  *
  * Returns an object on the form: {clientId, accessToken, certificate}
  */
-export const createTemporaryCredentials = function(options) {
+export const createTemporaryCredentials = options => {
   assert(options, 'options are required');
 
-  let now = new Date();
+  const now = new Date();
 
   // Set default options
-  options = _.defaults({}, options, {
-    // Clock drift is handled in auth service (PR #117)
-    // so no clock skew required.
-    start: now,
-    scopes: [],
-  }, _defaultOptions);
+  options = _.defaults(
+    {},
+    options,
+    {
+      // Clock drift is handled in auth service (PR #117)
+      // so no clock skew required.
+      start: now,
+      scopes: [],
+    },
+    _defaultOptions
+  );
 
   // Validate options
   assert(options.credentials, 'options.credentials is required');
-  assert(options.credentials.clientId,
-    'options.credentials.clientId is required');
-  assert(options.credentials.accessToken,
-    'options.credentials.accessToken is required');
-  assert(options.credentials.certificate === undefined ||
-         options.credentials.certificate === null,
-  'temporary credentials cannot be used to make new temporary ' +
-         'credentials; ensure that options.credentials.certificate is null');
+  assert(options.credentials.clientId, 'options.credentials.clientId is required');
+  assert(options.credentials.accessToken, 'options.credentials.accessToken is required');
+  assert(
+    options.credentials.certificate === undefined || options.credentials.certificate === null,
+    'temporary credentials cannot be used to make new temporary ' +
+      'credentials; ensure that options.credentials.certificate is null'
+  );
   assert(options.start instanceof Date, 'options.start must be a Date');
   assert(options.expiry instanceof Date, 'options.expiry must be a Date');
-  assert(options.scopes instanceof Array, 'options.scopes must be an array');
-  options.scopes.forEach(function(scope) {
-    assert(typeof scope === 'string',
-      'options.scopes must be an array of strings');
+  assert(Array.isArray(options.scopes), 'options.scopes must be an array');
+  options.scopes.forEach(scope => {
+    assert(typeof scope === 'string', 'options.scopes must be an array of strings');
   });
-  assert(options.expiry.getTime() - options.start.getTime() <=
-         31 * 24 * 60 * 60 * 1000, 'Credentials cannot span more than 31 days');
+  assert(
+    options.expiry.getTime() - options.start.getTime() <= 31 * 24 * 60 * 60 * 1000,
+    'Credentials cannot span more than 31 days'
+  );
 
-  let isNamed = !!options.clientId;
+  const isNamed = !!options.clientId;
 
   if (isNamed) {
-    assert(options.clientId !== options.credentials.clientId,
-      'Credential issuer must be different from the name');
+    assert(options.clientId !== options.credentials.clientId, 'Credential issuer must be different from the name');
   }
 
   // Construct certificate
-  let cert = {
+  const cert = {
     version: 1,
     scopes: _.cloneDeep(options.scopes),
     start: options.start.getTime(),
@@ -782,21 +790,21 @@ export const createTemporaryCredentials = function(options) {
   }
 
   // Construct signature
-  let sig = crypto.createHmac('sha256', options.credentials.accessToken);
-  sig.update('version:' + cert.version + '\n');
+  const sig = crypto.createHmac('sha256', options.credentials.accessToken);
+  sig.update(`version:${cert.version}\n`);
   if (isNamed) {
-    sig.update('clientId:' + options.clientId + '\n');
-    sig.update('issuer:' + options.credentials.clientId + '\n');
+    sig.update(`clientId:${options.clientId}\n`);
+    sig.update(`issuer:${options.credentials.clientId}\n`);
   }
-  sig.update('seed:' + cert.seed + '\n');
-  sig.update('start:' + cert.start + '\n');
-  sig.update('expiry:' + cert.expiry + '\n');
+  sig.update(`seed:${cert.seed}\n`);
+  sig.update(`start:${cert.start}\n`);
+  sig.update(`expiry:${cert.expiry}\n`);
   sig.update('scopes:\n');
   sig.update(cert.scopes.join('\n'));
   cert.signature = sig.digest('base64');
 
   // Construct temporary key
-  let accessToken = crypto
+  const accessToken = crypto
     .createHmac('sha256', options.credentials.accessToken)
     .update(cert.seed)
     .digest('base64')
@@ -831,8 +839,8 @@ export const createTemporaryCredentials = function(options) {
  *    scopes: [...],        // associated scopes (if available)
  * }
  */
-export const credentialInformation = function(rootUrl, credentials) {
-  let result = {};
+export const credentialInformation = (rootUrl, credentials) => {
+  const result = {};
   let issuer = credentials.clientId;
 
   result.clientId = issuer;
@@ -862,9 +870,9 @@ export const credentialInformation = function(rootUrl, credentials) {
     result.type = 'permanent';
   }
 
-  let anonClient = new clients.Auth({ rootUrl });
-  let clientLookup = anonClient.client(issuer).then(function(client) {
-    let expires = new Date(client.expires);
+  const anonClient = new clients.Auth({ rootUrl });
+  const clientLookup = anonClient.client(issuer).then(client => {
+    const expires = new Date(client.expires);
     if (!result.expiry || result.expiry > expires) {
       result.expiry = expires;
     }
@@ -873,14 +881,14 @@ export const credentialInformation = function(rootUrl, credentials) {
     }
   });
 
-  let credClient = new clients.Auth({ rootUrl, credentials });
-  let scopeLookup = credClient.currentScopes().then(function(response) {
+  const credClient = new clients.Auth({ rootUrl, credentials });
+  const scopeLookup = credClient.currentScopes().then(response => {
     result.scopes = response.scopes;
   });
 
-  return Promise.all([clientLookup, scopeLookup]).then(function() {
+  return Promise.all([clientLookup, scopeLookup]).then(() => {
     // re-calculate "active" based on updated start/expiration
-    let now = new Date();
+    const now = new Date();
     if (result.start && result.start > now) {
       result.active = false;
     } else if (result.expiry && now > result.expiry) {

package/src/download.js

@@ -13,7 +13,7 @@ const makeRetryCfg = ({ retries, delayFactor, randomizationFactor, maxDelay }) =
 });
 
 const s3 = async ({ url, streamFactory, retryCfg }) => {
-  return await retry(retryCfg, async (retriableError, attempt) => {
+  return await retry(retryCfg, async retriableError => {
     let contentType = 'application/binary';
     try {
       const src = got.stream(url, { retry: { limit: 0 } });
@@ -38,7 +38,7 @@ const getUrl = async ({ object, name, resp, streamFactory, retryCfg }) => {
   let hashStream;
   let contentType = 'application/binary';
 
-  await retry(retryCfg, async (retriableError, attempt) => {
+  await retry(retryCfg, async retriableError => {
     // renew the download URL if necessary (note that we assume the object-sevice
     // credentials are good for long enough)
     if (responseUsed && new Date(resp.expires) < new Date()) {
@@ -78,7 +78,7 @@ const getUrl = async ({ object, name, resp, streamFactory, retryCfg }) => {
 // "acceptable" hash algorithm.  Throws an exception on verification failure.
 const verifyHashes = (observedHashes, expectedHashes) => {
   let someValidAcceptableHash = false;
-  for (let algo of Object.keys(expectedHashes)) {
+  for (const algo of Object.keys(expectedHashes)) {
     const computed = observedHashes[algo];
     if (!computed) {
       // ignore unknown hash algorithms
@@ -94,12 +94,19 @@ const verifyHashes = (observedHashes, expectedHashes) => {
   }
 
   if (!someValidAcceptableHash) {
-    throw new Error("No acceptable hash algorithm found");
+    throw new Error('No acceptable hash algorithm found');
   }
 };
 
-export const download = async ({ name, object, streamFactory,
-  retries, delayFactor, randomizationFactor, maxDelay }) => {
+export const download = async ({
+  name,
+  object,
+  streamFactory,
+  retries,
+  delayFactor,
+  randomizationFactor,
+  maxDelay,
+}) => {
   const retryCfg = makeRetryCfg({ retries, delayFactor, randomizationFactor, maxDelay });
 
   const acceptDownloadMethods = {
@@ -111,24 +118,34 @@ export const download = async ({ name, object, streamFactory,
   if (resp.method === 'getUrl') {
     return await getUrl({ object, name, resp, streamFactory, retryCfg });
   } else {
-    throw new Error("Could not negotiate a download method");
+    throw new Error('Could not negotiate a download method');
   }
 };
 
 export const downloadArtifact = async ({
-  taskId, runId, name, queue, streamFactory, retries, delayFactor, randomizationFactor, maxDelay,
+  taskId,
+  runId,
+  name,
+  queue,
+  streamFactory,
+  retries,
+  delayFactor,
+  randomizationFactor,
+  maxDelay,
 }) => {
   const retryCfg = makeRetryCfg({ retries, delayFactor, randomizationFactor, maxDelay });
 
-  let artifact = await (runId === undefined ? queue.latestArtifact(taskId, name) : queue.artifact(taskId, runId, name));
+  const artifact = await (runId === undefined
+    ? queue.latestArtifact(taskId, name)
+    : queue.artifact(taskId, runId, name));
 
   switch (artifact.storageType) {
-    case "reference":
-    case "s3": {
+    case 'reference':
+    case 's3': {
       return await s3({ url: artifact.url, streamFactory, retryCfg });
     }
 
-    case "object": {
+    case 'object': {
       const object = new clients.Object({
         rootUrl: queue._options._trueRootUrl,
         credentials: artifact.credentials,
@@ -136,7 +153,7 @@ export const downloadArtifact = async ({
       return await download({ name: artifact.name, object, streamFactory, ...retryCfg });
     }
 
-    case "error": {
+    case 'error': {
       const err = new Error(artifact.message);
       err.reason = artifact.reason;
       throw err;

package/src/hashstream.js

@@ -1,9 +1,9 @@
-import { Transform } from 'stream';
-import { createHash } from 'crypto';
+import { Transform } from 'node:stream';
+import { createHash } from 'node:crypto';
 
 // The subset of hashes supported by HashStream which are "accepted" as per the
 // object service's schemas.
-export const ACCEPTABLE_HASHES = new Set(["sha256", "sha512"]);
+export const ACCEPTABLE_HASHES = new Set(['sha256', 'sha512']);
 
 /**
  * A stream that hashes the bytes passing through it
@@ -16,7 +16,7 @@ export class HashStream extends Transform {
     this.bytes = 0;
   }
 
-  _transform(chunk, enc, cb) {
+  _transform(chunk, _enc, cb) {
     this.sha256.update(chunk);
     this.sha512.update(chunk);
     this.bytes += chunk.length;

package/src/index.js

@@ -1,6 +1,6 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
-* License, v. 2.0. If a copy of the MPL was not distributed with this
-* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 export * from './client.js';
 export * from './utils.js';

package/src/parsetime.js

@@ -1,26 +1,29 @@
 // Regular expression matching:
 // A years B months C days D hours E minutes F seconds
-let timeExp = new RegExp([
-  '^(\\s*(-|\\+))?',
-  '(\\s*(\\d+)\\s*y((ears?)|r)?)?',
-  '(\\s*(\\d+)\\s*mo(nths?)?)?',
-  '(\\s*(\\d+)\\s*w((eeks?)|k)?)?',
-  '(\\s*(\\d+)\\s*d(ays?)?)?',
-  '(\\s*(\\d+)\\s*h((ours?)|r)?)?',
-  '(\\s*(\\d+)\\s*m(in(utes?)?)?)?',
-  '(\\s*(\\d+)\\s*s(ec(onds?)?)?)?',
-  '\\s*$',
-].join(''), 'i');
+const timeExp = new RegExp(
+  [
+    '^(\\s*(-|\\+))?',
+    '(\\s*(\\d+)\\s*y((ears?)|r)?)?',
+    '(\\s*(\\d+)\\s*mo(nths?)?)?',
+    '(\\s*(\\d+)\\s*w((eeks?)|k)?)?',
+    '(\\s*(\\d+)\\s*d(ays?)?)?',
+    '(\\s*(\\d+)\\s*h((ours?)|r)?)?',
+    '(\\s*(\\d+)\\s*m(in(utes?)?)?)?',
+    '(\\s*(\\d+)\\s*s(ec(onds?)?)?)?',
+    '\\s*$',
+  ].join(''),
+  'i'
+);
 
 /** Parse time string */
-let parseTime = function(str) {
+const parseTime = str => {
   // Parse the string
-  let match = timeExp.exec(str || '');
+  const match = timeExp.exec(str || '');
   if (!match) {
-    throw new Error('String: \'' + str + '\' isn\'t a time expression');
+    throw new Error(`String: '${str}' isn't a time expression`);
   }
   // Negate if needed
-  let neg = match[2] === '-' ? - 1 : 1;
+  const neg = match[2] === '-' ? -1 : 1;
   // Return parsed values
   return {
     years: parseInt(match[4] || 0, 10) * neg,

package/src/retry.js

@@ -15,7 +15,7 @@ export default async ({ retries, delayFactor, randomizationFactor, maxDelay }, f
 
     let retriableError = null;
 
-    const rv = await func(err => retriableError = err, attempt);
+    const rv = await func(err => (retriableError = err), attempt);
     if (!retriableError) {
       // success!
       return rv;
@@ -27,9 +27,9 @@ export default async ({ retries, delayFactor, randomizationFactor, maxDelay }, f
 
     // Sleep for 2 * delayFactor on the first attempt, and 2x as long
     // each time thereafter
-    let delay = Math.pow(2, attempt) * delayFactor;
+    let delay = 2 ** attempt * delayFactor;
     // Apply randomization factor
-    let rf = randomizationFactor;
+    const rf = randomizationFactor;
     delay *= Math.random() * 2 * rf + 1 - rf;
     // Always limit with a maximum delay
     delay = Math.min(delay, maxDelay);

package/src/upload.js

@@ -5,9 +5,9 @@ import { HashStream } from './hashstream.js';
 
 const DATA_INLINE_MAX_SIZE = 8192;
 
-const putUrl = async ({ streamFactory, contentLength, uploadMethod, retryCfg }) => {
+const putUrl = async ({ streamFactory, uploadMethod, retryCfg }) => {
   const { url, headers } = uploadMethod.putUrl;
-  await retry(retryCfg, async (retriableError, attempt) => {
+  await retry(retryCfg, async retriableError => {
     try {
       await got.put(url, {
         headers,
@@ -88,9 +88,9 @@ export const upload = async ({
   if (res.uploadMethod.dataInline) {
     // nothing to do
   } else if (res.uploadMethod.putUrl) {
-    await putUrl({ streamFactory: hashStreamFactory, contentLength, uploadMethod: res.uploadMethod, retryCfg });
+    await putUrl({ streamFactory: hashStreamFactory, uploadMethod: res.uploadMethod, retryCfg });
   } else {
-    throw new Error("Could not negotiate an upload method");
+    throw new Error('Could not negotiate an upload method');
   }
 
   const hashes = hashStream.hashes(contentLength);

package/src/utils.js

@@ -10,7 +10,7 @@ import sluglib from 'slugid';
  * short hand `1d2h3min`, it's fairly tolerant of different spelling forms and
  * whitespace. But only really meant to be used with constants.
  */
-export const fromNow = function(offset, reference) {
+export const fromNow = (offset, reference) => {
   if (reference === undefined) {
     reference = new Date();
   }
@@ -19,15 +19,15 @@ export const fromNow = function(offset, reference) {
   offset.days += 30 * offset.months;
   offset.days += 365 * offset.years;
 
-  let retval = new Date(
-    reference.getTime()
-    //    + offset.years * 365 * 24 * 60 * 60 * 1000
-    //   + offset.month  * 30 * 24 * 60 * 60 * 1000
-    + offset.weeks * 7 * 24 * 60 * 60 * 1000
-    + offset.days * 24 * 60 * 60 * 1000
-    + offset.hours * 60 * 60 * 1000
-    + offset.minutes * 60 * 1000
-    + offset.seconds * 1000,
+  const retval = new Date(
+    reference.getTime() +
+      //    + offset.years * 365 * 24 * 60 * 60 * 1000
+      //   + offset.month  * 30 * 24 * 60 * 60 * 1000
+      offset.weeks * 7 * 24 * 60 * 60 * 1000 +
+      offset.days * 24 * 60 * 60 * 1000 +
+      offset.hours * 60 * 60 * 1000 +
+      offset.minutes * 60 * 1000 +
+      offset.seconds * 1000
   );
   return retval;
 };
@@ -45,9 +45,7 @@ export const fromNow = function(offset, reference) {
  * short hand `1d2h3min`, it's fairly tolerant of different spelling forms and
  * whitespace. But only really meant to be used with constants.
  */
-export const fromNowJSON = function(offset, reference) {
-  return fromNow(offset, reference).toJSON();
-};
+export const fromNowJSON = (offset, reference) => fromNow(offset, reference).toJSON();
 
 // Export function to generate _nice_ slugids
 export const slugid = () => sluglib.nice();