@mini2/core 1.0.9 → 1.1.1

package/Readme.MD

@@ -1,33 +1,26 @@
 # @mini2/core
 
-**Mini Express Framework** - Express.js tabanlı hafif ve modüler web framework'ü. TypeScript desteği, otomatik Swagger dokümantasyonu, dependency injection ve decorator tabanlı routing sistemi ile modern API geliştirme deneyimi sağlar.
+**Mini REST Framework** - A lightweight and modular web framework built on top of Express.js. Features TypeScript support, automatic Swagger documentation, dependency injection, and decorator-based routing system for modern API development experience.
 
-## ✨ Özellikler
+## ✨ Features
 
-- 🚀 **Decorator Tabanlı Routing**: `@Get`, `@Post` gibi decorator'lar ile kolay route tanımlama
-- 📝 **Otomatik Swagger Dokümantasyonu**: API dokümantasyonu otomatik oluşturulur
-- 🔧 **Dependency Injection**: InversifyJS tabanlı güçlü DI container
-- 🛡️ **Güvenlik Middleware'leri**: Authentication, authorization ve validation
-- 📦 **Tam TypeScript Desteği**: Type-safe API geliştirme
-- 🎯 **Response Builder**: Tutarlı API yanıtları
-- ⚡ **Hızlı Kurulum**: Minimal konfigürasyon
+- 🚀 **Decorator-Based Routing**: Easy route definition with decorators like `@get`, `@post`
+- 📝 **Automatic Swagger Documentation**: API documentation generated automatically
+- 🔧 **Dependency Injection**: Powerful DI container based on InversifyJS
+- 🛡️ **Security Middlewares**: Authentication, authorization, and validation
+- 📦 **Full TypeScript Support**: Type-safe API development
+- 🎯 **Response Builder**: Consistent API responses
+- ⚡ **Quick Setup**: Minimal configuration required
 
-## 📦 Kurulum
+## 📦 Installation
 
 ```bash
 npm install @mini2/core
 ```
 
-### Peer Dependencies (Opsiyonel)
+## 🚀 Quick Start
 
-```bash
-# Eğer MongoDB kullanıyorsanız
-npm install mongoose
-```
-
-## 🚀 Hızlı Başlangıç
-
-### 1. Temel Konfigürasyon
+### 1. Basic Configuration
 
 ```typescript
 import { App, IConfig } from '@mini2/core';
@@ -38,9 +31,9 @@ const config: IConfig = {
 	applicationName: 'My API',
 };
 
-// Controller'ları tanımlayın
+// Define your controllers
 const controllers = [
-	// Controller sınıflarınız
+	// Your controller classes
 ];
 
 const app = new App(controllers);
@@ -48,89 +41,494 @@ await app.init(config);
 await app.afterInit();
 ```
 
-### 2. Controller Oluşturma
+### 2. Creating a Controller
 
 ```typescript
 import {
-	Controller,
-	Get,
-	Post,
+	controller,
+	get,
+	post,
+	put,
+	del,
+	req,
+	res,
 	ResponseBuilder,
-	validationMiddleware,
+	authenticated,
+	authorized,
+	validate,
 } from '@mini2/core';
 
-@Controller('/api/users')
+@controller('/api/users')
 export class UserController {
-	@Get('/')
-	async getUsers() {
-		const users = await this.userService.findAll();
+	@get('/')
+	async getUsers(@req() request: Request) {
+		const page = Number(request.query.page) || 1;
+		const users = await this.userService.findAll(page);
 		return new ResponseBuilder().ok(users);
 	}
 
-	@Post('/')
-	@Validation({ body: CreateUserDto })
-	async createUser(@Body() userData: CreateUserDto) {
+	@post('/')
+	@validate({ body: CreateUserDto })
+	async createUser(@req() req: Request) {
+		const userData = req.body;
 		const user = await this.userService.create(userData);
 		return new ResponseBuilder().created(user);
 	}
 
-	@Get('/:id')
-	@Authenticated()
-	@Authorized(['user:read'])
-	async getUser(@Param('id') id: string) {
+	@get('/:id')
+	@authenticated()
+	@authorized(['user:read'])
+	async getUser(@req() req: Request) {
+		const id = req.params.id;
 		const user = await this.userService.findById(id);
+		if (!user) throw new NotFoundException({ message: 'User not found' });
+		return new ResponseBuilder().ok(user);
+	}
+
+	@put('/:id')
+	@authenticated()
+	@authorized(['user:write'])
+	@validate({ body: UpdateUserDto, params: UserParamsDto })
+	async updateUser(@req() req: Request) {
+		const id = req.params.id;
+		const updateData = req.body;
+		const user = await this.userService.update(id, updateData);
 		return new ResponseBuilder().ok(user);
 	}
+
+	@del('/:id')
+	@authenticated()
+	@authorized(['admin', 'user:delete'])
+	async deleteUser(@req() req: Request) {
+		const id = req.params.id;
+		await this.userService.delete(id);
+		return new ResponseBuilder().ok({ message: 'User deleted successfully' });
+	}
+}
+```
+
+## 🎭 Decorators Deep Dive
+
+Decorators are the core feature of @mini2/core, providing a clean and intuitive way to define routes, middleware, and validation rules.
+
+### 🏷️ Class Decorators
+
+#### **@controller(path?: string)**
+
+Defines a controller class and optionally sets a base path for all routes in the controller.
+
+```typescript
+@controller('/api/v1/users')
+export class UserController {
+	// All routes will be prefixed with '/api/v1/users'
+}
+
+@controller('') // No base path
+export class HomeController {
+	@get('/') // Route: '/'
+	home() {
+		/* ... */
+	}
+}
+```
+
+**Features:**
+
+- Sets base path for all routes in the controller
+- Enables automatic route registration
+- Integrates with Swagger documentation generation
+
+### 🚦 HTTP Method Decorators
+
+#### **@get(path: string)**
+
+Defines a GET route handler.
+
+```typescript
+@get('/profile')
+async getProfile(@req() req: Request) {
+  // Handles GET /api/users/profile
+  return new ResponseBuilder().ok(req.user);
+}
+
+@get('/:id/posts')
+async getUserPosts(@req() req: Request) {
+  const userId = req.params.id;
+  // Handles GET /api/users/:id/posts
+}
+
+@get('/search')
+async searchUsers(@req() req: Request) {
+  const query = req.query.q;
+  // Handles GET /api/users/search?q=searchterm
+}
+```
+
+#### **@post(path: string)**
+
+Defines a POST route handler.
+
+```typescript
+@post('/')
+@validate({ body: CreateUserDto })
+async createUser(@req() req: Request) {
+  // Handles POST /api/users
+  const userData = req.body;
+  return new ResponseBuilder().created(userData);
+}
+
+@post('/:id/avatar')
+@authenticated()
+async uploadAvatar(@req() req: Request) {
+  const id = req.params.id;
+  // Handles POST /api/users/:id/avatar
+}
+```
+
+#### **@put(path: string)**
+
+Defines a PUT route handler for full resource updates.
+
+```typescript
+@put('/:id')
+@authenticated()
+@validate({ body: UpdateUserDto })
+async updateUser(@req() req: Request) {
+  const id = req.params.id;
+  const data = req.body;
+  // Handles PUT /api/users/:id
+}
+```
+
+#### **@patch(path: string)**
+
+Defines a PATCH route handler for partial resource updates.
+
+```typescript
+@patch('/:id')
+@authenticated()
+@validate({ body: PartialUserDto })
+async patchUser(@req() req: Request) {
+  const id = req.params.id;
+  const data = req.body;
+  // Handles PATCH /api/users/:id
+}
+```
+
+#### **@del(path: string)**
+
+Defines a DELETE route handler. Note: uses `@del` instead of `@delete` (reserved keyword).
+
+```typescript
+@del('/:id')
+@authenticated()
+@authorized(['admin'])
+async deleteUser(@req() req: Request) {
+  const id = req.params.id;
+  // Handles DELETE /api/users/:id
+}
+```
+
+### 📝 Parameter Decorators
+
+Parameter decorators inject Express request/response objects into method parameters.
+
+#### **@req()**
+
+Injects the Express request object.
+
+```typescript
+@get('/:id')
+async getUser(@req() request: Request) {
+  const id = request.params.id;
+  const userAgent = request.headers['user-agent'];
+  const query = request.query;
+  // Full access to Express Request object
+}
+```
+
+#### **@res()**
+
+Injects the Express response object. **Note: If you use @res(), you must handle the response manually.**
+
+```typescript
+@get('/download/:file')
+async downloadFile(@req() req: Request, @res() res: Response) {
+  const filename = req.params.file;
+
+  // Manual response handling required
+  res.setHeader('Content-Disposition', `attachment; filename=${filename}`);
+  res.sendFile(path.join(__dirname, 'files', filename));
+
+  // Don't return ResponseBuilder when using @res()
+}
+```
+
+### 🛡️ Security Decorators
+
+#### **@authenticated()**
+
+Ensures the user is authenticated before accessing the route.
+
+```typescript
+@get('/profile')
+@authenticated()
+async getProfile(@req() req: Request) {
+  // req.authenticated is guaranteed to be true
+  // User must be logged in to access this route
+  return new ResponseBuilder().ok(req.user);
+}
+```
+
+**Requirements:**
+
+- Request must have `authenticated: true` property
+- Usually set by authentication middleware
+- Throws `UnauthorizedException` if not authenticated
+
+#### **@authorized(permissions: string | string[])**
+
+Checks if the authenticated user has required permissions.
+
+```typescript
+@del('/:id')
+@authenticated()
+@authorized(['admin'])
+async deleteUser(@req() req: Request) {
+  // Only users with 'admin' permission can access
+  const id = req.params.id;
+}
+
+@get('/reports')
+@authenticated()
+@authorized(['reports:read', 'admin'])
+async getReports(@req() req: Request) {
+  // Users need either 'reports:read' OR 'admin' permission
+}
+```
+
+**Requirements:**
+
+- User must be authenticated first
+- Request must have `user.permissions: string[]` property
+- Uses OR logic: user needs ANY of the specified permissions
+- Throws `ForbiddenException` if insufficient permissions
+
+### ✅ Validation Decorators
+
+#### **@validate(options: ValidationOptions)**
+
+Validates request data using class-validator.
+
+```typescript
+@post('/')
+@validate({
+  body: CreateUserDto,
+  params: UserParamsDto,
+  query: SearchQueryDto
+})
+async createUser(@req() req: Request) {
+  // req.body, req.params, req.query are validated and transformed
+  const userData = req.body as CreateUserDto; // Typed as CreateUserDto
+  const params = req.params as UserParamsDto;  // Typed as UserParamsDto
+  const query = req.query as SearchQueryDto;    // Typed as SearchQueryDto
+}
+```
+
+**Options:**
+
+- `body`: DTO class for request body validation
+- `params`: DTO class for URL parameters validation
+- `query`: DTO class for query parameters validation
+
+**Example DTO Classes:**
+
+```typescript
+import {
+	IsEmail,
+	IsString,
+	MinLength,
+	IsOptional,
+	IsNumber,
+} from 'class-validator';
+
+export class CreateUserDto {
+	@IsEmail()
+	email: string;
+
+	@IsString()
+	@MinLength(3)
+	name: string;
+
+	@IsOptional()
+	@IsNumber()
+	age?: number;
+}
+
+export class UserParamsDto {
+	@IsString()
+	id: string;
+}
+
+export class SearchQueryDto {
+	@IsOptional()
+	@IsString()
+	q?: string;
+
+	@IsOptional()
+	@IsNumber()
+	page?: number = 1;
 }
 ```
 
-## 📚 API Referansı
+### 🔧 Custom Middleware Decorators
 
-### 🏗️ Ana Sınıflar
+#### **@middleware(middleware: RequestHandler)**
+
+Adds custom Express middleware to a specific route.
+
+```typescript
+import rateLimit from 'express-rate-limit';
+import multer from 'multer';
+
+const uploadMiddleware = multer({ dest: 'uploads/' });
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100
+});
+
+@post('/upload')
+@middleware(uploadMiddleware.single('file'))
+@middleware(limiter)
+async uploadFile(@req() req: Request) {
+  // Custom middleware applied before route handler
+  const file = req.file;
+  return new ResponseBuilder().created({ filename: file?.filename });
+}
+```
+
+### 🔄 Decorator Combination and Order
+
+Decorators can be combined and are executed in a specific order:
+
+```typescript
+@post('/:id/activate')
+@middleware(loggingMiddleware)      // 1. Custom middleware first
+@authenticated()                   // 2. Authentication check
+@authorized(['admin'])             // 3. Authorization check
+@validate({
+  params: UserParamsDto,           // 4. Validation (params, query, body)
+  body: ActivationDto
+})
+async activateUser(@req() req: Request) {
+  // 5. Route handler executes last
+  const id = req.params.id;
+  const data = req.body;
+}
+```
+
+**Execution Order:**
+
+1. Custom middlewares (from `@middleware`)
+2. Authentication middleware (from `@authenticated`)
+3. Authorization middleware (from `@authorized`)
+4. Validation middleware (from `@validate`)
+5. Route handler method
+
+### 🎯 Advanced Decorator Patterns
+
+#### **Multiple HTTP Methods on Same Path**
+
+```typescript
+@controller('/api/users/:id')
+export class UserDetailController {
+	@get('/')
+	async getUser(@req() req: Request) {
+		// GET /api/users/:id
+		const id = req.params.id;
+	}
+
+	@put('/')
+	@validate({ body: UpdateUserDto })
+	async updateUser(@req() req: Request) {
+		// PUT /api/users/:id
+		const id = req.params.id;
+		const data = req.body;
+	}
+
+	@del('/')
+	@authorized(['admin'])
+	async deleteUser(@req() req: Request) {
+		// DELETE /api/users/:id
+		const id = req.params.id;
+	}
+}
+```
+
+#### **Conditional Decorators**
+
+```typescript
+export class UserController {
+	@get('/public')
+	async getPublicUsers(@req() req: Request) {
+		// No authentication required
+	}
+
+	@get('/private')
+	@authenticated()
+	async getPrivateUsers(@req() req: Request) {
+		// Authentication required
+	}
+}
+```
+
+## 📚 API Reference
+
+### 🏗️ Core Classes
 
 #### **App**
 
-Ana uygulama sınıfı, Express server'ını yönetir.
+Main application class that manages the Express server.
 
 ```typescript
 import { App, IConfig } from '@mini2/core';
 
 const app = new App(controllers);
-await app.init(config); // Server'ı başlat
-await app.afterInit(); // Başlangıç sonrası işlemler
+await app.init(config); // Start the server
+await app.afterInit(); // Post-initialization tasks
 ```
 
-**Özellikler:**
+**Properties:**
 
-- Express server yönetimi
-- Middleware konfigürasyonu
-- Swagger dokümantasyon entegrasyonu
-- Controller routing sistemi
+- Express server management
+- Middleware configuration
+- Swagger documentation integration
+- Controller routing system
 
 #### **Container & container**
 
-Dependency injection için InversifyJS container'ları.
+InversifyJS containers for dependency injection.
 
 ```typescript
 import { Container, container } from '@mini2/core';
 
-// Yeni container oluştur
+// Create new container
 const myContainer = new Container();
 myContainer.bind('UserService').to(UserService);
 
-// Hazır container kullan
+// Use pre-configured container
 container.bind('UserService').to(UserService);
 ```
 
-### 📋 Arayüzler (Interfaces)
+### 📋 Interfaces
 
 #### **IConfig**
 
 ```typescript
 interface IConfig {
-	host: string; // Server host adresi
-	port: number; // Server portu
-	applicationName: string; // Uygulama adı
+	host: string; // Server host address
+	port: number; // Server port
+	applicationName: string; // Application name
 }
 ```
 
@@ -145,7 +543,7 @@ interface IApp {
 
 #### **IRepository<IdentifierType, ModelType>**
 
-Generic repository pattern interface'i.
+Generic repository pattern interface.
 
 ```typescript
 interface IRepository<IdentifierType, ModelType> {
@@ -184,82 +582,82 @@ interface IResponseBuilder<T = any> {
 }
 ```
 
-### 🛡️ Middleware'ler
+### 🛡️ Middlewares
 
 #### **validationMiddleware**
 
-Class-validator tabanlı veri doğrulama.
+Class-validator based data validation.
 
 ```typescript
 import { validationMiddleware } from '@mini2/core';
 
-// Controller içinde
-@Post('/users')
-@Validation({ body: CreateUserDto })
-async createUser(@Body() data: CreateUserDto) {
-  // Doğrulanmış data burada kullanılabilir
+// Usage in controller
+@post('/users')
+@validate({ body: CreateUserDto })
+async createUser(@req() req: Request) {
+  // Validated data available in req.body
 }
 ```
 
-**Desteklenen Validasyon Türleri:**
+**Supported Validation Types:**
 
-- `body` - Request body doğrulama
-- `params` - URL parametreleri doğrulama
-- `query` - Query parametreleri doğrulama
+- `body` - Request body validation
+- `params` - URL parameters validation
+- `query` - Query parameters validation
 
 #### **authenticatedMiddleware**
 
-Kimlik doğrulama kontrolü.
+Authentication control middleware.
 
 ```typescript
 import { authenticatedMiddleware, IAuthenticatedRequest } from '@mini2/core';
 
-// Kullanım
-@Get('/profile')
-@Authenticated()
-async getProfile(@Req() req: IAuthenticatedRequest) {
-  // req.authenticated === true kontrolü yapılır
+// Usage
+@get('/profile')
+@authenticated()
+async getProfile(@req() req: IAuthenticatedRequest) {
+  // req.authenticated === true is guaranteed
 }
 ```
 
 #### **authorizedMiddleware**
 
-Yetkilendirme kontrolü.
+Authorization control middleware.
 
 ```typescript
 import { authorizedMiddleware } from '@mini2/core';
 
-// Kullanım
-@Delete('/admin/users/:id')
-@Authenticated()
-@Authorized(['admin', 'user:delete'])
-async deleteUser(@Param('id') id: string) {
-  // req.user.permissions kontrolü yapılır
+// Usage
+@del('/admin/users/:id')
+@authenticated()
+@authorized(['admin', 'user:delete'])
+async deleteUser(@req() req: Request) {
+  // req.user.permissions is checked
 }
 ```
 
 ### 🎯 Response Builder
 
-HTTP yanıtlarını standardize etmek için kullanılır.
+Standardizes HTTP responses with a fluent API.
 
 ```typescript
 import { ResponseBuilder } from '@mini2/core';
 
-// Temel kullanım
+// Basic usage
 return new ResponseBuilder().ok({ message: 'Success', data: users });
 
-// Başarılı kayıt
+// Created response
 return new ResponseBuilder()
 	.created({ id: newUser.id })
 	.setHeader('Location', `/users/${newUser.id}`);
 
-// Dosya yanıtı
+// File response
 return new ResponseBuilder()
 	.ok(fileBuffer)
 	.setHeader('Content-Type', 'application/pdf')
 	.asFile();
 
-// Custom status ve header'lar
+// Custom status and headers
 return new ResponseBuilder()
 	.status(202)
 	.setHeaders({
@@ -269,41 +667,19 @@ return new ResponseBuilder()
 	.ok({ status: 'processing' });
 ```
 
-### 🏷️ Decorator'lar
-
-#### **HTTP Method Decorator'ları**
-
-```typescript
-@Get('/path')           // GET request
-@Post('/path')          // POST request
-@Put('/path')           // PUT request
-@Delete('/path')        // DELETE request
-@Patch('/path')         // PATCH request
-```
-
-#### **Parameter Decorator'ları**
-
-```typescript
-@Param('id') id: string              // URL parametresi
-@Body() data: CreateUserDto          // Request body
-@Query('page') page: number          // Query parametresi
-@Req() request: Request              // Request objesi
-@Res() response: Response            // Response objesi
-@Next() next: NextFunction           // Next function
-```
-
-#### **Middleware Decorator'ları**
+**Methods:**
 
-```typescript
-@Authenticated()                     // Kimlik doğrulama gerekli
-@Authorized(['admin'])              // Yetkilendirme kontrolü
-@Validation({ body: UserDto })       // Veri doğrulama
-@Middleware(customMiddleware)        // Custom middleware
-```
+- `ok(data)` - 200 OK response
+- `created(data)` - 201 Created response
+- `status(code)` - Set custom status code
+- `setHeader(key, value)` - Set single header
+- `setHeaders(headers)` - Set multiple headers
+- `asFile()` - Mark response as file download
+- `build(res)` - Build and send response
 
 ### ⚠️ Exception Handling
 
-Önceden tanımlanmış HTTP exception'ları.
+Pre-defined HTTP exceptions for common error scenarios.
 
 ```typescript
 import {
@@ -312,10 +688,12 @@ import {
 	UnauthorizedException,
 	ForbiddenException,
 	NotFoundException,
-	// ... diğer exception'lar
+	ConflictException,
+	UnprocessableEntityException,
+	InternalServerErrorException,
 } from '@mini2/core';
 
-// Temel kullanım
+// Basic usage
 throw new BadRequestException({
 	message: 'Invalid input data',
 	validationErrors: [{ field: 'email', errors: ['Invalid email format'] }],
@@ -329,9 +707,15 @@ throw new HttpException(
 	},
 	422
 );
+
+// Not found
+throw new NotFoundException({
+	message: 'User not found',
+	errorId: 404001,
+});
 ```
 
-**Mevcut Exception'lar:**
+**Available Exceptions:**
 
 - `BadRequestException` (400)
 - `UnauthorizedException` (401)
@@ -339,22 +723,27 @@ throw new HttpException(
 - `ForbiddenException` (403)
 - `NotFoundException` (404)
 - `MethodNotAllowedException` (405)
+- `NotAcceptableException` (406)
 - `ConflictException` (409)
 - `UnprocessableEntityException` (422)
 - `TooManyRequestsException` (429)
 - `InternalServerErrorException` (500)
-- ve daha fazlası...
+- `NotImplementedException` (501)
+- `BadGatewayException` (502)
+- `ServiceUnavailableException` (503)
+- `GatewayTimeoutException` (504)
 
-### 🛠️ Yardımcı Fonksiyonlar
+### 🛠️ Utility Functions
 
 #### **arrayUnify**
 
-Dizi elemanlarını birleştirir ve tekrarları kaldırır.
+Merges array elements and removes duplicates.
 
 ```typescript
 import { arrayUnify } from '@mini2/core';
 
 const result = arrayUnify([1, 2, 2, 3, 1]); // [1, 2, 3]
+const strings = arrayUnify(['a', 'b', 'a', 'c']); // ['a', 'b', 'c']
 ```
 
 #### **Math Utilities**
@@ -365,17 +754,86 @@ import { sum } from '@mini2/core';
 const result = sum(5, 3); // 8
 ```
 
-### 📖 Swagger Entegrasyonu
+### 📖 Swagger Integration
+
+@mini2/core automatically generates comprehensive API documentation using Swagger/OpenAPI 3.0 specification based on your decorators and DTOs.
+
+#### **📍 API Documentation Endpoints**
+
+When your application starts, Swagger documentation is automatically available at:
+
+```typescript
+// Interactive Swagger UI - Test your API directly in browser
+http://localhost:3000/api-docs
+
+// Raw OpenAPI JSON specification - For tools, imports, etc.
+http://localhost:3000/api-docs.json
+```
+
+#### **🔧 Automatic Documentation Features**
+
+- **Route Discovery**: All `@controller` and HTTP method decorators are automatically documented
+- **Request/Response Schemas**: DTO classes with `class-validator` decorators generate JSON schemas
+- **Security Requirements**: `@authenticated` and `@authorized` decorators add security info
+- **Parameter Documentation**: Path parameters, query parameters, and request bodies are documented
+- **HTTP Status Codes**: Response codes from `ResponseBuilder` and exceptions are included
+
+#### **📋 Example Generated Documentation**
+
+For this controller:
+
+```typescript
+@controller('/api/users')
+export class UserController {
+	@get('/:id')
+	@authenticated()
+	@authorized(['user:read'])
+	@validate({ params: UserParamsDto })
+	async getUser(@req() req: Request) {
+		const id = req.params.id;
+		const user = await this.userService.findById(id);
+		return new ResponseBuilder().ok(user);
+	}
+
+	@post('/')
+	@validate({ body: CreateUserDto })
+	async createUser(@req() req: Request) {
+		const userData = req.body;
+		const user = await this.userService.create(userData);
+		return new ResponseBuilder().created(user);
+	}
+}
+```
+
+Swagger will automatically generate:
 
-Otomatik API dokümantasyonu oluşturulur.
+- **GET /api/users/{id}** - Requires authentication and authorization
+- **POST /api/users** - With CreateUserDto schema for request body
+- Parameter definitions, security requirements, and response schemas
+
+#### **🎯 DTO-Based Schema Generation**
+
+Class-validator decorators automatically create OpenAPI schemas:
 
 ```typescript
-// Swagger dokümantasyonu şu adreslerde mevcut:
-// http://localhost:3000/api-docs      - Swagger UI
-// http://localhost:3000/api-docs.json - OpenAPI JSON
+export class CreateUserDto {
+	@IsEmail()
+	email: string;
+
+	@IsString()
+	@MinLength(2)
+	name: string;
+
+	@IsOptional()
+	@IsNumber()
+	@Min(0)
+	age?: number;
+}
 ```
 
-**Swagger Konfigürasyonu:**
+#### **⚙️ Swagger Configuration**
+
+Default configuration is applied automatically, but you can customize it:
 
 ```typescript
 const swaggerOptions = {
@@ -383,17 +841,69 @@ const swaggerOptions = {
 	description: `API documentation for ${config.applicationName}`,
 	version: '1.0.0',
 	servers: [{ url: `http://${config.host}:${config.port}` }],
-	docsPath: '/api-docs',
-	jsonPath: '/api-docs.json',
+	docsPath: '/api-docs', // Swagger UI endpoint
+	jsonPath: '/api-docs.json', // OpenAPI JSON endpoint
+	components: {
+		securitySchemes: {
+			bearerAuth: {
+				type: 'http',
+				scheme: 'bearer',
+				bearerFormat: 'JWT',
+			},
+		},
+	},
 };
 ```
 
-### 📝 TypeScript Desteği
+#### **🔐 Security Documentation**
+
+Security decorators automatically add authentication requirements:
+
+```typescript
+@get('/profile')
+@authenticated()
+@authorized(['user:profile'])
+async getProfile(@req() req: Request) {
+  // Swagger will show:
+  // - 🔒 Authentication required
+  // - 🛡️ Requires 'user:profile' permission
+  // - 401 Unauthorized response possible
+  // - 403 Forbidden response possible
+}
+```
+
+#### **📊 Response Documentation**
+
+ResponseBuilder methods automatically document response types:
+
+```typescript
+@post('/users')
+async createUser(@req() req: Request) {
+  const user = await this.userService.create(req.body);
+
+  // Swagger documents:
+  // - 201 Created status
+  // - User object schema in response body
+  // - Location header if set
+  return new ResponseBuilder()
+    .created(user)
+    .setHeader('Location', `/users/${user.id}`);
+}
+```
+
+#### **🚀 Production Usage**
+
+- Swagger UI is automatically available in all environments
+- For production, consider disabling Swagger UI and keeping only JSON endpoint
+- OpenAPI JSON can be used with external documentation tools
+- All validation errors are automatically documented with examples
 
-Tam TypeScript desteği ile type-safe API geliştirme:
+### 📝 TypeScript Support
+
+Full TypeScript support with type-safe API development:
 
 ```typescript
-// DTO sınıfları
+// Strong typing for DTOs
 export class CreateUserDto {
   @IsEmail()
   email: string;
@@ -407,60 +917,122 @@ export class CreateUserDto {
   age?: number;
 }
 
-// Controller'da kullanım
-@Post('/users')
-@Validation({ body: CreateUserDto })
-async createUser(@Body() userData: CreateUserDto): Promise<ResponseBuilder<User>> {
+// Type-safe controller methods
+@post('/users')
+@validate({ body: CreateUserDto })
+async createUser(@req() req: Request): Promise<ResponseBuilder<User>> {
+  const userData = req.body as CreateUserDto; // Type-safe after validation
   const user = await this.userService.create(userData);
   return new ResponseBuilder<User>().created(user);
 }
 ```
 
-## 🔧 Gelişmiş Kullanım
+## 🔧 Advanced Usage
 
-### Custom Middleware Ekleme
+### Custom Middleware Creation
 
 ```typescript
+import { RequestHandler } from 'express';
 import { middleware } from '@mini2/core';
 
-const loggerMiddleware = (req: Request, res: Response, next: NextFunction) => {
-  console.log(`${req.method} ${req.path}`);
+// Logging middleware
+const loggingMiddleware: RequestHandler = (req, res, next) => {
+  console.log(`${new Date().toISOString()} - ${req.method} ${req.path}`);
   next();
 };
 
-@Get('/users')
-@Middleware(loggerMiddleware)
-async getUsers() {
-  // Logger middleware otomatik çalışır
+// Rate limiting middleware
+const createRateLimiter = (requests: number, windowMs: number): RequestHandler => {
+  const requests_map = new Map();
+  return (req, res, next) => {
+    const clientId = req.ip;
+    const now = Date.now();
+    const windowStart = now - windowMs;
+
+    const clientRequests = requests_map.get(clientId) || [];
+    const recentRequests = clientRequests.filter((time: number) => time > windowStart);
+
+    if (recentRequests.length >= requests) {
+      return res.status(429).json({ error: 'Too many requests' });
+    }
+
+    recentRequests.push(now);
+    requests_map.set(clientId, recentRequests);
+    next();
+  };
+};
+
+// Usage in controller
+@get('/users')
+@middleware(loggingMiddleware)
+@middleware(createRateLimiter(10, 60000))
+async getUsers(@req() req: Request) {
+  // Middleware chain: logging -> rate limiting -> route handler
 }
 ```
 
-### Dependency Injection
+### Dependency Injection Patterns
 
 ```typescript
 import { Container, injectable, inject } from '@mini2/core';
 
+// Service interfaces
+interface IUserService {
+	create(userData: CreateUserDto): Promise<User>;
+	findById(id: string): Promise<User | null>;
+}
+
+// Service implementations
 @injectable()
-export class UserService {
+class UserService implements IUserService {
 	constructor(@inject('UserRepository') private userRepo: IUserRepository) {}
+
+	async create(userData: CreateUserDto): Promise<User> {
+		return this.userRepo.create(userData);
+	}
+
+	async findById(id: string): Promise<User | null> {
+		return this.userRepo.findById(id);
+	}
 }
 
-// Container konfigürasyonu
-container.bind('UserRepository').to(UserRepository);
-container.bind('UserService').to(UserService);
+// Container configuration
+container.bind<IUserRepository>('UserRepository').to(UserRepository);
+container.bind<IUserService>('UserService').to(UserService);
+
+// Controller with dependency injection
+@controller('/api/users')
+@injectable()
+export class UserController {
+	constructor(@inject('UserService') private userService: IUserService) {}
+
+	@post('/')
+	@validate({ body: CreateUserDto })
+	async createUser(@req() req: Request) {
+		const userData = req.body;
+		const user = await this.userService.create(userData);
+		return new ResponseBuilder().created(user);
+	}
+}
 ```
 
-## 📋 Tam Export Listesi
+## 📋 Complete Export List
 
 ```typescript
-// Ana sınıflar
+// Core classes
 export { App } from '@mini2/core';
 export { Container, container } from '@mini2/core';
 
 // Interfaces
-export { IApp, IConfig, IRepository, IResponseBuilder } from '@mini2/core';
+export {
+	IApp,
+	IConfig,
+	IRepository,
+	IResponseBuilder,
+	IAuthenticatedRequest,
+} from '@mini2/core';
 
-// Middleware'ler
+// Middlewares
 export {
 	validationMiddleware,
 	authenticatedMiddleware,
@@ -470,44 +1042,52 @@ export {
 // Utilities
 export { arrayUnify, sum, ResponseBuilder } from '@mini2/core';
 
-// Exception'lar
+// Exceptions
 export {
 	HttpException,
 	BadRequestException,
 	UnauthorizedException,
-	// ... tüm exception'lar
+	ForbiddenException,
+	NotFoundException,
+	MethodNotAllowedException,
+	ConflictException,
+	UnprocessableEntityException,
+	TooManyRequestsException,
+	InternalServerErrorException,
+	// ... all other exceptions
 } from '@mini2/core';
 
-// Types ve decorators
+// Types and constants
 export { MINI_TYPES } from '@mini2/core';
+
+// Decorators
 export {
-	Controller,
-	Get,
-	Post,
-	Put,
-	Delete,
-	Patch,
-	Body,
-	Param,
-	Query,
-	Req,
-	Res,
-	Next,
-	Authenticated,
-	Authorized,
-	Validation,
-	Middleware,
+	controller,
+	get,
+	post,
+	put,
+	del,
+	patch,
+	req,
+	res,
+	authenticated,
+	authorized,
+	validate,
+	middleware,
 } from '@mini2/core';
 
 // Swagger
 export { SwaggerIntegration, SwaggerOptions } from '@mini2/core';
+
+// REST utilities
+export { buildApp, Method, RouteOptions } from '@mini2/core';
 ```
 
-## 📄 Lisans
+## 📄 License
 
 ISC
 
-## 👨‍💻 Yazar
+## 👨‍💻 Author
 
 **Mustafa Çolakoğlu**  
 Email: mustafacolakoglu94@gmail.com  
@@ -515,4 +1095,4 @@ GitHub: https://github.com/mustafa-colakoglu
 
 ---
 
-**Not:** Bu framework aktif olarak geliştirilmektedir. Öneriler ve katkılar için GitHub repository'sini ziyaret edin.
+**Note:** This framework is actively maintained. Visit the GitHub repository for contributions and suggestions.

package/dist/interfaces/repository.interface.d.ts

@@ -1,34 +1,9 @@
 export interface IRepository<IdentifierType, ModelType> {
-    findAll(): Promise<(ModelType & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-    })[]>;
-    findById(id: IdentifierType): Promise<(ModelType & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-    }) | null>;
-    create(item: ModelType): Promise<ModelType & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-    }>;
-    update(id: IdentifierType, item: Partial<ModelType>): Promise<ModelType & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-    }>;
+    findAll(): Promise<ModelType[]>;
+    findById(id: IdentifierType): Promise<ModelType | null>;
+    create(item: ModelType): Promise<ModelType>;
+    update(id: IdentifierType, item: Partial<ModelType>): Promise<ModelType>;
     delete(id: IdentifierType): Promise<void>;
-    findPaginated(query: Partial<ModelType>, page: number, limit: number): Promise<(ModelType & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-    })[]>;
-    mapper(model: any): ModelType & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-    };
+    findPaginated(query: Partial<ModelType>, page: number, limit: number): Promise<ModelType[]>;
 }
 //# sourceMappingURL=repository.interface.d.ts.map

package/dist/interfaces/repository.interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repository.interface.d.ts","sourceRoot":"","sources":["../../interfaces/repository.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW,CAAC,cAAc,EAAE,SAAS;IACrD,OAAO,IAAI,OAAO,CACjB,CAAC,SAAS,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC,EAAE,CAChE,CAAC;IACF,QAAQ,CACP,EAAE,EAAE,cAAc,GAChB,OAAO,CACT,CAAC,SAAS,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC,GAAG,IAAI,CACrE,CAAC;IACF,MAAM,CACL,IAAI,EAAE,SAAS,GACb,OAAO,CAAC,SAAS,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IACzE,MAAM,CACL,EAAE,EAAE,cAAc,EAClB,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,GACtB,OAAO,CAAC,SAAS,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IACzE,MAAM,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,aAAa,CACZ,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,EACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,SAAS,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC,EAAE,CAAC,CAAC;IAC7E,MAAM,CACL,KAAK,EAAE,GAAG,GACR,SAAS,GAAG;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC;CAChE"}
+{"version":3,"file":"repository.interface.d.ts","sourceRoot":"","sources":["../../interfaces/repository.interface.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,WAAW,CAAC,cAAc,EAAE,SAAS;IACrD,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IACxD,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5C,MAAM,CAAC,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACzE,MAAM,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,aAAa,CACZ,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,EACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;CACxB"}

package/package.json

@@ -6,7 +6,7 @@
 		"rebuild": "npm run clean && npm run build",
 		"prepublishOnly": "npm run rebuild",
 		"dev": "tsc --watch",
-		"publish1": "npm run build && npm publish",
+		"publish:npm": "npm run build && npm publish",
 		"publish:patch": "tsc && npm version patch && npm publish",
 		"publish:minor": "tsc && npm version minor && npm publish",
 		"publish:major": "tsc && npm version major && npm publish"
@@ -25,7 +25,7 @@
 	"license": "ISC",
 	"description": "Mini Express Framework - Lightweight and modular Express.js framework with TypeScript support",
 	"name": "@mini2/core",
-	"version": "1.0.9",
+	"version": "1.1.1",
 	"author": "Mustafa Çolakoglu <mustafacolakoglu94@gmail.com> (https://github.com/mustafa-colakoglu)",
 	"dependencies": {
 		"class-transformer": "^0.5.1",
@@ -45,13 +45,5 @@
 		"@types/node": "^20.14.9",
 		"@types/swagger-ui-express": "^4.1.6",
 		"typescript": "^5.5.3"
-	},
-	"peerDependencies": {
-		"mongoose": "^8.0.0"
-	},
-	"peerDependenciesMeta": {
-		"mongoose": {
-			"optional": true
-		}
 	}
 }