Working with TypeScript

npm i express
npm i -D typescript tsx @types/node @types/express

{
  "compilerOptions": {
    "target": "ES2023",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "dist",
    "rootDir": "src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "resolveJsonModule": true,
    "verbatimModuleSyntax": true
  },
  "include": ["src/**/*"]
}

import type { Request, Response, NextFunction } from "express";

export const ping = (req: Request, res: Response) => {
  res.json({ ok: true });
};

// src/types/express.d.ts
import "express";
declare module "express-serve-static-core" {
  interface Request {
    id: string;
    user?: { sub: string; role: "admin" | "user"; email: string };
  }
}

import type { RequestHandler } from "express";

export const requireAuth: RequestHandler = (req, res, next) => {
  if (!req.user) return next(new HttpError(401));
  next();
};

import type { Request, Response } from "express";

type Params = { id: string };
type Body   = { email: string };
type Resp   = { id: string; email: string };
type Query  = { include?: string };

export const updateUser = async (
  req: Request<Params, Resp, Body, Query>,
  res: Response<Resp>
) => {
  const user = await db.users.update(req.params.id, req.body);
  res.json(user);
};

import { z, ZodSchema } from "zod";

export const handler = <P, B, Q, R>(
  schemas: { params?: ZodSchema<P>; body?: ZodSchema<B>; query?: ZodSchema<Q> },
  fn: (input: { params: P; body: B; query: Q }) => Promise<R>
): RequestHandler => async (req, res, next) => {
  try {
    const input = {
      params: schemas.params ? schemas.params.parse(req.params) : ({} as P),
      body:   schemas.body   ? schemas.body.parse(req.body)     : ({} as B),
      query:  schemas.query  ? schemas.query.parse(req.query)   : ({} as Q)
    };
    res.json(await fn(input));
  } catch (err) { next(err); }
};

import express, { type Express, type Router } from "express";

export function createApp(): Express {
  const app = express();
  app.use(express.json());
  return app;
}

export class HttpError extends Error {
  constructor(public status: number, msg = "") { super(msg); }
}

export function isHttpError(e: unknown): e is HttpError {
  return e instanceof HttpError;
}

{
  "scripts": {
    "dev":   "tsx watch --env-file=.env src/server.ts",
    "build": "tsc -p tsconfig.json",
    "start": "node --enable-source-maps dist/server.js",
    "typecheck": "tsc --noEmit"
  }
}