@jshaftoe/infra/src/uninstrumentedHttpUtils.js

// @flow

import request from 'request'
import _ from 'lodash'

import { asyncRetry, sleep } from './asyncUtils'
import { ExtendedError } from './errorUtils'

const promisifiedRequest = async (options: Object) => await new Promise((resp, rej) => request(options, (err, data) => err ? rej(err) : resp(data)))

const DEFAULT_REQ_HEADERS = {}
const DEFAULT_REQ_REJECT_UNAUTHORIZED = true

export type HttpReqResponse = {|
  bodyObj: ?Object, 
  body: string, 
  statusCode: number, 
  triesExecuted: number,
|}

export type HttpReqOptions = {
  url?: ?string,
  method?: string,
  timeout?: ?number,
  headers?: { [id: string]: string },
  body?: ?string | Object,
  maxRetries?: number,
  expoBackoffMs?: ?number,
  asyncErrorHandler?: ?(Object) => Promise<void>,
  rejectUnauthorized?: boolean,
  trackingName?: ?string,
  parseJsonResponse?: ?boolean,
}

export async function httpReq(url: string, options: HttpReqOptions = {}): Promise<HttpReqResponse> {
  let body: ?string = null
  try {
    options = options || {}
    options.url = url
    options.method = options.method ? options.method.toUpperCase() : 'GET'
    options.timeout = typeof options.timeout !== 'undefined' ? options.timeout : 5000
    options.headers = options.headers || DEFAULT_REQ_HEADERS
    options.body = typeof options.body === 'string' ? options.body : JSON.stringify(options.body)
    options.rejectUnauthorized = typeof options.rejectUnauthorized !== 'undefined' ? options.rejectUnauthorized : DEFAULT_REQ_REJECT_UNAUTHORIZED

    options.maxRetries = options.maxRetries || 0
    options.expoBackoffMs = options.expoBackoffMs || 100

    return await asyncRetry(async (triesExecuted) => {
      body = null
      const resp = await promisifiedRequest(options)
      if (options.parseJsonResponse === true) {
        try {
          body = resp.body
          resp.bodyObj = JSON.parse(resp.body)
          resp.triesExecuted = triesExecuted
        } catch (err) {
          // NOTE: don't change this string without searching the code for it
          throw new ExtendedError('Failed to parse HTTP response as JSON', { url: url, bodyStart: resp.body.substr(0, 1000) })
        } 
      }
      return resp
    }, {
      opName: `${options.url}`,
      maxRetries: options.maxRetries,
      expoBackoffMs: options.expoBackoffMs,
      asyncErrorHandler: options.asyncErrorHandler,
    })
  } catch (err) {
    throw new ExtendedError('HTTP request failed', { url, err, body })
  }
}


type ResultHandlerTrigger = {|
  onError: RegExp,
|} | {|
  onStatus: number | RegExp,
|} | {||}
type ResultHandlerAction = {|
  retry: number,
  nextBackoffMs?: ?number,
|} | {|
  throw: Error,
|} | {|
  return: HttpReqResponse,
|}
type ResultHandler = {|
  ...ResultHandlerTrigger,
  ...ResultHandlerAction,
|}

export type HttpReqOptions2 = {
  url?: ?string,
  method?: string,
  timeout?: ?number,
  headers?: { [id: string]: string },
  body?: ?string | Object,
  maxRetries?: number,
  rejectUnauthorized?: boolean,
  trackingName?: ?string,
  parseJsonResponse?: ?boolean,
  resultHandlers?: ?Array<ResultHandler>
}

export async function httpReq2(url: string, options: HttpReqOptions2 = {}): Promise<HttpReqResponse> {
  let body: ?string = null
  try {
    options = options || {}
    options.url = url
    options.method = options.method ? options.method.toUpperCase() : 'GET'
    options.timeout = typeof options.timeout !== 'undefined' ? options.timeout : 5000
    options.headers = options.headers || DEFAULT_REQ_HEADERS
    options.body = typeof options.body === 'string' ? options.body : JSON.stringify(options.body)
    options.rejectUnauthorized = typeof options.rejectUnauthorized !== 'undefined' ? options.rejectUnauthorized : DEFAULT_REQ_REJECT_UNAUTHORIZED
    options.resultHandlers = options.resultHandlers ? _.clone(options.resultHandlers) : options.resultHandlers

    let triesLeft = 1
    let triesExecuted = 0

    let resp: ?HttpReqResponse = null
    let error: ?Error = null

    while (triesLeft > 0) {

      try {
        triesExecuted++
        triesLeft--
        resp = await promisifiedRequest(options)
      } catch (err) {
        error = err
      }
      
      if (options.resultHandlers) {
        for (const resultHandler of options.resultHandlers) {
          if (
            (
              resultHandler.onStatus == null && 
              resultHandler.onError == null
            ) || (
              resp && 
              typeof resultHandler.onStatus === 'number' &&
              resultHandler.onStatus === resp.statusCode
            ) || (
              resp && 
              resultHandler.onStatus && 
              typeof resultHandler.onStatus.test === 'function' && 
              // $FlowIgnore
              resultHandler.onStatus.test(resp.statusCode.toString())
            ) || (
              error && 
              resultHandler.onError && 
              typeof resultHandler.onError.test === 'function' && 
              resultHandler.onError.test(error.message)
            )
          ) {
            if (resultHandler.retry != null) {
              if (resultHandler.retry > 0) {
                triesLeft++
                resultHandler.retry--
                // $FlowIgnore
                resultHandler.nextBackoffMs = resultHandler.nextBackoffMs == null ? 100 : resultHandler.nextBackoffMs
                await sleep(resultHandler.nextBackoffMs)
                // $FlowIgnore
                resultHandler.nextBackoffMs *= 1.5

                error = undefined
                resp = undefined
              }
            } else if (resultHandler.throw != null) {
              throw resultHandler.throw
            } else if (resultHandler.return != null) {
              return resultHandler.return
            } else {
              throw new ExtendedError('Invalid result handler in httpReq', resultHandler)
            }
          }
        }
      }
    }

    if (resp) {
      if (options.parseJsonResponse === true) {
        try {
          body = resp.body
          resp.bodyObj = JSON.parse(resp.body)
          resp.triesExecuted = triesExecuted
        } catch (err) {
          // NOTE: don't change this string without searching the code for it
          throw new ExtendedError('Failed to parse HTTP response as JSON', { url: url, bodyStart: resp.body.substr(0, 1000) })
        }
      }
      return resp
    }

    throw error

  } catch (err) {
    throw new ExtendedError('HTTP request failed', { url, err, body })
  }
}