@elsikora/nestjs-crud-automator 1.8.0-dev.2 → 1.9.0-dev.1

package/README.md

@@ -1,14 +1,14 @@
 <p align="center">
-		<img src="https://6jft62zmy9nx2oea.public.blob.vercel-storage.com/nestjs-crud-automator-HhXThTDhKyqznMLCgdmWhsPa287fIi.png" width="500" alt="project-logo">
-			</p>
+  <img src="https://6jft62zmy9nx2oea.public.blob.vercel-storage.com/nestjs-crud-automator-HhXThTDhKyqznMLCgdmWhsPa287fIi.png" width="500" alt="project-logo">
+</p>
 
-<h1 align="center">🚀 NestJS-Crud-Automator</h1>
-<p align="center"><em>Automate CRUD operations in NestJS with powerful decorators and type-safe APIs</em></p>
+<h1 align="center">NestJS-Crud-Automator 🚀</h1>
+<p align="center"><em>A powerful library for automating CRUD operations in NestJS applications</em></p>
 
 <p align="center">
     <a aria-label="ElsiKora logo" href="https://elsikora.com">
   <img src="https://img.shields.io/badge/MADE%20BY%20ElsiKora-333333.svg?style=for-the-badge" alt="ElsiKora">
-</a> <img src="https://img.shields.io/badge/version-blue.svg?style=for-the-badge&logo=npm&logoColor=white" alt="version"> <img src="https://img.shields.io/badge/typescript-blue.svg?style=for-the-badge&logo=typescript&logoColor=white" alt="typescript"> <img src="https://img.shields.io/badge/nestjs-red.svg?style=for-the-badge&logo=nestjs&logoColor=white" alt="nestjs"> <img src="https://img.shields.io/badge/typeorm-orange.svg?style=for-the-badge&logo=typeorm&logoColor=white" alt="typeorm"> <img src="https://img.shields.io/badge/license-green.svg?style=for-the-badge&logo=license&logoColor=white" alt="license"> <img src="https://img.shields.io/badge/swagger-green.svg?style=for-the-badge&logo=swagger&logoColor=white" alt="swagger">
+</a> <img src="https://img.shields.io/badge/npm-blue.svg?style=for-the-badge&logo=npm&logoColor=white" alt="npm"> <img src="https://img.shields.io/badge/typescript-blue.svg?style=for-the-badge&logo=typescript&logoColor=white" alt="typescript"> <img src="https://img.shields.io/badge/nestjs-red.svg?style=for-the-badge&logo=nestjs&logoColor=white" alt="nestjs"> <img src="https://img.shields.io/badge/swagger-green.svg?style=for-the-badge&logo=swagger&logoColor=white" alt="swagger"> <img src="https://img.shields.io/badge/license-blue.svg?style=for-the-badge&logo=license&logoColor=white" alt="license"> <img src="https://img.shields.io/badge/version-1.6.2-brightgreen.svg?style=for-the-badge&logo=v&logoColor=white" alt="version-1.6.2">
 </p>
 
 
@@ -23,24 +23,27 @@
 
 
 ## 📖 Description
-NestJS-Crud-Automator is a comprehensive library designed to streamline the development of RESTful APIs in NestJS applications. It eliminates boilerplate code by providing decorators that automatically generate controllers, services, DTOs, and validation. With strong TypeScript support, it offers type-safe CRUD operations while enforcing best practices in API design. The library integrates seamlessly with TypeORM, enhances Swagger documentation, and provides built-in validation through class-validator. It's perfect for developers looking to accelerate development without sacrificing code quality or architectural principles. Whether you're building a simple API or a complex enterprise application, NestJS-Crud-Automator helps maintain clean, consistent, and well-documented endpoints with minimal effort.
+NestJS-Crud-Automator is a comprehensive library designed to eliminate repetitive code when building RESTful APIs with NestJS. It provides a suite of decorators, utilities, and validation tools that automatically generate controllers, DTOs, and service methods for handling Create, Read, Update, and Delete operations. This library significantly reduces development time by providing a declarative approach to API development. By simply describing your entity properties once, the library auto-generates all the necessary boilerplate code including Swagger documentation, validation rules, and transformation logic. Perfect for developers working on data-heavy applications who want to focus on business logic rather than repetitive CRUD implementation.
 
 ## 🚀 Features
-- ✨ **Automatic CRUD operations with a single decorator**
-- ✨ **Type-safe API development with full TypeScript support**
-- ✨ **Seamless integration with TypeORM for database operations**
-- ✨ **Auto-generated DTOs with comprehensive validation rules**
-- ✨ **Complete Swagger/OpenAPI documentation generation**
-- ✨ **Customizable request/response transformers**
-- ✨ **Built-in relation handling and eager/lazy loading support**
-- ✨ **Automatic validation using class-validator**
-- ✨ **Request correlation tracking for improved debugging**
-- ✨ **Rate limiting and throttling capabilities**
-- ✨ **Powerful filtering, pagination, and sorting for list endpoints**
-- ✨ **Custom validation decorators for complex business rules**
+- ✨ **🏗️ Automatic generation of controllers, DTOs, and service methods for CRUD operations**
+- ✨ **📝 Comprehensive Swagger/OpenAPI documentation generation for all endpoints**
+- ✨ **✅ Built-in validation rules with class-validator integration**
+- ✨ **🔄 Data transformation with class-transformer for request/response handling**
+- ✨ **🧩 Type-safe decorators for entity properties with rich metadata support**
+- ✨ **🔒 Authentication and authorization guards integration**
+- ✨ **🔍 Advanced filtering, sorting, and pagination for list operations**
+- ✨ **📚 Support for object relations with automatic loading strategies**
+- ✨ **⚡ Performance optimized with TypeORM integration for database operations**
+- ✨ **🌐 Full support for TypeScript with strong typing throughout the library**
 
 ## 🛠 Installation
 ```bash
+## Installation
+
+Install NestJS-Crud-Automator using your preferred package manager:
+
+
 # Using npm
 npm install @elsikora/nestjs-crud-automator
 
@@ -50,52 +53,40 @@ yarn add @elsikora/nestjs-crud-automator
 # Using pnpm
 pnpm add @elsikora/nestjs-crud-automator
 
-# Using bun
-bun add @elsikora/nestjs-crud-automator
-
 
-You'll also need to install peer dependencies if you haven't already:
+### Prerequisites
 
+Make sure you have the following dependencies installed in your NestJS project:
 
-npm install @nestjs/common @nestjs/swagger typeorm class-transformer class-validator reflect-metadata
+- NestJS (^9.0.0)
+- TypeORM (^0.3.0)
+- class-validator (^0.14.0)
+- class-transformer (^0.5.1)
+- @nestjs/swagger (^6.0.0)
 
+You might need to install these peer dependencies if they're not already in your project:
 
-Once installed, you need to set up your NestJS module to import the library:
 
-typescript
-// app.module.ts
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-// Import other modules and entities as needed
-
-@Module({
-  imports: [
-    TypeOrmModule.forRoot({
-      // your TypeORM configuration
-    }),
-    // Register your entities and other modules
-  ],
-})
-export class AppModule {}
+npm install @nestjs/common @nestjs/swagger @nestjs/throttler typeorm class-transformer class-validator reflect-metadata
 ```
 
 ## 💡 Usage
 ## Basic Usage
 
-Create an entity using TypeORM and enhance it with property decorators:
+### 1. Define Your Entity
+
+First, define your entity with the `ApiPropertyDescribe` decorators to provide metadata for CRUD generation:
 
 ```typescript
-// user.entity.ts
 import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
-import { ApiPropertyDescribe } from '@elsikora/nestjs-crud-automator';
-import { EApiPropertyDescribeType, EApiPropertyStringType } from '@elsikora/nestjs-crud-automator';
+import { ApiPropertyDescribe, EApiPropertyDescribeType, EApiPropertyStringType, EApiPropertyDateIdentifier, EApiPropertyDateType } from '@elsikora/nestjs-crud-automator';
 
 @Entity('users')
-export class User {
+export class UserEntity {
   @PrimaryGeneratedColumn('uuid')
   @ApiPropertyDescribe({
     type: EApiPropertyDescribeType.UUID,
-    description: 'Unique identifier',
+    description: 'User unique identifier'
   })
   id: string;
 
@@ -117,366 +108,338 @@ export class User {
     description: 'User email',
     format: EApiPropertyStringType.EMAIL,
     minLength: 5,
-    maxLength: 100,
+    maxLength: 255,
     pattern: '/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/',
-    exampleValue: 'john.doe@example.com'
+    exampleValue: 'user@example.com'
   })
   email: string;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  @ApiPropertyDescribe({
+    type: EApiPropertyDescribeType.DATE,
+    identifier: EApiPropertyDateIdentifier.CREATED_AT,
+    format: EApiPropertyDateType.DATE_TIME
+  })
+  createdAt: Date;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP', onUpdate: 'CURRENT_TIMESTAMP' })
+  @ApiPropertyDescribe({
+    type: EApiPropertyDescribeType.DATE,
+    identifier: EApiPropertyDateIdentifier.UPDATED_AT,
+    format: EApiPropertyDateType.DATE_TIME
+  })
+  updatedAt: Date;
 }
 ```
 
-## Creating a Service
+### 2. Create a Service
 
-Create a service that extends the base service class:
+Create a service with the `ApiService` decorator to add CRUD operations:
 
 ```typescript
-// user.service.ts
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
-import { ApiServiceBase, ApiService } from '@elsikora/nestjs-crud-automator';
-import { User } from './user.entity';
+import { ApiService, ApiServiceBase } from '@elsikora/nestjs-crud-automator';
+import { UserEntity } from './user.entity';
 
 @Injectable()
-@ApiService({
-  entity: User
+@ApiService<UserEntity>({
+  entity: UserEntity
 })
-export class UserService extends ApiServiceBase<User> {
+export class UserService extends ApiServiceBase<UserEntity> {
   constructor(
-    @InjectRepository(User)
-    public repository: Repository<User>
+    @InjectRepository(UserEntity)
+    public repository: Repository<UserEntity>
   ) {
     super();
   }
-  
-  // You can add custom methods here
-  async findByEmail(email: string): Promise<User | undefined> {
+
+  // You can add custom methods here that go beyond basic CRUD
+  async findByEmail(email: string): Promise<UserEntity | undefined> {
     return this.repository.findOne({ where: { email } });
   }
 }
 ```
 
-## Creating a Controller
+### 3. Create a Controller
 
-Create a controller with automated CRUD operations:
+Create a controller with the `ApiController` decorator to generate all CRUD endpoints:
 
 ```typescript
-// user.controller.ts
-import { Controller } from '@nestjs/common';
-import { ApiController } from '@elsikora/nestjs-crud-automator';
-import { User } from './user.entity';
+import { Controller, UseGuards } from '@nestjs/common';
+import { ApiController, EApiRouteType } from '@elsikora/nestjs-crud-automator';
+import { UserEntity } from './user.entity';
 import { UserService } from './user.service';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
 
-@ApiController<User>({
-  entity: User,
+@Controller('users')
+@ApiController<UserEntity>({
+  entity: UserEntity,
   name: 'Users',
-  path: 'users',
   routes: {
-    // Configure specific routes if needed
+    [EApiRouteType.CREATE]: {
+      authentication: {
+        guard: JwtAuthGuard,
+        bearerStrategies: ['jwt']
+      }
+    },
+    [EApiRouteType.UPDATE]: {
+      authentication: {
+        guard: JwtAuthGuard,
+        bearerStrategies: ['jwt']
+      }
+    },
+    [EApiRouteType.DELETE]: {
+      authentication: {
+        guard: JwtAuthGuard,
+        bearerStrategies: ['jwt']
+      }
+    },
+    [EApiRouteType.GET]: {},
+    [EApiRouteType.GET_LIST]: {}
   }
 })
-@Controller('users')
 export class UserController {
-  constructor(
-    public service: UserService
-  ) {}
-  
-  // The controller methods are automatically generated
-  // You can add custom endpoints here if needed
+  constructor(public service: UserService) {}
 }
 ```
 
-## Custom Route Configuration
+## Advanced Usage
 
-You can customize individual routes with advanced options:
+### Custom Validation
+
+Add custom validators to your DTOs:
 
 ```typescript
-// user.controller.ts with route customization
-import { Controller } from '@nestjs/common';
-import { ApiController } from '@elsikora/nestjs-crud-automator';
-import { EApiRouteType, EApiControllerLoadRelationsStrategy } from '@elsikora/nestjs-crud-automator';
-import { User } from './user.entity';
-import { UserService } from './user.service';
-import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { ApiController, EApiRouteType, EApiDtoType, AllOrNoneOfListedPropertiesValidator } from '@elsikora/nestjs-crud-automator';
 
-@ApiController<User>({
-  entity: User,
+@ApiController<UserEntity>({
+  entity: UserEntity,
   name: 'Users',
-  path: 'users',
   routes: {
     [EApiRouteType.CREATE]: {
-      authentication: {
-        guard: JwtAuthGuard,
-        type: 'user',
-        bearerStrategies: ['jwt']
-      },
-      request: {
-        validators: [
-          // custom validators
-        ],
-        transformers: {
-          body: [
-            // request transformers
+      autoDto: {
+        [EApiDtoType.BODY]: {
+          validators: [
+            {
+              constraintClass: AllOrNoneOfListedPropertiesValidator,
+              options: ['firstName', 'lastName']
+            }
           ]
         }
       }
-    },
-    [EApiRouteType.GET_LIST]: {
-      request: {
-        relations: {
-          shouldLoadRelations: true,
-          relationsLoadStrategy: EApiControllerLoadRelationsStrategy.AUTO,
-          servicesLoadStrategy: EApiControllerLoadRelationsStrategy.AUTO
-        }
-      }
     }
   }
 })
-@Controller('users')
 export class UserController {
-  constructor(
-    public service: UserService
-  ) {}
+  constructor(public service: UserService) {}
 }
 ```
 
-## Working with DTOs
+### Request Transformation
 
-The library automatically generates DTOs for your entities, but you can also provide custom ones:
+Automatically transform request data:
 
 ```typescript
-// custom-create-user.dto.ts
-import { ApiPropertyString, ApiPropertyUUID } from '@elsikora/nestjs-crud-automator';
-import { EApiPropertyStringType } from '@elsikora/nestjs-crud-automator';
+import { ApiController, EApiRouteType, EApiDtoType, EApiControllerRequestTransformerType, TRANSFORMER_VALUE_DTO_CONSTANT } from '@elsikora/nestjs-crud-automator';
 
-export class CustomCreateUserDto {
-  @ApiPropertyString({
-    entity: { name: 'User' },
-    description: 'User name',
-    format: EApiPropertyStringType.STRING,
-    minLength: 3,
-    maxLength: 50,
-    pattern: '/^[a-zA-Z0-9_-]+$/',
-    exampleValue: 'john_doe',
-    isRequired: true
-  })
-  username: string;
-
-  @ApiPropertyString({
-    entity: { name: 'User' },
-    description: 'User email',
-    format: EApiPropertyStringType.EMAIL,
-    minLength: 5,
-    maxLength: 100,
-    pattern: '/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/',
-    exampleValue: 'john.doe@example.com',
-    isRequired: true
-  })
-  email: string;
+@ApiController<UserEntity>({
+  entity: UserEntity,
+  name: 'Users',
+  routes: {
+    [EApiRouteType.CREATE]: {
+      request: {
+        transformers: {
+          [EApiDtoType.BODY]: [
+            {
+              key: 'createdBy',
+              type: EApiControllerRequestTransformerType.DYNAMIC,
+              value: TRANSFORMER_VALUE_DTO_CONSTANT.AUTHORIZED_ENTITY,
+              shouldSetValueEvenIfMissing: true
+            }
+          ]
+        }
+      }
+    }
+  }
+})
+export class UserController {
+  constructor(public service: UserService) {}
 }
 ```
 
-## Request Validation
+### Handling Relations
 
-You can add custom validators to your endpoints:
+Automatically load related entities:
 
 ```typescript
-// user.validator.ts
-import { EErrorStringAction, EException } from '@elsikora/nestjs-crud-automator';
-import { BadRequestException } from '@nestjs/common';
-import { User } from './user.entity';
-
-export const UniqueEmailValidator = {
-  errorType: EErrorStringAction.VALIDATION_ERROR,
-  exception: BadRequestException,
-  validationFunction: async (entity: Partial<User>, userService: any) => {
-    if (!entity.email) return true;
-    const existingUser = await userService.findByEmail(entity.email);
-    return !existingUser;
+import { ApiController, EApiRouteType, EApiControllerLoadRelationsStrategy } from '@elsikora/nestjs-crud-automator';
+
+@ApiController<PostEntity>({
+  entity: PostEntity,
+  name: 'Posts',
+  routes: {
+    [EApiRouteType.GET]: {
+      request: {
+        relations: {
+          shouldLoadRelations: true,
+          relationsLoadStrategy: EApiControllerLoadRelationsStrategy.AUTO,
+          servicesLoadStrategy: EApiControllerLoadRelationsStrategy.AUTO,
+          shouldForceAllServicesToBeSpecified: false,
+          relationsToLoad: ['author', 'comments']
+        }
+      },
+      response: {
+        relations: ['author', 'comments']
+      }
+    }
   }
-};
+})
+export class PostController {
+  constructor(
+    public service: PostService,
+    public authorService: UserService,
+    public commentsService: CommentService
+  ) {}
+}
 ```
 
-## Using Filters, Pagination and Sorting
+### Custom DTOs
 
-With the GET_LIST endpoints, you get built-in filtering, pagination and sorting:
+Use custom DTOs instead of auto-generated ones:
 
 ```typescript
-// Example HTTP request
-// GET /users?limit=10&page=1&orderBy=username&orderDirection=asc&username[operator]=cont&username[value]=john
+import { ApiController, EApiRouteType } from '@elsikora/nestjs-crud-automator';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+import { UserResponseDto } from './dto/user-response.dto';
+
+@ApiController<UserEntity>({
+  entity: UserEntity,
+  name: 'Users',
+  routes: {
+    [EApiRouteType.CREATE]: {
+      dto: {
+        body: CreateUserDto,
+        response: UserResponseDto
+      }
+    },
+    [EApiRouteType.UPDATE]: {
+      dto: {
+        body: UpdateUserDto,
+        response: UserResponseDto
+      }
+    }
+  }
+})
+export class UserController {
+  constructor(public service: UserService) {}
+}
 ```
 
-## Using the Correlation ID Interceptor
+### Swagger Documentation
 
-Add the built-in correlation ID interceptor for better request tracking:
+The library automatically generates Swagger/OpenAPI documentation for all endpoints. To enable it in your NestJS application:
 
 ```typescript
-// main.ts
 import { NestFactory } from '@nestjs/core';
-import { ValidationPipe } from '@nestjs/common';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
-import { CorrelationIDResponseBodyInterceptor } from '@elsikora/nestjs-crud-automator';
 import { AppModule } from './app.module';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   
-  app.useGlobalInterceptors(new CorrelationIDResponseBodyInterceptor());
-  app.useGlobalPipes(new ValidationPipe({ transform: true }));
-  
   const config = new DocumentBuilder()
-    .setTitle('My API')
-    .setDescription('API Documentation')
+    .setTitle('Your API')
+    .setDescription('API description')
     .setVersion('1.0')
     .addBearerAuth()
     .build();
     
   const document = SwaggerModule.createDocument(app, config);
   SwaggerModule.setup('api', app, document);
-  
+
   await app.listen(3000);
 }
 bootstrap();
 ```
 
-## Custom Property Decorators
+### Custom Filtering
 
-The library provides various property decorators for different data types:
+The library provides advanced filtering capabilities for list endpoints:
 
 ```typescript
-// Example of various property decorators
-import { 
-  ApiPropertyBoolean, 
-  ApiPropertyDate, 
-  ApiPropertyNumber, 
-  ApiPropertyObject, 
-  ApiPropertyString, 
-  ApiPropertyUUID,
-  ApiPropertyEnum
-} from '@elsikora/nestjs-crud-automator';
-import { 
-  EApiPropertyDateIdentifier, 
-  EApiPropertyDateType,
-  EApiPropertyNumberType,
-  EApiPropertyStringType
-} from '@elsikora/nestjs-crud-automator';
-
-// Example enum
-enum UserRole {
-  ADMIN = 'admin',
-  USER = 'user'
-}
-
-class ExampleDto {
-  @ApiPropertyUUID({ entity: { name: 'Example' }, isRequired: true })
-  id: string;
-  
-  @ApiPropertyString({
-    entity: { name: 'Example' },
-    description: 'Example name',
-    format: EApiPropertyStringType.STRING,
-    minLength: 3,
-    maxLength: 50,
-    pattern: '/^[a-zA-Z0-9 ]+$/',
-    exampleValue: 'Example Item',
-    isRequired: true
-  })
-  name: string;
-  
-  @ApiPropertyBoolean({
-    entity: { name: 'Example' },
-    description: 'Is active',
-    isRequired: false
-  })
-  isActive: boolean;
-  
-  @ApiPropertyNumber({
-    entity: { name: 'Example' },
-    description: 'Price',
-    format: EApiPropertyNumberType.DOUBLE,
-    minimum: 0,
-    maximum: 1000,
-    multipleOf: 0.01,
-    exampleValue: 29.99,
-    isRequired: true
-  })
-  price: number;
-  
-  @ApiPropertyDate({
-    entity: { name: 'Example' },
-    format: EApiPropertyDateType.DATE_TIME,
-    identifier: EApiPropertyDateIdentifier.CREATED_AT,
-    isResponse: true
-  })
-  createdAt: Date;
-  
-  @ApiPropertyEnum({
-    entity: { name: 'Example' },
-    description: 'User role',
-    enum: UserRole,
-    enumName: 'UserRole',
-    isRequired: true
-  })
-  role: UserRole;
-}
+// GET /users?username[operator]=cont&username[value]=john&createdAt[operator]=between&createdAt[values]=["2023-01-01","2023-12-31"]
 ```
 
+This query would search for users with "john" in their username and created between Jan 1 and Dec 31, 2023.
+
 ## 🛣 Roadmap
+## Roadmap
+
 | Task / Feature | Status |
 |---------------|--------|
-| ✅ Core CRUD operations | ✅ Done |
-| ✅ TypeORM integration | ✅ Done |
-| ✅ Auto-generated DTOs | ✅ Done |
-| ✅ Swagger documentation | ✅ Done |
-| ✅ Request validation | ✅ Done |
-| ✅ Response transformation | ✅ Done |
-| ✅ Request correlation tracking | ✅ Done |
-| ✅ Filtering, pagination and sorting | ✅ Done |
-| ✅ Custom validation decorators | ✅ Done |
-| ✅ Authentication integration | ✅ Done |
-| 🚧 MongoDB support | 🚧 In Progress |
-| 🚧 GraphQL support | 🚧 In Progress |
-| 🚧 Caching mechanisms | 🚧 In Progress |
-| 🚧 Advanced query building | 🚧 In Progress |
-| 🚧 Soft delete functionality | 🚧 In Progress |
-| 🚧 Event dispatching | 🚧 In Progress |
-| 🚧 Bulk operations | 🚧 In Progress |
-| 🚧 File upload handling | 🚧 In Progress |
-| 🚧 Custom migration scripts | 🚧 In Progress |
-| 🚧 CLI for scaffold generation | 🚧 In Progress |
+| Core CRUD operations | ✅ Done |
+| TypeORM integration | ✅ Done |
+| Swagger/OpenAPI documentation | ✅ Done |
+| Validation with class-validator | ✅ Done |
+| Transformation with class-transformer | ✅ Done |
+| Advanced filtering for GET_LIST operation | ✅ Done |
+| Authentication guard integration | ✅ Done |
+| Request/response transformers | ✅ Done |
+| Relation loading strategies | ✅ Done |
+| Custom validator integration | ✅ Done |
+| Pagination support | ✅ Done |
+| Error handling with standardized responses | ✅ Done |
+| Support for TypeScript decorators | ✅ Done |
+| Support for ESM and CommonJS modules | ✅ Done |
+| MongoDB support | 🚧 In Progress |
+| GraphQL integration | 🚧 In Progress |
+| Support for soft deletes | 🚧 In Progress |
+| Role-based access control | 🚧 In Progress |
+| Cache integration | 🚧 In Progress |
+| Audit logging middleware | 🚧 In Progress |
+| Bulk operations (create many, update many) | 🚧 In Progress |
+| Query complexity analyzer | 🚧 In Progress |
+| Rate limiting enhancements | 🚧 In Progress |
+| Custom parameter decorators | 🚧 In Progress |
 
 ## ❓ FAQ
 ## Frequently Asked Questions
 
-### What is NestJS-Crud-Automator?
-NestJS-Crud-Automator is a library that automates the creation of CRUD (Create, Read, Update, Delete) operations in NestJS applications. It provides decorators and utilities to generate controllers, services, DTOs, and validation with minimal boilerplate code.
+### How does NestJS-Crud-Automator compare to @nestjsx/crud?
+
+While @nestjsx/crud provides similar functionality, NestJS-Crud-Automator offers more comprehensive TypeScript integration, better Swagger documentation, and more flexible customization options. It's designed from the ground up to work with the latest NestJS and TypeORM versions.
+
+### Can I customize the generated endpoints?
+
+Yes! The library provides multiple ways to customize your endpoints:
+1. You can disable specific routes
+2. Add authentication guards to specific routes
+3. Customize DTO validation and transformation
+4. Add custom request validators
+5. Override the auto-generated DTOs with your own
+
+### Does it support pagination?
 
-### Does it work with any database?
-Currently, the library is optimized for TypeORM which supports multiple databases including PostgreSQL, MySQL, MariaDB, SQLite, MS SQL Server, Oracle, and MongoDB. Support for other ORMs is planned for future releases.
+Yes, the GET_LIST operation automatically includes pagination with limit and page parameters, and returns count, currentPage, totalCount, and totalPages in the response.
 
-### How do I customize the generated endpoints?
-You can customize the endpoints by providing configuration in the `routes` property of the `@ApiController` decorator. Each route type (CREATE, GET, GET_LIST, UPDATE, PARTIAL_UPDATE, DELETE) can be configured separately with custom authentication, validation, transformation, and relation loading strategies.
+### How is filtering implemented?
 
-### Can I extend the generated functionality?
-Yes! The generated CRUD operations serve as a starting point. You can extend the controllers and services with custom methods to implement business-specific logic.
+Filtering is implemented using a flexible operator-based approach that supports various operations like equals, contains, greater than, less than, between, etc. Filters can be applied to any property of your entity.
 
-### Does it support validation?
-Yes, it integrates with class-validator and provides automatic validation based on the property decorators. You can also add custom validators to the routes configuration.
+### Can I use this with NestJS microservices?
 
-### How does it handle relationships?
-The library provides automatic relation loading with configurable strategies. You can specify eager or lazy loading, and control which relations are loaded for each endpoint.
+Yes, while the library primarily targets REST APIs, you can use the generated DTOs and validation logic in microservice implementations as well.
 
-### Can I use it with GraphQL?
-Currently, the library focuses on REST APIs, but GraphQL support is planned for future releases.
+### Does it support file uploads?
 
-### How do I handle authentication?
-You can configure authentication at the route level by specifying the authentication guard, type, and strategies in the route configuration.
+The core library doesn't include file upload functionality, but you can easily extend the generated controllers to add file upload capabilities using NestJS's built-in features.
 
-### What about performance?
-The library is designed to be lightweight and efficient. It uses TypeORM's query builder to optimize database queries and supports pagination, filtering, and sorting for list endpoints.
+### Is it compatible with custom database repositories?
 
-### Can I use it with existing NestJS applications?
-Yes, the library is designed to integrate seamlessly with existing NestJS applications. You can apply it gradually to specific modules or entities without affecting the rest of your application.
+Yes, as long as your repository follows the TypeORM Repository pattern, it will work with NestJS-Crud-Automator.
 
 ## 🔒 License
 This project is licensed under **MIT License