@hazeljs/cli 0.2.0-alpha.1

package/dist/commands/generate-auth.test.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const generate_auth_1 = require("./generate-auth");
+jest.mock('fs');
+describe('generateAuth', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(false);
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate all auth files', async () => {
+        (0, generate_auth_1.generateAuth)(program);
+        await program.parseAsync(['node', 'test', 'auth']);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
+        expect(writtenFiles.some(f => f.includes('auth.module.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('auth.service.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('auth.controller.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('jwt-auth.guard.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('register.dto.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('login.dto.ts'))).toBe(true);
+    });
+    it('should use @hazeljs/auth imports in guard', async () => {
+        (0, generate_auth_1.generateAuth)(program);
+        await program.parseAsync(['node', 'test', 'auth']);
+        const guardContent = mockFs.writeFileSync.mock.calls
+            .find(call => call[0].includes('jwt-auth.guard'))?.[1];
+        expect(guardContent).toContain("from '@hazeljs/auth'");
+        expect(guardContent).toContain('JwtService');
+    });
+    it('should support --dry-run flag', async () => {
+        (0, generate_auth_1.generateAuth)(program);
+        await program.parseAsync(['node', 'test', 'auth', '--dry-run']);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/generate-cache.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateCache(command: Command): void;

package/dist/commands/generate-cache.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCache = generateCache;
+const generator_1 = require("../utils/generator");
+const chalk_1 = __importDefault(require("chalk"));
+const CACHE_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';
+
+@Service()
+export class {{className}}CacheService {
+  constructor(private readonly cacheService: CacheService) {}
+
+  @Cacheable({ key: '{{fileName}}:all', ttl: 60 })
+  async findAll() {
+    // This result will be cached for 60 seconds
+    return [];
+  }
+
+  @Cacheable({ key: '{{fileName}}:{{=<% %>=}}#{id}<%={{ }}=%>', ttl: 300 })
+  async findOne(id: string) {
+    // This result will be cached for 5 minutes
+    return { id };
+  }
+
+  @CacheEvict({ key: '{{fileName}}:all' })
+  async create(data: any) {
+    // Creating a new item evicts the list cache
+    return data;
+  }
+
+  async clearAll() {
+    await this.cacheService.clear();
+  }
+}
+`;
+class CacheServiceGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'cache';
+    }
+    getDefaultTemplate() {
+        return CACHE_SERVICE_TEMPLATE;
+    }
+}
+function generateCache(command) {
+    command
+        .command('cache <name>')
+        .description('Generate a cache service with decorators')
+        .option('-p, --path <path>', 'Specify the path')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new CacheServiceGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        if (!options.dryRun) {
+            console.log(chalk_1.default.gray('\nNext steps:'));
+            console.log(chalk_1.default.gray('  1. npm install @hazeljs/cache'));
+            console.log(chalk_1.default.gray('  2. Add CacheModule to your module imports'));
+            console.log(chalk_1.default.gray('  3. Configure the cache strategy (memory, redis, or multi-tier)'));
+        }
+    });
+}

package/dist/commands/generate-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate-cache.test.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const generate_cache_1 = require("./generate-cache");
+jest.mock('fs');
+describe('generateCache', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate a cache service file', async () => {
+        (0, generate_cache_1.generateCache)(program);
+        await program.parseAsync(['node', 'test', 'cache', 'product']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('product.cache.ts'), expect.stringContaining('ProductCacheService'));
+    });
+    it('should import from @hazeljs/cache', async () => {
+        (0, generate_cache_1.generateCache)(program);
+        await program.parseAsync(['node', 'test', 'cache', 'product']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/cache'");
+        expect(writtenContent).toContain('@Cacheable');
+        expect(writtenContent).toContain('@CacheEvict');
+    });
+});

package/dist/commands/generate-config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateConfig(command: Command): void;

package/dist/commands/generate-config.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConfig = generateConfig;
+const generator_1 = require("../utils/generator");
+const chalk_1 = __importDefault(require("chalk"));
+const CONFIG_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
+import { ConfigModule, ConfigService } from '@hazeljs/config';
+
+// Import ConfigModule.forRoot() in your app module:
+//
+// @HazelModule({
+//   imports: [
+//     ConfigModule.forRoot({
+//       envFilePath: '.env',
+//     }),
+//   ],
+// })
+//
+// Then inject ConfigService wherever you need it:
+//
+// constructor(private readonly config: ConfigService) {}
+//
+// Usage:
+//   this.config.get('DATABASE_URL');
+//   this.config.get('PORT', '3000');  // with default value
+
+export { ConfigModule, ConfigService };
+`;
+class ConfigGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'config';
+    }
+    getDefaultTemplate() {
+        return CONFIG_TEMPLATE;
+    }
+}
+function generateConfig(command) {
+    command
+        .command('config')
+        .description('Generate a config module setup')
+        .option('-p, --path <path>', 'Specify the path', 'src')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (options) => {
+        const generator = new ConfigGenerator();
+        await generator.generate({ name: 'app', path: options.path, dryRun: options.dryRun });
+        if (!options.dryRun) {
+            console.log(chalk_1.default.gray('\nNext steps:'));
+            console.log(chalk_1.default.gray('  1. npm install @hazeljs/config'));
+            console.log(chalk_1.default.gray('  2. Add ConfigModule.forRoot({ envFilePath: ".env" }) to your app module imports'));
+            console.log(chalk_1.default.gray('  3. Create a .env file in your project root'));
+        }
+    });
+}

package/dist/commands/generate-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate-config.test.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const generate_config_1 = require("./generate-config");
+jest.mock('fs');
+describe('generateConfig', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate a config module file', async () => {
+        (0, generate_config_1.generateConfig)(program);
+        await program.parseAsync(['node', 'test', 'config']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('app.config.ts'), expect.stringContaining('ConfigModule'));
+    });
+    it('should import from @hazeljs/config', async () => {
+        (0, generate_config_1.generateConfig)(program);
+        await program.parseAsync(['node', 'test', 'config']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/config'");
+        expect(writtenContent).toContain('ConfigService');
+    });
+});

package/dist/commands/generate-controller.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateController(program: Command): void;

package/dist/commands/generate-controller.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateController = generateController;
+const generator_1 = require("../utils/generator");
+const CONTROLLER_TEMPLATE = `import { Controller, Get, Post, Body, Param, Delete, Put } from '@hazeljs/core';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+import { Update{{className}}Dto } from './dto/update-{{fileName}}.dto';
+
+@Controller('{{fileName}}')
+export class {{className}}Controller {
+  constructor(private readonly {{camelName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{camelName}}Service.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.{{camelName}}Service.findOne(id);
+  }
+
+  @Post()
+  create(@Body(Create{{className}}Dto) createDto: Create{{className}}Dto) {
+    return this.{{camelName}}Service.create(createDto);
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body(Update{{className}}Dto) updateDto: Update{{className}}Dto) {
+    return this.{{camelName}}Service.update(id, updateDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.{{camelName}}Service.remove(id);
+  }
+}
+`;
+class ControllerGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'controller';
+    }
+    getDefaultTemplate() {
+        return CONTROLLER_TEMPLATE;
+    }
+}
+function generateController(program) {
+    program
+        .command('controller <name>')
+        .description('Generate a new controller')
+        .alias('c')
+        .option('-p, --path <path>', 'Path where the controller should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new ControllerGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

package/dist/commands/generate-controller.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate-controller.test.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const generate_controller_1 = require("./generate-controller");
+jest.mock('fs');
+describe('generateController', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the controller command with alias', () => {
+        (0, generate_controller_1.generateController)(program);
+        const cmd = program.commands.find(c => c.name() === 'controller');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('c');
+    });
+    it('should generate a controller file with correct suffix', async () => {
+        (0, generate_controller_1.generateController)(program);
+        await program.parseAsync(['node', 'test', 'controller', 'user']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('user.controller.ts'), expect.stringContaining('UserController'));
+    });
+    it('should include proper imports from @hazeljs/core', async () => {
+        (0, generate_controller_1.generateController)(program);
+        await program.parseAsync(['node', 'test', 'controller', 'user']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/core'");
+        expect(writtenContent).toContain('Controller');
+        expect(writtenContent).toContain('Get');
+        expect(writtenContent).toContain('Post');
+    });
+    it('should support --dry-run flag', async () => {
+        (0, generate_controller_1.generateController)(program);
+        await program.parseAsync(['node', 'test', 'controller', 'user', '--dry-run']);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/generate-cron.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateCron(command: Command): void;

package/dist/commands/generate-cron.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCron = generateCron;
+const generator_1 = require("../utils/generator");
+const chalk_1 = __importDefault(require("chalk"));
+const CRON_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { Cron, CronExpression } from '@hazeljs/cron';
+
+@Service()
+export class {{className}}CronService {
+  @Cron(CronExpression.EVERY_MINUTE)
+  handleEveryMinute() {
+    console.log('[{{className}}Cron] Running every minute...');
+    // Add your cron job logic here
+  }
+
+  @Cron('0 0 * * *')  // Every day at midnight
+  handleDaily() {
+    console.log('[{{className}}Cron] Running daily task...');
+    // Add your daily task logic here
+  }
+
+  @Cron(CronExpression.EVERY_HOUR)
+  handleHourly() {
+    console.log('[{{className}}Cron] Running hourly cleanup...');
+    // Add your hourly task logic here
+  }
+}
+`;
+class CronServiceGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'cron';
+    }
+    getDefaultTemplate() {
+        return CRON_SERVICE_TEMPLATE;
+    }
+}
+function generateCron(command) {
+    command
+        .command('cron <name>')
+        .description('Generate a cron/scheduled job service')
+        .alias('job')
+        .option('-p, --path <path>', 'Specify the path')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new CronServiceGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        if (!options.dryRun) {
+            console.log(chalk_1.default.gray('\nNext steps:'));
+            console.log(chalk_1.default.gray('  1. npm install @hazeljs/cron'));
+            console.log(chalk_1.default.gray('  2. Add CronModule to your module imports'));
+            console.log(chalk_1.default.gray('  3. Register this service as a provider'));
+        }
+    });
+}

package/dist/commands/generate-cron.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate-cron.test.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const generate_cron_1 = require("./generate-cron");
+jest.mock('fs');
+describe('generateCron', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the cron command with alias', () => {
+        (0, generate_cron_1.generateCron)(program);
+        const cmd = program.commands.find(c => c.name() === 'cron');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('job');
+    });
+    it('should generate a cron service file', async () => {
+        (0, generate_cron_1.generateCron)(program);
+        await program.parseAsync(['node', 'test', 'cron', 'cleanup']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('cleanup.cron.ts'), expect.stringContaining('CleanupCronService'));
+    });
+    it('should import from @hazeljs/cron', async () => {
+        (0, generate_cron_1.generateCron)(program);
+        await program.parseAsync(['node', 'test', 'cron', 'cleanup']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/cron'");
+        expect(writtenContent).toContain('@Cron');
+        expect(writtenContent).toContain('CronExpression');
+    });
+});

package/dist/commands/generate-crud.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateCrud(command: Command): void;

package/dist/commands/generate-crud.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCrud = generateCrud;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const generator_1 = require("../utils/generator");
+const controllerTemplate = `import { Controller, Get, Post, Put, Delete, Body, Param } from '@hazeljs/core';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto, Update{{className}}Dto } from './dto/{{fileName}}.dto';
+
+@Controller('/{{{routePath}}}')
+export class {{className}}Controller {
+  constructor(private {{camelName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{camelName}}Service.findAll();
+  }
+
+  @Get('/:id')
+  findOne(@Param('id') id: string) {
+    return this.{{camelName}}Service.findOne(id);
+  }
+
+  @Post()
+  create(@Body() createDto: Create{{className}}Dto) {
+    return this.{{camelName}}Service.create(createDto);
+  }
+
+  @Put('/:id')
+  update(@Param('id') id: string, @Body() updateDto: Update{{className}}Dto) {
+    return this.{{camelName}}Service.update(id, updateDto);
+  }
+
+  @Delete('/:id')
+  delete(@Param('id') id: string) {
+    return this.{{camelName}}Service.delete(id);
+  }
+}
+`;
+const serviceTemplate = `import { Service } from '@hazeljs/core';
+import { Create{{className}}Dto, Update{{className}}Dto } from './dto/{{fileName}}.dto';
+
+@Service()
+export class {{className}}Service {
+  private {{camelName}}s: any[] = [];
+
+  findAll() {
+    return this.{{camelName}}s;
+  }
+
+  findOne(id: string) {
+    const {{camelName}} = this.{{camelName}}s.find(item => item.id === id);
+    if (!{{camelName}}) {
+      throw new Error('{{className}} not found');
+    }
+    return {{camelName}};
+  }
+
+  create(createDto: Create{{className}}Dto) {
+    const {{camelName}} = {
+      id: Date.now().toString(),
+      ...createDto,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+    this.{{camelName}}s.push({{camelName}});
+    return {{camelName}};
+  }
+
+  update(id: string, updateDto: Update{{className}}Dto) {
+    const index = this.{{camelName}}s.findIndex(item => item.id === id);
+    if (index === -1) {
+      throw new Error('{{className}} not found');
+    }
+    this.{{camelName}}s[index] = {
+      ...this.{{camelName}}s[index],
+      ...updateDto,
+      updatedAt: new Date(),
+    };
+    return this.{{camelName}}s[index];
+  }
+
+  delete(id: string) {
+    const index = this.{{camelName}}s.findIndex(item => item.id === id);
+    if (index === -1) {
+      throw new Error('{{className}} not found');
+    }
+    const deleted = this.{{camelName}}s.splice(index, 1);
+    return deleted[0];
+  }
+}
+`;
+const dtoTemplate = `import { IsString, IsOptional, IsNotEmpty } from 'class-validator';
+
+export class Create{{className}}Dto {
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+
+export class Update{{className}}Dto {
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+`;
+const moduleTemplate = `import { HazelModule } from '@hazeljs/core';
+import { {{className}}Controller } from './{{fileName}}.controller';
+import { {{className}}Service } from './{{fileName}}.service';
+
+@HazelModule({
+  controllers: [{{className}}Controller],
+  providers: [{{className}}Service],
+})
+export class {{className}}Module {}
+`;
+function generateCrud(command) {
+    command
+        .command('crud <name>')
+        .description('Generate a complete CRUD resource (controller, service, module, DTOs)')
+        .option('-p, --path <path>', 'Specify the path', 'src')
+        .option('-r, --route <route>', 'Specify the route path')
+        .option('--dry-run', 'Preview files without writing them')
+        .action((name, options) => {
+        const className = (0, generator_1.toPascalCase)(name);
+        const fileName = (0, generator_1.toKebabCase)(name);
+        const camelName = (0, generator_1.toCamelCase)(name);
+        const routePath = options.route || fileName;
+        const basePath = path_1.default.join(process.cwd(), options.path || 'src', fileName);
+        const data = { className, fileName, camelName, routePath };
+        const files = [
+            { file: `${fileName}.controller.ts`, template: controllerTemplate },
+            { file: `${fileName}.service.ts`, template: serviceTemplate },
+            { file: `dto/${fileName}.dto.ts`, template: dtoTemplate },
+            { file: `${fileName}.module.ts`, template: moduleTemplate },
+        ];
+        try {
+            for (const { file, template } of files) {
+                const filePath = path_1.default.join(basePath, file);
+                if (options.dryRun) {
+                    console.log(chalk_1.default.blue(`[dry-run] Would create ${filePath}`));
+                    continue;
+                }
+                const dir = path_1.default.dirname(filePath);
+                if (!fs_1.default.existsSync(dir)) {
+                    fs_1.default.mkdirSync(dir, { recursive: true });
+                }
+                fs_1.default.writeFileSync(filePath, (0, generator_1.renderTemplate)(template, data));
+                console.log(chalk_1.default.green(`\u2713 Generated ${filePath}`));
+            }
+            if (!options.dryRun) {
+                console.log(chalk_1.default.blue('\n\uD83D\uDCE6 CRUD resource generated successfully!'));
+                console.log(chalk_1.default.gray(`\nNext steps:`));
+                console.log(chalk_1.default.gray(`1. Import ${className}Module in your app module`));
+                console.log(chalk_1.default.gray(`2. Customize the DTOs`));
+                console.log(chalk_1.default.gray(`3. Implement your business logic in the service`));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error generating CRUD resource:'), error);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/generate-crud.test.d.ts

@@ -0,0 +1 @@
+export {};