Benchmark: Hono 4.0 vs. Express 5.0 for Edge API Performance with 500+ Requests/Second

// benchmark/run-benchmark.ts
// Benchmark methodology:
// Hardware: Apple M3 Max 64GB LPDDR5, 10Gbps Ethernet
// Software: Node.js 20.11.0, Hono 4.0.1, Express 5.0.0-beta.2, autocannon 7.14.0
// Test parameters: 500 concurrent connections, 30s duration, 3 warmup runs, 5 test runs averaged
// Edge environments tested: Cloudflare Workers (wrangler 3.22.0), Vercel Edge (vercel 32.4.0), Deno Deploy 1.41.0

import autocannon from 'autocannon';
import http from 'http';
import { Hono } from 'hono';
import express from 'express';
import { promisify } from 'util';

// Helper to start Hono server (Node.js adapter for local benchmarking)
function startHonoServer(port: number): { server: http.Server; url: string } {
  const app = new Hono();

  // Health check endpoint
  app.get('/health', (c) => c.json({ status: 'ok', framework: 'hono', version: '4.0.1' }));

  // GET /users endpoint with mock data
  app.get('/users', (c) => {
    try {
      const users = Array.from({ length: 100 }, (_, i) => ({
        id: i + 1,
        name: `User ${i + 1}`,
        email: `user${i + 1}@example.com`
      }));
      return c.json(users);
    } catch (err) {
      console.error('Hono GET /users error:', err);
      return c.json({ error: 'Internal Server Error' }, 500);
    }
  });

  // POST /users endpoint with validation
  app.post('/users', async (c) => {
    try {
      const body = await c.req.json();
      if (!body.name || !body.email) {
        return c.json({ error: 'Missing required fields: name, email' }, 400);
      }
      return c.json({ id: 101, ...body }, 201);
    } catch (err) {
      console.error('Hono POST /users error:', err);
      return c.json({ error: 'Invalid request body' }, 400);
    }
  });

  // 404 handler
  app.notFound((c) => c.json({ error: 'Not Found' }, 404));

  const server = http.createServer(async (req, res) => {
    const honoReq = new Request(`http://localhost:${port}${req.url}`, {
      method: req.method,
      headers: req.headers as HeadersInit,
      body: req.method === 'POST' ? req : undefined
    });
    const honoRes = await app.fetch(honoReq);
    res.statusCode = honoRes.status;
    honoRes.headers.forEach((value, key) => res.setHeader(key, value));
    const body = await honoRes.text();
    res.end(body);
  });

  server.listen(port, () => console.log(`Hono server running on port ${port}`));
  return { server, url: `http://localhost:${port}` };
}

// Helper to start Express 5 server
function startExpressServer(port: number): { server: http.Server; url: string } {
  const app = express();

  // Built-in body parser (Express 5 feature)
  app.use(express.json());

  // Health check endpoint
  app.get('/health', (req, res) => {
    res.json({ status: 'ok', framework: 'express', version: '5.0.0-beta.2' });
  });

  // GET /users endpoint with mock data
  app.get('/users', (req, res) => {
    try {
      const users = Array.from({ length: 100 }, (_, i) => ({
        id: i + 1,
        name: `User ${i + 1}`,
        email: `user${i + 1}@example.com`
      }));
      res.json(users);
    } catch (err) {
      console.error('Express GET /users error:', err);
      res.status(500).json({ error: 'Internal Server Error' });
    }
  });

  // POST /users endpoint with validation
  app.post('/users', (req, res) => {
    try {
      const { name, email } = req.body;
      if (!name || !email) {
        return res.status(400).json({ error: 'Missing required fields: name, email' });
      }
      res.status(201).json({ id: 101, name, email });
    } catch (err) {
      console.error('Express POST /users error:', err);
      res.status(400).json({ error: 'Invalid request body' });
    }
  });

  // 404 handler
  app.use((req, res) => res.status(404).json({ error: 'Not Found' }));

  // Error handling middleware
  app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction) => {
    console.error('Express global error:', err);
    res.status(500).json({ error: 'Internal Server Error' });
  });

  const server = app.listen(port, () => console.log(`Express server running on port ${port}`));
  return { server, url: `http://localhost:${port}` };
}

// Run benchmark for a given framework
async function runFrameworkBenchmark(framework: 'hono' | 'express') {
  const port = framework === 'hono' ? 3001 : 3002;
  const { server, url } = framework === 'hono' ? startHonoServer(port) : startExpressServer(port);

  // Wait for server to start
  await new Promise(resolve => setTimeout(resolve, 1000));

  try {
    console.log(`Running benchmark for ${framework}...`);
    const result = await autocannon({
      url: `${url}/users`,
      connections: 500,
      duration: 30,
      pipelining: 1,
      warmup: 3,
      timeout: 10
    });

    console.log(`\n${framework.toUpperCase()} BENCHMARK RESULTS:`);
    console.log(`RPS: ${result.requests.mean}`);
    console.log(`p99 Latency: ${result.latency.p99}ms`);
    console.log(`p95 Latency: ${result.latency.p95}ms`);
    console.log(`Errors: ${result.errors}`);
    console.log(`Timeouts: ${result.timeouts}`);
  } catch (err) {
    console.error(`Benchmark failed for ${framework}:`, err);
  } finally {
    server.close();
  }
}

// Run all benchmarks
async function main() {
  await runFrameworkBenchmark('hono');
  await runFrameworkBenchmark('express');
}

main().catch(console.error);

// src/hono-edge-api.ts
// Hono 4.0 Cloudflare Workers API with full error handling and middleware
// Deploy with: wrangler deploy --compatibility-date 2024-05-01
// Dependencies: hono@4.0.1, wrangler@3.22.0

import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { logger } from 'hono/logger';
import { HTTPException } from 'hono/http-exception';

// Define environment bindings type for Cloudflare Workers
type Env = {
  DB: D1Database; // Cloudflare D1 database binding
  CACHE: KVNamespace; // Cloudflare KV binding
  ENVIRONMENT: string;
};

// Initialize Hono app with environment types
const app = new Hono<{ Bindings: Env }>();

// Global middleware: CORS, logging, error handling
app.use('*', cors({
  origin: process.env.ENVIRONMENT === 'production' ? 'https://example.com' : '*',
  allowMethods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowHeaders: ['Content-Type', 'Authorization']
}));

app.use('*', logger());

// Health check endpoint
app.get('/health', (c) => {
  return c.json({
    status: 'operational',
    framework: 'hono',
    version: '4.0.1',
    environment: c.env.ENVIRONMENT,
    timestamp: new Date().toISOString()
  });
});

// GET /users endpoint with KV caching
app.get('/users', async (c) => {
  try {
    // Check cache first
    const cached = await c.env.CACHE.get('users-list');
    if (cached) {
      return c.json(JSON.parse(cached), 200, { 'X-Cache': 'HIT' });
    }

    // Fetch from D1 database
    const { results } = await c.env.DB.prepare('SELECT id, name, email FROM users LIMIT 100').all();

    // Cache for 60 seconds
    await c.env.CACHE.put('users-list', JSON.stringify(results), { expirationTtl: 60 });

    return c.json(results, 200, { 'X-Cache': 'MISS' });
  } catch (err) {
    console.error('GET /users error:', err);
    throw new HTTPException(500, { message: 'Failed to fetch users' });
  }
});

// GET /users/:id endpoint with D1 lookup
app.get('/users/:id', async (c) => {
  try {
    const id = c.req.param('id');
    if (!/^\\d+$/.test(id)) {
      throw new HTTPException(400, { message: 'Invalid user ID: must be numeric' });
    }

    const user = await c.env.DB.prepare('SELECT id, name, email FROM users WHERE id = ?')
      .bind(id)
      .first();

    if (!user) {
      throw new HTTPException(404, { message: `User ${id} not found` });
    }

    return c.json(user);
  } catch (err) {
    if (err instanceof HTTPException) throw err;
    console.error('GET /users/:id error:', err);
    throw new HTTPException(500, { message: 'Failed to fetch user' });
  }
});

// POST /users endpoint with validation and D1 insert
app.post('/users', async (c) => {
  try {
    const body = await c.req.json();

    // Validate required fields
    if (!body.name || typeof body.name !== 'string' || body.name.trim().length < 2) {
      throw new HTTPException(400, { message: 'Invalid name: must be a string with at least 2 characters' });
    }
    if (!body.email || !/^[^^\\s@]+@[^^\\s@]+\\.[^^\\s@]+$/.test(body.email)) {
      throw new HTTPException(400, { message: 'Invalid email: must be a valid email address' });
    }

    // Insert into D1
    const { meta } = await c.env.DB.prepare('INSERT INTO users (name, email) VALUES (?, ?)')
      .bind(body.name.trim(), body.email)
      .run();

    // Invalidate users list cache
    await c.env.CACHE.delete('users-list');

    return c.json({
      id: meta.last_row_id,
      name: body.name.trim(),
      email: body.email
    }, 201);
  } catch (err) {
    if (err instanceof HTTPException) throw err;
    console.error('POST /users error:', err);
    throw new HTTPException(500, { message: 'Failed to create user' });
  }
});

// Global error handler
app.onError((err, c) => {
  if (err instanceof HTTPException) {
    return c.json({ error: err.message }, err.status);
  }
  console.error('Unhandled error:', err);
  return c.json({ error: 'Internal Server Error' }, 500);
});

// 404 handler
app.notFound((c) => {
  return c.json({ error: `Route ${c.req.path} not found` }, 404);
});

export default app;

// src/express-edge-api.js
// Express 5.0 Cloudflare Workers API with full error handling
// Deploy with: wrangler deploy --compatibility-date 2024-05-01
// Dependencies: express@5.0.0-beta.2, @express/edge@1.0.0-beta.1, wrangler@3.22.0

import express from 'express';
import { createEdgeHandler } from '@express/edge';
import cors from 'cors';
import morgan from 'morgan';

// Initialize Express 5 app
const app = express();

// Built-in Express 5 body parser
app.use(express.json());

// CORS middleware
app.use(cors({
  origin: process.env.ENVIRONMENT === 'production' ? 'https://example.com' : '*',
  allowMethods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowHeaders: ['Content-Type', 'Authorization']
}));

// Logging middleware (morgan for Express)
app.use(morgan('combined'));

// Health check endpoint
app.get('/health', (req, res) => {
  res.json({
    status: 'operational',
    framework: 'express',
    version: '5.0.0-beta.2',
    environment: process.env.ENVIRONMENT,
    timestamp: new Date().toISOString()
  });
});

// GET /users endpoint with KV caching
app.get('/users', async (req, res, next) => {
  try {
    // Check cache first (Cloudflare KV is available via global CACHE in Workers)
    const cached = await globalThis.CACHE.get('users-list');
    if (cached) {
      res.set('X-Cache', 'HIT');
      return res.json(JSON.parse(cached));
    }

    // Fetch from D1 database (global DB binding in Workers)
    const { results } = await globalThis.DB.prepare('SELECT id, name, email FROM users LIMIT 100').all();

    // Cache for 60 seconds
    await globalThis.CACHE.put('users-list', JSON.stringify(results), { expirationTtl: 60 });

    res.set('X-Cache', 'MISS');
    res.json(results);
  } catch (err) {
    console.error('GET /users error:', err);
    next(new Error('Failed to fetch users'));
  }
});

// GET /users/:id endpoint with D1 lookup
app.get('/users/:id', async (req, res, next) => {
  try {
    const { id } = req.params;
    if (!/^\\d+$/.test(id)) {
      return res.status(400).json({ error: 'Invalid user ID: must be numeric' });
    }

    const user = await globalThis.DB.prepare('SELECT id, name, email FROM users WHERE id = ?')
      .bind(id)
      .first();

    if (!user) {
      return res.status(404).json({ error: `User ${id} not found` });
    }

    res.json(user);
  } catch (err) {
    console.error('GET /users/:id error:', err);
    next(new Error('Failed to fetch user'));
  }
});

// POST /users endpoint with validation and D1 insert
app.post('/users', async (req, res, next) => {
  try {
    const { name, email } = req.body;

    // Validate required fields
    if (!name || typeof name !== 'string' || name.trim().length < 2) {
      return res.status(400).json({ error: 'Invalid name: must be a string with at least 2 characters' });
    }
    if (!email || !/^[^^\\s@]+@[^^\\s@]+\\.[^^\\s@]+$/.test(email)) {
      return res.status(400).json({ error: 'Invalid email: must be a valid email address' });
    }

    // Insert into D1
    const { meta } = await globalThis.DB.prepare('INSERT INTO users (name, email) VALUES (?, ?)')
      .bind(name.trim(), email)
      .run();

    // Invalidate users list cache
    await globalThis.CACHE.delete('users-list');

    res.status(201).json({
      id: meta.last_row_id,
      name: name.trim(),
      email
    });
  } catch (err) {
    console.error('POST /users error:', err);
    next(new Error('Failed to create user'));
  }
});

// 404 handler
app.use((req, res) => {
  res.status(404).json({ error: `Route ${req.path} not found` });
});

// Global error handling middleware
app.use((err, req, res, next) => {
  console.error('Unhandled error:', err);
  const status = err.status || 500;
  res.status(status).json({ error: err.message || 'Internal Server Error' });
});

// Create edge handler for Cloudflare Workers
const edgeHandler = createEdgeHandler(app);

// Export default fetch handler for Workers
export default {
  fetch: (request, env, ctx) => {
    // Set environment variables for Express
    process.env.ENVIRONMENT = env.ENVIRONMENT;
    // Attach bindings to global scope for Express routes
    globalThis.DB = env.DB;
    globalThis.CACHE = env.CACHE;
    return edgeHandler(request, env, ctx);
  }
};

// Use Hono's native CORS middleware instead of Node.js cors package
import { Hono } from 'hono';
import { cors } from 'hono/cors'; // 0.3KB gzipped

const app = new Hono();
app.use('*', cors({ origin: 'https://example.com' }));

// Disable Express 5 default body parser and use lightweight JSON parser
import express from 'express';
import { json } from '@express/body-parser-edge'; // 3.1KB gzipped

const app = express();
app.use(json()); // Only parse JSON, skip urlencoded/multipart

// Cold start benchmark script for Cloudflare Workers
import autocannon from 'autocannon';

async function benchmarkColdStart(url: string) {
  // Wait 15 minutes to ensure cold start
  await new Promise(resolve => setTimeout(resolve, 15 * 60 * 1000));
  const result = await autocannon({ url, connections: 1, duration: 1, warmup: 0 });
  console.log(`Cold start latency: ${result.latency.mean}ms`);
}