ngx-http-client-service
Version:
<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section --> [](#contributors-) <!-- ALL-CONTRIBUTORS-BADGE:END -->
566 lines (530 loc) • 27.3 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common/http')) :
typeof define === 'function' && define.amd ? define('ngx-http-client-service', ['exports', '@angular/core', '@angular/common/http'], factory) :
(global = global || self, factory(global['ngx-http-client-service'] = {}, global.ng.core, global.ng.common.http));
}(this, (function (exports, core, http) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __createBinding(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}
function __exportStar(m, exports) {
for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result.default = mod;
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
var NgxHttpParams = /** @class */ (function () {
function NgxHttpParams() {
}
return NgxHttpParams;
}());
var NgxHttpHeaders = /** @class */ (function () {
function NgxHttpHeaders() {
}
return NgxHttpHeaders;
}());
var HttpOptions = /** @class */ (function () {
function HttpOptions() {
}
return HttpOptions;
}());
var NgxHttpOptions = /** @class */ (function () {
function NgxHttpOptions() {
}
return NgxHttpOptions;
}());
/**
* Injectable Http Options Service
*/
var HttpOptionsService = /** @class */ (function () {
/**
* @description Creates an instance of http options service.
*/
function HttpOptionsService() {
}
/**
* @description appendHttpParams is a common method.
* @param httpParam contains an object of NgxHttpParams.
* @returns returns constructed httpParameters of type HttpParam
*/
HttpOptionsService.prototype.appendHttpParams = function (ngxHttpParams) {
var httpParams = new http.HttpParams();
Object.entries(ngxHttpParams).forEach(function (_a) {
var _b = __read(_a, 2), param = _b[0], paramValue = _b[1];
if (param && paramValue.toString()) {
httpParams = httpParams.append(param, paramValue.toString());
}
});
return httpParams;
};
/**
* @description appendHttpHeaders is a common method.
* @param headers contains an object of NgxHttpHeaders.
* @returns returns constructed httpParameters of type HttpParam
*/
HttpOptionsService.prototype.appendHttpHeaders = function (ngxHttpHeaders) {
var httpHeaders = new http.HttpHeaders();
Object.entries(ngxHttpHeaders).forEach(function (_a) {
var _b = __read(_a, 2), header = _b[0], headerValue = _b[1];
if (header && headerValue.toString()) {
httpHeaders = httpHeaders.append(header, headerValue.toString());
}
});
return httpHeaders;
};
/**
* @description provides the http options.
* @param httpOptionsParameters contains params of type NgxHttpOptions.
* @returns returns appendd http options.
*/
HttpOptionsService.prototype.appendHttpOptions = function (httpOptionsParameters) {
if (!httpOptionsParameters) {
httpOptionsParameters = new NgxHttpOptions();
httpOptionsParameters.header = {};
httpOptionsParameters.param = {};
}
var httpOptions = new HttpOptions();
if (httpOptionsParameters.param) {
httpOptions.params = this.appendHttpParams(httpOptionsParameters.param);
}
else {
httpOptions.params = this.appendHttpParams({});
}
if (httpOptionsParameters.header) {
httpOptions.headers = this.appendHttpHeaders(httpOptionsParameters.header);
}
else {
httpOptions.headers = this.appendHttpHeaders({});
}
if (httpOptionsParameters.observe) {
httpOptions.observe = httpOptionsParameters.observe;
}
if (httpOptionsParameters.reportProgress) {
httpOptions.reportProgress = httpOptionsParameters.reportProgress;
}
if (httpOptionsParameters.responseType) {
httpOptions.responseType = httpOptionsParameters.responseType;
}
if (httpOptionsParameters.withCredentials) {
httpOptions.withCredentials = httpOptionsParameters.withCredentials;
}
return httpOptions;
};
HttpOptionsService.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function HttpOptionsService_Factory() { return new HttpOptionsService(); }, token: HttpOptionsService, providedIn: "root" });
HttpOptionsService = __decorate([
core.Injectable({
providedIn: 'root'
})
/** HttpOptionsService where all http options creations methods are defined
* It can contains http params and http headers creation functionality
*/
], HttpOptionsService);
return HttpOptionsService;
}());
var ApiPathConstants = /** @class */ (function () {
function ApiPathConstants() {
}
ApiPathConstants.PATH_BASE = '/';
ApiPathConstants.PATH_DIVIDER = '/';
ApiPathConstants.QUERY_SPECIFIER = '?';
ApiPathConstants.QUERY_DIVIDER = '&';
ApiPathConstants.QUERY_ASSIGNER = '=';
ApiPathConstants.BASIC_HEADER = {};
return ApiPathConstants;
}());
/**
* Injectable Http Options Service
*/
var ApiPathService = /** @class */ (function () {
/**
* @description creates an instance of APIPathGenerationLibrary
*/
function ApiPathService() {
// Common Constants
this.PATH_BASE = ApiPathConstants.PATH_BASE;
this.PATH_DIVIDER = ApiPathConstants.PATH_DIVIDER;
this.QUERY_SPECIFIER = ApiPathConstants.QUERY_SPECIFIER;
this.QUERY_DIVIDER = ApiPathConstants.QUERY_DIVIDER;
this.QUERY_ASSIGNER = ApiPathConstants.QUERY_ASSIGNER;
}
/**
* @description validating QueryParam.
* @param pathQuery as an argument of type PathQuery.
* @return constructed PathQuery Object.
*/
ApiPathService.prototype.modifyPathQuery = function (pathQuery) {
var constructedPathQuery = {};
Object.entries(pathQuery).filter(function (_a) {
var _b = __read(_a, 2), query = _b[0], queryValue = _b[1];
if (query) {
constructedPathQuery[query] = queryValue;
}
});
return constructedPathQuery;
};
/**
* @description createApiPath is a constructing method.
* @param pathComponent contains an array of string.
* @returns returns constructed api path url.
*/
ApiPathService.prototype.createApiPath = function (pathComponent) {
var _this = this;
var path = this.PATH_BASE;
pathComponent = pathComponent.filter(function (param) {
return param !== _this.PATH_DIVIDER;
});
path = path + pathComponent.join(this.PATH_DIVIDER);
return encodeURI(path);
};
/**
* @description Returns router parameterized path.
* @param apiPathParams contains partial url.
* @param pathQuery contains parameters to be passed as query parameters.
* @returns returns generated routed paramerized path.
*/
ApiPathService.prototype.createApiPathWithQuery = function (apiPathParams, pathQuery) {
var _this = this;
var path = this.createApiPath(apiPathParams);
if (!pathQuery) {
return path;
}
else {
pathQuery = this.modifyPathQuery(pathQuery);
if (Object.keys(pathQuery).length) {
path = decodeURI(path) + this.QUERY_SPECIFIER;
Object.entries(pathQuery).forEach(function (_a, index) {
var _b = __read(_a, 2), query = _b[0], queryValue = _b[1];
if (Object.keys(pathQuery).length === (index + 1)) {
path = path + query + _this.QUERY_ASSIGNER + queryValue;
}
else {
path = path + query + _this.QUERY_ASSIGNER + queryValue + _this.QUERY_DIVIDER;
}
});
}
return encodeURI(path);
}
};
ApiPathService.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function ApiPathService_Factory() { return new ApiPathService(); }, token: ApiPathService, providedIn: "root" });
ApiPathService = __decorate([
core.Injectable({
providedIn: 'root'
})
/** api url generator Service all reusable and repeated functionalities can be managed
* It can contains common methods and common methods related params.
*/
], ApiPathService);
return ApiPathService;
}());
/**
* @description Injectable Http Client Service
*/
var NgxHttpClientService = /** @class */ (function () {
/**
* @description Creates an instance of http client service.
* @param httpClient - an instance of HttpClient
* @param httpOptionsService - an instance of HttpOptionsService
*/
function NgxHttpClientService(httpClient, httpOptionsService, apiPathService) {
this.httpClient = httpClient;
this.httpOptionsService = httpOptionsService;
this.apiPathService = apiPathService;
}
/**
* @description will expose get method of http client.
* @param pathParams contains path parameters of type string array
* @param HttpOptions contains parameter of type HttpOptions.
*/
NgxHttpClientService.prototype.get = function (pathParams, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.get(apiUrl, options);
};
/**
* @description will expose post method of http client.
* @param pathParams contains path parameters of type string array
* @param HttpOptions contains parameter of type HttpOptions.
* @param body contains parameter for http post body
*/
NgxHttpClientService.prototype.post = function (pathParams, body, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.post(apiUrl, body, options);
};
/**
* @description will expose put method of http client.
* @param pathParams contains path parameters of type string array
* @param HttpOptions contains parameter of type HttpOptions.
* @param body contains parameter for http put body
*/
NgxHttpClientService.prototype.put = function (pathParams, body, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.put(apiUrl, body, options);
};
/**
* @description will expose delete method of http client.
* @param pathParams contains path parameters of type string array
* @param HttpOptions contains parameter of type HttpOptions.
*/
NgxHttpClientService.prototype.delete = function (pathParams, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.delete(apiUrl, options);
};
/**
* @description will expose request method of http client.
* @param method contains the method parameter of type string.
* @param pathParams contains path parameters of type string array.
* @param HttpOptions contains parameter of type HttpOptions.
*/
NgxHttpClientService.prototype.request = function (method, pathParams, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.request(method, apiUrl, options);
};
/**
* @description will expose head method of http client.
* @param pathParams contains path parameters of type string array.
* @param HttpOptions contains parameter of type HttpOptions.
*/
NgxHttpClientService.prototype.head = function (pathParams, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.head(apiUrl, options);
};
/**
* @description will expose jsonp method of http client.
* @param pathParams contains path parameters of type string array.
* @param callbackFn contains parameter of type string.
*/
NgxHttpClientService.prototype.jsonp = function (pathParams, callbackFn) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
return this.httpClient.jsonp(apiUrl, callbackFn);
};
/**
* @description will expose options method of http client.
* @param pathParams contains path parameters of type string array.
* @param HttpOptions contains parameter of type HttpOptions.
*/
NgxHttpClientService.prototype.options = function (pathParams, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.options(apiUrl, options);
};
/**
* @description will expose patch method of http client.
* @param pathParams contains path parameters of type string array.
* @param body of type any.
* @param HttpOptions contains parameter of type HttpOptions.
*/
NgxHttpClientService.prototype.patch = function (pathParams, body, httpOptions) {
var apiUrl = this.apiPathService.createApiPath(pathParams);
var options = this.httpOptionsService.appendHttpOptions(httpOptions);
return this.httpClient.patch(apiUrl, body, options);
};
NgxHttpClientService.ctorParameters = function () { return [
{ type: http.HttpClient },
{ type: HttpOptionsService },
{ type: ApiPathService }
]; };
NgxHttpClientService.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function NgxHttpClientService_Factory() { return new NgxHttpClientService(core.ɵɵinject(http.HttpClient), core.ɵɵinject(HttpOptionsService), core.ɵɵinject(ApiPathService)); }, token: NgxHttpClientService, providedIn: "root" });
NgxHttpClientService = __decorate([
core.Injectable({
providedIn: 'root'
})
/** NgxHttpClientService Library where all reusable and repeated functionalities can be managed
* It can contains common methods and common methods related params.
*/
], NgxHttpClientService);
return NgxHttpClientService;
}());
exports.NgxHttpClientService = NgxHttpClientService;
exports.NgxHttpOptions = NgxHttpOptions;
exports.ɵa = HttpOptionsService;
exports.ɵb = ApiPathService;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=ngx-http-client-service.umd.js.map