ng2-rest/client/rest-request.js

import { __awaiter } from "tslib";
import { Subject } from 'rxjs/Subject';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/takeUntil';
import 'rxjs/add/operator/take';
import * as _ from 'lodash';
import { Models } from './models';
import { RestHeaders } from './rest-headers';
import { Helpers, Level } from 'ng2-logger/browser';
import axios from 'axios';
import { Resource } from './resource.service';
import { Log } from 'ng2-logger/browser';
import { isUndefined } from 'util';
import { RequestCache } from './request-cache';
const log = Log.create('rest-resource', Level.__NOTHING);
const jobIDkey = 'jobID';
//#region mock request
//#endregion
export class RestRequest {
    constructor() {
        this.subjectInuUse = {};
        this.meta = {};
        //#endregion
        this.replaySubjects = {};
    }
    handlerResult(options, sourceRequest) {
        if (isUndefined(options)) {
            options = {};
        }
        const { res, jobid, isArray, method } = options;
        if (typeof res !== 'object')
            throw new Error('[ng2-rest] No resposnse for request. ');
        if (Helpers.isBrowser) {
            res.headers = RestHeaders.from(res.headers);
        }
        // error no internet
        if (res.error) {
            this.subjectInuUse[jobid].error(new Models.HttpResponseError(res.error, res.data, res.headers, res.code));
            return;
        }
        const entity = this.meta[jobid].entity;
        const circular = this.meta[jobid].circular;
        // normal request case
        this.subjectInuUse[jobid].next(new Models.HttpResponse(sourceRequest, res.data, res.headers, res.code, entity, circular, isArray));
        return;
    }
    checkCache(sourceRequest, jobid) {
        const existedInCache = RequestCache.findBy(sourceRequest);
        if (existedInCache) {
            log.i('cache exists', existedInCache);
            this.subjectInuUse[jobid].next(existedInCache);
            return true;
        }
        log.i('cache not exists', existedInCache);
        return false;
    }
    req(url, method, headers, body, jobid, isArray = false, mockHttp) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.checkCache({
                url,
                body,
                isArray,
                method
            }, jobid)) {
                return;
            }
            var response;
            if (mockHttp) {
                if (typeof mockHttp === 'object') {
                    response = {
                        data: mockHttp.data,
                        status: mockHttp.code,
                        headers: mockHttp.headers,
                        statusText: mockHttp.error,
                        config: {}
                    };
                }
                else if (typeof mockHttp === 'function') {
                    const r = mockHttp(url, method, headers, body);
                    response = {
                        data: r.data,
                        status: r.code,
                        headers: r.headers,
                        statusText: r.error,
                        config: {}
                    };
                }
            }
            try {
                if (!response) {
                    response = yield axios({
                        url,
                        method,
                        data: body,
                        responseType: 'text',
                        headers: headers.toJSON()
                    });
                }
                this.handlerResult({
                    res: {
                        code: response.status,
                        data: JSON.stringify(response.data),
                        isArray,
                        jobid,
                        headers: RestHeaders.from(response.headers)
                    },
                    method,
                    jobid,
                    isArray
                }, {
                    url,
                    body,
                    method,
                    isArray,
                });
            }
            catch (catchedError) {
                // console.log('ERROR RESPONESE catchedError typeof ', typeof catchedError)
                // console.log('ERROR RESPONESE catchedError', catchedError)
                if (typeof catchedError === 'object' && catchedError.response && catchedError.response.data) {
                    const err = catchedError.response.data;
                    const msg = catchedError.response.data.message || '';
                    let stack = (err.stack || '').split('\n');
                    Resource['_listenErrors'].next({
                        msg,
                        stack,
                        data: catchedError.response.data
                    });
                }
                const error = (catchedError && catchedError.response) ? `[${catchedError.response.statusText}]: ` : '';
                this.handlerResult({
                    res: {
                        code: (catchedError && catchedError.response) ? catchedError.response.status : undefined,
                        error: `${error}${catchedError.message}`,
                        data: (catchedError && catchedError.response) ? JSON.stringify(catchedError.response.data) : undefined,
                        isArray,
                        jobid,
                        headers: RestHeaders.from(catchedError && catchedError.response && catchedError.response.headers)
                    },
                    method,
                    jobid,
                    isArray
                }, {
                    url,
                    body,
                    isArray,
                    method
                });
            }
        });
    }
    getSubject(method, meta) {
        if (_.isUndefined(this.replaySubjects[meta.endpoint])) {
            log.i(`[getSubject][recreate] (${meta.endpoint}) `);
            this.replaySubjects[meta.endpoint] = {};
        }
        if (_.isUndefined(this.replaySubjects[meta.endpoint][meta.path])) {
            log.i(`[getSubject][recreate] (${meta.endpoint})(${meta.path}) `);
            this.replaySubjects[meta.endpoint][meta.path] = {};
        }
        if (_.isUndefined(this.replaySubjects[meta.endpoint][meta.path][method])) {
            log.i(`[getSubject][recreate] (${meta.endpoint})(${meta.path})(${method}) `);
            this.replaySubjects[meta.endpoint][meta.path][method] = {
                subject: new Subject(),
                data: undefined,
            };
        }
        const replay = this.replaySubjects[meta.endpoint][meta.path][method];
        const id = RestRequest.jobId++;
        replay.id = id;
        const subject = replay.subject;
        subject[jobIDkey] = id;
        this.meta[id] = meta;
        this.subjectInuUse[id] = subject;
        return replay;
    }
    //#region http methods
    metaReq(method, url, body, headers, meta, isArray, mockHttp) {
        const replay = this.getSubject(method, meta);
        replay.data = { url, body, headers, isArray };
        setTimeout(() => this.req(url, method, headers, body, replay.id, isArray, mockHttp));
        const resp = replay.subject.asObservable().take(1).toPromise();
        resp.observable = replay.subject.asObservable();
        resp.cache = RequestCache.findBy({
            body,
            isArray,
            method,
            url
        });
        return resp;
    }
    get(url, body, headers, meta, isArray, mockHttp) {
        return this.metaReq('get', url, body, headers, meta, isArray, mockHttp);
    }
    head(url, body, headers, meta, isArray, mockHttp) {
        return this.metaReq('head', url, body, headers, meta, isArray, mockHttp);
    }
    delete(url, body, headers, meta, isArray, mockHttp) {
        return this.metaReq('delete', url, body, headers, meta, isArray, mockHttp);
    }
    post(url, body, headers, meta, isArray, mockHttp) {
        return this.metaReq('post', url, body, headers, meta, isArray, mockHttp);
    }
    put(url, body, headers, meta, isArray, mockHttp) {
        return this.metaReq('put', url, body, headers, meta, isArray, mockHttp);
    }
    patch(url, body, headers, meta, isArray, mockHttp) {
        return this.metaReq('patch', url, body, headers, meta, isArray, mockHttp);
    }
    jsonp(url, body, headers, meta, isArray, mockHttp) {
        const replay = this.getSubject('jsonp', meta);
        const jobid = replay.id;
        const method = 'jsonp';
        setTimeout(() => {
            if (url.endsWith('/'))
                url = url.slice(0, url.length - 1);
            let num = Math.round(10000 * Math.random());
            let callbackMethodName = "cb_" + num;
            window[callbackMethodName] = (data) => {
                if (this.checkCache({
                    url,
                    body,
                    isArray,
                    method
                }, jobid)) {
                    return;
                }
                this.handlerResult({
                    res: {
                        data, isArray
                    },
                    method,
                    jobid,
                    isArray
                }, {
                    url,
                    body,
                    isArray,
                    method,
                });
            };
            let sc = document.createElement('script');
            sc.src = `${url}?callback=${callbackMethodName}`;
            document.body.appendChild(sc);
            document.body.removeChild(sc);
        });
        // return replay.subject.asObservable();
        const resp = replay.subject.asObservable().take(1).toPromise();
        resp.observable = replay.subject.asObservable();
        resp.cache = RequestCache.findBy({
            body,
            isArray,
            method,
            url
        });
        return resp;
    }
    replay(method, meta) {
        const replay = this.getSubject(method, meta);
        if (!replay.data) {
            console.warn(`Canno replay first ${method} request from ${meta.endpoint}/${meta.path}`);
            return;
        }
        ;
        if (replay && replay.subject && Array.isArray(replay.subject.observers) &&
            replay.subject.observers.length == 0) {
            console.warn(`No observators for ${method} request from ${meta.endpoint}/${meta.path}`);
            return;
        }
        const url = replay.data.url;
        const headers = replay.data.headers;
        const body = replay.data.body;
        const isArray = replay.data.isArray;
        setTimeout(() => this.req(url, method, headers, body, replay.id, isArray));
    }
}
RestRequest.jobId = 0;
//# sourceMappingURL=rest-request.js.map