@datanimbus/postman-request 3.0.1

package/lib/autohttp/request.js

@@ -0,0 +1,192 @@
+const { EventEmitter } = require('events')
+const { Http2Request: HTTP2Request } = require('../../lib/http2/request')
+const { globalAgent } = require('./agent')
+const { validateRequestHeaders } = require('./headerValidations')
+
+const kJobs = Symbol('kJobs')
+
+class MultiProtocolRequest extends EventEmitter {
+  constructor (options) {
+    super()
+    this[kJobs] = []
+    this.options = options
+    this.options.host = options.hostname || options.host || 'localhost'
+
+    const agent = options.agent || globalAgent
+    // Request agent to perform alpn and return either an http agent or https agent
+    // Pass the request to the agent, the agent then calls the callback with http or http2 argument based on the result
+    // of alpn negotiation
+    agent.createConnection(this, options, (err, proto, req) => {
+      if (err) {
+        this.emit('error', err)
+        return
+      }
+      if (proto === 'http2') {
+        this.onHttp2(req)
+      }
+      if (proto === 'http1') {
+        this.onHttp(req)
+      }
+    }, (socket) => {
+      // Need to register callback after this tick, after the on socket handlers have been registered.
+      // Node also does something similar when emitting the socket event.
+      process.nextTick(() => this.emit('socket', socket))
+      this.socket = socket
+    })
+  }
+
+  onHttp2 (connection) {
+    const options = {
+      ...this.options,
+      agent: {
+        createConnection: () => connection
+      }
+    }
+
+    let req
+    try {
+      req = new HTTP2Request(options)
+    } catch (e) {
+      this.emit('error', e)
+      return
+    }
+    this.registerCallbacks(req)
+    this._req = req
+    this.processQueuedOpens()
+  }
+
+  onHttp (req) {
+    this.registerCallbacks(req)
+    this._req = req
+    this.processQueuedOpens()
+  }
+
+  registerCallbacks (ob) {
+    ob.on('drain', (...args) => this.emit('drain', ...args))
+    ob.on('end', (...args) => this.emit('end', ...args))
+    ob.on('close', (...args) => this.emit('close', ...args))
+    ob.on('response', (...args) => this.emit('response', ...args))
+    ob.on('error', (...args) => this.emit('error', ...args))
+  }
+
+  processQueuedOpens () {
+    this[kJobs].forEach((action) => {
+      action()
+    })
+    this[kJobs] = []
+  }
+
+  write (data) {
+    const action = () => this._req.write(data)
+    if (this._req) {
+      action()
+      return true
+    }
+    this[kJobs].push(action)
+    return true
+  }
+
+  end (data) {
+    const action = () => {
+      this._req.end(data)
+    }
+    if (this._req) {
+      action()
+      return this
+    }
+    this[kJobs].push(action)
+    return this
+  }
+
+  setDefaultEncoding (encoding) {
+    const action = () => this._req.setDefaultEncoding(encoding)
+    if (this._req) {
+      action()
+      return this
+    }
+
+    this[kJobs].push(action)
+    return this
+  }
+
+  get _header () {
+    if (this._req && this._req._header) {
+      return this._req._header
+    }
+    return new Promise((resolve) => {
+      const action = () => resolve(this._req._header)
+      this[kJobs].push(action)
+    })
+  }
+
+  pipe (destination, options) {
+    const action = () => this._req.pipe(destination, options)
+    if (this._req) {
+      action()
+      return destination
+    }
+    this[kJobs].push(action)
+    return destination
+  }
+
+  setTimeout (timeout, callback) {
+    const action = () => this._req.setTimeout(timeout, callback)
+    if (this._req) {
+      action()
+      return this
+    }
+    this[kJobs].push(action)
+    return this
+  }
+
+  abort () {
+    const action = () => this._req.abort()
+    if (this._req) {
+      action()
+      return this
+    }
+    this[kJobs].push(action)
+    return this
+  }
+
+  setHeader (name, value) {
+    const action = () => this._req.setHeader(name, value)
+    if (this._req) {
+      action()
+      return this
+    }
+    this[kJobs].push(action)
+    return this
+  }
+
+  removeHeader (name) {
+    const action = () => this._req.removeHeader(name)
+    if (this._req) {
+      action()
+      return this
+    }
+    this[kJobs].push(action)
+    return this
+  }
+}
+
+function request (options) {
+  // request was received here, that means protocol is auto, that means priority order is http2, http
+  // There can be 2 cases
+
+  // 1. We have performed ALPN negotiation before for this host/port with the same agent options
+  // 2. We need to perform ALPN negotiation, add the socket used to perform negotiation to the appropriate agent
+  // 2.1 Add the agent to the pool if it didn't already exist
+
+  // HTTP/2 internal implementation sucks. In case of an invalid HTTP/2 header, it destroys the entire session and
+  // emits an error asynchronously, instead of throwing it synchronously. Hence, it makes more sense to perform all
+  // validations before sending the request.
+  validateRequestHeaders(options.headers)
+
+  return new MultiProtocolRequest(options)
+}
+
+module.exports = {
+  request,
+  MultiProtocolRequest
+}

package/lib/autohttp/requestName.js

@@ -0,0 +1,86 @@
+/*
+   * This function has been referenced from Node.js HTTPS Agent implementation
+   * Ref: v20.15.0 https://github.com/nodejs/node/blob/6bf148e12b00a3ec596f4c123ec35445a48ab209/lib/https.js
+   */
+function getName (options) {
+  let name = options.host || 'localhost'
+
+  name += ':'
+  if (options.port) { name += options.port }
+
+  name += ':'
+  if (options.localAddress) { name += options.localAddress }
+  if (options.socketPath) { name += `:${options.socketPath}` }
+
+  name += ':'
+  if (options.ca) { name += options.ca }
+
+  name += ':'
+  if (options.extraCA) { name += options.extraCA }
+
+  name += ':'
+  if (options.cert) { name += options.cert }
+
+  name += ':'
+  if (options.clientCertEngine) { name += options.clientCertEngine }
+
+  name += ':'
+  if (options.ciphers) { name += options.ciphers }
+
+  name += ':'
+  if (options.key) { name += options.key }
+
+  name += ':'
+  if (options.pfx) { name += options.pfx }
+
+  name += ':'
+  if (options.rejectUnauthorized !== undefined) { name += options.rejectUnauthorized }
+
+  name += ':'
+  if (options.servername && options.servername !== options.host) { name += options.servername }
+
+  name += ':'
+  if (options.minVersion) { name += options.minVersion }
+
+  name += ':'
+  if (options.maxVersion) { name += options.maxVersion }
+
+  name += ':'
+  if (options.secureProtocol) { name += options.secureProtocol }
+
+  name += ':'
+  if (options.crl) { name += options.crl }
+
+  name += ':'
+  if (options.honorCipherOrder !== undefined) { name += options.honorCipherOrder }
+
+  name += ':'
+  if (options.ecdhCurve) { name += options.ecdhCurve }
+
+  name += ':'
+  if (options.dhparam) { name += options.dhparam }
+
+  name += ':'
+  if (options.secureOptions !== undefined) { name += options.secureOptions }
+
+  name += ':'
+  if (options.sessionIdContext) { name += options.sessionIdContext }
+
+  name += ':'
+  if (options.sigalgs) { name += JSON.stringify(options.sigalgs) }
+
+  name += ':'
+  if (options.privateKeyIdentifier) { name += options.privateKeyIdentifier }
+
+  name += ':'
+  if (options.privateKeyEngine) { name += options.privateKeyEngine }
+
+    // Create new connection since previous connection cannot be reused since it will not emit secureConnect event which will not set the session data
+  name += ':' + Boolean(options.verbose)
+
+  return name
+}
+
+module.exports = {
+  getName
+}

package/lib/cookies.js

@@ -0,0 +1,20 @@
+'use strict'
+
+var tough = require('@postman/tough-cookie')
+
+var Cookie = tough.Cookie
+var CookieJar = tough.CookieJar
+
+exports.parse = function (str) {
+  if (str && str.uri) {
+    str = str.uri
+  }
+  if (typeof str !== 'string') {
+    throw new Error('The cookie function only accepts STRING as param')
+  }
+  return Cookie.parse(str, {loose: true})
+}
+
+exports.jar = function (store) {
+  return new CookieJar(store, {looseMode: true})
+}

package/lib/getProxyFromURI.js

@@ -0,0 +1,79 @@
+'use strict'
+
+function formatHostname (hostname) {
+  // canonicalize the hostname, so that 'oogle.com' won't match 'google.com'
+  return hostname.replace(/^\.*/, '.').toLowerCase()
+}
+
+function parseNoProxyZone (zone) {
+  zone = zone.trim().toLowerCase()
+
+  var zoneParts = zone.split(':', 2)
+  var zoneHost = formatHostname(zoneParts[0])
+  var zonePort = zoneParts[1]
+  var hasPort = zone.indexOf(':') > -1
+
+  return {hostname: zoneHost, port: zonePort, hasPort: hasPort}
+}
+
+function uriInNoProxy (uri, noProxy) {
+  var port = uri.port || (uri.protocol === 'https:' ? '443' : '80')
+  var hostname = formatHostname(uri.hostname)
+  var noProxyList = noProxy.split(',')
+
+  // iterate through the noProxyList until it finds a match.
+  return noProxyList.map(parseNoProxyZone).some(function (noProxyZone) {
+    var isMatchedAt = hostname.indexOf(noProxyZone.hostname)
+    var hostnameMatched = (
+      isMatchedAt > -1 &&
+        (isMatchedAt === hostname.length - noProxyZone.hostname.length)
+    )
+
+    if (noProxyZone.hasPort) {
+      return (port === noProxyZone.port) && hostnameMatched
+    }
+
+    return hostnameMatched
+  })
+}
+
+function getProxyFromURI (uri) {
+  // Decide the proper request proxy to use based on the request URI object and the
+  // environmental variables (NO_PROXY, HTTP_PROXY, etc.)
+  // respect NO_PROXY environment variables (see: http://lynx.isc.org/current/breakout/lynx_help/keystrokes/environments.html)
+
+  var noProxy = process.env.NO_PROXY || process.env.no_proxy || ''
+
+  // if the noProxy is a wildcard then return null
+
+  if (noProxy === '*') {
+    return null
+  }
+
+  // if the noProxy is not empty and the uri is found return null
+
+  if (noProxy !== '' && uriInNoProxy(uri, noProxy)) {
+    return null
+  }
+
+  // Check for HTTP or HTTPS Proxy in environment Else default to null
+
+  if (uri.protocol === 'http:') {
+    return process.env.HTTP_PROXY ||
+      process.env.http_proxy || null
+  }
+
+  if (uri.protocol === 'https:') {
+    return process.env.HTTPS_PROXY ||
+      process.env.https_proxy ||
+      process.env.HTTP_PROXY ||
+      process.env.http_proxy || null
+  }
+
+  // if none of that works, return null
+  // (What uri protocol are you using then?)
+
+  return null
+}
+
+module.exports = getProxyFromURI

package/lib/har.js

@@ -0,0 +1,200 @@
+'use strict'
+
+var fs = require('fs')
+var qs = require('querystring')
+var extend = require('extend')
+
+function Har (request) {
+  this.request = request
+}
+
+Har.prototype.reducer = function (obj, pair) {
+  // new property ?
+  if (obj[pair.name] === undefined) {
+    obj[pair.name] = pair.value
+    return obj
+  }
+
+  // existing? convert to array
+  var arr = [
+    obj[pair.name],
+    pair.value
+  ]
+
+  obj[pair.name] = arr
+
+  return obj
+}
+
+Har.prototype.prep = function (data) {
+  // construct utility properties
+  data.queryObj = {}
+  data.headersObj = {}
+  data.postData.jsonObj = false
+  data.postData.paramsObj = false
+
+  // construct query objects
+  if (data.queryString && data.queryString.length) {
+    data.queryObj = data.queryString.reduce(this.reducer, {})
+  }
+
+  // construct headers objects
+  if (data.headers && data.headers.length) {
+    // loweCase header keys
+    data.headersObj = data.headers.reduceRight(function (headers, header) {
+      headers[header.name] = header.value
+      return headers
+    }, {})
+  }
+
+  // construct Cookie header
+  if (data.cookies && data.cookies.length) {
+    var cookies = data.cookies.map(function (cookie) {
+      return cookie.name + '=' + cookie.value
+    })
+
+    if (cookies.length) {
+      data.headersObj.cookie = cookies.join('; ')
+    }
+  }
+
+  // prep body
+  function some (arr) {
+    return arr.some(function (type) {
+      return data.postData.mimeType.indexOf(type) === 0
+    })
+  }
+
+  if (some([
+    'multipart/mixed',
+    'multipart/related',
+    'multipart/form-data',
+    'multipart/alternative'])) {
+    // reset values
+    data.postData.mimeType = 'multipart/form-data'
+  } else if (some([
+    'application/x-www-form-urlencoded'])) {
+    if (!data.postData.params) {
+      data.postData.text = ''
+    } else {
+      data.postData.paramsObj = data.postData.params.reduce(this.reducer, {})
+
+      // always overwrite
+      data.postData.text = qs.stringify(data.postData.paramsObj)
+    }
+  } else if (some([
+    'text/json',
+    'text/x-json',
+    'application/json',
+    'application/x-json'])) {
+    data.postData.mimeType = 'application/json'
+
+    if (data.postData.text) {
+      try {
+        data.postData.jsonObj = JSON.parse(data.postData.text)
+      } catch (e) {
+        this.request.debug(e)
+
+        // force back to text/plain
+        data.postData.mimeType = 'text/plain'
+      }
+    }
+  }
+
+  return data
+}
+
+Har.prototype.options = function (options) {
+  // skip if no har property defined
+  if (!options.har) {
+    return options
+  }
+
+  var har = {}
+  extend(har, options.har)
+
+  // only process the first entry
+  if (har.log && har.log.entries) {
+    har = har.log.entries[0]
+  }
+
+  // add optional properties to make validation successful
+  har.url = har.url || options.url || options.uri || options.baseUrl || '/'
+  har.httpVersion = har.httpVersion || 'HTTP/1.1'
+  har.queryString = har.queryString || []
+  har.headers = har.headers || []
+  har.cookies = har.cookies || []
+  har.postData = har.postData || {}
+  har.postData.mimeType = har.postData.mimeType || 'application/octet-stream'
+
+  har.bodySize = 0
+  har.headersSize = 0
+  har.postData.size = 0
+
+  // clean up and get some utility properties
+  var req = this.prep(har)
+
+  // construct new options
+  if (req.url) {
+    options.url = req.url
+  }
+
+  if (req.method) {
+    options.method = req.method
+  }
+
+  if (Object.keys(req.queryObj).length) {
+    options.qs = req.queryObj
+  }
+
+  if (Object.keys(req.headersObj).length) {
+    options.headers = req.headersObj
+  }
+
+  function test (type) {
+    return req.postData.mimeType.indexOf(type) === 0
+  }
+  if (test('application/x-www-form-urlencoded')) {
+    options.form = req.postData.paramsObj
+  } else if (test('application/json')) {
+    if (req.postData.jsonObj) {
+      options.body = req.postData.jsonObj
+      options.json = true
+    }
+  } else if (test('multipart/form-data')) {
+    options.formData = {}
+
+    req.postData.params.forEach(function (param) {
+      var attachment = {}
+
+      if (!param.fileName && !param.contentType) {
+        options.formData[param.name] = param.value
+        return
+      }
+
+      // attempt to read from disk!
+      if (param.fileName && !param.value) {
+        attachment.value = fs.createReadStream(param.fileName)
+      } else if (param.value) {
+        attachment.value = param.value
+      }
+
+      if (param.fileName) {
+        attachment.options = {
+          filename: param.fileName,
+          contentType: param.contentType ? param.contentType : null
+        }
+      }
+
+      options.formData[param.name] = attachment
+    })
+  } else {
+    if (req.postData.text) {
+      options.body = req.postData.text
+    }
+  }
+
+  return options
+}
+
+exports.Har = Har

package/lib/hawk.js

@@ -0,0 +1,89 @@
+'use strict'
+
+var crypto = require('crypto')
+
+function randomString (size) {
+  var bits = (size + 1) * 6
+  var buffer = crypto.randomBytes(Math.ceil(bits / 8))
+  var string = buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+  return string.slice(0, size)
+}
+
+function calculatePayloadHash (payload, algorithm, contentType) {
+  var hash = crypto.createHash(algorithm)
+  hash.update('hawk.1.payload\n')
+  hash.update((contentType ? contentType.split(';')[0].trim().toLowerCase() : '') + '\n')
+  hash.update(payload || '')
+  hash.update('\n')
+  return hash.digest('base64')
+}
+
+exports.calculateMac = function (credentials, opts) {
+  var normalized = 'hawk.1.header\n' +
+    opts.ts + '\n' +
+    opts.nonce + '\n' +
+    (opts.method || '').toUpperCase() + '\n' +
+    opts.resource + '\n' +
+    opts.host.toLowerCase() + '\n' +
+    opts.port + '\n' +
+    (opts.hash || '') + '\n'
+
+  if (opts.ext) {
+    normalized = normalized + opts.ext.replace('\\', '\\\\').replace('\n', '\\n')
+  }
+
+  normalized = normalized + '\n'
+
+  if (opts.app) {
+    normalized = normalized + opts.app + '\n' + (opts.dlg || '') + '\n'
+  }
+
+  var hmac = crypto.createHmac(credentials.algorithm, credentials.key).update(normalized)
+  var digest = hmac.digest('base64')
+  return digest
+}
+
+exports.header = function (uri, method, opts) {
+  var timestamp = opts.timestamp || Math.floor((Date.now() + (opts.localtimeOffsetMsec || 0)) / 1000)
+  var credentials = opts.credentials
+  if (!credentials || !credentials.id || !credentials.key || !credentials.algorithm) {
+    return ''
+  }
+
+  if (['sha256'].indexOf(credentials.algorithm) === -1) {
+    return ''
+  }
+
+  var artifacts = {
+    ts: timestamp,
+    nonce: opts.nonce || randomString(6),
+    method: method,
+    resource: uri.pathname + (uri.search || ''),
+    host: uri.hostname,
+    port: uri.port || (uri.protocol === 'http:' ? 80 : 443),
+    hash: opts.hash,
+    ext: opts.ext,
+    app: opts.app,
+    dlg: opts.dlg
+  }
+
+  if (!artifacts.hash && (opts.payload || opts.payload === '')) {
+    artifacts.hash = calculatePayloadHash(opts.payload, credentials.algorithm, opts.contentType)
+  }
+
+  var mac = exports.calculateMac(credentials, artifacts)
+
+  var hasExt = artifacts.ext !== null && artifacts.ext !== undefined && artifacts.ext !== ''
+  var header = 'Hawk id="' + credentials.id +
+    '", ts="' + artifacts.ts +
+    '", nonce="' + artifacts.nonce +
+    (artifacts.hash ? '", hash="' + artifacts.hash : '') +
+    (hasExt ? '", ext="' + artifacts.ext.replace(/\\/g, '\\\\').replace(/"/g, '\\"') : '') +
+    '", mac="' + mac + '"'
+
+  if (artifacts.app) {
+    header = header + ', app="' + artifacts.app + (artifacts.dlg ? '", dlg="' + artifacts.dlg : '') + '"'
+  }
+
+  return header
+}