@webex/webex-core 3.0.0-beta.2 → 3.0.0-beta.21

package/src/index.js

@@ -13,13 +13,7 @@ import './plugins/logger';
 import './lib/credentials';
 import './lib/services';
 
-export {
-  Credentials,
-  filterScope,
-  grantErrors,
-  sortScope,
-  Token
-} from './lib/credentials';
+export {Credentials, filterScope, grantErrors, sortScope, Token} from './lib/credentials';
 
 export {
   constants as serviceConstants,
@@ -30,7 +24,7 @@ export {
   ServerErrorInterceptor,
   Services,
   ServiceHost,
-  ServiceUrl
+  ServiceUrl,
 } from './lib/services';
 
 export {
@@ -40,14 +34,10 @@ export {
   NotFoundError,
   persist,
   StorageError,
-  waitForValue
+  waitForValue,
 } from './lib/storage';
 
-export {
-  default,
-  registerPlugin,
-  registerInternalPlugin
-} from './webex-core';
+export {default, registerPlugin, registerInternalPlugin} from './webex-core';
 
 export {default as WebexHttpError} from './lib/webex-http-error';
 export {default as StatelessWebexPlugin} from './lib/stateless-webex-plugin';

package/src/interceptors/auth.js

@@ -34,19 +34,17 @@ export default class AuthInterceptor extends Interceptor {
       return Promise.resolve(options);
     }
 
-    return this.requiresCredentials(options)
-      .then((requires) => {
-        if (!requires) {
-          return options;
-        }
+    return this.requiresCredentials(options).then((requires) => {
+      if (!requires) {
+        return options;
+      }
 
-        return this.webex.credentials.getUserToken()
-          .then((token) => {
-            options.headers.authorization = token.toString();
+      return this.webex.credentials.getUserToken().then((token) => {
+        options.headers.authorization = token.toString();
 
-            return options;
-          });
+        return options;
       });
+    });
   }
 
   /**
@@ -77,26 +75,26 @@ export default class AuthInterceptor extends Interceptor {
 
     // Unique validation for the u2c service.
     if ((service && service === 'u2c') || (name && name === 'u2c')) {
-      if (
-        (resource && resource.includes('limited')) ||
-        (uri && uri.includes('limited'))
-      ) {
+      if ((resource && resource.includes('limited')) || (uri && uri.includes('limited'))) {
         return Promise.resolve(false);
       }
 
       return Promise.resolve(true);
     }
 
-
     // Validate that the allowed domains can be utilized.
-    if (services.validateDomains &&
+    if (
+      services.validateDomains &&
       services.hasAllowedDomains() &&
-      (uri && services.isAllowedDomainUrl(uri))) {
+      uri &&
+      services.isAllowedDomainUrl(uri)
+    ) {
       return Promise.resolve(true);
     }
 
     // Perform an additional validation in case the service does not exist yet.
-    return services.waitForService({name: service, url: uri})
+    return services
+      .waitForService({name: service, url: uri})
       .then((detectedUrl) => {
         // Validate that the url exists in the catalog.
         if (services.getServiceFromUrl(detectedUrl)) {
@@ -123,23 +121,21 @@ export default class AuthInterceptor extends Interceptor {
    * @returns {Object}
    */
   onResponseError(options, reason) {
-    return this.shouldAttemptReauth(reason, options)
-      .then((shouldAttemptReauth) => {
-        if (shouldAttemptReauth) {
-          this.webex.logger.info('auth: received 401, attempting to reauthenticate');
-
-          if (reason.options.headers) {
-            Reflect.deleteProperty(reason.options.headers, 'authorization');
-          }
-
-          if (this.webex.credentials.canRefresh) {
-            return this.webex.credentials.refresh()
-              .then(() => this.replay(options));
-          }
+    return this.shouldAttemptReauth(reason, options).then((shouldAttemptReauth) => {
+      if (shouldAttemptReauth) {
+        this.webex.logger.info('auth: received 401, attempting to reauthenticate');
+
+        if (reason.options.headers) {
+          Reflect.deleteProperty(reason.options.headers, 'authorization');
         }
 
-        return Promise.reject(reason);
-      });
+        if (this.webex.credentials.canRefresh) {
+          return this.webex.credentials.refresh().then(() => this.replay(options));
+        }
+      }
+
+      return Promise.reject(reason);
+    });
   }
 
   /**
@@ -150,15 +146,18 @@ export default class AuthInterceptor extends Interceptor {
   replay(options) {
     if (options.replayCount) {
       options.replayCount += 1;
-    }
-    else {
+    } else {
       options.replayCount = 1;
     }
 
     if (options.replayCount > this.webex.config.maxAuthenticationReplays) {
-      this.webex.logger.error(`auth: failed after ${this.webex.config.maxAuthenticationReplays} replay attempts`);
+      this.webex.logger.error(
+        `auth: failed after ${this.webex.config.maxAuthenticationReplays} replay attempts`
+      );
 
-      return Promise.reject(new Error(`Failed after ${this.webex.config.maxAuthenticationReplays} replay attempts`));
+      return Promise.reject(
+        new Error(`Failed after ${this.webex.config.maxAuthenticationReplays} replay attempts`)
+      );
     }
 
     this.webex.logger.info(`auth: replaying request ${options.replayCount} time`);

package/src/interceptors/default-options.js

@@ -4,7 +4,6 @@
 
 import {Interceptor} from '@webex/http-core';
 
-
 /**
  * Allows the user of the SDK to set default options that apply every http request made by the SDK
  * For example a default timeout could be set for all requests like this :

package/src/interceptors/embargo.js

@@ -27,7 +27,7 @@ export default class EmbargoInterceptor extends Interceptor {
       const {device} = this.webex.internal;
       const loggerMessage = [
         'Received `HTTP 451 Unavailable For Legal Reasons`, ',
-        'discarding credentials and device registration'
+        'discarding credentials and device registration',
       ].join('');
 
       if (device) {

package/src/interceptors/payload-transformer.js

@@ -50,7 +50,6 @@ export default class PayloadTransformerInterceptor extends Interceptor {
    * @returns {Object}
    */
   onResponseError(options, reason) {
-    return this.webex.transform('inbound', reason)
-      .then((r) => Promise.reject(r || reason));
+    return this.webex.transform('inbound', reason).then((r) => Promise.reject(r || reason));
   }
 }

package/src/interceptors/rate-limit.js

@@ -23,10 +23,10 @@ export default class RateLimitInterceptor extends Interceptor {
   }
 
   /**
-  * constructor
-  * @param {mixed} args
-  * @returns {Exception}
-  */
+   * constructor
+   * @param {mixed} args
+   * @returns {Exception}
+   */
   constructor(...args) {
     super(...args);
     rateLimitExpiryTime.set(this, new Map());
@@ -52,7 +52,10 @@ export default class RateLimitInterceptor extends Interceptor {
    * @returns {Object}
    */
   onResponseError(options, reason) {
-    if (reason.statusCode === 429 && (options.uri.includes('idbroker') || options.uri.includes('identity'))) {
+    if (
+      reason.statusCode === 429 &&
+      (options.uri.includes('idbroker') || options.uri.includes('identity'))
+    ) {
       // set the retry after in the map, setting to milliseconds
       this.setRateLimitExpiry(options.uri, this.extractRetryAfterTime(options));
     }

package/src/interceptors/redirect.js

@@ -1,3 +1,5 @@
+/* eslint-disable prefer-destructuring */
+
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
@@ -27,10 +29,12 @@ export default class RedirectInterceptor extends Interceptor {
    */
   onRequest(options) {
     if (options && options.uri && typeof options.uri === 'string') {
-      if (options.uri.includes('https://idbroker') ||
+      if (
+        options.uri.includes('https://idbroker') ||
         options.uri.includes(this.webex.config.credentials.samlUrl) ||
         options.uri.includes(this.webex.config.credentials.tokenUrl) ||
-        options.uri.includes(this.webex.config.credentials.authorizeUrl)) {
+        options.uri.includes(this.webex.config.credentials.authorizeUrl)
+      ) {
         return options;
       }
     }
@@ -68,20 +72,22 @@ export default class RedirectInterceptor extends Interceptor {
       }
 
       return this.webex.request(options);
-    }
-    else if (response.headers &&
+    } else if (
+      response.headers &&
       response.body &&
       response.body.errorCode === LOCUS_REDIRECT_ERROR &&
-      response.body.location) {
+      response.body.location
+    ) {
       options = clone(options);
 
       this.webex.logger.warn('redirect: url redirects needed from', options.uri);
-      if (response.options && response.options.qs) { // for POST requests
+      if (response.options && response.options.qs) {
+        // for POST requests
         const newUrl = response.body.location.split('?');
 
         options.uri = newUrl[0]; // params are already present in the qs
-      }
-      else { // for GET requests
+      } else {
+        // for GET requests
         options.uri = response.body.location;
       }
 

package/src/interceptors/request-event.js

@@ -26,8 +26,7 @@ export default class RequestEventInterceptor extends Interceptor {
 
     try {
       this.webex.trigger('request:start', options);
-    }
-    catch (error) {
+    } catch (error) {
       logger.warn('event handler for request:start failed ', error);
     }
 
@@ -48,8 +47,7 @@ export default class RequestEventInterceptor extends Interceptor {
     try {
       this.webex.trigger('request:end', options, reason);
       this.webex.trigger('request:failure', options, reason);
-    }
-    catch (error) {
+    } catch (error) {
       logger.warn('event handler for request:end failed ', error);
     }
 
@@ -67,8 +65,7 @@ export default class RequestEventInterceptor extends Interceptor {
 
     try {
       this.webex.trigger('request:success', response.options, response);
-    }
-    catch (error) {
+    } catch (error) {
       logger.warn('event handler for request:success failed ', error);
     }
 
@@ -87,8 +84,7 @@ export default class RequestEventInterceptor extends Interceptor {
     try {
       this.webex.trigger('request:end', options, reason);
       this.webex.trigger('request:failure', options, reason);
-    }
-    catch (error) {
+    } catch (error) {
       logger.warn('event handler for request:failure failed ', error);
     }
 

package/src/interceptors/request-logger.js

@@ -40,14 +40,17 @@ export default class RequestLoggerInterceptor extends Interceptor {
       try {
         // Determine if body is a buffer without relying on Buffer to avoid
         // node/browser conflicts.
-        if (options.body && options.body.length && !isArray(options.body) && !isString(options.body)) {
+        if (
+          options.body &&
+          options.body.length &&
+          !isArray(options.body) &&
+          !isString(options.body)
+        ) {
           logger.info('Request Options:', util.inspect(omit(options, 'body'), {depth: null}));
-        }
-        else {
+        } else {
           logger.info('Request Options:', util.inspect(options, {depth: null}));
         }
-      }
-      catch (e) {
+      } catch (e) {
         logger.warn('Could not stringify request options:', e);
       }
     }

package/src/interceptors/response-logger.js

@@ -36,12 +36,10 @@ export default class ResponseLoggerInterceptor extends Interceptor {
       logger.info('timestamp (end): ', now.getTime(), now.toISOString());
       if (typeof response.body === 'string' || isBuffer(response.body)) {
         logger.info('Response: ', 'Not printed, it`s probably a file');
-      }
-      else if (typeof response.body === 'object') {
+      } else if (typeof response.body === 'object') {
         try {
           logger.info('Response: ', util.inspect(omit(response.body, 'features'), {depth: null}));
-        }
-        catch (err) {
+        } catch (err) {
           logger.info('Response: ', '[Not Serializable]', err);
         }
       }
@@ -68,8 +66,7 @@ export default class ResponseLoggerInterceptor extends Interceptor {
       logger.info('timestamp (end): ', now.getTime(), now.toISOString());
       try {
         logger.error('Response: ', util.inspect(reason.body, {depth: null}));
-      }
-      catch (err) {
+      } catch (err) {
         logger.error('Response: ', reason.body);
       }
     }
@@ -88,8 +85,14 @@ export default class ResponseLoggerInterceptor extends Interceptor {
     const logger = get(this, 'webex.logger', console);
 
     logger.info('Status Code:', response.statusCode);
-    logger.info('WEBEX_TRACKINGID:', get(options, 'headers.trackingid') || get(response, 'headers.trackingid'));
+    logger.info(
+      'WEBEX_TRACKINGID:',
+      get(options, 'headers.trackingid') || get(response, 'headers.trackingid')
+    );
     logger.info('Network duration:', options.$timings.networkEnd - options.$timings.networkStart);
-    logger.info('Processing duration:', options.$timings.requestEnd - options.$timings.requestStart);
+    logger.info(
+      'Processing duration:',
+      options.$timings.requestEnd - options.$timings.requestStart
+    );
   }
 }

package/src/interceptors/user-agent.js

@@ -41,8 +41,7 @@ export default class UserAgentInterceptor extends Interceptor {
     super(options);
     if (appName) {
       strings.set(this, `${appName}/${appVersion}`);
-    }
-    else {
+    } else {
       strings.set(this, '@webex/http-core'); // Using the traditional default from http-core
     }
   }

package/src/interceptors/webex-user-agent.js

@@ -40,11 +40,7 @@ export default class WebexUserAgentInterceptor extends Interceptor {
    */
   onRequest(options) {
     options.headers = options.headers || {};
-    const {
-      appName,
-      appVersion,
-      appPlatform
-    } = this.webex?.config ?? {};
+    const {appName, appVersion, appPlatform} = this.webex?.config ?? {};
     let sparkUserAgent = `${strings.get(this)}`;
 
     if (appName) {
@@ -61,11 +57,9 @@ export default class WebexUserAgentInterceptor extends Interceptor {
 
     if (
       options.uri &&
-      (
-        options.uri.includes(this.webex.config.credentials.samlUrl) ||
+      (options.uri.includes(this.webex.config.credentials.samlUrl) ||
         options.uri.includes(this.webex.config.credentials.tokenUrl) ||
-        options.uri.includes(this.webex.config.credentials.authorizeUrl)
-      )
+        options.uri.includes(this.webex.config.credentials.authorizeUrl))
     ) {
       return options;
     }

package/src/lib/batcher.js

@@ -3,11 +3,7 @@
  */
 
 import {has} from 'lodash';
-import {
-  cappedDebounce,
-  Defer,
-  tap
-} from '@webex/common';
+import {cappedDebounce, Defer, tap} from '@webex/common';
 
 import WebexPlugin from './webex-plugin';
 import WebexHttpError from './webex-http-error';
@@ -22,14 +18,14 @@ const Batcher = WebexPlugin.extend({
       type: 'object',
       default() {
         return new Map();
-      }
+      },
     },
     queue: {
       type: 'array',
       default() {
         return [];
-      }
-    }
+      },
+    },
   },
 
   derived: {
@@ -37,10 +33,10 @@ const Batcher = WebexPlugin.extend({
       fn() {
         return cappedDebounce((...args) => this.executeQueue(...args), this.config.batcherWait, {
           maxCalls: this.config.batcherMaxCalls,
-          maxWait: this.config.batcherMaxWait
+          maxWait: this.config.batcherMaxWait,
         });
-      }
-    }
+      },
+    },
   },
 
   /**
@@ -113,25 +109,30 @@ const Batcher = WebexPlugin.extend({
     const queue = this.queue.splice(0, this.config.batcherMaxCalls);
 
     return new Promise((resolve) => {
-      resolve(this.prepareRequest(queue)
-        .then((payload) => this.submitHttpRequest(payload)
-          .then((res) => this.handleHttpSuccess(res)))
-        .catch((reason) => {
-          if (reason instanceof WebexHttpError) {
-            return this.handleHttpError(reason);
-          }
-
-          return Promise.all(queue.map((item) => this.getDeferredForRequest(item)
-            .then((defer) => {
-              defer.reject(reason);
-            })));
-        }));
-    })
-      .catch((reason) => {
-        this.logger.error(process.env.NODE_ENV === 'production' ? reason : reason.stack);
-
-        return Promise.reject(reason);
-      });
+      resolve(
+        this.prepareRequest(queue)
+          .then((payload) =>
+            this.submitHttpRequest(payload).then((res) => this.handleHttpSuccess(res))
+          )
+          .catch((reason) => {
+            if (reason instanceof WebexHttpError) {
+              return this.handleHttpError(reason);
+            }
+
+            return Promise.all(
+              queue.map((item) =>
+                this.getDeferredForRequest(item).then((defer) => {
+                  defer.reject(reason);
+                })
+              )
+            );
+          })
+      );
+    }).catch((reason) => {
+      this.logger.error(process.env.NODE_ENV === 'production' ? reason : reason.stack);
+
+      return Promise.reject(reason);
+    });
   },
 
   /**
@@ -162,7 +163,9 @@ const Batcher = WebexPlugin.extend({
    * @returns {Promise<undefined>}
    */
   handleHttpSuccess(res) {
-    return Promise.all((res.body && res.body.items || res.body).map((item) => this.acceptItem(item)));
+    return Promise.all(
+      ((res.body && res.body.items) || res.body).map((item) => this.acceptItem(item))
+    );
   },
 
   /**
@@ -176,10 +179,13 @@ const Batcher = WebexPlugin.extend({
   handleHttpError(reason) {
     if (reason instanceof WebexHttpError) {
       if (has(reason, 'options.body.map')) {
-        return Promise.all(reason.options.body.map((item) => this.getDeferredForRequest(item)
-          .then((defer) => {
-            defer.reject(reason);
-          })));
+        return Promise.all(
+          reason.options.body.map((item) =>
+            this.getDeferredForRequest(item).then((defer) => {
+              defer.reject(reason);
+            })
+          )
+        );
       }
     }
     this.logger.error('http error handler called without a WebexHttpError object', reason);
@@ -193,14 +199,13 @@ const Batcher = WebexPlugin.extend({
    * @returns {Promise<undefined>}
    */
   acceptItem(item) {
-    return this.didItemFail(item)
-      .then((didFail) => {
-        if (didFail) {
-          return this.handleItemFailure(item);
-        }
+    return this.didItemFail(item).then((didFail) => {
+      if (didFail) {
+        return this.handleItemFailure(item);
+      }
 
-        return this.handleItemSuccess(item);
-      });
+      return this.handleItemSuccess(item);
+    });
   },
 
   /**
@@ -221,10 +226,9 @@ const Batcher = WebexPlugin.extend({
    * @returns {Promise<undefined>}
    */
   handleItemFailure(item) {
-    return this.getDeferredForResponse(item)
-      .then((defer) => {
-        defer.reject(item);
-      });
+    return this.getDeferredForResponse(item).then((defer) => {
+      defer.reject(item);
+    });
   },
 
   /**
@@ -234,10 +238,9 @@ const Batcher = WebexPlugin.extend({
    * @returns {Promise<undefined>}
    */
   handleItemSuccess(item) {
-    return this.getDeferredForResponse(item)
-      .then((defer) => {
-        defer.resolve(item);
-      });
+    return this.getDeferredForResponse(item).then((defer) => {
+      defer.resolve(item);
+    });
   },
 
   /**
@@ -246,17 +249,16 @@ const Batcher = WebexPlugin.extend({
    * @returns {Promise<Defer>}
    */
   getDeferredForRequest(item) {
-    return this.fingerprintRequest(item)
-      .then((idx) => {
-        const defer = this.deferreds.get(idx);
+    return this.fingerprintRequest(item).then((idx) => {
+      const defer = this.deferreds.get(idx);
 
-        /* istanbul ignore if */
-        if (!defer) {
-          throw new Error('Could not find pending request for received response');
-        }
+      /* istanbul ignore if */
+      if (!defer) {
+        throw new Error('Could not find pending request for received response');
+      }
 
-        return defer;
-      });
+      return defer;
+    });
   },
 
   /**
@@ -265,17 +267,16 @@ const Batcher = WebexPlugin.extend({
    * @returns {Promise<Defer>}
    */
   getDeferredForResponse(item) {
-    return this.fingerprintResponse(item)
-      .then((idx) => {
-        const defer = this.deferreds.get(idx);
+    return this.fingerprintResponse(item).then((idx) => {
+      const defer = this.deferreds.get(idx);
 
-        /* istanbul ignore if */
-        if (!defer) {
-          throw new Error('Could not find pending request for received response');
-        }
+      /* istanbul ignore if */
+      if (!defer) {
+        throw new Error('Could not find pending request for received response');
+      }
 
-        return defer;
-      });
+      return defer;
+    });
   },
 
   /**
@@ -300,7 +301,7 @@ const Batcher = WebexPlugin.extend({
   // eslint-disable-next-line no-unused-vars
   fingerprintResponse(item) {
     throw new Error('fingerprintResponse() must be implemented');
-  }
+  },
 });
 
 export default Batcher;