@jeli/http
Version:
jeli-js http
326 lines (311 loc) • 9.9 kB
JavaScript
import { ChangeDetector, Subject, InterceptorResolver, ProviderToken} from '@jeli/core';
import { inarray, isobject, isundefined, isstring, isnull} from '@jeli/helpers';
import { serialize} from '@jeli/helpers/utils';
var __buildOptions = {};
function HttpRequestError(message) {
this.errorType = null;
this.message = message;
this.status = 400;
}
HttpRequestError.prototype.setMessage = function (message) {
this.message = message;
};
HttpRequestError.prototype.setErrorType = function (type) {
this.errorType = type;
};
var unsafeHeaders = {
'Accept-Charset': true,
'Accept-Encoding': true,
'Connection': true,
'Content-Length': true,
'Cookie': true,
'Cookie2': true,
'Content-Transfer-Encoding': true,
'Date': true,
'Expect': true,
'Host': true,
'Keep-Alive': true,
'Referer': true,
'TE': true,
'Trailer': true,
'Transfer-Encoding': true,
'Upgrade': true,
'User-Agent': true,
'Via': true
};
function HttpRequest(url, options) {
if (!options && isobject(url)) {
options = url;
}
this.url = options.url || url;
this.type = (options.type || 'GET').toLowerCase();
this.processData = !isundefined(option.processData) ? option.processData : true;
this.headers = Object.assign({
'Accept': 'application/json',
'CONTENT-TYPE': 'application/json'
}, options.headers || {});
this.asynchronous = !isundefined(option.asynchronous) ? option.asynchronous : true;
this.data = options.data || '';
this.xhrInstance = new XMLHttpRequest();
this.cache = !isundefined(options.cache) ? options.cache : true;
}
HttpRequest.prototype.progress = function (progressCallback) {
this.xhrInstance.addEventListener('progress', progressCallback, false);
};
HttpRequest.prototype.setHeaders = function (headers) {
Object.assign(this.headers, headers);
};
HttpRequest.prototype.processRequest = function () {
this.processData = false;
if (!isstring(this.data)) {
if (this.type === 'get') {
this.data = serialize(this.data);
} else {
this.data = JSON.stringify(this.data);
}
}
if (this.type === 'get') {
if (this.data) {
this.url += (/\?/.test(this.url) ? '&' : '?') + this.data;
}
if (!this.cache) {
this.url += (/\?/.test(this.url) ? '&' : '?') + '_=' + Date.now();
}
}
};
HttpRequest.prototype.processRequestHeaders = function () {
for (var name in this.headers) {
if (unsafeHeaders[name] || /^(Sec-|Proxy-)/.test(name)) {
throw new Error('Refused to set unsafe header "' + name + '"');
}
this.xhrInstance.setRequestHeader(name, this.headers[name]);
}
};
function HttpResponse(httpRequest) {
this.status = httpRequest.xhrInstance.status;
this.readyState = httpRequest.xhrInstance.readyState;
this.url = httpRequest.url;
this.data = null;
this.success = httpRequest.xhrInstance.status >= 200 && httpRequest.xhrInstance.status < 300 || httpRequest.xhrInstance.status == 304 || httpRequest.xhrInstance.status == 0 && httpRequest.xhrInstance.responseText;
this.headers = Object({
getResponseHeader: function (name) {
if (!isobject(name)) {
return httpRequest.xhrInstance.getResponseHeader(name);
} else {
return name.map(httpRequest.xhrInstance.getResponseHeader);
}
}
});
}
var HTTP_INTERCEPTORS = new ProviderToken('interceptors', true);
function parseJSON(response) {
var content;
var tError = !!response;
try {
content = JSON.parse(response);
} catch (e) {
if (tError) {
throw new Error(e);
} else {
content = response;
}
}
return content;
}
function CoreHttp(url, options, changeDetection) {
var xhrPromise = new Subject();
var httpRequest = new HttpRequest(url, options);
var httpError = new HttpRequestError('');
InterceptorResolver(HTTP_INTERCEPTORS, httpRequest).then(function (request) {
if (!request) {
httpError.setMessage('HTTP: Interceptor should return a value');
return xhrPromise.error(httpError);
}
if (changeDetection) {
changeDetection();
}
if (request.processData) {
request.processRequest();
}
sendRequest();
});
function respondToReadyState() {
var response = new HttpResponse(httpRequest);
if (httpRequest.xhrInstance.readyState == 4) {
try {
var data = parseJSON(httpRequest.xhrInstance.responseText);
xhrPromise.next(data, response);
} catch (e) {
xhrPromise.error(httpError);
}
xhrPromise.completed();
changeDetection();
}
}
function attachListener() {
httpRequest.xhrInstance.addEventListener('load', respondToReadyState);
httpRequest.xhrInstanceaddEventListener('timeout', handleError);
httpRequest.xhrInstance.addEventListener('error', handleError);
httpRequest.xhrInstance.addEventListener('abort', handleError);
function handleError(e) {
httpError.setErrorType(e.type);
xhrPromise.error(httpError);
}
}
function sendRequest() {
attachListener();
httpRequest.xhrInstance.open(httpRequest.type, httpRequest.url, httpRequest.asynchronous);
httpRequest.processRequestHeaders();
var body = null;
if (inarray(httpRequest.type, [
'post',
'put',
'delete'
])) {
body = httpRequest.data;
}
try {
httpRequest.xhrInstance.send(body);
} catch (e) {
httpError.setMessage(e);
xhrPromise.error(httpError);
}
}
return xhrPromise;
}
var staticMethods = [
'put',
'get',
'post',
'request',
'patch',
'delete'
];/** compiled HttpService **/
var HttpService = function(){
;
function HttpService(changeDetector) {
function http(url, options) {
return CoreHttp(url, options, changeDetector);
}
function generateOptionalHTTP(type) {
http[type] = function (url, data, headers) {
var options = {};
options.type = type;
options.data = data;
options.headers = headers || {};
return http(url, options);
};
}
staticMethods.forEach(generateOptionalHTTP);
return http;
}
HttpService.ctors = {
DI: [
ChangeDetector
]
};
return HttpService;
}();
/** compiled HttpModule **/
var HttpModule = function(){
;
function HttpModule() {
}
return HttpModule;
}();
/** compiled HttpCookieManager **/
var HttpCookieManager = function(){
;
function HttpCookieManager() {
Object.defineProperty(this, 'cookies', {
get: function () {
return this._getAll();
}
});
}
;
HttpCookieManager.prototype.set = function (name, value, options) {
if (!isnull(value) && !isundefined(value)) {
if (value === null) {
value = '';
options.expires = -1;
}
var expires = '';
var isNumberExpires = typeof options.expires === 'number';
if (options.expires && (isNumberExpires || options.expires.toUTCString)) {
var date;
if (isNumberExpires) {
date = new Date();
date.setTime(date.getTime() + options.expires * 24 * 60 * 60 * 1000);
} else {
date = options.expires;
}
expires = '; expires=' + date.toUTCString();
}
var path = options.path ? '; path=' + options.path : '';
var domain = options.domain ? '; domain=' + options.domain : '';
var secure = options.secure ? '; secure' : '';
document.cookie = [
name,
'=',
encodeURIComponent(value),
expires,
path,
domain,
secure
].join('');
}
};
HttpCookieManager.prototype.get = function (name) {
return this.cookies[name];
};
HttpCookieManager.prototype._getAll = function () {
var cookieValues = {};
var cookies = (document.cookie || '').split(';');
if (cookies.length) {
for (var i = 0; i < cookies.length; i++) {
var cookie = cookies[i].trim().split('=');
cookieValues[cookie[0]] = cookie[1];
}
}
return cookieValues;
};
HttpCookieManager.ctors = {};
return HttpCookieManager;
}();
var csrfCookieConfig = {
cookieName: 'X-CSRF-TOKEN',
headerName: 'X-CSRF-TOKEN'
};/** compiled CSRFCookieHeaderService **/
var CSRFCookieHeaderService = function(){
;
function CSRFCookieHeaderService(cookieManager) {
this.resolve = function (httpRequest, next) {
var cookie = cookieManager.get(csrfCookieConfig.cookieName);
if (cookie) {
var tokenHeader = {};
tokenHeader[csrfCookieConfig.headerName] = cookie;
httpRequest.setHeaders(tokenHeader);
}
next();
};
}
CSRFCookieHeaderService.ctors = {
DI: [
HttpCookieManager
]
};
return CSRFCookieHeaderService;
}();
/** compiled HttpCSRFModule **/
var HttpCSRFModule = function(){
;
function HttpCSRFModule() {
}
HttpCSRFModule.setCookieValue = function (config) {
Object.assign(csrfCookieConfig, config);
};
HTTP_INTERCEPTORS.register({useClass: CSRFCookieHeaderService}, true);
return HttpCSRFModule;
}();
export { HttpModule , HttpService , HttpRequestError , HttpRequest , HttpResponse , HTTP_INTERCEPTORS , HttpCSRFModule , HttpCookieManager , csrfCookieConfig , CSRFCookieHeaderService }