HTTP/2 & gRPC

gRPC service definition and TypeScript server implementation

// order_service.proto
// syntax = "proto3";
// package orders.v1;
//
// service OrderService {
//   rpc GetOrder (GetOrderRequest) returns (Order);
//   rpc ListOrders (ListOrdersRequest) returns (stream Order);
//   rpc CreateOrder (CreateOrderRequest) returns (Order);
// }
//
// message GetOrderRequest { string order_id = 1; }
// message Order {
//   string id = 1;
//   string customer_id = 2;
//   int64 total_cents = 3;
//   string status = 4;
//   google.protobuf.Timestamp created_at = 5;
// }

// Generated with: npx grpc_tools_node_protoc ...
import * as grpc from '@grpc/grpc-js';
import { OrderServiceImplementation } from './generated/order_grpc_pb';
import { Order, GetOrderRequest } from './generated/order_pb';

const implementation: OrderServiceImplementation = {
  getOrder(call: grpc.ServerUnaryCall<GetOrderRequest, Order>, callback) {
    const orderId = call.request.getOrderId();
    const order = db.orders.findById(orderId);
    if (!order) {
      callback({ code: grpc.status.NOT_FOUND, message: 'Order not found' });
      return;
    }
    const response = new Order();
    response.setId(order.id);
    response.setTotalCents(order.totalCents);
    callback(null, response);
  },
};

Protocol Buffers serialisation is 3-10x smaller than equivalent JSON and 5-10x faster to serialise/deserialise. The .proto file is the source of truth for the API contract; code is generated for both client and server, preventing interface drift.

HTTP/2 server push and connection reuse in Node.js

import http2 from 'http2';
import fs from 'fs';

const server = http2.createSecureServer({
  key: fs.readFileSync('./key.pem'),
  cert: fs.readFileSync('./cert.pem'),
  allowHTTP1: true, // Fallback for HTTP/1.1 clients
});

server.on('stream', (stream, headers) => {
  const path = headers[':path'];

  if (path === '/') {
    // Server Push: push CSS and JS before browser requests them
    stream.pushStream({ ':path': '/static/app.css' }, (err, pushStream) => {
      if (!err) {
        pushStream.respondWithFile('./public/static/app.css', {
          'content-type': 'text/css',
          'cache-control': 'public, max-age=31536000',
        });
      }
    });

    stream.respondWithFile('./public/index.html', {
      'content-type': 'text/html; charset=utf-8',
      ':status': 200,
    });
  }
});

server.listen(443);
// HTTP/2 multiplexes all streams on one TLS connection
// Multiple concurrent requests do not open multiple connections

Server push (HTTP/2 PUSH_PROMISE) proactively sends resources the browser will need, eliminating the waterfall of HTML parse -> discover CSS link -> request CSS. In practice, server push is often misconfigured; the Early Hints header (HTTP 103) is a simpler alternative.