@zeroid/trimble.httpclient/HttpClient.js

The base HttpClient implementation

'use strict';
// implements IHttpClient
(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        // AMD
        define([], factory);
    } else if (typeof exports === 'object') {
        // CommonJS
        module.exports = factory();
    } else {
        // Browser globals (Note: root is window)
        root.HttpClient = factory();
    }
}(this, function () {

    var _httpClient = function (baseAddress = null, defaultSettings = {}) {
        this._baseAddress = baseAddress;
        this._defaultSettings = defaultSettings;
    }

    var _calculateAddress = function (baseAddress, relativeAddress) {
        if (!baseAddress) return relativeAddress;
        if (!relativeAddress) return baseAddress;
        if (relativeAddress.includes('://')) return relativeAddress; // relativeAddress is an absolute address
        if (relativeAddress.startsWith('/')) {
            // todo
        }
        return baseAddress + (baseAddress.endsWith('/') ? '' : '/') + relativeAddress;
    }

    var _combineSettings = function (defaultSettings, requestSettings) {
        return Object.assign(requestSettings, defaultSettings);        
    }

    _httpClient.prototype.httpPost = function (relativeAddress, value = null, requestSettings = {}) {
        var self = this;
        return new Promise(function (resolve, reject) {
            var xmlHttp = new XMLHttpRequest();
            xmlHttp.onreadystatechange = function () {
                if (xmlHttp.readyState == 4) {
                    if (xmlHttp.status == 200)
                        resolve(xmlHttp.responseText);
                    else
                        reject();
                }
            }
            xmlHttp.open("POST", _calculateAddress(self._baseAddress, relativeAddress), true); // true for asynchronous
            var settings = _combineSettings(self._defaultSettings, requestSettings);
            if (settings && settings.headers) {
                for (var header in settings.headers) {
                    xmlHttp.setRequestHeader(header, settings.headers[header]);
                }
            }
            xmlHttp.send(value);
        });
    }

    _httpClient.prototype.httpGet = function (relativeAddress, requestSettings = {}) {
        var self = this;
        return new Promise(function (resolve, reject) {
            var xmlHttp = new XMLHttpRequest();
            xmlHttp.onreadystatechange = function () {
                if (xmlHttp.readyState == 4) {
                    if (xmlHttp.status == 200)
                        resolve(xmlHttp.responseText);
                    else
                        reject();
                }
            }
            xmlHttp.open("GET", _calculateAddress(self._baseAddress, relativeAddress), true); // true for asynchronous
            var settings = _combineSettings(self._defaultSettings, requestSettings);
            if (settings && settings.headers) {
                for (var header in settings.headers) {
                    xmlHttp.setRequestHeader(header, settings.headers[header]);
                }
            }
            xmlHttp.send(null);
        });
    }

    _httpClient.prototype.httpPut = function (relativeAddress, value = null, requestSettings = {}) {
        var self = this;
        return new Promise(function (resolve, reject) {
            var xmlHttp = new XMLHttpRequest();
            xmlHttp.onreadystatechange = function () {
                if (xmlHttp.readyState == 4) {
                    if (xmlHttp.status == 200)
                        resolve(xmlHttp.responseText);
                    else
                        reject();
                }
            }
            xmlHttp.open("PUT", _calculateAddress(self._baseAddress, relativeAddress), true); // true for asynchronous
            var settings = _combineSettings(self._defaultSettings, requestSettings);
            if (settings && settings.headers) {
                for (var header in settings.headers) {
                    xmlHttp.setRequestHeader(header, settings.headers[header]);
                }
            }
            xmlHttp.send(value);
        });
    }

    _httpClient.prototype.httpDelete = function (relativeAddress, requestSettings = {}) {
        var self = this;
        return new Promise(function (resolve, reject) {
            var xmlHttp = new XMLHttpRequest();
            xmlHttp.onreadystatechange = function () {
                if (xmlHttp.readyState == 4) {
                    if (xmlHttp.status == 200)
                        resolve(xmlHttp.responseText);
                    else
                        reject();
                }
            }
            xmlHttp.open("DELETE", _calculateAddress(self._baseAddress, relativeAddress), true); // true for asynchronous
            var settings = _combineSettings(self._defaultSettings, requestSettings);
            if (settings && settings.headers) {
                for (var header in settings.headers) {
                    xmlHttp.setRequestHeader(header, settings.headers[header]);
                }
            }
            xmlHttp.send(null);
        });
    }

    _httpClient.prototype.httpPostJSON = function (relativeUrl, value, requestSettings = {}) {
        var self = this;
        return new Promise((resolve, reject) => {
            var settings = _combineSettings(requestSettings, 
                { 
                    headers: { 
                        "content-type": 'application/json',
                        accept: 'application/json'
                    }
                });
            self.httpPost(relativeUrl, json, settings)
                .then((json) => {
                    resolve(JSON.parse(json));
                })
                .catch(() => { reject(); });
        });
    }

    _httpClient.prototype.httpGetJSON = function (relativeUrl, requestSettings = {}) {
        var self = this;
        return new Promise((resolve, reject) => {
            var settings = _combineSettings(requestSettings, { headers: { accept: 'application/json' } });
            self.httpGet(relativeUrl, settings)
                .then((json) => {
                    resolve(JSON.parse(json));
                })
                .catch(() => { reject(); });
        });
    }

    _httpClient.prototype.httpPutJSON = function (relativeUrl, value, requestSettings = {}) {
        var self = this;
        return new Promise((resolve, reject) => {
            var settings = _combineSettings(requestSettings, 
                { 
                    headers: { 
                        "content-type": 'application/json',
                        accept: 'application/json'
                    }
                });
            self.httpPut(relativeUrl, json, settings)
                .then((json) => {
                    resolve(JSON.parse(json));
                })
                .catch(() => { reject(); });
        });
    }

    // Exposed public methods
    return _httpClient;
}));