Benchmarks

CPU:        Apple M2 Pro (12 cores)
Memory:     32GB RAM
OS:         macOS 14.0
Node.js:    v20.10.0
Connections: 100 concurrent
Duration:   30 seconds per test
Tool:       wrk (HTTP benchmarking tool)

import { createApp } from 'ramapi';
 
const app = createApp({
  adapter: { type: 'uwebsockets' }, // or 'node-http'
});
 
app.get('/json', async (ctx) => {
  ctx.json({ message: 'Hello World' });
});
 
await app.listen(3000);

import Fastify from 'fastify';
const fastify = Fastify();
 
fastify.get('/json', async () => {
  return { message: 'Hello World' };
});
 
await fastify.listen({ port: 3000 });

import express from 'express';
const app = express();
 
app.get('/json', (req, res) => {
  res.json({ message: 'Hello World' });
});
 
app.listen(3000);

wrk -t12 -c100 -d30s http://localhost:3000/json

import { createApp, logger, cors } from 'ramapi';
 
const app = createApp({
  adapter: { type: 'uwebsockets' },
});
 
// Middleware stack
app.use(logger());
app.use(cors());
app.use(async (ctx, next) => {
  ctx.state.requestId = Math.random().toString(36);
  await next();
});
 
app.get('/api/users', async (ctx) => {
  ctx.json({
    requestId: ctx.state.requestId,
    users: [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ],
  });
});
 
await app.listen(3000);

import Fastify from 'fastify';
import cors from '@fastify/cors';
const fastify = Fastify();
 
await fastify.register(cors);
 
fastify.addHook('onRequest', async (request, reply) => {
  request.requestId = Math.random().toString(36);
});
 
fastify.get('/api/users', async (request) => {
  return {
    requestId: request.requestId,
    users: [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ],
  };
});
 
await fastify.listen({ port: 3000 });

import express from 'express';
import cors from 'cors';
import morgan from 'morgan';
 
const app = express();
 
app.use(morgan('tiny'));
app.use(cors());
app.use((req, res, next) => {
  req.requestId = Math.random().toString(36);
  next();
});
 
app.get('/api/users', (req, res) => {
  res.json({
    requestId: req.requestId,
    users: [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ],
  });
});
 
app.listen(3000);

wrk -t12 -c100 -d30s http://localhost:3000/api/users

import { createApp, validate } from 'ramapi';
import { z } from 'zod';
import Database from 'better-sqlite3';
 
const db = new Database('benchmark.db');
const app = createApp({
  adapter: { type: 'uwebsockets' },
});
 
// Auth middleware
const authenticate = async (ctx: Context, next: () => Promise<void>) => {
  const token = ctx.headers.authorization;
  if (!token || token !== 'Bearer valid-token') {
    ctx.json({ error: 'Unauthorized' }, 401);
    return;
  }
  await next();
};
 
// Route with validation
app.get(
  '/api/users/:id',
  authenticate,
  validate({
    params: z.object({
      id: z.string().regex(/^\d+$/),
    }),
  }),
  async (ctx) => {
    const userId = parseInt(ctx.params.id);
    const user = db.prepare('SELECT * FROM users WHERE id = ?').get(userId);
 
    if (!user) {
      ctx.json({ error: 'User not found' }, 404);
      return;
    }
 
    ctx.json({ user });
  }
);
 
await app.listen(3000);

wrk -t12 -c100 -d30s -H "Authorization: Bearer valid-token" \
    http://localhost:3000/api/users/123

import { createApp, validate } from 'ramapi';
import { z } from 'zod';
import Database from 'better-sqlite3';
 
const db = new Database('benchmark.db');
const app = createApp({
  adapter: { type: 'uwebsockets' },
});
 
const userSchema = z.object({
  name: z.string().min(2).max(100),
  email: z.string().email(),
  age: z.number().int().min(18).max(120),
});
 
app.post(
  '/api/users',
  validate({ body: userSchema }),
  async (ctx) => {
    const { name, email, age } = ctx.body;
 
    // Check if email exists
    const existing = db
      .prepare('SELECT id FROM users WHERE email = ?')
      .get(email);
 
    if (existing) {
      ctx.json({ error: 'Email already exists' }, 409);
      return;
    }
 
    // Insert user
    const result = db
      .prepare('INSERT INTO users (name, email, age) VALUES (?, ?, ?)')
      .run(name, email, age);
 
    // Fetch created user
    const user = db
      .prepare('SELECT * FROM users WHERE id = ?')
      .get(result.lastInsertRowid);
 
    ctx.json({ user }, 201);
  }
);
 
await app.listen(3000);

wrk -t12 -c100 -d30s -s post.lua http://localhost:3000/api/users

# Install wrk (macOS)
brew install wrk
 
# Install wrk (Ubuntu)
sudo apt-get install wrk
 
# Install wrk (from source)
git clone https://github.com/wg/wrk.git
cd wrk
make
sudo cp wrk /usr/local/bin

# Simple GET request
wrk -t12 -c100 -d30s http://localhost:3000/json
 
# With custom header
wrk -t12 -c100 -d30s \
    -H "Authorization: Bearer token" \
    http://localhost:3000/api/users
 
# POST request with Lua script
wrk -t12 -c100 -d30s -s post.lua http://localhost:3000/api/users

wrk.method = "POST"
wrk.body   = '{"name":"Alice","email":"alice@example.com","age":25}'
wrk.headers["Content-Type"] = "application/json"

# Clone repository
git clone https://github.com/yourusername/ramapi.git
cd ramapi
 
# Install dependencies
npm install
 
# Build the project
npm run build
 
# Run benchmark server
npm run benchmark:server
 
# In another terminal, run benchmarks
npm run benchmark:run

// benchmark/custom.ts
import { createApp } from 'ramapi';
 
const app = createApp({
  adapter: { type: 'uwebsockets' },
});
 
app.get('/custom', async (ctx) => {
  // Your test endpoint
  ctx.json({ result: 'data' });
});
 
await app.listen(3000);
console.log('Benchmark server ready on http://localhost:3000');

# Run custom benchmark
ts-node benchmark/custom.ts
 
# In another terminal
wrk -t12 -c100 -d30s http://localhost:3000/custom

wrk -t12 -c100 -d30s <url>
 
-t12    # 12 threads (matches CPU cores)
-c100   # 100 concurrent connections
-d30s   # 30 second duration

# Warmup
wrk -t12 -c100 -d10s http://localhost:3000/test
 
# Actual benchmark
wrk -t12 -c100 -d30s http://localhost:3000/test

for i in {1..5}; do
  echo "Run $i"
  wrk -t12 -c100 -d30s http://localhost:3000/json >> results.txt
  sleep 5
done