@datanimbus/postman-request 3.0.1

package/lib/tunnel.js

@@ -0,0 +1,175 @@
+'use strict'
+
+var tunnel = require('@postman/tunnel-agent')
+
+var defaultProxyHeaderWhiteList = [
+  'accept',
+  'accept-charset',
+  'accept-encoding',
+  'accept-language',
+  'accept-ranges',
+  'cache-control',
+  'content-encoding',
+  'content-language',
+  'content-location',
+  'content-md5',
+  'content-range',
+  'content-type',
+  'connection',
+  'date',
+  'expect',
+  'max-forwards',
+  'pragma',
+  'referer',
+  'te',
+  'user-agent',
+  'via'
+]
+
+var defaultProxyHeaderExclusiveList = [
+  'proxy-authorization'
+]
+
+function constructProxyHost (uriObject) {
+  var port = uriObject.port
+  var protocol = uriObject.protocol
+  var proxyHost = uriObject.hostname + ':'
+
+  if (port) {
+    proxyHost += port
+  } else if (protocol === 'https:') {
+    proxyHost += '443'
+  } else {
+    proxyHost += '80'
+  }
+
+  return proxyHost
+}
+
+function constructProxyHeaderWhiteList (headers, proxyHeaderWhiteList) {
+  var whiteList = proxyHeaderWhiteList
+    .reduce(function (set, header) {
+      set[header.toLowerCase()] = true
+      return set
+    }, {})
+
+  return Object.keys(headers)
+    .filter(function (header) {
+      return whiteList[header.toLowerCase()]
+    })
+    .reduce(function (set, header) {
+      set[header] = headers[header]
+      return set
+    }, {})
+}
+
+function constructTunnelOptions (request, proxyHeaders) {
+  var proxy = request.proxy
+
+  var tunnelOptions = {
+    proxy: {
+      host: proxy.hostname,
+      port: +proxy.port,
+      proxyAuth: proxy.auth,
+      headers: proxyHeaders
+    },
+    headers: request.headers,
+    ca: request.ca,
+    cert: request.cert,
+    key: request.key,
+    passphrase: request.passphrase,
+    pfx: request.pfx,
+    ciphers: request.ciphers,
+    rejectUnauthorized: request.rejectUnauthorized,
+    secureOptions: request.secureOptions,
+    secureProtocol: request.secureProtocol,
+    extraCA: request.extraCA
+  }
+
+  return tunnelOptions
+}
+
+function constructTunnelFnName (uri, proxy) {
+  var uriProtocol = (uri.protocol === 'https:' ? 'https' : 'http')
+  var proxyProtocol = (proxy.protocol === 'https:' ? 'Https' : 'Http')
+  return [uriProtocol, proxyProtocol].join('Over')
+}
+
+function getTunnelFn (request) {
+  var uri = request.uri
+  var proxy = request.proxy
+  var tunnelFnName = constructTunnelFnName(uri, proxy)
+  return tunnel[tunnelFnName]
+}
+
+function Tunnel (request) {
+  this.request = request
+  this.proxyHeaderWhiteList = defaultProxyHeaderWhiteList
+  this.proxyHeaderExclusiveList = []
+  if (typeof request.tunnel !== 'undefined') {
+    this.tunnelOverride = request.tunnel
+  }
+}
+
+Tunnel.prototype.isEnabled = function () {
+  var self = this
+  var request = self.request
+    // Tunnel HTTPS by default. Allow the user to override this setting.
+
+  // If self.tunnelOverride is set (the user specified a value), use it.
+  if (typeof self.tunnelOverride !== 'undefined') {
+    return self.tunnelOverride
+  }
+
+  // If the destination is HTTPS, tunnel.
+  if (request.uri.protocol === 'https:') {
+    return true
+  }
+
+  // Otherwise, do not use tunnel.
+  return false
+}
+
+Tunnel.prototype.setup = function (options) {
+  var self = this
+  var request = self.request
+
+  options = options || {}
+
+  if (typeof request.proxy === 'string') {
+    request.proxy = request.urlParser.parse(request.proxy)
+  }
+
+  if (!request.proxy || !request.tunnel) {
+    return false
+  }
+
+  // Setup Proxy Header Exclusive List and White List
+  if (options.proxyHeaderWhiteList) {
+    self.proxyHeaderWhiteList = options.proxyHeaderWhiteList
+  }
+  if (options.proxyHeaderExclusiveList) {
+    self.proxyHeaderExclusiveList = options.proxyHeaderExclusiveList
+  }
+
+  var proxyHeaderExclusiveList = self.proxyHeaderExclusiveList.concat(defaultProxyHeaderExclusiveList)
+  var proxyHeaderWhiteList = self.proxyHeaderWhiteList.concat(proxyHeaderExclusiveList)
+
+  // Setup Proxy Headers and Proxy Headers Host
+  // Only send the Proxy White Listed Header names
+  var proxyHeaders = constructProxyHeaderWhiteList(request.headers, proxyHeaderWhiteList)
+  proxyHeaders.host = constructProxyHost(request.uri)
+
+  proxyHeaderExclusiveList.forEach(request.removeHeader, request)
+
+  // Set Agent from Tunnel Data
+  var tunnelFn = getTunnelFn(request)
+  var tunnelOptions = constructTunnelOptions(request, proxyHeaders)
+  request.agent = tunnelFn(tunnelOptions)
+
+  return true
+}
+
+Tunnel.defaultProxyHeaderWhiteList = defaultProxyHeaderWhiteList
+Tunnel.defaultProxyHeaderExclusiveList = defaultProxyHeaderExclusiveList
+exports.Tunnel = Tunnel

package/lib/url-parse.js

@@ -0,0 +1,187 @@
+var url = require('url')
+var EMPTY = ''
+var ZERO = '0'
+var PERCENT = '%'
+var STRING = 'string'
+var AMPERSAND = '&'
+var EQUALS = '='
+var QUESTION_MARK = '?'
+var stringify
+var parse
+
+/**
+ * Percent encode a character with given code.
+ *
+ * @param {Number} c - character code of the character to encode
+ * @returns {String} - percent encoding of given character
+ */
+var percentEncode = function (c) {
+  var hex = c.toString(16).toUpperCase()
+  hex.length === 1 && (hex = ZERO + hex)
+  return PERCENT + hex
+}
+
+/**
+ * Checks if character with given code is valid hexadecimal digit or not.
+ *
+ * @param {Number} byte
+ * @returns {Boolean}
+ */
+var isPreEncodedCharacter = function (byte) {
+  return (byte >= 0x30 && byte <= 0x39) || // 0-9
+    (byte >= 0x41 && byte <= 0x46) || // A-F
+    (byte >= 0x61 && byte <= 0x66) // a-f
+}
+
+/**
+ * Checks if character at given index in the buffer is already percent encoded or not.
+ *
+ * @param {Buffer} buffer
+ * @param {Number} i
+ * @returns {Boolean}
+ */
+var isPreEncoded = function (buffer, i) {
+  // If it is % check next two bytes for percent encode characters
+  // looking for pattern %00 - %FF
+  return (buffer[i] === 0x25 &&
+    (isPreEncodedCharacter(buffer[i + 1]) &&
+    isPreEncodedCharacter(buffer[i + 2]))
+  )
+}
+
+/**
+ * Checks whether given character should be percent encoded or not for fixture.
+ *
+ * @param {Number} byte
+ * @returns {Boolean}
+ */
+var charactersToPercentEncode = function (byte) {
+  return (byte < 0x23 || byte > 0x7E || // Below # and after ~
+    byte === 0x3C || byte === 0x3E || // > and <
+    byte === 0x28 || byte === 0x29 || // ( and )
+    byte === 0x25 || // %
+    byte === 0x27 || // '
+    byte === 0x2A // *
+  )
+}
+
+/**
+ * Percent encode a query string according to RFC 3986.
+ * Note: This function is supposed to be used on top of node's inbuilt url encoding
+ *       to solve issue https://github.com/nodejs/node/issues/8321
+ *
+ * @param {String} value
+ * @returns {String}
+ */
+var encode = function (value) {
+  if (!value) { return EMPTY }
+
+  var buffer = Buffer.from(value)
+  var ret = EMPTY
+  var i
+  var ii
+
+  for (i = 0, ii = buffer.length; i < ii; ++i) {
+    if (charactersToPercentEncode(buffer[i]) && !isPreEncoded(buffer, i)) {
+      ret += percentEncode(buffer[i])
+    } else {
+      ret += String.fromCodePoint(buffer[i]) // Only works in ES6 (available in Node v4+)
+    }
+  }
+
+  return ret
+}
+
+/**
+ * Parses a query string into an array, preserving parameter values
+ *
+ * @param string
+ * @returns {*}
+ */
+parse = function (string) {
+  var parts
+  if (typeof string === STRING) { // eslint-disable-line valid-typeof
+    parts = string.split(AMPERSAND)
+    return parts.map(function (param, idx) {
+      if (param === EMPTY && idx !== (parts.length - 1)) {
+        return { key: null, value: null }
+      }
+
+      var index = (typeof param === STRING) ? param.indexOf(EQUALS) : -1 // eslint-disable-line valid-typeof
+      var paramObj = {}
+
+      // this means that there was no value for this key (not even blank, so we store this info) and the value is set
+      // to null
+      if (index < 0) {
+        paramObj.key = param.substr(0, param.length)
+        paramObj.value = null
+      } else {
+        paramObj.key = param.substr(0, index)
+        paramObj.value = param.substr(index + 1)
+      }
+
+      return paramObj
+    })
+  }
+  return []
+}
+
+/**
+ * Stringifies a query string, from an array of parameters
+ *
+ * @param parameters
+ * @returns {string}
+ */
+stringify = function (parameters) {
+  return parameters ? parameters.map(function (param) {
+    var key = param.key
+    var value = param.value
+
+    if (value === undefined) {
+      return EMPTY
+    }
+
+    if (key === null) {
+      key = EMPTY
+    }
+
+    if (value === null) {
+      return encode(key)
+    }
+
+    return encode(key) + EQUALS + encode(value)
+  }).join(AMPERSAND) : EMPTY
+}
+
+/**
+ * Correctly URL encodes query parameters in a URL and returns the final parsed URL.
+ *
+ * @param str
+ */
+module.exports = function (str) {
+  var parsed = url.parse(str)
+  var rawQs
+  var search
+  var path
+  var qs
+
+  rawQs = parsed.query
+
+  if (rawQs && rawQs.length) {
+    qs = stringify(parse(parsed.query))
+    search = QUESTION_MARK + qs
+    path = parsed.pathname + search
+
+    parsed.query = qs
+    parsed.search = search
+    parsed.path = path
+
+    str = url.format(parsed)
+  }
+
+  // Parse again, because Node does not guarantee consistency of properties
+  return url.parse(str)
+}
+
+module.exports.parse = parse
+module.exports.stringify = stringify

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@datanimbus/postman-request",
+  "description": "Simplified HTTP request client.",
+  "keywords": [
+    "http",
+    "simple",
+    "util",
+    "utility"
+  ],
+  "version": "3.0.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/postmanlabs/postman-request.git"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">= 16"
+  },
+  "main": "index.js",
+  "files": [
+    "lib/",
+    "index.js",
+    "request.js"
+  ],
+  "dependencies": {
+    "@postman/form-data": "~3.1.1",
+    "@postman/tough-cookie": "~4.1.3-postman.1",
+    "@postman/tunnel-agent": "^0.6.8",
+    "aws-sign2": "~0.7.0",
+    "aws4": "^1.12.0",
+    "caseless": "~0.12.0",
+    "combined-stream": "~1.0.6",
+    "extend": "~3.0.2",
+    "forever-agent": "~0.6.1",
+    "http-signature": "~1.4.0",
+    "is-typedarray": "~1.0.0",
+    "isstream": "~0.1.2",
+    "json-stringify-safe": "~5.0.1",
+    "mime-types": "^2.1.35",
+    "oauth-sign": "~0.9.0",
+    "qs": "~6.14.1",
+    "safe-buffer": "^5.1.2",
+    "socks-proxy-agent": "^8.0.5",
+    "stream-length": "^1.0.2",
+    "uuid": "^8.3.2"
+  },
+  "scripts": {
+    "test": "npm run lint && npm run test-ci && npm run test-browser",
+    "test-ci": "taper tests/test-*.js",
+    "test-cov": "istanbul cover tape tests/test-*.js",
+    "test-browser": "node tests/browser/start.js",
+    "lint": "standard"
+  },
+  "devDependencies": {
+    "bluebird": "^3.2.1",
+    "browserify": "^16.5.2",
+    "browserify-istanbul": "^3.0.0",
+    "buffer-equal": "^1.0.1",
+    "codecov": "^3.0.4",
+    "coveralls": "^3.0.2",
+    "function-bind": "^1.0.2",
+    "istanbul": "^0.4.0",
+    "karma": "^6.4.4",
+    "karma-browserify": "^8.1.0",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-cli": "^2.0.0",
+    "karma-coverage": "^2.2.1",
+    "karma-tap": "^4.2.0",
+    "postman-url-encoder": "^3.0.6",
+    "puppeteer": "^1.20.0",
+    "rimraf": "^2.2.8",
+    "server-destroy": "^1.0.1",
+    "standard": "^9.0.0",
+    "tape": "^4.6.0",
+    "taper": "^0.5.0"
+  }
+}