@akanass/rx-http-request
Version:
The world-famous HTTP client Request now RxJS compliant, wrote in Typescript | ES6 for client and server side.
238 lines • 7.91 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
// import libraries
const request = require("request");
const buffer_1 = require("buffer");
const rxjs_1 = require("rxjs");
const operators_1 = require("rxjs/operators");
const rx_cookie_jar_1 = require("./rx-cookie-jar");
/**
* Class definition
*/
class RxHttpRequest {
/**
* Returns singleton instance
*
* @return {RxHttpRequest}
*/
static instance() {
if (!(RxHttpRequest._instance instanceof RxHttpRequest)) {
RxHttpRequest._instance = new RxHttpRequest(request);
}
return RxHttpRequest._instance;
}
/**
* Class constructor
*/
constructor(req) {
// check request parameter
this._checkRequestParam(req);
// set request object
this._request = req;
}
/**
* Returns private attribute _request
*
* @return {RequestAPI<Request, CoreOptions, RequiredUriUrl>}
*/
get request() {
return this._request;
}
/**
* This method returns a wrapper around the normal rx-http-request API that defaults to whatever options
* you pass to it.
* It does not modify the global rx-http-request API; instead, it returns a wrapper that has your default settings
* applied to it.
* You can _call .defaults() on the wrapper that is returned from rx-http-request.defaults to add/override defaults
* that were previously defaulted.
*
* @param options
*
* @return {RxHttpRequest}
*/
defaults(options) {
return new RxHttpRequest(this._request.defaults(options));
}
/**
* Function to do a GET HTTP request
*
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*/
get(uri, options) {
return this._call('get', uri, Object.assign({}, options || {}));
}
/**
* Function to do a GET HTTP request and to return a buffer
*
* @param uri
* @param options
*
* @return {Observable<RxHttpRequestResponse<Buffer>>}
*/
getBuffer(uri, options) {
return new rxjs_1.Observable((observer) => {
try {
this._request.get(uri, Object.assign({}, options || {}))
.on('response', (response) => {
let res;
response.on('data', (data) => res = res ? buffer_1.Buffer.concat([].concat(res, data)) : data);
response.on('end', () => {
observer.next(Object.assign({}, {
response: response,
body: res
}));
observer.complete();
});
})
.on('error', /* istanbul ignore next */ /* istanbul ignore next */ error => observer.error(error));
}
catch (error) {
observer.error(error);
}
});
}
/**
* Function to do a POST HTTP request
*
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*/
post(uri, options) {
return this._call('post', uri, Object.assign({}, options || {}));
}
/**
* Function to do a PUT HTTP request
*
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*/
put(uri, options) {
return this._call('put', uri, Object.assign({}, options || {}));
}
/**
* Function to do a PATCH HTTP request
*
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*/
patch(uri, options) {
return this._call('patch', uri, Object.assign({}, options || {}));
}
/**
* Function to do a DELETE HTTP request
*
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*/
delete(uri, options) {
return this._call('del', uri, Object.assign({}, options || {}));
}
/**
* Function to do a HEAD HTTP request
*
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*/
head(uri, options) {
return this._call('head', uri, Object.assign({}, options || {}));
}
/**
* Function to do a OPTIONS HTTP request
*
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*/
options(uri, options) {
return this._call('options', uri, Object.assign({}, options || {}));
}
/**
* Function that creates a new rx cookie jar
*
* @return {Observable<RxCookieJar>}
*/
jar() {
return rxjs_1.of(new rx_cookie_jar_1.RxCookieJar(this._request.jar()));
}
/**
* Function that creates a new cookie
*
* @param str {string}
*
* @return {Observable<Cookie>}
*/
cookie(str) {
return rxjs_1.of(this._request.cookie(str));
}
/**
* Function to do a HTTP request for given method
*
* @param method {string}
* @param uri {string}
* @param options {CoreOptions}
*
* @return {Observable<RxHttpRequestResponse<R>>}
*
* @private
*/
_call(method, uri, options) {
return new rxjs_1.Observable((observer) => {
rxjs_1.of([].concat(uri, Object.assign({}, options || {}), ((error, response, body) => {
rxjs_1.of(rxjs_1.of(error))
.pipe(operators_1.flatMap(obsError => rxjs_1.merge(obsError
.pipe(operators_1.filter(_ => !!_), operators_1.tap(err => observer.error(err))), obsError
.pipe(operators_1.filter(_ => !_), operators_1.flatMap(() => !!response ?
rxjs_1.of(response) :
rxjs_1.throwError(new Error('No response found'))), operators_1.flatMap(_ => rxjs_1.of({
response: _,
body: body
})), operators_1.tap(_ => observer.next(_)), operators_1.tap(() => observer.complete())))))
.subscribe(() => undefined, err => observer.error(err));
})))
.pipe(operators_1.map(_ => this._request[method].apply(this._request, _)))
.subscribe(() => undefined, err => observer.error(err));
});
}
/**
* Function to check existing function in request API passed in parameter for a new instance
*
* @param req {RequestAPI<Request, CoreOptions, RequiredUriUrl>}
*
* @private
*/
_checkRequestParam(req) {
// check existing function in API
if (!req ||
Object.prototype.toString.call(req.get) !== '[object Function]' ||
Object.prototype.toString.call(req.head) !== '[object Function]' ||
Object.prototype.toString.call(req.post) !== '[object Function]' ||
Object.prototype.toString.call(req.put) !== '[object Function]' ||
Object.prototype.toString.call(req.patch) !== '[object Function]' ||
Object.prototype.toString.call(req.del) !== '[object Function]' ||
Object.prototype.toString.call(req.defaults) !== '[object Function]' ||
Object.prototype.toString.call(req.jar) !== '[object Function]' ||
Object.prototype.toString.call(req.cookie) !== '[object Function]') {
throw new TypeError('Parameter must be a valid `request` module API');
}
}
}
exports.RxHttpRequest = RxHttpRequest;
/**
* Export {RxHttpRequest} instance
*/
exports.RxHR = RxHttpRequest.instance();
//# sourceMappingURL=rx-http-request.js.map