Reiatsu

A Minimal, Type-Safe HTTP Server Framework Built from First Principles

Reiatsu is a lightweight HTTP server framework for Node.js, crafted entirely from first principles using only Node.js core modules. With zero external dependencies, full TypeScript support, and production-ready features, Reiatsu proves that you don't need a massive framework to build powerful, performant web applications.

The Philosophy: Back to Basics

In a world where modern web frameworks come bundled with hundreds of dependencies and megabytes of node_modules, Reiatsu takes a different approach. It's built directly on Node.js's http module, leveraging the raw power and simplicity of the platform without external abstractions.

This isn't just minimalism for the sake of it, it's about understanding the fundamentals, having complete control over your stack, and building web applications that are fast, secure, and maintainable.

Why Reiatsu?

Zero Dependencies No external packages. No supply chain vulnerabilities. No dependency hell. Just Node.js and your code.

Pure Node.js HTTP Built directly on Node.js's http module for maximum performance and minimal overhead.

TypeScript First Fully typed with comprehensive TypeScript support. IntelliSense works perfectly, and your IDE will catch errors before runtime.

Production Ready Despite its minimalist approach, Reiatsu includes everything you need for production: middleware support, security headers, rate limiting, CORS, error handling, and more.

Core Features

Advanced Routing

Dynamic route parameters with type safety
Parameterized routes (e.g., /users/:id)
Wildcard routes for flexible matching
Chainable route definitions

Flexible Middleware

Global middleware that runs for all routes
Per-route middleware for granular control
Async/await support throughout
Clean, composable middleware functions

Request/Response Helpers

Modern, chainable API for response building
Built-in JSON, HTML, and text response methods
Query parameter parsing
Cookie handling
Status code helpers

Built-in Middleware Reiatsu ships with production-ready middleware:

CORS: Configurable cross-origin resource sharing with presets for development and production
Rate Limiting: Token bucket algorithm to prevent abuse
Logger: Detailed request/response logging with customizable options
Security Headers: Automatic security headers (HSTS, X-Frame-Options, CSP, etc.)
Static File Serving: Efficient static asset delivery
Body Parsing: JSON and URL-encoded request body parsing
Error Handling: Centralized error handling with custom error classes

Security & Production Features

Request ID tracking for debugging
Input validation with custom validators
Environment-specific optimizations
Comprehensive error handling
Request timeout management
Graceful shutdown support

Example Usage


typescript
1import { router, serve, use } from "reiatsu";
2import {
3  createLoggerMiddleware,
4  corsPresets,
5  errorHandlerMiddleware,
6} from "reiatsu";
7
8// Global middleware
9use(errorHandlerMiddleware);
10use(createLoggerMiddleware({ colorize: true }));
11use(corsPresets.development());
12
13// Simple route
14router.get("/", (ctx) => {
15  ctx.status(200).json({ message: "Hello, World!" });
16});
17
18// Dynamic route with type-safe parameters
19router.get("/users/:id", (ctx) => {
20  const userId = ctx.params.id; // TypeScript knows this exists
21  ctx.json({ user: userId });
22});
23
24// Start server
25serve(3000);

Technical Excellence

Reiatsu demonstrates deep understanding of several technical concepts:

HTTP Protocol Direct implementation using Node.js http module, showcasing understanding of request/response cycles, headers, status codes, and HTTP methods.

Routing Algorithms Custom routing engine with efficient pattern matching for dynamic routes and wildcards.

Middleware Pattern Implementation of the middleware pattern with proper async flow control and error handling.

Type Safety Advanced TypeScript usage with generic types for route parameters, ensuring compile-time safety.

Performance Optimization Minimal overhead, efficient parsing, and smart caching strategies for production use.

Published on npm

Reiatsu is publicly available on npm and ready for production use:


bash
1npm install reiatsu

The package includes:

Full TypeScript definitions
Comprehensive documentation
Example applications
Middleware library
Production optimizations

Use Cases

Learning Tool Perfect for developers who want to understand how web frameworks work under the hood. The codebase is clean, well-documented, and educational.

Microservices Ideal for building lightweight microservices where you don't need the overhead of larger frameworks.

API Servers Build fast, type-safe REST APIs with minimal dependencies.

Edge Computing The zero-dependency approach makes it perfect for edge environments where bundle size matters.

Production Applications Don't let the simplicity fool you, Reiatsu includes all the features needed for production deployments.

The Impact

Reiatsu proves that modern web development doesn't require complex dependency chains. It's a reminder that understanding fundamentals and building from first principles can result in software that's faster, more secure, and easier to maintain.

This project has been downloaded by developers worldwide, used in production applications, and serves as an educational resource for those learning Node.js internals and web framework architecture.

Notes

Published on npm with regular downloads
Zero external dependencies (only Node.js core modules)
Fully documented with comprehensive TypeScript types
Includes built-in middleware for common use cases
Suitable for production use
Educational value for learning web framework internals
Active maintenance

Tech Stack