Ship production-ready REST APIs in minutes 🐿️   •   Documentation 📖

What is YasuiJS?

Yasui (meaning "easy" in Japanese) is a lightweight multi-runtime framework built on Web Standards and pushed with SRVX, that brings the developer experience of modern frameworks without the complexity. It runs on Node.js, Deno, and Bun, providing the structure you need with just the features you'll actually use.

Features Summary

• Multi-Runtime: Runs on Node.js, Deno, and Bun via SRVX and Web Standards
• Lightweight & Fast: Minimal dependencies with focus on essentials without the bloat
• Complete Error Handling: Everything can throw without try/catch - automatic error handling everywhere
• Automatic Type-Casting: Query params automatically converted to proper types. Even in middlewares
• Flexible DI System: Constructor and method-level injection with configurable scopes for better control
• Simple Middlewares: Apply at global, controller, or route level. Use the same decorators as controllers
• Rich Swagger Generation: Flexible decorators for enums, arrays, classes, OpenAPI schemas
• HTTPS/HTTP2 Support: Built-in TLS configuration with automatic HTTP/2 on Node.js
• Type-safe: Full TypeScript support with proper typing

Quick Start

npm install yasui

import yasui, { Controller, Get } from 'yasui';

@Controller('/')
export class AppController {
  @Get('/')
  hello() {
    return { message: 'Hello World!' };
  }
}

yasui.createServer({
  controllers: [AppController]
});

📖 Documentation

• Configuration - Server setup and global options
• Controllers - Define routes with decorators and automatic type casting
• Dependency Injection - Constructor and method-level injection with flexible scopes
• Error Handling - Automatic error catching without try/catch blocks
• Logging - Built-in timing and color-coded logging service
• Middlewares - Apply at multiple levels with same decorators as controllers
• Pipes - Transform and validate request data automatically
• Swagger Doc. - Generate OpenAPI docs with flexible decorators

Plugins

Production-ready middlewares and utilities for YasuiJS:

• @yasui/cors (JSR) - CORS middleware
• @yasui/rate-limit (JSR) - Rate limiting middleware
• @yasui/validation (JSR) - Automatic DTO validation middleware

Why YasuiJS?

YasuiJS adopts a class-based, object-oriented approach with decorators, bringing significant architectural advantages:

Better Code Organization

Classes and decorators provide better organization, encapsulation, and maintainability. This approach naturally supports established architectural patterns like onion architecture, hexagonal architecture, and clean architecture.

Dependency Injection

Built-in dependency injection enables loose coupling, better testability, and cleaner separation of concerns. Dependencies are explicitly declared and automatically resolved.

Declarative Over Imperative

Instead of manually registering routes and extracting parameters, you declare what you want using decorators. The framework handles the implementation details.

Multi-Runtime Support

Built on web standards, YasuiJS provides a portable, standard codebase for JavaScript runtimes, capable of running on Node.js, Deno, and Bun with SRVX, a universal server abstraction based on the Fetch API. Future-proof your applications with standard web APIs.

Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.
Please use npm run commit to standardize commits nomenclature.

License

This project is licensed under the GNU Affero General Public License v3.0 or later. See the LICENSE file for details.