@playkit-js/playkit-js-providers 2.40.1 → 2.40.2-canary.0-45b4098

package/src/util/request-builder.ts

@@ -0,0 +1,187 @@
+import Error from './error/error';
+import {ProviderNetworkRetryParameters} from '../types';
+
+const KALTURA_HEADER_PREFIX: string = 'x-';
+
+export default class RequestBuilder {
+  /**
+   * @member - Service name
+   * @type {string}
+   */
+  public service!: string;
+  /**
+   * @member - Service action
+   * @type {string}
+   */
+  public action!: string;
+  /**
+   * @member - Service params
+   * @type {any}
+   */
+  public params: any;
+  /**
+   * @memberof - Service headers
+   * @type {Map<string, string>}
+   */
+  public headers: Map<string, string>;
+  /**
+   * @memberof - Service URL
+   * @type {string}
+   */
+  public url!: string;
+  /**
+   * @memberof - Service method (POST,GET,DELETE etc..)
+   * @type {string}
+   */
+  public method!: string;
+  /**
+   * @memberof - Service tag
+   * @type {string}
+   */
+  public tag!: string;
+  /**
+   * @memberof - the response headers of the arra
+   * @type {Array<string>}
+   */
+  public responseHeaders!: Array<string>;
+  /**
+   * @description network retry configuration
+   * @memberof RequestBuilder
+   * @type {ProviderNetworkRetryParameters}
+   */
+  public retryConfig: ProviderNetworkRetryParameters = {
+    async: true,
+    timeout: 0,
+    maxAttempts: 4
+  };
+
+  /**
+   * @description number of xhr attempts for the same multi - request.
+   * @memberof RequestBuilder
+   * @type {number}
+   * @private
+   */
+  private _attemptCounter: number = 1;
+
+  /**
+   * @description hold the promise result of the XHR request(s) - if all tries fails, it rejects with the error.
+   * @memberof RequestBuilder
+   * @type {Object}
+   * @private
+   */
+  private _requestPromise: any;
+
+  /**
+   * @constructor
+   * @param {Map<string, string>} headers The request headers
+   */
+  constructor(headers: Map<string, string> = new Map()) {
+    this.headers = headers;
+  }
+
+  /**
+   * Builds restful service URL
+   * @function getUrl
+   * @param {string} serviceUrl - The service base URL
+   * @returns {string} The service URL
+   */
+  public getUrl(serviceUrl: string): string {
+    return serviceUrl + '/service/' + this.service + (this.action ? '/action/' + this.action : '');
+  }
+
+  /**
+   * Executes service
+   * @function doHttpRequest
+   * @returns {Promise.<any>} Service response as promise
+   */
+  public doHttpRequest(): Promise<any> {
+    const promise = new Promise((resolve, reject) => {
+      this._requestPromise = {
+        resolve,
+        reject
+      };
+    });
+    if (!this.url) {
+      this._requestPromise.reject(
+        new Error(Error.Severity.CRITICAL, Error.Category.NETWORK, Error.Code.MALFORMED_DATA_URI, {
+          url: this.url
+        })
+      );
+    }
+    this._createXHR();
+    return promise;
+  }
+
+  private _createXHR(): void {
+    const request = new XMLHttpRequest();
+    request.onreadystatechange = (): void => {
+      if (request.readyState === 4) {
+        if (request.status === 200) {
+          try {
+            const response = JSON.parse(request.responseText);
+            this.responseHeaders = this._getResponseHeaders(request);
+            // the promise returns the response for backwards compatibility
+            return this._requestPromise.resolve(response);
+          } catch (error) {
+            this._requestPromise.reject(
+              this._createError(request, Error.Code.BAD_SERVER_RESPONSE, {
+                text: request.responseText
+              })
+            );
+          }
+        }
+      }
+    };
+    request.open(this.method, this.url, this.retryConfig.async);
+    if (this.retryConfig.async && this.retryConfig.timeout) {
+      request.timeout = this.retryConfig.timeout;
+    }
+    const requestTime = performance.now();
+    request.ontimeout = (): void => {
+      this._handleError(request, Error.Code.TIMEOUT, {
+        timeout: (performance.now() - requestTime) / 1000,
+        statusText: request.statusText
+      });
+    };
+    request.onerror = request.onabort = (): void => {
+      this._handleError(request, Error.Code.HTTP_ERROR, {
+        text: request.responseText,
+        statusText: request.statusText
+      });
+    };
+    this.headers.forEach((value, key) => {
+      request.setRequestHeader(key, value);
+    });
+    request.send(this.params);
+  }
+
+  private _getResponseHeaders(request: XMLHttpRequest): Array<string> {
+    return request
+      .getAllResponseHeaders()
+      .split('\n')
+      .filter(header => header.toLowerCase().indexOf(KALTURA_HEADER_PREFIX) === 0);
+  }
+
+  private _handleError(request: XMLHttpRequest, code: number, data: any): Promise<void> | void {
+    const error = this._createError(request, code, data);
+    request.onreadystatechange = function (): void {};
+    request.onerror = function (): void {};
+    request.ontimeout = function (): void {};
+    request.onabort = function (): void {};
+    if (this.retryConfig.maxAttempts && this._attemptCounter < this.retryConfig.maxAttempts) {
+      this._attemptCounter++;
+      this._createXHR();
+    } else {
+      return this._requestPromise.reject(error);
+    }
+  }
+
+  private _createError(request: XMLHttpRequest, code: number, data: any): Error {
+    Object.assign(data, {
+      url: this.url,
+      headers: this._getResponseHeaders(request),
+      attempt: this._attemptCounter
+    });
+    return new Error(Error.Severity.CRITICAL, Error.Category.NETWORK, code, data);
+  }
+}

package/src/util/xml-parser.ts

@@ -0,0 +1,39 @@
+export default class XmlParser {
+  /**
+   * Parses xml string to json object
+   * @param {string} xml The xml to parse
+   * @returns {{}} The parsed xml as Json object
+   * @static
+   */
+  public static xmlToJson(xml: Document | ChildNode): any {
+    let obj: any = {};
+    if (xml.nodeType === 1) {
+      if (xml['attributes'].length > 0) {
+        obj['@attributes'] = {};
+        for (let j = 0; j < xml['attributes'].length; j++) {
+          const attribute = xml['attributes'].item(j);
+          obj['@attributes'][attribute.nodeName] = attribute.nodeValue;
+        }
+      }
+    } else if (xml.nodeType === 3) {
+      obj = xml.nodeValue;
+    }
+    if (xml.hasChildNodes()) {
+      for (let i = 0; i < xml.childNodes.length; i++) {
+        const item = xml.childNodes.item(i);
+        const nodeName = item.nodeName;
+        if (typeof obj[nodeName] === 'undefined') {
+          obj[nodeName] = this.xmlToJson(item);
+        } else {
+          if (typeof obj[nodeName].push === 'undefined') {
+            const old = obj[nodeName];
+            obj[nodeName] = [];
+            obj[nodeName].push(old);
+          }
+          obj[nodeName].push(this.xmlToJson(item));
+        }
+      }
+    }
+    return obj;
+  }
+}