@ima/plugin-http-client/dist/cjs/HttpClient.js

Generic http client for the IMA application framework.

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    HttpClient: function() {
        return HttpClient;
    },
    OPTION_TRANSFORM_PROCESSORS: function() {
        return OPTION_TRANSFORM_PROCESSORS;
    }
});
const _core = require("@ima/core");
const _AbstractProcessor = require("./AbstractProcessor");
const OPTION_TRANSFORM_PROCESSORS = 'transformProcessors';
class HttpClient {
    #http;
    #defaultProcessors;
    static get $dependencies() {
        return [
            '$Http',
            '...?HttpClientDefaultProcessors'
        ];
    }
    constructor(http, ...defaultProcessors){
        this.#http = http;
        //ima returns undefined for empty optional spread dependency - which result in [undefined] so we filter it
        const processors = defaultProcessors.filter(Boolean);
        this.#checkProcessorsType(processors);
        this.#defaultProcessors = processors;
    }
    /**
   * Method registerProcessor added to defaultProcessors new processor
   * @param processor
   */ registerProcessor(processor) {
        this.#checkProcessorsType([
            processor
        ]);
        this.#defaultProcessors.push(processor);
    }
    /**
   * You can call request with additionalParams for processors. The request is processed by pre request processors method.
   * If pre request processors don't return response, ima HttpAgent request is called.
   * In the end the request is processed by post request processors method.
   *
   * @param request
   * @param additionalParams
   */ async request(request, additionalParams) {
        const processors = this.#getProcessors(request);
        this.#checkProcessorsType(processors);
        const processorResult = await this.#runProcessors(processors, _AbstractProcessor.Operation.PRE_REQUEST, {
            additionalParams,
            request,
            response: null
        });
        const { request: processedRequest } = processorResult;
        let { response: processedResponse } = processorResult;
        if (!processedResponse) {
            processedResponse = await this.#http[processedRequest.method](processedRequest.url, processedRequest.data, processedRequest.options);
        }
        return await this.#runProcessors(processors, _AbstractProcessor.Operation.POST_REQUEST, {
            additionalParams,
            request: processedRequest,
            response: processedResponse
        });
    }
    invalidateCache(...args) {
        this.#http.invalidateCache(...args);
    }
    /**
   * RunProcessors runs every registred processor and patch the response.
   *
   * @param processors
   * @param operation
   * @param processorParams
   * @private
   */ async #runProcessors(processors, operation, processorParams) {
        for (const processor of processors){
            const processorResult = await processor[operation](processorParams);
            processorParams = {
                ...processorParams,
                ...processorResult
            };
        }
        return processorParams;
    }
    #checkProcessorsType(processors) {
        processors.forEach((processor)=>{
            if (!(processor instanceof _AbstractProcessor.AbstractProcessor)) {
                throw new _core.GenericError(`HttpClient: The processor  ${processor?.constructor?.name} must extend AbstractProcessor class.`);
            }
        });
    }
    /**
   * Method for default transforming registered processors
   * @param processors
   * @returns Processor[]
   */ defaultTransformProcessors(processors) {
        return processors;
    }
    /**
   * getProcessors returns processors transformed by defaultTransformProcessors method or by method from request options.
   *
   * @param request
   * @private
   *
   * @returns Processor[]
   */ #getProcessors(request) {
        const defaultProcessors = this.#defaultProcessors;
        let transformProcessors = this.defaultTransformProcessors;
        if (request?.options?.[OPTION_TRANSFORM_PROCESSORS] && typeof request.options[OPTION_TRANSFORM_PROCESSORS] === 'function') {
            transformProcessors = request.options[OPTION_TRANSFORM_PROCESSORS];
        }
        return transformProcessors(defaultProcessors);
    }
}

//# sourceMappingURL=HttpClient.js.map