Routing Without Frameworks

import { createServer } from "node:http";
 
type Handler = (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse) => void;
 
const routes = new Map<string, Handler>([
  ["GET /health", (_req, res) => {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ status: "ok" }));
  }],
  ["GET /users", (_req, res) => {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify([{ id: 1 }]));
  }],
]);
 
const server = createServer((req, res) => {
  const key = `${req.method} ${new URL(req.url ?? "/", "http://localhost").pathname}`;
  const handler = routes.get(key);
  if (handler) return handler(req, res);
  res.writeHead(404).end();
});

import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 
type RouteHandler = (req: IncomingMessage, res: ServerResponse, params: Record<string, string>) => void;
 
interface Route {
  method: string;
  pattern: RegExp;
  paramNames: string[];
  handler: RouteHandler;
}
 
function route(method: string, path: string, handler: RouteHandler): Route {
  const paramNames: string[] = [];
  const pattern = new RegExp(
    "^" + path.replace(/:([a-zA-Z]+)/g, (_, name) => {
      paramNames.push(name);
      return "([^/]+)";
    }) + "$"
  );
  return { method, pattern, paramNames, handler };
}
 
const routes: Route[] = [
  route("GET", "/users/:id", (req, res, params) => {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ id: params.id }));
  }),
  route("DELETE", "/users/:id", (req, res, params) => {
    res.writeHead(204).end();
    console.log(`Deleted user ${params.id}`);
  }),
];
 
function match(req: IncomingMessage): { handler: RouteHandler; params: Record<string, string> } | null {
  const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
  for (const r of routes) {
    if (r.method !== req.method) continue;
    const m = pathname.match(r.pattern);
    if (!m) continue;
    const params: Record<string, string> = {};
    r.paramNames.forEach((name, i) => { params[name] = m[i + 1]; });
    return { handler: r.handler, params };
  }
  return null;
}
 
const server = createServer((req, res) => {
  const found = match(req);
  if (found) return found.handler(req, res, found.params);
  res.writeHead(404, { "Content-Type": "application/json" });
  res.end(JSON.stringify({ error: "Not found" }));
});
 
server.listen(3000);

// Narrow method at the boundary
const ALLOWED = new Set(["GET", "POST", "PUT", "DELETE", "PATCH"]);
if (!ALLOWED.has(req.method ?? "")) {
  res.writeHead(405, { Allow: [...ALLOWED].join(", ") }).end();
  return;
}