diff options
Diffstat (limited to 'together/node_modules/superagent/lib/node/http2wrapper.js')
| -rw-r--r-- | together/node_modules/superagent/lib/node/http2wrapper.js | 210 |
1 files changed, 210 insertions, 0 deletions
diff --git a/together/node_modules/superagent/lib/node/http2wrapper.js b/together/node_modules/superagent/lib/node/http2wrapper.js new file mode 100644 index 0000000..52d0b11 --- /dev/null +++ b/together/node_modules/superagent/lib/node/http2wrapper.js @@ -0,0 +1,210 @@ +"use strict"; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +const Stream = require('stream'); + +const util = require('util'); + +const net = require('net'); + +const tls = require('tls'); // eslint-disable-next-line node/no-deprecated-api + + +const _require = require('url'), + parse = _require.parse; + +const process = require('process'); + +const semverGte = require('semver/functions/gte'); + +let http2; +if (semverGte(process.version, 'v10.10.0')) http2 = require('http2');else throw new Error('superagent: this version of Node.js does not support http2'); +const _http2$constants = http2.constants, + HTTP2_HEADER_PATH = _http2$constants.HTTP2_HEADER_PATH, + HTTP2_HEADER_STATUS = _http2$constants.HTTP2_HEADER_STATUS, + HTTP2_HEADER_METHOD = _http2$constants.HTTP2_HEADER_METHOD, + HTTP2_HEADER_AUTHORITY = _http2$constants.HTTP2_HEADER_AUTHORITY, + HTTP2_HEADER_HOST = _http2$constants.HTTP2_HEADER_HOST, + HTTP2_HEADER_SET_COOKIE = _http2$constants.HTTP2_HEADER_SET_COOKIE, + NGHTTP2_CANCEL = _http2$constants.NGHTTP2_CANCEL; + +function setProtocol(protocol) { + return { + request(options) { + return new Request(protocol, options); + } + + }; +} + +function Request(protocol, options) { + Stream.call(this); + const defaultPort = protocol === 'https:' ? 443 : 80; + const defaultHost = 'localhost'; + const port = options.port || defaultPort; + const host = options.host || defaultHost; + delete options.port; + delete options.host; + this.method = options.method; + this.path = options.path; + this.protocol = protocol; + this.host = host; + delete options.method; + delete options.path; + + const sessionOptions = _objectSpread({}, options); + + if (options.socketPath) { + sessionOptions.socketPath = options.socketPath; + sessionOptions.createConnection = this.createUnixConnection.bind(this); + } + + this._headers = {}; + const session = http2.connect("".concat(protocol, "//").concat(host, ":").concat(port), sessionOptions); + this.setHeader('host', "".concat(host, ":").concat(port)); + session.on('error', error => this.emit('error', error)); + this.session = session; +} +/** + * Inherit from `Stream` (which inherits from `EventEmitter`). + */ + + +util.inherits(Request, Stream); + +Request.prototype.createUnixConnection = function (authority, options) { + switch (this.protocol) { + case 'http:': + return net.connect(options.socketPath); + + case 'https:': + options.ALPNProtocols = ['h2']; + options.servername = this.host; + options.allowHalfOpen = true; + return tls.connect(options.socketPath, options); + + default: + throw new Error('Unsupported protocol', this.protocol); + } +}; // eslint-disable-next-line no-unused-vars + + +Request.prototype.setNoDelay = function (bool) {// We can not use setNoDelay with HTTP/2. + // Node 10 limits http2session.socket methods to ones safe to use with HTTP/2. + // See also https://nodejs.org/api/http2.html#http2_http2session_socket +}; + +Request.prototype.getFrame = function () { + if (this.frame) { + return this.frame; + } + + const method = { + [HTTP2_HEADER_PATH]: this.path, + [HTTP2_HEADER_METHOD]: this.method + }; + let headers = this.mapToHttp2Header(this._headers); + headers = Object.assign(headers, method); + const frame = this.session.request(headers); // eslint-disable-next-line no-unused-vars + + frame.once('response', (headers, flags) => { + headers = this.mapToHttpHeader(headers); + frame.headers = headers; + frame.statusCode = headers[HTTP2_HEADER_STATUS]; + frame.status = frame.statusCode; + this.emit('response', frame); + }); + this._headerSent = true; + frame.once('drain', () => this.emit('drain')); + frame.on('error', error => this.emit('error', error)); + frame.on('close', () => this.session.close()); + this.frame = frame; + return frame; +}; + +Request.prototype.mapToHttpHeader = function (headers) { + const keys = Object.keys(headers); + const http2Headers = {}; + + for (var _i = 0, _keys = keys; _i < _keys.length; _i++) { + let key = _keys[_i]; + let value = headers[key]; + key = key.toLowerCase(); + + switch (key) { + case HTTP2_HEADER_SET_COOKIE: + value = Array.isArray(value) ? value : [value]; + break; + + default: + break; + } + + http2Headers[key] = value; + } + + return http2Headers; +}; + +Request.prototype.mapToHttp2Header = function (headers) { + const keys = Object.keys(headers); + const http2Headers = {}; + + for (var _i2 = 0, _keys2 = keys; _i2 < _keys2.length; _i2++) { + let key = _keys2[_i2]; + let value = headers[key]; + key = key.toLowerCase(); + + switch (key) { + case HTTP2_HEADER_HOST: + key = HTTP2_HEADER_AUTHORITY; + value = /^http:\/\/|^https:\/\//.test(value) ? parse(value).host : value; + break; + + default: + break; + } + + http2Headers[key] = value; + } + + return http2Headers; +}; + +Request.prototype.setHeader = function (name, value) { + this._headers[name.toLowerCase()] = value; +}; + +Request.prototype.getHeader = function (name) { + return this._headers[name.toLowerCase()]; +}; + +Request.prototype.write = function (data, encoding) { + const frame = this.getFrame(); + return frame.write(data, encoding); +}; + +Request.prototype.pipe = function (stream, options) { + const frame = this.getFrame(); + return frame.pipe(stream, options); +}; + +Request.prototype.end = function (data) { + const frame = this.getFrame(); + frame.end(data); +}; // eslint-disable-next-line no-unused-vars + + +Request.prototype.abort = function (data) { + const frame = this.getFrame(); + frame.close(NGHTTP2_CANCEL); + this.session.destroy(); +}; + +exports.setProtocol = setProtocol; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Stream","require","util","net","tls","parse","process","semverGte","http2","version","Error","constants","HTTP2_HEADER_PATH","HTTP2_HEADER_STATUS","HTTP2_HEADER_METHOD","HTTP2_HEADER_AUTHORITY","HTTP2_HEADER_HOST","HTTP2_HEADER_SET_COOKIE","NGHTTP2_CANCEL","setProtocol","protocol","request","options","Request","call","defaultPort","defaultHost","port","host","method","path","sessionOptions","socketPath","createConnection","createUnixConnection","bind","_headers","session","connect","setHeader","on","error","emit","inherits","prototype","authority","ALPNProtocols","servername","allowHalfOpen","setNoDelay","bool","getFrame","frame","headers","mapToHttp2Header","Object","assign","once","flags","mapToHttpHeader","statusCode","status","_headerSent","close","keys","http2Headers","key","value","toLowerCase","Array","isArray","test","name","getHeader","write","data","encoding","pipe","stream","end","abort","destroy","exports"],"sources":["../../src/node/http2wrapper.js"],"sourcesContent":["const Stream = require('stream');\nconst util = require('util');\nconst net = require('net');\nconst tls = require('tls');\n// eslint-disable-next-line node/no-deprecated-api\nconst { parse } = require('url');\nconst process = require('process');\nconst semverGte = require('semver/functions/gte');\n\nlet http2;\n\nif (semverGte(process.version, 'v10.10.0')) http2 = require('http2');\nelse\n  throw new Error('superagent: this version of Node.js does not support http2');\n\nconst {\n  HTTP2_HEADER_PATH,\n  HTTP2_HEADER_STATUS,\n  HTTP2_HEADER_METHOD,\n  HTTP2_HEADER_AUTHORITY,\n  HTTP2_HEADER_HOST,\n  HTTP2_HEADER_SET_COOKIE,\n  NGHTTP2_CANCEL\n} = http2.constants;\n\nfunction setProtocol(protocol) {\n  return {\n    request(options) {\n      return new Request(protocol, options);\n    }\n  };\n}\n\nfunction Request(protocol, options) {\n  Stream.call(this);\n  const defaultPort = protocol === 'https:' ? 443 : 80;\n  const defaultHost = 'localhost';\n  const port = options.port || defaultPort;\n  const host = options.host || defaultHost;\n\n  delete options.port;\n  delete options.host;\n\n  this.method = options.method;\n  this.path = options.path;\n  this.protocol = protocol;\n  this.host = host;\n\n  delete options.method;\n  delete options.path;\n\n  const sessionOptions = { ...options };\n  if (options.socketPath) {\n    sessionOptions.socketPath = options.socketPath;\n    sessionOptions.createConnection = this.createUnixConnection.bind(this);\n  }\n\n  this._headers = {};\n\n  const session = http2.connect(`${protocol}//${host}:${port}`, sessionOptions);\n  this.setHeader('host', `${host}:${port}`);\n\n  session.on('error', (error) => this.emit('error', error));\n\n  this.session = session;\n}\n\n/**\n * Inherit from `Stream` (which inherits from `EventEmitter`).\n */\nutil.inherits(Request, Stream);\n\nRequest.prototype.createUnixConnection = function (authority, options) {\n  switch (this.protocol) {\n    case 'http:':\n      return net.connect(options.socketPath);\n    case 'https:':\n      options.ALPNProtocols = ['h2'];\n      options.servername = this.host;\n      options.allowHalfOpen = true;\n      return tls.connect(options.socketPath, options);\n    default:\n      throw new Error('Unsupported protocol', this.protocol);\n  }\n};\n\n// eslint-disable-next-line no-unused-vars\nRequest.prototype.setNoDelay = function (bool) {\n  // We can not use setNoDelay with HTTP/2.\n  // Node 10 limits http2session.socket methods to ones safe to use with HTTP/2.\n  // See also https://nodejs.org/api/http2.html#http2_http2session_socket\n};\n\nRequest.prototype.getFrame = function () {\n  if (this.frame) {\n    return this.frame;\n  }\n\n  const method = {\n    [HTTP2_HEADER_PATH]: this.path,\n    [HTTP2_HEADER_METHOD]: this.method\n  };\n\n  let headers = this.mapToHttp2Header(this._headers);\n\n  headers = Object.assign(headers, method);\n\n  const frame = this.session.request(headers);\n  // eslint-disable-next-line no-unused-vars\n  frame.once('response', (headers, flags) => {\n    headers = this.mapToHttpHeader(headers);\n    frame.headers = headers;\n    frame.statusCode = headers[HTTP2_HEADER_STATUS];\n    frame.status = frame.statusCode;\n    this.emit('response', frame);\n  });\n\n  this._headerSent = true;\n\n  frame.once('drain', () => this.emit('drain'));\n  frame.on('error', (error) => this.emit('error', error));\n  frame.on('close', () => this.session.close());\n\n  this.frame = frame;\n  return frame;\n};\n\nRequest.prototype.mapToHttpHeader = function (headers) {\n  const keys = Object.keys(headers);\n  const http2Headers = {};\n  for (let key of keys) {\n    let value = headers[key];\n    key = key.toLowerCase();\n    switch (key) {\n      case HTTP2_HEADER_SET_COOKIE:\n        value = Array.isArray(value) ? value : [value];\n        break;\n      default:\n        break;\n    }\n\n    http2Headers[key] = value;\n  }\n\n  return http2Headers;\n};\n\nRequest.prototype.mapToHttp2Header = function (headers) {\n  const keys = Object.keys(headers);\n  const http2Headers = {};\n  for (let key of keys) {\n    let value = headers[key];\n    key = key.toLowerCase();\n    switch (key) {\n      case HTTP2_HEADER_HOST:\n        key = HTTP2_HEADER_AUTHORITY;\n        value = /^http:\\/\\/|^https:\\/\\//.test(value)\n          ? parse(value).host\n          : value;\n        break;\n      default:\n        break;\n    }\n\n    http2Headers[key] = value;\n  }\n\n  return http2Headers;\n};\n\nRequest.prototype.setHeader = function (name, value) {\n  this._headers[name.toLowerCase()] = value;\n};\n\nRequest.prototype.getHeader = function (name) {\n  return this._headers[name.toLowerCase()];\n};\n\nRequest.prototype.write = function (data, encoding) {\n  const frame = this.getFrame();\n  return frame.write(data, encoding);\n};\n\nRequest.prototype.pipe = function (stream, options) {\n  const frame = this.getFrame();\n  return frame.pipe(stream, options);\n};\n\nRequest.prototype.end = function (data) {\n  const frame = this.getFrame();\n  frame.end(data);\n};\n\n// eslint-disable-next-line no-unused-vars\nRequest.prototype.abort = function (data) {\n  const frame = this.getFrame();\n  frame.close(NGHTTP2_CANCEL);\n  this.session.destroy();\n};\n\nexports.setProtocol = setProtocol;\n"],"mappings":"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"}
\ No newline at end of file |