@webex/http-core 3.0.0-beta.3 → 3.0.0-beta.300

package/src/request/request.shim.js

@@ -22,7 +22,15 @@ import detect from '../lib/detect';
  */
 export default function _request(options) {
   return new Promise((resolve) => {
-    const params = pick(options, 'method', 'uri', 'withCredentials', 'headers', 'timeout', 'responseType');
+    const params = pick(
+      options,
+      'method',
+      'uri',
+      'withCredentials',
+      'headers',
+      'timeout',
+      'responseType'
+    );
 
     // Set `response` to `true` to approximate an `HttpResponse` object
     params.response = true;
@@ -37,54 +45,64 @@ export default function _request(options) {
     setPayload(params, options);
     setQs(params, options);
 
-    options.logger.debug(`start http ${options.method ? options.method : 'request'} to ${options.uri}`);
+    options.logger.debug(
+      `start http ${options.method ? options.method : 'request'} to ${options.uri}`
+    );
 
     const x = xhr(params, (error, response) => {
       /* istanbul ignore next */
       if (error) {
-        options.logger.warn(error);
+        options.logger.warn(
+          `XHR error for ${options.method || 'request'} to ${options.uri} :`,
+          error
+        );
       }
 
       /* istanbul ignore else */
       if (response) {
         if (response.statusCode >= 400) {
-          options.logger.warn(`http ${options.method ? options.method : 'request'} to ${options.uri} result: ${response.statusCode}`);
-        }
-        else {
-          options.logger.debug(`http ${options.method ? options.method : 'request'} to ${options.uri} result: ${response.statusCode}`);
+          options.logger.warn(
+            `http ${options.method ? options.method : 'request'} to ${options.uri} result: ${
+              response.statusCode
+            }`
+          );
+        } else {
+          options.logger.debug(
+            `http ${options.method ? options.method : 'request'} to ${options.uri} result: ${
+              response.statusCode
+            }`
+          );
         }
         response.options = options;
         processResponseJson(response, params);
         resolve(response);
-      }
-      else {
+      } else {
         resolve({
           statusCode: 0,
           options,
           headers: options.headers,
           method: options.method,
           url: options.uri,
-          body: error
+          body: error,
         });
       }
     });
 
     x.onprogress = options.download.emit.bind(options.download, 'progress');
-  })
-    .catch((error) => {
-      options.logger.warn(error);
-
-      /* eslint arrow-body-style: [0] */
-      /* istanbul ignore next */
-      return {
-        statusCode: 0,
-        options,
-        headers: options.headers,
-        method: options.method,
-        url: options.uri,
-        body: error
-      };
-    });
+  }).catch((error) => {
+    options.logger.warn(error);
+
+    /* eslint arrow-body-style: [0] */
+    /* istanbul ignore next */
+    return {
+      statusCode: 0,
+      options,
+      headers: options.headers,
+      method: options.method,
+      url: options.uri,
+      body: error,
+    };
+  });
 
   /**
    * @param {Object} params
@@ -121,8 +139,7 @@ export default function _request(options) {
     if (o.auth) {
       if (o.auth.bearer) {
         params.headers.authorization = `Bearer ${o.auth.bearer}`;
-      }
-      else {
+      } else {
         const user = o.auth.user || o.auth.username;
         const pass = o.auth.pass || o.auth.password;
 
@@ -157,7 +174,7 @@ export default function _request(options) {
       // raynos/xhr defaults withCredentials to true if cors is true, so we need
       // to make it explicitly false by default
       withCredentials: false,
-      timeout: 0
+      timeout: 0,
     };
 
     defaults(params, pick(o, Object.keys(defs)), defs);
@@ -184,7 +201,7 @@ export default function _request(options) {
   async function setContentType(params, o) {
     if (o.body instanceof Blob || o.body instanceof ArrayBuffer) {
       o.json = params.json = false;
-      params.headers['content-type'] = params.headers['content-type'] || await detect(o.body);
+      params.headers['content-type'] = params.headers['content-type'] || (await detect(o.body));
     }
   }
 
@@ -238,8 +255,7 @@ export default function _request(options) {
     if (value.name) {
       value.filename = value.name;
       form.append(key, value, value.name);
-    }
-    else {
+    } else {
       form.append(key, value);
     }
   }
@@ -253,13 +269,11 @@ export default function _request(options) {
   function setPayload(params, o) {
     if ((!('json' in o) || o.json === true) && o.body) {
       params.json = o.body;
-    }
-    else if (o.form) {
+    } else if (o.form) {
       params.headers['Content-Type'] = 'application/x-www-form-urlencoded';
       params.body = qs.stringify(o.form);
       Reflect.deleteProperty(params, 'json');
-    }
-    else if (o.formData) {
+    } else if (o.formData) {
       params.body = Object.keys(o.formData).reduce((fd, key) => {
         const value = o.formData[key];
 
@@ -267,8 +281,7 @@ export default function _request(options) {
 
         return fd;
       }, new FormData());
-    }
-    else {
+    } else {
       params.body = o.body;
       Reflect.deleteProperty(params, 'json');
     }
@@ -286,8 +299,7 @@ export default function _request(options) {
     if (!params.json && typeof response.body !== 'object') {
       try {
         response.body = JSON.parse(response.body);
-      }
-      catch (e) {
+      } catch (e) {
         /* eslint no-empty: [0] */
       }
     }

package/src/request/utils.ts

@@ -0,0 +1,78 @@
+/* eslint-disable import/prefer-default-export */
+import {EventEmitter} from 'events';
+import Interceptor from '../lib/interceptor';
+
+/**
+ * @param {Object} options
+ * @param {Array<Object>} interceptors
+ * @param {string} key
+ * @param {Object | undefined} res
+ * @private
+ * @returns {Promise}
+ */
+export function intercept(
+  options: object,
+  interceptors: Array<Interceptor>,
+  key: string,
+  res: object = undefined
+): Promise<any> {
+  const successKey = `on${key}`;
+  const errorKey = `on${key}Error`;
+
+  return interceptors.reduce(
+    (promise, interceptor) =>
+      promise.then(
+        (result) => {
+          interceptor.logOptions(options);
+          if (interceptor[successKey]) {
+            return interceptor[successKey](options, result);
+          }
+
+          return Promise.resolve(result);
+        },
+        (reason) => {
+          interceptor.logOptions(options);
+          if (interceptor[errorKey]) {
+            return interceptor[errorKey](options, reason);
+          }
+
+          return Promise.reject(reason);
+        }
+      ),
+    Promise.resolve(res)
+  );
+}
+
+/**
+ * Prepare options for a fetch.
+ * @param {object} options
+ * @returns {Promise}
+ */
+export async function prepareFetchOptions(options: any): Promise<any> {
+  if (options.url) {
+    options.uri = options.url;
+    options.url = null;
+  }
+
+  options.headers = options.headers || {};
+
+  if (options.json) {
+    // don't override existing accept header declared by user
+    options.headers.accept = options.headers.accept || options.headers.Accept || 'application/json';
+
+    // don't override existing content-type header declared by user
+    if (options.method !== 'GET' && options.method !== 'HEAD') {
+      options.headers['content-type'] =
+        options.headers['content-type'] || options.headers['Content-Type'] || 'application/json';
+      options.body = JSON.stringify(options.json === true ? options.body : options.json);
+    }
+  } else if (options.json !== undefined) {
+    Reflect.deleteProperty(options, 'json');
+  }
+
+  options.download = new EventEmitter();
+  options.upload = new EventEmitter();
+  options.keepalive = true;
+
+  return intercept(options, options.interceptors, 'Request').then(() => options);
+}

package/test/integration/spec/http-error.js

@@ -71,7 +71,7 @@ describe('http-core', () => {
 
     it('falls back to a default error message', () => {
       const res = {
-        statusCode: 400
+        statusCode: 400,
       };
 
       const error = new HttpError(res);
@@ -83,7 +83,7 @@ describe('http-core', () => {
       const message = 'an error occurred';
       const res = {
         statusCode: 400,
-        body: message
+        body: message,
       };
 
       const error = new HttpError(res);
@@ -93,12 +93,12 @@ describe('http-core', () => {
 
     it('parses JSON responses', () => {
       const message = {
-        data: 'an error'
+        data: 'an error',
       };
 
       const res = {
         statusCode: 400,
-        body: message
+        body: message,
       };
 
       const error = new HttpError(res);
@@ -108,12 +108,12 @@ describe('http-core', () => {
 
     it('parses stringified JSON responses', () => {
       const message = JSON.stringify({
-        data: 'an error'
+        data: 'an error',
       });
 
       const res = {
         statusCode: 400,
-        body: message
+        body: message,
       };
 
       const error = new HttpError(res);
@@ -126,8 +126,8 @@ describe('http-core', () => {
       const res = {
         statusCode: 400,
         body: {
-          error: message
-        }
+          error: message,
+        },
       };
 
       const error = new HttpError(res);
@@ -141,9 +141,9 @@ describe('http-core', () => {
         statusCode: 400,
         body: {
           error: {
-            errorString: message
-          }
-        }
+            errorString: message,
+          },
+        },
       };
 
       const error = new HttpError(res);

package/test/integration/spec/interceptor.js

@@ -13,15 +13,21 @@ describe('http-core', () => {
   describe('interceptor', () => {
     let webex;
 
-    before('create users', () => testUsers.create({count: 1})
-      .then(([user]) => new Promise((resolve) => {
-        setTimeout(() => resolve(user), 3000);
-      }))
-      .then((user) => {
-        webex = new WebexCore({credentials: user.token});
-      })
-      .then(() => webex.internal.device.register())
-      .then(() => webex.internal.services.waitForCatalog('postauth', 10)));
+    before('create users', () =>
+      testUsers
+        .create({count: 1})
+        .then(
+          ([user]) =>
+            new Promise((resolve) => {
+              setTimeout(() => resolve(user), 3000);
+            })
+        )
+        .then((user) => {
+          webex = new WebexCore({credentials: user.token});
+        })
+        .then(() => webex.internal.device.register())
+        .then(() => webex.internal.services.waitForCatalog('postauth', 10))
+    );
 
     describe('logOptions', () => {
       let flagged;
@@ -46,10 +52,11 @@ describe('http-core', () => {
       it('calls logger plugin', () => {
         const spy = sinon.spy(webex.logger, 'info');
 
-        return webex.request({
-          service: 'hydra',
-          resource: 'people/me'
-        })
+        return webex
+          .request({
+            service: 'hydra',
+            resource: 'people/me',
+          })
           .then(() => {
             assert.called(spy);
           });

package/test/integration/spec/progress-event.js

@@ -47,35 +47,35 @@ describe('http-core', () => {
           {
             loaded: undefined,
             total: undefined,
-            result: false
+            result: false,
           },
           {
             loaded: 10,
             total: undefined,
-            result: false
+            result: false,
           },
           {
             loaded: undefined,
             total: 10,
-            result: false
+            result: false,
           },
           {
             loaded: 10,
             total: 10,
-            result: true
+            result: true,
           },
           {
             loaded: 10,
             total: 0,
-            result: false
+            result: false,
           },
           {
             loaded: 0,
             total: 0,
-            result: false
-          }
+            result: false,
+          },
         ].forEach((item) => {
-          assert.equal((new ProgressEvent(item.loaded, item.total)).lengthComputable, item.result);
+          assert.equal(new ProgressEvent(item.loaded, item.total).lengthComputable, item.result);
         });
       });
     });