@codefresh-io/http-infra/lib/request.js

'use strict';

const requestretry = require('requestretry');
const request = require('request');
const Promise = require('bluebird');
const _ = require('lodash');
const { getRequestId, getAuthenticatedEntity } = require('./correlation');
const { REQUEST_ID_HEADER, AUTHENTICATED_ENTITY_HEADER } = require('./headers');
const { envVarBasedStrategy, compositionStrategy, specifcErrorCodesStrategy, RETRY_STATUS_CODES } = require('./requestStrategies');

const maxAttempts = 5;
const retryDelay = 5000;

function isNetworkError(err) {
    return _.get(err, 'code') || RETRY_STATUS_CODES.includes(err.statusCode);
}

function serviceRequest(opt) {
    opt = opt || {};

    const serviceConfig = opt.serviceConfig;
    if (!serviceConfig) {
        throw new Error('Service config not provided');
    }
    const serviceBasePath = `${serviceConfig.protocol}://${serviceConfig.uri}:${serviceConfig.port}`;
    const path = opt.path;
    const requestOptions = opt.requestOptions || {};
    const headers = Object.assign({}, requestOptions.headers);

    // overriding the authenticated entity is something that should only be done in rare rare cases
    // please advise and discuss before overriding it
    const authenticatedEntity = opt.authenticatedEntity || getAuthenticatedEntity();
    if (authenticatedEntity) {
        headers[AUTHENTICATED_ENTITY_HEADER] =
            authenticatedEntity.encodeToBase64String();
    }
    const requestId = getRequestId();
    if (requestId) {
        headers[REQUEST_ID_HEADER] = requestId;
    }

    const systemOptions = {
        url: `${serviceBasePath}${path}`,
        headers
    };
    const retryOptions = opt.retryStrategy || {
        retryStrategy: (err, response = {}) => {
            return envVarBasedStrategy('HTTP_SKIP_RETRY').excludeOnEnvironmentVariableStrategy() &&
            compositionStrategy(requestretry.RetryStrategies.NetworkError,
                 specifcErrorCodesStrategy)(err, response);
        },
        maxAttempts: opt.maxAttempts || maxAttempts,
        retryDelay: opt.retryDelay || retryDelay
    };

    if (opt.stream) {
        return request(systemOptions);
    } else {
        systemOptions.json = true;
        systemOptions.promiseFactory = (resolver) => {
            return new Promise(resolver);
        };
        return requestretry(Object.assign({}, requestOptions, systemOptions, retryOptions))
            .then((response) => {
                if (response.statusCode >= 400) {
                    const error = {};
                    error.statusCode = response.statusCode;
                    error.code = response.code;
                    error.message = `${response.statusCode} - ${JSON && JSON.stringify ? JSON.stringify(response.body) : response.body}`;
                    error.attempts = response.attempts;
                    error.error = response.body;
                    error.response = response;
                    throw error;
                } else {
                    return response;
                }
            })
            .catch((err) => {
                err.isNetworkError = isNetworkError(err);
                throw err;
            });
    }
}

module.exports = serviceRequest;