mini-nest 1.0.0

package/README.md

@@ -0,0 +1,556 @@
+# mini-nest
+
+A lightweight, NestJS-inspired BFF (Backend-for-Frontend) framework for Node.js.
+
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org/)
+[![Test Coverage](https://img.shields.io/badge/coverage-92.5%25-brightgreen.svg)]()
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+English | [中文](README-CN.md)
+
+## Features
+
+- 🎯 **Decorator-based** - Familiar NestJS-style decorators
+- 💉 **Dependency Injection** - Automatic constructor injection
+- 🛡️ **Guards & Interceptors** - Request pipeline control
+- ⚡ **AOP Decorators** - `@Cache`, `@Retry`, `@Timeout`, `@CircuitBreaker`
+- 🔗 **HTTP Client** - Built-in client with `aggregate()` for BFF patterns
+- 🌳 **Trie-based Routing** - Fast route matching with params
+- 🔄 **Lifecycle Hooks** - `OnInit`, `OnDestroy`, etc.
+- 📦 **Lightweight** - Minimal dependencies, ~65% Express performance, ~90% fastify performance
+
+
+## Design Boundaries
+
+mini-nest is intentionally lightweight. Here's what it **does** and **doesn't** do:
+
+| Feature | Status | Notes |
+|---------|--------|-------|
+| Singleton DI | ✅ | No request-scope support yet |
+| Static routing | ✅ | No regex/wildcard patterns |
+| JSON API | ✅ | No streaming/multipart built-in |
+| Single-tenant | ✅ | Multi-tenant needs manual handling |
+| Decorator-based | ✅ | No runtime route registration |
+
+**Best for:**
+- BFF (Backend-for-Frontend) layers
+- Small to medium APIs
+- Teams familiar with NestJS patterns
+- Projects prioritizing simplicity over features
+
+**Not ideal for:**
+- Large monoliths needing module isolation
+- Real-time streaming applications
+- Multi-tenant SaaS (without custom work)
+- Projects requiring request-scoped DI
+
+## Installation
+
+```bash
+npm install mini-nest
+```
+
+## Quick Start
+
+```typescript
+import 'reflect-metadata';
+import { createMiniNestApp, Controller, Get, Injectable, Param } from 'mini-nest';
+
+@Injectable()
+class UserService {
+    getUser(id: string) {
+        return { id, name: 'Alice' };
+    }
+}
+
+@Controller('/api/users')
+class UserController {
+    constructor(private userService: UserService) {}
+
+    @Get('/:id')
+    getUser(@Param('id') id: string) {
+        return this.userService.getUser(id);
+    }
+}
+
+const app = createMiniNestApp({
+    port: 3000,
+    controllers: [UserController],
+});
+
+app.listen(() => console.log('Server running on http://localhost:3000'));
+```
+
+## Documentation
+
+### Controllers & Routes
+
+```typescript
+import { Controller, Get, Post, Put, Delete, Patch } from 'mini-nest';
+
+@Controller('/api/users')
+class UserController {
+    @Get('/')
+    findAll() {
+        return [];
+    }
+
+    @Get('/:id')
+    findOne(@Param('id') id: string) {
+        return { id };
+    }
+
+    @Post('/')
+    create(@Body() data: any) {
+        return data;
+    }
+
+    @Put('/:id')
+    update(@Param('id') id: string, @Body() data: any) {
+        return { id, ...data };
+    }
+
+    @Delete('/:id')
+    remove(@Param('id') id: string) {
+        return { deleted: id };
+    }
+}
+```
+
+### Parameter Decorators
+
+```typescript
+import { Body, Query, Param, Header } from 'mini-nest';
+
+@Controller('/api')
+class ExampleController {
+    @Post('/search')
+    search(
+        @Body() body: any,                    // Full body
+        @Body('query') query: string,         // Specific field
+        @Query('page') page: string,          // Query param
+        @Param('id') id: string,              // Route param
+        @Header('authorization') auth: string // Header
+    ) {
+        return { body, query, page, id, auth };
+    }
+}
+```
+
+### Dependency Injection
+
+```typescript
+import { Injectable } from 'mini-nest';
+
+@Injectable()
+class DatabaseService {
+    query(sql: string) {
+        return [{ id: 1 }];
+    }
+}
+
+@Injectable()
+class UserRepository {
+    constructor(private db: DatabaseService) {}
+
+    findAll() {
+        return this.db.query('SELECT * FROM users');
+    }
+}
+
+@Injectable()
+class UserService {
+    constructor(private repo: UserRepository) {}
+
+    getUsers() {
+        return this.repo.findAll();
+    }
+}
+```
+
+### Guards
+
+```typescript
+import { Injectable, Guard, UseGuard, ExecutionContext } from 'mini-nest';
+
+@Injectable()
+class AuthGuard implements Guard {
+    canActivate(ctx: ExecutionContext): boolean {
+        const request = ctx.getRequest();
+        const token = request.header('authorization');
+        return token === 'Bearer valid-token';
+    }
+}
+
+@Controller('/api/admin')
+class AdminController {
+    @Get('/dashboard')
+    @UseGuard([AuthGuard])
+    getDashboard() {
+        return { data: 'secret' };
+    }
+}
+```
+
+### Interceptors
+
+```typescript
+import { Injectable, Interceptor, UseInterceptor } from 'mini-nest';
+
+@Injectable()
+class LoggingInterceptor implements Interceptor {
+    async intercept(next: () => Promise<unknown>) {
+        console.log('Before...');
+        const result = await next();
+        console.log('After...');
+        return result;
+    }
+}
+
+@Injectable()
+class TransformInterceptor implements Interceptor {
+    async intercept(next: () => Promise<unknown>) {
+        const result = await next();
+        return { data: result, timestamp: Date.now() };
+    }
+}
+
+@Controller('/api')
+@UseInterceptor(LoggingInterceptor)
+class ApiController {
+    @Get('/data')
+    @UseInterceptor(TransformInterceptor)
+    getData() {
+        return { message: 'Hello' };
+    }
+}
+```
+
+### AOP Decorators
+
+#### @Cache
+
+```typescript
+import { Cache } from 'mini-nest';
+
+@Injectable()
+class DataService {
+    @Cache({ ttl: 60 })  // Cache for 60 seconds
+    getExpensiveData() {
+        return computeExpensiveOperation();
+    }
+
+    @Cache({ ttl: 300, key: 'custom-key' })
+    getWithCustomKey() {
+        return data;
+    }
+}
+```
+
+#### @Retry
+
+```typescript
+import { Retry } from 'mini-nest';
+
+@Injectable()
+class ExternalApiService {
+    @Retry(3)  // Retry up to 3 times with exponential backoff
+    async fetchData() {
+        return await fetch('https://api.example.com/data');
+    }
+}
+```
+
+#### @Timeout
+
+```typescript
+import { Timeout } from 'mini-nest';
+
+@Injectable()
+class SlowService {
+    @Timeout(5000)  // Timeout after 5 seconds
+    async slowOperation() {
+        return await longRunningTask();
+    }
+}
+```
+
+#### @CircuitBreaker
+
+```typescript
+import { CircuitBreaker } from 'mini-nest';
+
+@Injectable()
+class RiskyService {
+    @CircuitBreaker({ 
+        failureThreshold: 5,  // Open after 5 failures
+        resetTimeout: 30000   // Try again after 30s
+    })
+    async callExternalService() {
+        return await externalApi.call();
+    }
+}
+```
+
+### HttpClient
+
+Built-in HTTP client with retry, timeout, and aggregation support:
+
+```typescript
+import { Injectable, HttpClient } from 'mini-nest';
+
+@Injectable()
+class ApiService {
+    constructor(private http: HttpClient) {}
+
+    async getUser(id: string) {
+        const res = await this.http.get(`https://api.example.com/users/${id}`);
+        return res.data;
+    }
+
+    async createUser(data: any) {
+        const res = await this.http.post('https://api.example.com/users', data);
+        return res.data;
+    }
+}
+```
+
+#### Aggregate (BFF Pattern)
+
+Combine multiple API calls into a single response:
+
+```typescript
+@Injectable()
+class BffService {
+    constructor(private http: HttpClient) {}
+
+    async getUserProfile(userId: string) {
+        const { data, errors } = await this.http.aggregate({
+            baseUrl: 'https://api.example.com',
+            params: { id: userId },
+            sources: {
+                user: '/users/:id',
+                posts: '/users/:id/posts',
+                followers: '/users/:id/followers',
+            },
+            output: (sources) => ({
+                id: sources.user.id,
+                name: sources.user.name,
+                postCount: sources.posts.length,
+                followerCount: sources.followers.length,
+            }),
+            timeout: 5000,
+            partial: true,  // Continue even if some requests fail
+        });
+
+        return data;
+    }
+}
+```
+
+### Lifecycle Hooks
+
+```typescript
+import { Injectable, OnInit, OnDestroy } from 'mini-nest';
+
+@Injectable()
+class DatabaseService implements OnInit, OnDestroy {
+    private connection: any;
+
+    OnInit() {
+        console.log('Connecting to database...');
+        this.connection = createConnection();
+    }
+
+    OnDestroy() {
+        console.log('Closing database connection...');
+        this.connection.close();
+    }
+}
+```
+
+### Validation
+
+```typescript
+import { Query, Body, rule } from 'mini-nest';
+
+@Controller('/api')
+class ValidationController {
+    @Get('/search')
+    search(
+        @Query({ 
+            key: 'page', 
+            validator: rule().required().min(1) 
+        }) 
+        page: number,
+
+        @Query({ 
+            key: 'email', 
+            validator: rule().required().pattern(/^[\w-]+@[\w-]+\.\w+$/) 
+        }) 
+        email: string
+    ) {
+        return { page, email };
+    }
+
+    @Post('/users')
+    createUser(
+        @Body({
+            key: 'name',
+            validator: rule().required().minLength(2).maxLength(50)
+        })
+        name: string
+    ) {
+        return { name };
+    }
+}
+```
+
+### Exception Handling
+
+```typescript
+import { 
+    NotFoundException, 
+    BadRequestException, 
+    UnauthorizedException,
+    ForbiddenException,
+    InternalServerErrorException 
+} from 'mini-nest';
+
+@Controller('/api/users')
+class UserController {
+    @Get('/:id')
+    getUser(@Param('id') id: string) {
+        const user = findUser(id);
+        if (!user) {
+            throw new NotFoundException(`User ${id} not found`);
+        }
+        return user;
+    }
+}
+```
+
+Custom exception filter:
+
+```typescript
+import { ExceptionFilter, ExecutionContext } from 'mini-nest';
+
+class CustomExceptionFilter implements ExceptionFilter {
+    canHandle(exception: unknown): boolean {
+        return exception instanceof CustomError;
+    }
+
+    catch(exception: CustomError, context: ExecutionContext) {
+        const response = context.getResponse();
+        response.status(400).json({
+            error: 'CustomError',
+            message: exception.message,
+        });
+    }
+}
+```
+
+## Configuration
+
+```typescript
+const app = createMiniNestApp({
+    port: 3000,
+    adapter: 'express' | 'fastify',  
+    controllers: [UserController, PostController],
+    https: {             // Optional HTTPS
+        key: '/path/to/key.pem',
+        cert: '/path/to/cert.pem',
+    },
+});
+```
+
+## Benchmark
+
+Compared against Express and Fastify (10s, 100 connections):
+
+
+| Framework | Requests | Relative |
+|-----------|----------|----------|
+| Fastify (raw) | 2,544,032 | 100% |
+| mini-nest + Fastify | 2,290,571 | 90.0% |
+| Express (raw) | 1,742,452 | 68.5% |
+| mini-nest + Express | 1,739,737 | 68.4% |
+
+mini-nest performs comparably to Express while providing:
+- Dependency Injection
+- Decorator-based routing
+- AOP features (Cache, Retry, Timeout, CircuitBreaker)
+- Guards & Interceptors
+- Built-in HTTP client with aggregation
+
+Run benchmarks locally:
+
+```bash
+npm run benchmark
+```
+
+## Project Structure
+
+```
+src/
+├── core/
+│   ├── app/           # Application bootstrap
+│   ├── container/     # DI container
+│   └── pipeline/      # Request pipeline
+├── decorators/
+│   ├── http/          # @Controller, @Get, @Post, etc.
+│   └── aop/           # @Cache, @Retry, @Timeout, @CircuitBreaker
+├── http/
+│   ├── adapters/      # Express and Fastify adapter
+│   └── client/        # HttpClient
+├── guards/            # Guard system
+├── interceptors/      # Interceptor system
+├── exceptions/        # Exception handling
+├── routing/           # Trie-based router
+├── validation/        # Parameter validation
+└── lifecycle/         # Lifecycle hooks
+```
+
+## Requirements
+
+- Node.js 18+
+- TypeScript 5.0+
+- `experimentalDecorators: true`
+- `emitDecoratorMetadata: true`
+
+tsconfig.json:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "experimentalDecorators": true, //very important
+    "emitDecoratorMetadata": true, //very important
+    "esModuleInterop": true,
+    "strict": true
+  }
+}
+```
+
+## Testing
+
+```bash
+# Run tests
+npm test
+
+# Run with coverage
+npm run test:coverage
+```
+
+## Roadmap
+
+- [ ] Module system (`@Module()`)
+- [ ] WebSocket support
+- [ ] OpenAPI/Swagger generation
+- [ ] CLI tool
+
+## License
+
+MIT

package/dist/aop/aopWrapper.d.ts

@@ -0,0 +1,17 @@
+import { Constructor } from "../core/container/container";
+import { CacheOptions } from "../decorators/aop/Cache";
+import { CircuitBreakerOptions } from "../decorators/aop/CircuitBreaker";
+export interface AOPContext {
+    target: Object;
+    method: Function;
+    args: any[];
+    methodName: string;
+    className: string;
+    timeout?: number;
+    retry?: number;
+    cache?: CacheOptions;
+    circuitBreaker?: CircuitBreakerOptions;
+}
+export declare function wrapWithAOP<T extends object>(instance: T, token: Constructor<T>): T;
+export declare function executeWithAOP(ctx: AOPContext): Promise<any>;
+//# sourceMappingURL=aopWrapper.d.ts.map

package/dist/aop/aopWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aopWrapper.d.ts","sourceRoot":"","sources":["../../src/aop/aopWrapper.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAGzE,MAAM,WAAW,UAAU;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,QAAQ,CAAC;IACjB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,cAAc,CAAC,EAAE,qBAAqB,CAAC;CAC1C;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAkCnF;AAID,wBAAsB,cAAc,CAAC,GAAG,EAAE,UAAU,gBA8DnD"}

package/dist/aop/aopWrapper.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapWithAOP = wrapWithAOP;
+exports.executeWithAOP = executeWithAOP;
+const cacheManager_1 = require("../cache/cacheManager");
+const circuitBreakerManager_1 = require("../circuitBreaker/circuitBreakerManager");
+const circuitOpenError_1 = require("../circuitBreaker/circuitOpenError");
+const metadataKeys_1 = require("../routing/metadataKeys");
+function wrapWithAOP(instance, token) {
+    const proto = token.prototype;
+    return new Proxy(instance, {
+        get(target, prop, receiver) {
+            const original = Reflect.get(target, prop, receiver);
+            if (typeof original !== 'function') {
+                return original;
+            }
+            const propKey = String(prop);
+            const timeout = metadataKeys_1.TIMEOUT.get(proto, propKey);
+            const cache = metadataKeys_1.CACHE.get(proto, propKey);
+            const retry = metadataKeys_1.RETRY.get(proto, propKey);
+            const circuitBreaker = metadataKeys_1.CIRCUITBREAKER.get(proto, propKey);
+            if (timeout === undefined && cache === undefined && retry === undefined && circuitBreaker === undefined) {
+                return original.bind(target);
+            }
+            return async function (...args) {
+                return executeWithAOP({
+                    target,
+                    method: original,
+                    args,
+                    methodName: propKey,
+                    className: token.name,
+                    timeout,
+                    cache,
+                    retry,
+                    circuitBreaker
+                });
+            };
+        }
+    });
+}
+async function executeWithAOP(ctx) {
+    const { target, method, args, timeout, className, methodName, retry, cache, circuitBreaker } = ctx;
+    const circuitKey = `${className}-${methodName}`;
+    if (circuitBreaker) {
+        const { failureThreshold = 5, resetTimeout = 30000 } = circuitBreaker;
+        const { allowed, reason } = circuitBreakerManager_1.circuitBreakerManager.canExecute(circuitKey, resetTimeout);
+        if (!allowed) {
+            throw new circuitOpenError_1.CircuitOpenError(reason);
+        }
+    }
+    const cacheKey = cache
+        ? (cache.key ?? `${className}:${methodName}:${JSON.stringify(args)}`)
+        : null;
+    if (cacheKey && cacheManager_1.cacheManager.has(cacheKey)) {
+        return cacheManager_1.cacheManager.get(cacheKey);
+    }
+    //build execution function
+    const execute = async () => {
+        const promise = method.apply(target, args);
+        if (timeout === undefined) {
+            return promise;
+        }
+        return withTimeout(promise, timeout);
+    };
+    try {
+        const result = retry !== undefined ? await withRetry(execute, retry) : await execute();
+        if (circuitBreaker) {
+            circuitBreakerManager_1.circuitBreakerManager.recordSuccess(circuitKey);
+        }
+        if (cacheKey && cache) {
+            cacheManager_1.cacheManager.set(cacheKey, result, cache.ttl);
+        }
+        return result;
+    }
+    catch (error) {
+        if (circuitBreaker) {
+            const { failureThreshold = 5 } = circuitBreaker;
+            circuitBreakerManager_1.circuitBreakerManager.recordFailure(circuitKey, failureThreshold);
+        }
+        throw error;
+    }
+}
+async function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            return setTimeout(() => reject(new Error(`Request timeout after ${ms}ms`)), ms);
+        })
+    ]);
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function withRetry(fn, maxRetryTime) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetryTime; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                error = new Error(String(error));
+            }
+            lastError = error;
+            if (attempt < maxRetryTime) {
+                await delay(100 * Math.pow(2, attempt));
+            }
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=aopWrapper.js.map

package/dist/aop/aopWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aopWrapper.js","sourceRoot":"","sources":["../../src/aop/aopWrapper.ts"],"names":[],"mappings":"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"}

package/dist/cache/cacheManager.d.ts

@@ -0,0 +1,11 @@
+declare class CacheManager {
+    private cache;
+    get<T>(key: string | symbol): T | undefined;
+    set(key: string | symbol, value: any, ttlSeconds: number): void;
+    delete(key: string | symbol): void;
+    clear(): void;
+    has(key: string | symbol): boolean;
+}
+export declare const cacheManager: CacheManager;
+export {};
+//# sourceMappingURL=cacheManager.d.ts.map