@webex/http-core 3.0.0-bnr.4 → 3.0.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/request.js

@@ -78,7 +78,8 @@ describe('http-core', function () {
           }));
       });
 
-      it('makes CORS compatible calls', () =>
+      // SPARK-413317
+      it.skip('makes CORS compatible calls', () =>
         request({
           uri: 'https://ds.ciscospark.com/v1/region/',
         }).then((res) => {

package/test/unit/spec/index.js

@@ -0,0 +1,58 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+
+import * as utils from '@webex/http-core/src/request/utils';
+import WebexTrackingIdInterceptor from '@webex/webex-core/src/interceptors/webex-tracking-id';
+import UserAgentInterceptor from '@webex/webex-core/src/interceptors/webex-user-agent';
+import {protoprepareFetchOptions, setTimingsAndFetch} from '@webex/http-core/src/index';
+
+describe('http-core index tests', () => {
+  describe('#protoprepareFetchOptions()', () => {
+    it('uses default options and adds expected options', async () => {
+      const defaultOptions = {
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+      const options = {};
+
+      const prepareFetchOptions = protoprepareFetchOptions(defaultOptions);
+
+      await prepareFetchOptions(options);
+
+      assert.deepEqual(options, {
+        headers: {
+          trackingid: 'undefined_1',
+          'spark-user-agent': 'webex-js-sdk/development (node)',
+        },
+        keepalive: true,
+      });
+
+      assert.equal(typeof options.logger, 'object');
+      assert.equal(typeof options.upload, 'object');
+      assert.equal(typeof options.download, 'object');
+      assert.isArray(options.interceptors);
+    });
+  });
+
+  describe('#setTimingsAndFetch()', () => {
+    const now = Date.now();
+    let stubbedFetch;
+
+    beforeEach(() => {
+      global.fetch = sinon.stub();
+    });
+
+    it('calls fetch with expected options', async () => {
+      sinon.useFakeTimers(now);
+      const options = {uri: 'foo'};
+
+      const newOptions = setTimingsAndFetch(options);
+
+      sinon.assert.calledOnce(global.fetch);
+      sinon.assert.calledWith(global.fetch, 'foo', {
+        uri: 'foo',
+        $timings: {requestStart: now, networkStart: now},
+      });
+      sinon.restore();
+    });
+  });
+});

package/test/unit/spec/request/request.shim.js

@@ -0,0 +1,28 @@
+import {assert} from '@webex/test-helper-chai';
+import window from 'global/window';
+import request from '@webex/http-core/src/request/request.shim';
+import {EventEmitter} from 'events';
+
+describe('Request shim', () => {
+  describe('#setAuth()', () => {
+    beforeAll(() => {
+      global.Blob = function (content, options) {
+        return { content, options };
+      };
+    });
+    it('sets auth header', () => {
+
+      class DummyXMLHttpRequest {
+        upload = new EventEmitter();
+      }
+
+      window.XMLHttpRequest = DummyXMLHttpRequest;
+
+      const options = {upload: new EventEmitter(), headers: [], method: 'post', ...options, auth: {user: 'test', pass: 'pw'}, logger: {warn: () => {}}};
+
+      request(options);
+
+      assert.equal(options.headers.Authorization, 'Basic dGVzdDpwdw==');
+    });
+  });
+});

package/test/unit/spec/request/utils.js

@@ -0,0 +1,77 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+
+import * as utils from '@webex/http-core/src/request/utils';
+import WebexTrackingIdInterceptor from '@webex/webex-core/src/interceptors/webex-tracking-id';
+import UserAgentInterceptor from '@webex/webex-core/src/interceptors/webex-user-agent';
+
+describe('Request utils', () => {
+  describe('#intercept()', () => {
+    it('updates options from interceptors', async () => {
+      const options = {};
+      const interceptors = [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()];
+
+      return utils.intercept(options, interceptors, 'Request').then(() => {
+        assert.equal(Object.keys(options.headers).length, 2);
+        assert.equal(options.headers.trackingid, 'undefined_1');
+        assert.equal(options.headers['spark-user-agent'], 'webex-js-sdk/development (node)');
+      });
+    });
+  });
+
+  describe('#prepareFetchOptions()', () => {
+    it('updates options as expected', async () => {
+      const options = {
+        json: true,
+        body: {foo: 'bar'},
+        headers: {},
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+
+      return utils.prepareFetchOptions(options).then(() => {
+        assert.deepEqual(options.headers, {
+          accept: 'application/json',
+          'content-type': 'application/json',
+          trackingid: 'undefined_1',
+          'spark-user-agent': 'webex-js-sdk/development (node)',
+        });
+
+        assert.equal(options.body, '{"foo":"bar"}');
+
+        assert.equal(options.download != undefined, true);
+        assert.equal(options.upload != undefined, true);
+        assert.equal(options.keepalive, true);
+      });
+    });
+
+    it('updates options as expected when accept and content-type exist', async () => {
+      const options = {
+        json: true,
+        body: {foo: 'bar'},
+        headers: {accept: 'foo', 'content-type': 'bar'},
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+
+      return utils.prepareFetchOptions(options).then(() => {
+        assert.deepEqual(options.headers, {
+          accept: 'foo',
+          'content-type': 'bar',
+          trackingid: 'undefined_1',
+          'spark-user-agent': 'webex-js-sdk/development (node)',
+        });
+      });
+    });
+
+    it('updates body as expected when json = some object', async () => {
+      const options = {
+        json: {bar: 'baz'},
+        headers: {accept: 'foo', 'content-type': 'bar'},
+        interceptors: [WebexTrackingIdInterceptor.create(), UserAgentInterceptor.create()],
+      };
+
+      return utils.prepareFetchOptions(options).then(() => {
+        assert.equal(options.body, '{"bar":"baz"}');
+      });
+    });
+  });
+});

package/dist/types/http-error-subtypes.d.ts

@@ -1,8 +0,0 @@
-/*!
- * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
- */
-/**
- * @param {Error} Base
- * @returns {undefined}
- */
-export default function makeSubTypes(Base: Error): undefined;

package/dist/types/http-error.d.ts

@@ -1,41 +0,0 @@
-/**
- * Base HttpError class. Unlikely to be thrown directly, but handy for general
- * type comparison.
- */
-declare class HttpError {
-    /**
-     * @example Extend via
-     * MyError extends HttpError {
-     *  static errorKeys = HttpError.errorKeys.concat([
-     *    `key1`,
-     *    `key2`
-     *  ])
-     * }
-     *
-     * @type {Array}
-     */
-    static errorKeys: any[];
-    /**
-     * Default error string if no error can be extracted from the http response
-     * @type {string}
-     */
-    static defaultMessage: string;
-    /**
-     * Parses HttpResponse objects for useful information (status, headers, etc)
-     * as well as attempting to extract a useful error message.
-     * @param {HttpResponse} res
-     * @returns {string}
-     */
-    parse(res: HttpResponse): string;
-    /**
-     * Recursively parses an error body looking for a likely error candidate
-     * @param {object} body
-     * @returns {string}
-     */
-    parseObject(body: object): string;
-}
-declare namespace HttpError {
-    export { makeSubTypes };
-}
-export default HttpError;
-import makeSubTypes from "./http-error-subtypes";

package/dist/types/index.d.ts

@@ -1,7 +0,0 @@
-export const defaults: import("lodash").CurriedFunction1<any, Promise<any>>;
-export const request: Promise<any>;
-export { default as ProgressEvent } from "./progress-event";
-export { default as Interceptor } from "./lib/interceptor";
-export { default as HttpError } from "./http-error";
-export { default as HttpStatusInterceptor } from "./interceptors/http-status";
-export { default as detect } from "./lib/detect";

package/dist/types/interceptors/http-status.d.ts

@@ -1,17 +0,0 @@
-/**
- * @class
- */
-export default class HttpStatusInterceptor extends Interceptor {
-    /**
-     * @param {Object} options
-     * @returns {HttpStatusInterceptor}
-     */
-    static create(options: any): HttpStatusInterceptor;
-    /**
-     * @param {Object} webex
-     * @param {Object} options
-     * @returns {HttpStatusInterceptor}
-     */
-    constructor(webex: any, options: any);
-}
-import Interceptor from "../lib/interceptor";

package/dist/types/lib/detect.d.ts

@@ -1,6 +0,0 @@
-/**
- * Determine mimeType for the specified buffer;
- * @param {Buffer|Uint8Array|ArrayBuffer} buffer
- * @returns {Promise<string>}
- */
-export default function detect(buffer: Buffer | Uint8Array | ArrayBuffer): Promise<string>;

package/dist/types/lib/interceptor.d.ts

@@ -1,51 +0,0 @@
-/**
- * @class
- */
-export default class Interceptor {
-    /**
-     * @abstract
-     * @returns {Interceptor}
-     */
-    static create(): Interceptor;
-    /**
-     * @constructor
-     * @param {Object} attrs
-     * @returns {UrlInterceptor}
-     */
-    constructor(attrs: any);
-    /**
-     * Logs the options of a request. This should be utilized
-     * during the intercepting process, but can be used at any
-     * time otherwise.
-     * @param {object} options
-     * @returns {void}
-     */
-    logOptions(options?: object): void;
-    /**
-     * Transform request options before sending them
-     * @param {Object} options
-     * @returns {Promise<Object>}
-     */
-    onRequest(options: any): Promise<any>;
-    /**
-     * Handle request failures
-     * @param {Object} options
-     * @param {Error} reason
-     * @returns {RejectedPromise<Error>}
-     */
-    onRequestError(options: any, reason: Error): RejectedPromise<Error>;
-    /**
-     * Transform response before returning it
-     * @param {Object} options
-     * @param {HttpResponse} response
-     * @returns {Promise<HttpResponse>}
-     */
-    onResponse(options: any, response: HttpResponse): Promise<HttpResponse>;
-    /**
-     * Handle response errors
-     * @param {Object} options
-     * @param {WebexHttpError} reason
-     * @returns {Promise<WebexHttpError>}
-     */
-    onResponseError(options: any, reason: WebexHttpError): Promise<WebexHttpError>;
-}

package/dist/types/lib/xhr.d.ts

@@ -1,6 +0,0 @@
-export default createXHR;
-declare function createXHR(uri: any, options: any, callback: any): any;
-declare namespace createXHR {
-    const XMLHttpRequest: any;
-    const XDomainRequest: any;
-}

package/dist/types/progress-event.d.ts

@@ -1,18 +0,0 @@
-/**
- * Object of the same shape as web browser ProgressEvents
- * @class ProgressEvent
- * @param {integer} loaded
- * @param {integer} total
- * @returns {ProgressEvent}
- */
-export default function ProgressEvent(loaded: integer, total: integer): ProgressEvent;
-export default class ProgressEvent {
-    /**
-     * Object of the same shape as web browser ProgressEvents
-     * @class ProgressEvent
-     * @param {integer} loaded
-     * @param {integer} total
-     * @returns {ProgressEvent}
-     */
-    constructor(loaded: integer, total: integer);
-}

package/dist/types/request/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * @param {Object} options
- * @returns {Promise}
- */
-export default function request(options: any): Promise<any>;

package/dist/types/request/request.d.ts

@@ -1,6 +0,0 @@
-/**
- * @name request
- * @param {Object} options
- * @returns {Promise}
- */
-export default function _request(options: any): Promise<any>;

package/dist/types/request/request.shim.d.ts

@@ -1,6 +0,0 @@
-/**
- * @name request
- * @param {Object} options
- * @returns {Promise}
- */
-export default function _request(options: any): Promise<any>;