Zod at Boundaries

import { z } from 'zod';
 
const EnvSchema = z.object({
  PORT: z.coerce.number().default(3000),
  DATABASE_URL: z.string().url(),
  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
});
 
export const env = EnvSchema.parse(process.env);

const CreateUser = z.object({
  email: z.string().email(),
  name: z.string().min(1).max(100),
});
type CreateUser = z.infer<typeof CreateUser>;

import { z } from 'zod';
import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
 
const EnvSchema = z.object({
  PORT: z.coerce.number().default(3000),
});
const env = EnvSchema.parse(process.env);
 
const CreateItem = z.object({
  name: z.string().min(1),
  qty: z.number().int().positive(),
});
 
async function readJson(req: IncomingMessage): Promise<unknown> {
  const chunks: Buffer[] = [];
  for await (const chunk of req) chunks.push(chunk as Buffer);
  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
}
 
function sendJson(res: ServerResponse, status: number, body: unknown): void {
  res.writeHead(status, { 'content-type': 'application/json' });
  res.end(JSON.stringify(body));
}
 
const server = createServer(async (req, res) => {
  if (req.method === 'POST' && req.url === '/items') {
    try {
      const raw = await readJson(req);
      const item = CreateItem.parse(raw);
      sendJson(res, 201, { id: '1', ...item });
    } catch (err) {
      if (err instanceof z.ZodError) {
        sendJson(res, 400, { error: 'validation_failed', issues: err.flatten() });
        return;
      }
      throw err;
    }
    return;
  }
  sendJson(res, 404, { error: 'not_found' });
});
 
server.listen(env.PORT);

import { z } from 'zod';
 
const IdParams = z.object({ id: z.string().uuid() });
 
// Reusable middleware pattern
function parseParams<T extends z.ZodType>(schema: T, input: unknown): z.infer<T> {
  return schema.parse(input);
}