@eqxjs/swagger-codegen 1.0.0-beta.0 → 1.0.0-beta.2

package/README.md

@@ -31,7 +31,17 @@ A TypeScript CLI tool to generate NestJS modules, controllers, services, and DTO
 
 ## Installation
 
+### From NPM
+
+```bash
+npm install -g @eqxjs/swagger-codegen
+```
+
+### From Source
+
 ```bash
+git clone <repository-url>
+cd swagger-nestjs-codegen
 npm install
 npm run build
 ```
@@ -74,28 +84,138 @@ npm run dev -- generate -i ./openapi3-example.yaml -o ./generated
 ### Production Mode
 
 ```bash
-# Build the project first
-npm run build
+# Using the global CLI
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./generated
 
-# Run the CLI with JSON
-node dist/cli.js generate -i ./swagger.json -o ./generated
+# Using npx (no installation required)
+npx @eqxjs/swagger-codegen generate -i ./swagger.json -o ./generated
 
-# Run the CLI with YAML
-node dist/cli.js generate -i ./swagger.yaml -o ./generated
+# With YAML files
+eqxjs-swagger-codegen generate -i ./swagger.yaml -o ./generated
 
-# Or use the npm script
-npm start -- generate -i ./swagger.json -o ./generated
+# Local installation
+node dist/cli.js generate -i ./swagger.json -o ./generated
 ```
 
 ### Command Options
 
 ```bash
-swagger-nestjs-codegen generate [options]
+eqxjs-swagger-codegen generate [options]
 
 Options:
-  -i, --input <path>   Path to Swagger/OpenAPI file (JSON or YAML) [required]
-  -o, --output <path>  Output directory for generated files (default: "./generated")
-  -h, --help          Display help for command
+  -i, --input <path>    Path to Swagger/OpenAPI file (JSON or YAML) [required]
+  -o, --output <path>   Output directory for generated files (default: "./generated")
+  -m, --mode <mode>     Generation mode: server, client, or both (default: "server")
+  --with-test          Generate test files (.spec.ts) for all generated files
+  --with-validate      Add class-validator decorators to DTOs for validation
+  --only-dtos          Generate only DTOs (skip services, controllers, modules)
+  -h, --help           Display help for command
+```
+
+### Generating with Test Files
+
+Use the `--with-test` flag to automatically generate test files for all controllers, services, and DTOs:
+
+```bash
+# Generate with test files
+eqxjs-swagger-codegen generate -i ./example-swagger.json -o ./generated --with-test
+
+# Using npx
+npx @eqxjs/swagger-codegen generate -i ./swagger.json -o ./generated --with-test
+
+# Development mode
+npm run dev -- generate -i ./example-swagger.json -o ./generated --with-test
+```
+
+### Generating with Validation Decorators
+
+Use the `--with-validate` flag to add class-validator decorators to all DTO properties:
+
+```bash
+# Generate DTOs with validation decorators
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./generated --with-validate
+
+# Combine with test generation
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./generated --with-validate --with-test
+```
+
+**Generated validators include:**
+- `@IsString()`, `@IsNumber()`, `@IsInt()`, `@IsBoolean()`, `@IsDate()` for basic types
+- `@IsEmail()` for email format
+- `@IsUUID()` for UUID format
+- `@IsUrl()` for URL format
+- `@IsEnum()` for enum values
+- `@IsArray()` with `@IsString({ each: true })` for arrays
+- `@ValidateNested()` with `@Type()` for nested objects
+- `@Min()`, `@Max()` for number constraints
+- `@MinLength()`, `@MaxLength()` for string length
+- `@Matches()` for regex patterns
+
+**Example output:**
+```typescript
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, IsEmail, IsInt, Min } from 'class-validator';
+
+export class CreateUserDto {
+  @IsString()
+  @IsEmail()
+  @ApiProperty({ description: 'User email', type: String })
+  email!: string;
+
+  @IsInt()
+  @Min(18)
+  @ApiProperty({ description: 'User age', type: Number })
+  age!: number;
+}
+```
+
+### Generating Only DTOs
+
+Use the `--only-dtos` flag to generate only Data Transfer Objects without services, controllers, or modules:
+
+```bash
+# Generate only DTOs
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./dtos --only-dtos
+
+# DTOs with validators
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./dtos --only-dtos --with-validate
+```
+
+This is useful when you:
+- Only need the data models for a separate project
+- Want to share DTOs between multiple services
+- Are building a monorepo and need consistent type definitions
+- Want to generate TypeScript interfaces from your API spec
+
+This will create test files alongside their corresponding source files:
+- **Controller specs**: Test files with mocked services and test cases for each endpoint
+- **Service specs**: Test files with basic setup and method existence checks
+- **DTO specs**: Test files with class-validator integration for validating DTOs
+
+**Example output:**
+```
+generated/
+├── dtos/
+│   ├── user.dto.ts
+│   └── post.dto.ts
+├── users/
+│   ├── users.service.ts
+│   ├── users.controller.ts
+│   └── users.module.ts
+├── posts/
+│   ├── posts.service.ts
+│   ├── posts.controller.ts
+│   └── posts.module.ts
+└── tests/                           # 🧪 Test files with same structure
+    ├── dtos/
+    │   ├── user.dto.spec.ts
+    │   └── post.dto.spec.ts
+    ├── users/
+    │   ├── users.controller.spec.ts
+    │   └── users.service.spec.ts
+    └── posts/
+        ├── posts.controller.spec.ts
+        └── posts.service.spec.ts
 ```
 
 ## Generated File Structure
@@ -152,6 +272,53 @@ output/
 
 **Note:** Service, controller, and module for each resource are grouped together in the same folder by tag name.
 
+## App Module Auto-Generation
+
+When generating in **server** or **both** modes, the tool automatically creates or updates an `app.module.ts` file in the output directory that imports all generated feature modules.
+
+### Features:
+- ✅ **Auto-creates** `app.module.ts` if it doesn't exist
+- ✅ **Auto-updates** existing `app.module.ts` with all generated modules
+- ✅ **Preserves custom imports** (e.g., `ConfigModule`, `DatabaseModule`, etc.)
+- ✅ **Updates module imports array** automatically
+
+### Example Generated `app.module.ts`:
+
+```typescript
+import { Module } from '@nestjs/common';
+import { UsersModule } from './users/users.module';
+import { PostsModule } from './posts/posts.module';
+
+@Module({
+  imports: [
+    UsersModule,
+    PostsModule
+  ],
+})
+export class AppModule {}
+```
+
+### With Custom Imports:
+
+If your `app.module.ts` already has custom imports like `ConfigModule`, they will be preserved:
+
+```typescript
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';  // ✅ Preserved
+import { UsersModule } from './users/users.module';
+import { PostsModule } from './posts/posts.module';
+
+@Module({
+  imports: [
+    UsersModule,
+    PostsModule
+  ],
+})
+export class AppModule {}
+```
+
+**Note:** The generator will replace all feature module imports but preserve any custom third-party module imports you've added.
+
 ## Example
 
 ### Input Swagger File (JSON)

package/SUMMARY.md

@@ -1,24 +1,35 @@
 # Project Summary
 
 ## Overview
-This is a complete TypeScript CLI tool for generating NestJS code from Swagger/OpenAPI specifications.
+A complete TypeScript CLI tool that generates NestJS server code, TypeScript client SDKs, or both from Swagger/OpenAPI specifications. Published as **`@eqxjs/swagger-codegen`** on npm.
+
+## Package Information
+- **NPM Package**: `@eqxjs/swagger-codegen`
+- **CLI Command**: `eqxjs-swagger-codegen`
+- **Version**: 1.0.0-beta.1
+- **License**: MIT
 
 ## What Was Built
 
 ### Core CLI Tool
-- **Entry Point**: `src/cli.ts` - Commander-based CLI interface
-- **Main Generator**: `src/generator.ts` - Orchestrates the entire generation process
+- **Entry Point**: `src/cli.ts` - Commander-based CLI interface with `--mode` and `--with-test` options
+- **Main Generator**: `src/generator.ts` - Orchestrates the entire generation process with mode selection
 - **Parser**: `src/parser.ts` - Parses and validates Swagger/OpenAPI files
 - **Utilities**: `src/utils.ts` - Helper functions for naming conventions and type conversions
 - **File Writer**: `src/file-writer.ts` - Handles file system operations
 
 ### Code Generators
 Located in `src/generators/`:
+### Code Generators
+Located in `src/generators/`:
+
+#### Server Code Generators
 1. **DTO Generator** (`dto.generator.ts`)
    - Generates Data Transfer Objects from Swagger schemas
    - Adds `@ApiProperty` decorators with proper metadata
    - Handles nested objects, arrays, enums, and references
    - Supports required/optional properties
+   - **Fixed**: Prevents circular self-imports in DTOs
 
 2. **Service Generator** (`service.generator.ts`)
    - Creates service classes with `@Injectable()` decorator
@@ -37,8 +48,65 @@ Located in `src/generators/`:
    - Creates an app module that imports all feature modules
    - Sets up proper dependency injection
 
+5. **App Module Generator** (`app-module.generator.ts`)
+   - **NEW**: Automatically generates or updates `app.module.ts`
+   - Preserves custom imports (ConfigModule, DatabaseModule, etc.)
+   - Intelligently replaces only generated module imports
+   - Maintains code formatting and structure
+
+#### Client Code Generators
+6. **Client Generator** (`client.generator.ts`)
+   - Generates TypeScript client SDK using Axios
+   - Creates typed request/response interfaces
+   - Includes all API methods with proper types
+   - Supports path, query, and body parameters
+
+#### Test Generators
+7. **Controller Test Generator** (`controller.spec.generator.ts`)
+   - Generates unit tests for controllers
+   - Includes mocked service dependencies
+   - Creates test cases for each endpoint
+   - Uses @nestjs/testing framework
+
+8. **Service Test Generator** (`service.spec.generator.ts`)
+   - Generates unit tests for services
+   - Includes basic setup and method existence checks
+   - Ready for implementation-specific tests
+
+9. **DTO Test Generator** (`dto.spec.generator.ts`)
+   - Generates validation tests for DTOs
+   - Integrates with class-validator
+   - Tests class instantiation and properties
+
 ## Features Implemented
 
+✅ **Three Generation Modes**
+   - **Server Mode** (default): NestJS backend with controllers, services, and modules
+   - **Client Mode**: TypeScript SDK with Axios HTTP client
+   - **Both Mode**: Generate server and client code simultaneously
+
+✅ **Test Generation**
+   - Optional `--with-test` flag
+   - Generates comprehensive test suites
+   - Tests organized in separate `tests/` directory with mirrored structure
+   - Includes controller, service, and DTO tests
+   - Uses Jest and @nestjs/testing
+
+✅ **Validation Decorators**
+   - Optional `--with-validate` flag
+   - Adds class-validator decorators to all DTO properties
+   - Includes @IsString, @IsNumber, @IsEmail, @IsUUID, @Min, @Max, etc.
+   - Automatically adds @Type() decorators from class-transformer
+   - Supports nested validation with @ValidateNested()
+   - Handles arrays with { each: true } option
+
+✅ **DTOs Only Mode**
+   - Optional `--only-dtos` flag
+   - Generates only Data Transfer Objects
+   - Skips services, controllers, modules, and tests
+   - Useful for shared type libraries and monorepos
+   - Works with `--with-validate` for validated DTOs
+
 ✅ **Swagger/OpenAPI Support**
    - Supports both Swagger 2.0 and OpenAPI 3.x
    - Validates input files
@@ -48,6 +116,7 @@ Located in `src/generators/`:
    - TypeScript types inferred from schemas
    - Proper type annotations throughout
    - Support for complex types (arrays, nested objects, enums)
+   - **Fixed**: Prevents circular self-imports in DTOs with self-references
 
 ✅ **NestJS Best Practices**
    - Proper decorator usage
@@ -66,12 +135,18 @@ Located in `src/generators/`:
    - Extracts base paths from endpoints
    - Groups endpoints by tags
 
+✅ **Automatic App Module Management**
+   - Auto-generates `app.module.ts` if not present
+   - Updates existing `app.module.ts` with new modules
+   - Preserves custom imports and configuration
+
 ## Generated Code Structure
 
 For each Swagger file, the tool generates:
 
+### Server Mode (Default)
 ```
-output/
+generated/
 ├── dtos/                    # Data Transfer Objects
 │   ├── *.dto.ts            # Schema-based DTOs with @ApiProperty
 ├── users/                   # User feature module (by tag)
@@ -82,103 +157,261 @@ output/
 │   ├── posts.service.ts
 │   ├── posts.controller.ts
 │   └── posts.module.ts
-├── app.module.ts           # Root application module
+├── app.module.ts           # Root application module (auto-updated)
+└── index.ts                # Barrel export file
+```
+
+### Client Mode
+```
+generated/
+├── dtos/                    # Data Transfer Objects
+│   ├── *.dto.ts            # Interface definitions
+├── client/                  # API Client
+│   ├── api-client.ts       # Axios-based HTTP client with all methods
+│   └── types.ts            # Request/Response type definitions
 └── index.ts                # Barrel export file
 ```
 
-**Structure:** Each resource (tag) is organized in its own folder with service, controller, and module grouped together.
+### With Tests (--with-test flag)
+```
+generated/
+├── dtos/                    # Source DTOs
+│   ├── *.dto.ts
+├── users/                   # Source code
+│   ├── users.service.ts
+│   ├── users.controller.ts
+│   └── users.module.ts
+├── tests/                   # Separate test directory (mirrors structure)
+│   ├── dtos/
+│   │   ├── user.dto.spec.ts
+│   │   └── post.dto.spec.ts
+│   └── users/
+│       ├── users.service.spec.ts
+│       └── users.controller.spec.ts
+├── app.module.ts
+└── index.ts
+```
+
+**Structure:** Each resource (tag) is organized in its own folder with service, controller, and module grouped together. Tests mirror the source structure in a separate `tests/` directory.
 
 ## Usage
 
 ### Installation
 ```bash
+# Global installation
+npm install -g @eqxjs/swagger-codegen
+
+# Or use npx (no installation required)
+npx @eqxjs/swagger-codegen generate -i ./swagger.json -o ./generated
+
+# Or from source
+git clone <repository-url>
+cd swagger-nestjs-codegen
 npm install
 npm run build
 ```
 
-### Generate Code
+### Generate Server Code (Default)
 ```bash
-# Swagger 2.0
-npm run dev -- generate -i ./example-swagger.json -o ./generated
-npm run dev -- generate -i ./example-swagger.yaml -o ./generated
+# Using global CLI
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./generated
 
-# OpenAPI 3.0
-npm run dev -- generate -i ./openapi3-example.json -o ./generated
-npm run dev -- generate -i ./openapi3-example.yaml -o ./generated
+# Swagger 2.0 JSON
+eqxjs-swagger-codegen generate -i ./example-swagger.json -o ./generated
+
+# Swagger 2.0 YAML
+eqxjs-swagger-codegen generate -i ./example-swagger.yaml -o ./generated
+
+# OpenAPI 3.0 JSON
+eqxjs-swagger-codegen generate -i ./openapi3-example.json -o ./generated
+
+# OpenAPI 3.0 YAML
+eqxjs-swagger-codegen generate -i ./openapi3-example.yaml -o ./generated
+```
+
+### Generate Client SDK
+```bash
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./client --mode client
+```
+
+### Generate Both Server and Client
+```bash
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./generated --mode both
 ```
 
-### Test
+### Generate with Tests
 ```bash
-npm test
+eqxjs-swagger-codegen generate -i ./swagger.json -o ./generated --with-test
+```
+
+### Development Mode
+```bash
+# For developing the tool itself
+npm run dev -- generate -i ./example-swagger.json -o ./generated
+npm run dev -- generate -i ./example-swagger.json -o ./generated --with-test
 ```
 
 ## Example Output
 
-### Swagger 2.0 Examples
-From `example-swagger.json` / `example-swagger.yaml`:
+### Swagger 2.0 Examples (example-swagger.json/yaml)
+**Generated Files:**
 - **5 DTOs**: User, CreateUserDto, UpdateUserDto, Post, CreatePostDto
 - **2 Services**: UsersService, PostsService  
 - **2 Controllers**: UsersController, PostsController
 - **2 Modules**: UsersModule, PostsModule
-- **1 App Module**: AppModule
+- **1 App Module**: AppModule (auto-updated)
 - **1 Index file**: index.ts
 
-### OpenAPI 3.0 Examples
-From `openapi3-example.json` / `openapi3-example.yaml`:
+**With --with-test flag:**
+- **9 Test Files**: 5 DTO tests + 2 service tests + 2 controller tests
+
+### OpenAPI 3.0 Examples (openapi3-example.json/yaml)
+**Generated Files:**
 - **6 DTOs**: Product, CreateProductDto, UpdateProductDto, Category, CreateCategoryDto, Error
 - **2 Services**: ProductsService, CategoriesService
 - **2 Controllers**: ProductsController, CategoriesController
 - **2 Modules**: ProductsModule, CategoriesModule
-- **1 App Module**: AppModule
+- **1 App Module**: AppModule (auto-updated)
 - **1 Index file**: index.ts
 
+**With --with-test flag:**
+- **10 Test Files**: 6 DTO tests + 2 service tests + 2 controller tests
+
+### Large-Scale Example (TMF620 Product Catalog)
+Tested with real-world TMF620 specification:
+- **294 DTOs** generated without circular import issues
+- **9 Feature Modules** with services and controllers
+- **312 Test Files** in mirrored directory structure
+- Generation time: < 3 seconds
+
 ## Technical Stack
 
+### Runtime Dependencies
 - **TypeScript 5.3.3** - Type-safe development
 - **Commander 11.1.0** - CLI framework
 - **Swagger Parser 10.0.3** - Swagger/OpenAPI parsing and validation
 - **Chalk 4.1.2** - Terminal output coloring
 - **fs-extra 11.2.0** - Enhanced file system operations
+- **Axios 1.6.5** - HTTP client for generated client code
+
+### Development Dependencies
+- **@nestjs/common** - NestJS framework core
+- **@nestjs/swagger** - Swagger decorators
+- **@nestjs/testing** - Testing utilities (for generated tests)
+- **Jest** - Test framework (for generated tests)
+- **class-validator** - Validation decorators (for `--with-validate`)
+- **class-transformer** - Transformation decorators (for `--with-validate`)
 
 ## Key Algorithms
 
-1. **Schema Resolution**: Resolves `$ref` references in Swagger schemas
+1. **Schema Resolution**: Resolves `$ref` references in Swagger schemas with circular reference prevention
 2. **Endpoint Grouping**: Groups API endpoints by tags for modular generation
 3. **Type Inference**: Maps Swagger types to TypeScript types
-4. **Name Conversion**: Converts between different naming conventions
+4. **Name Conversion**: Converts between different naming conventions (PascalCase, camelCase, kebab-case)
 5. **Code Generation**: Template-based code generation with proper imports
+6. **Self-Import Detection**: Prevents DTOs from importing themselves (circular dependency fix)
+7. **App Module Merging**: Intelligently updates app.module.ts while preserving custom imports
+8. **Test Structure Mirroring**: Replicates source directory structure in tests/ folder
+
+## Recent Enhancements
+
+### ✅ Self-Import Fix (Circular Reference Prevention)
+- Fixed issue where DTOs would import themselves
+- Pass `currentClassName` to prevent self-references
+- Handles both direct `$ref` and array item references
+
+### ✅ Automatic App Module Management
+- Auto-generates `app.module.ts` if not present
+- Updates existing app modules intelligently
+- Preserves custom imports (ConfigModule, DatabaseModule, etc.)
+- Only replaces generated module imports
+
+### ✅ Test File Generation
+- Added `--with-test` CLI option
+- Generates comprehensive test suites for all code
+- Controller tests with mocked dependencies
+- Service tests with method existence checks
+- DTO tests with validation integration
+
+### ✅ Test Structure Organization
+- Tests in separate `tests/` directory
+- Mirrors source folder structure
+- Proper relative imports (../../module/file)
+- Clean separation of source and tests
+
+### ✅ Multiple Generation Modes
+- Server mode: NestJS backend (default)
+- Client mode: TypeScript SDK with Axios
+- Both mode: Server + Client simultaneously
+
+### ✅ Validation Decorators (NEW)
+- Added `--with-validate` CLI option
+- Automatically adds class-validator decorators to DTOs
+- Includes @IsString, @IsEmail, @IsInt, @Min, @Max, etc.
+- Handles nested objects with @ValidateNested()
+- Adds @Type() decorators from class-transformer
+- Supports all common validation scenarios
+
+### ✅ DTOs Only Mode (NEW)
+- Added `--only-dtos` CLI option
+- Generates only Data Transfer Objects
+- Skips services, controllers, modules, and app.module.ts
+- Perfect for shared type libraries
+- Works with `--with-validate` for validated DTOs
 
 ## Future Enhancements
 
 Potential improvements:
-- Support for authentication decorators (@UseGuards)
-- Validation decorators (class-validator)
-- Database integration (TypeORM/Prisma)
-- Custom templates
-- Configuration file support
-- Incremental updates (don't overwrite manual changes)
-- Unit test generation
+- ~~Support for authentication decorators (@UseGuards)~~ → Ready for implementation
+- ~~Validation decorators (class-validator)~~ → Partially implemented in DTO tests
+- Database integration templates (TypeORM/Prisma)
+- Custom template support
+- Configuration file support (.swaggerrc)
+- Incremental updates (smart merge, don't overwrite manual changes)
+- GraphQL schema generation
+- OpenAPI 3.1 support
+- WebSocket endpoint generation
 
 ## Project Statistics
 
-- **Source Files**: 11 TypeScript files
-- **Lines of Code**: ~1,500+ lines
-- **Dependencies**: 4 runtime, 4 dev dependencies
+- **Source Files**: 16 TypeScript files (11 core + 3 test generators + 2 additional)
+- **Lines of Code**: ~2,500+ lines
+- **Dependencies**: 6 runtime, 5+ dev dependencies
 - **Build Time**: < 5 seconds
-- **Generation Time**: < 2 seconds for typical APIs
+- **Generation Time**: 
+  - Small APIs (< 10 endpoints): < 1 second
+  - Medium APIs (20-50 endpoints): < 2 seconds
+  - Large APIs (294 DTOs, 9 modules): < 3 seconds
+- **Test Coverage**: Generated code includes comprehensive test suites
 
 ## Testing
 
 Tested with:
 - ✅ Swagger 2.0 specification (JSON and YAML)
 - ✅ OpenAPI 3.0 format support
-- ✅ Multiple resource types (users, posts)
-- ✅ Various HTTP methods (GET, POST, PUT, DELETE)
+- ✅ Multiple resource types (users, posts, products, categories)
+- ✅ Various HTTP methods (GET, POST, PUT, DELETE, PATCH)
 - ✅ Path parameters, query parameters, body parameters
-- ✅ Array responses
-- ✅ Schema references
-- ✅ Nested objects
+- ✅ Array responses and nested objects
+- ✅ Schema references and circular references
+- ✅ Complex schema compositions (allOf, oneOf, anyOf)
+- ✅ Large-scale APIs (TMF620 with 294 DTOs)
+- ✅ Test file generation with proper structure
+- ✅ Client SDK generation with Axios
+- ✅ App module auto-update functionality
 
 ## Conclusion
 
-This CLI tool provides a complete, production-ready solution for generating NestJS boilerplate code from Swagger specifications. It follows NestJS best practices, generates type-safe code, and significantly speeds up the development process by automating the creation of DTOs, services, controllers, and modules.
+This CLI tool provides a complete, production-ready solution for generating NestJS boilerplate code and TypeScript client SDKs from Swagger specifications. It follows NestJS best practices, generates type-safe code with comprehensive test coverage and validation, and significantly speeds up the development process by automating the creation of DTOs, services, controllers, modules, and client APIs.
+
+**Key Achievements:**
+- 🎯 Three generation modes (server, client, both)
+- 🧪 Comprehensive test generation with `--with-test`
+- ✅ Built-in validation with `--with-validate`
+- 📦 DTOs only mode with `--only-dtos`
+- 🔄 Automatic app.module.ts management
+- 🚫 Circular import prevention
+- 📦 Published on npm as `@eqxjs/swagger-codegen`
+- ⚡ Fast generation (< 3s for large APIs)
+- 🏗️ Clean, maintainable code structure
+- 📚 Complete documentation (README, QUICKSTART, ARCHITECTURE, FORMATS)

package/dist/cli.js

@@ -19,6 +19,9 @@ program
     .requiredOption('-i, --input <path>', 'Path to Swagger/OpenAPI file (JSON or YAML)')
     .option('-o, --output <path>', 'Output directory for generated files', './generated')
     .option('-m, --mode <mode>', 'Generation mode: server, client, or both', 'server')
+    .option('--with-test', 'Generate test files (.spec.ts) for all generated files', false)
+    .option('--with-validate', 'Add class-validator decorators to DTOs', false)
+    .option('--only-dtos', 'Generate only DTOs (skip services, controllers, modules)', false)
     .action(async (options) => {
     try {
         const validModes = ['server', 'client', 'both'];
@@ -30,9 +33,18 @@ program
         console.log(chalk_1.default.gray(`Input: ${options.input}`));
         console.log(chalk_1.default.gray(`Output: ${options.output}`));
         console.log(chalk_1.default.gray(`Mode: ${options.mode}`));
+        if (options.withTest) {
+            console.log(chalk_1.default.gray(`Generate Tests: Yes`));
+        }
+        if (options.withValidate) {
+            console.log(chalk_1.default.gray(`Add Validators: Yes`));
+        }
+        if (options.onlyDtos) {
+            console.log(chalk_1.default.gray(`Only DTOs: Yes`));
+        }
         const inputPath = path_1.default.resolve(process.cwd(), options.input);
         const outputPath = path_1.default.resolve(process.cwd(), options.output);
-        await (0, generator_1.generateFromSwagger)(inputPath, outputPath, options.mode);
+        await (0, generator_1.generateFromSwagger)(inputPath, outputPath, options.mode, options.withTest, options.withValidate, options.onlyDtos);
         console.log(chalk_1.default.green('✅ Code generation completed successfully!'));
     }
     catch (error) {