Typed Error Middleware

Express error middleware has a distinct signature:

// Define structured error types
interface AppError extends Error {
	statusCode: number;
	code: string;
	details?: unknown;
}

// Create typed error classes
class NotFoundError extends Error implements AppError {
	statusCode = 404;
	code = 'NOT_FOUND';

	constructor(message = 'Resource not found') {
		super(message);
		this.name = 'NotFoundError';
	}
}

class ValidationError extends Error implements AppError {
	statusCode = 400;
	code = 'VALIDATION_ERROR';
	details: unknown;

	constructor(message = 'Validation failed', details?: unknown) {
		super(message);
		this.name = 'ValidationError';
		this.details = details;
	}
}

// Create a type-safe error handler
function errorHandler(err: Error, req: Request, res: Response, next: NextFunction): void {
	console.error(err);

	// Handle known error types
	if ('statusCode' in err && 'code' in err) {
		const appError = err as AppError;

		return res.status(appError.statusCode).json({
			error: {
				message: appError.message,
				code: appError.code,
				...(appError.details && { details: appError.details }),
			},
		});
	}

	// Handle unknown errors
	res.status(500).json({
		error: {
			message: 'Internal server error',
			code: 'INTERNAL_ERROR',
		},
	});
}

// Register the error handler (must be last)
app.use(errorHandler);

// Usage in routes
app.get(
	'/users/:id',
	asyncHandler(async (req, res) => {
		const user = await getUserById(req.params.id);

		if (!user) {
			throw new NotFoundError(`User with ID ${req.params.id} not found`);
		}

		res.json(user);
	}),
);

app.post(
	'/users',
	asyncHandler(async (req, res) => {
		try {
			// Validation logic
			const validatedData = validateUser(req.body);

			// Create user
			const user = await createUser(validatedData);

			res.status(201).json(user);
		} catch (error) {
			if (error.name === 'ValidationError') {
				throw new ValidationError('User validation failed', error.details);
			}
			throw error;
		}
	}),
);

This structured approach to error handling ensures that:

1. All errors are properly typed
2. Error responses follow a consistent format
3. Different error types result in appropriate HTTP status codes
4. Error details are preserved when needed