http2-wrapper

What is http2-wrapper?

The http2-wrapper npm package is a module that provides an easy-to-use wrapper around the native HTTP/2 client and server capabilities in Node.js. It simplifies the process of making HTTP/2 requests and handling responses, as well as creating HTTP/2 servers.

What are http2-wrapper's main functionalities?

Making HTTP/2 requests

This feature allows you to make HTTP/2 requests to a server. The code sample demonstrates how to perform a simple GET request using the http2-wrapper.

const http2wrapper = require('http2-wrapper');

const options = {
  hostname: 'example.com',
  protocol: 'https:',
  path: '/',
  method: 'GET'
};

http2wrapper.request(options, (res) => {
  console.log(`Status Code: ${res.statusCode}`);

  res.on('data', (chunk) => {
    console.log(chunk);
  });
}).end();

Creating HTTP/2 servers

This feature allows you to create an HTTP/2 server. The code sample shows how to set up a simple HTTP/2 server that responds with 'Hello World' to all requests.

const http2wrapper = require('http2-wrapper');
const http2 = require('http2');

const server = http2.createSecureServer({
  key: fs.readFileSync('server-key.pem'),
  cert: fs.readFileSync('server-cert.pem')
});

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html',
    ':status': 200
  });
  stream.end('<h1>Hello World</h1>');
});

http2wrapper.createServer(server).listen(8443);

Other packages similar to http2-wrapper

spdy

The 'spdy' package is an HTTP/2 and SPDY protocol client and server implementation for Node.js. It provides similar functionalities to http2-wrapper but also includes support for SPDY, which is a now-deprecated protocol that was a precursor to HTTP/2.

node-fetch

While 'node-fetch' is primarily a light-weight module that brings window.fetch to Node.js, it can be used to make HTTP/2 requests when combined with the built-in http2 module in Node.js. It does not provide server capabilities like http2-wrapper.

README

http2-wrapper

Use HTTP2 the same way like HTTP1

This package was created for the purpose of supporting HTTP2 without rewriting your code.
I recommend adapting to the http2 module if possible, because it's much simpler to use and has many cool features.

Tip: http2-wrapper is very useful when you rely on other modules that use the HTTP1 API and you want to support HTTP2.

Usage

'use strict';
const http2 = require('http2-wrapper');

const options = {
	hostname: 'nghttp2.org',
	protocol: 'https:',
	path: '/httpbin/post',
	method: 'POST',
	headers: {
		'content-length': 6
	}
};

const req = http2.request(options, res => {
	console.log('statusCode:', res.statusCode);
	console.log('headers:', res.headers);

	const body = [];
	res.on('data', chunk => {
		body.push(chunk);
	});
	res.on('end', () => {
		console.log('body:', Buffer.concat(body).toString());
	});
});

req.on('error', e => console.error(e));

req.write('123');
req.end('456');

// statusCode: 200
// headers: { ':status': 200,
//   date: 'Sat, 11 Aug 2018 09:37:41 GMT',
//   'content-type': 'application/json',
//   'content-length': '264',
//   'access-control-allow-origin': '*',
//   'access-control-allow-credentials': 'true',
//   'x-backend-header-rtt': '0.002997',
//   'strict-transport-security': 'max-age=31536000',
//   server: 'nghttpx',
//   via: '1.1 nghttpx',
//   'x-frame-options': 'SAMEORIGIN',
//   'x-xss-protection': '1; mode=block',
//   'x-content-type-options': 'nosniff' }
// body: {
//   "args": {},
//   "data": "123456",
//   "files": {},
//   "form": {},
//   "headers": {
//     "Content-Length": "6",
//     "Host": "nghttp2.org:443",
//     "Via": "2 nghttpx"
//   },
//   "json": 123456,
//   "origin": "xxx.xxx.xxx.xxx",
//   "url": "https://nghttp2.org:443/httpbin/post"
// }

Differences between the HTTP1 API

This wrapper may work a bit different than the HTTP1 API:

• the upgrade event is not supported (yet),
• the HTTP2ClientRequest class has no setSocketKeepAlive function,
• close events inform that the underlying request is no longer usable (instead of: the socket has been closed),
• there's a session option (accepts ClientHttp2Session) instead of the agent option.

HTTP2IncomingMessage

• Event: 'aborted'
• Event: 'close'
• message.destroy([error])
• message.headers
• message.httpVersion
• message.rawHeaders
• message.rawTrailers
• message.setTimeout(msecs, callback)
• message.socket
• message.statusCode
• message.statusMessage
• message.trailers

HTTP2ClientRequest

• Event: 'abort'
• Event: 'connect'
• Event: 'continue'
• Event: 'information'
• Event: 'response'
• Event: 'socket'
• Event: 'timeout'
• Event: 'upgrade'
• request.abort()
• request.aborted
• request.connection
• request.end([data[, encoding]][, callback])
• request.flushHeaders()
• request.getHeader(name)
• request.removeHeader(name)
• request.setHeader(name, value)
• request.setNoDelay([noDelay])
• request.setSocketKeepAlive([enable][, initialDelay])
• request.setTimeout(timeout[, callback])
• request.socket
• request.write(chunk[, encoding][, callback])

License

MIT