@hazeljs/cli 0.2.0-beta.1

package/src/commands/generate-crud.ts

@@ -0,0 +1,214 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+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 { Injectable } from '@hazeljs/core';
+import { Create{{className}}Dto, Update{{className}}Dto } from './dto/{{fileName}}.dto';
+
+@Injectable()
+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 toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+function toKebabCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+function toCamelCase(str: string): string {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function renderTemplate(template: string, data: Record<string, string>): string {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] || '');
+}
+
+export function generateCrud(command: 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')
+    .action((name: string, options: { path?: string; route?: string }) => {
+      const className = toPascalCase(name);
+      const fileName = toKebabCase(name);
+      const camelName = toCamelCase(name);
+      const routePath = options.route || fileName;
+      const basePath = path.join(process.cwd(), options.path || 'src', fileName);
+
+      const data = {
+        className,
+        fileName,
+        camelName,
+        routePath,
+      };
+
+      try {
+        // Create directory
+        if (!fs.existsSync(basePath)) {
+          fs.mkdirSync(basePath, { recursive: true });
+        }
+
+        // Create DTO directory
+        const dtoPath = path.join(basePath, 'dto');
+        if (!fs.existsSync(dtoPath)) {
+          fs.mkdirSync(dtoPath, { recursive: true });
+        }
+
+        // Generate controller
+        const controllerPath = path.join(basePath, `${fileName}.controller.ts`);
+        fs.writeFileSync(controllerPath, renderTemplate(controllerTemplate, data));
+        console.log(chalk.green(`✓ Generated ${controllerPath}`));
+
+        // Generate service
+        const servicePath = path.join(basePath, `${fileName}.service.ts`);
+        fs.writeFileSync(servicePath, renderTemplate(serviceTemplate, data));
+        console.log(chalk.green(`✓ Generated ${servicePath}`));
+
+        // Generate DTOs
+        const dtoFilePath = path.join(dtoPath, `${fileName}.dto.ts`);
+        fs.writeFileSync(dtoFilePath, renderTemplate(dtoTemplate, data));
+        console.log(chalk.green(`✓ Generated ${dtoFilePath}`));
+
+        // Generate module
+        const modulePath = path.join(basePath, `${fileName}.module.ts`);
+        fs.writeFileSync(modulePath, renderTemplate(moduleTemplate, data));
+        console.log(chalk.green(`✓ Generated ${modulePath}`));
+
+        console.log(chalk.blue('\n📦 CRUD resource generated successfully!'));
+        console.log(chalk.gray(`\nNext steps:`));
+        console.log(chalk.gray(`1. Import ${className}Module in your app module`));
+        console.log(chalk.gray(`2. Customize the DTOs in ${dtoFilePath}`));
+        console.log(chalk.gray(`3. Implement your business logic in ${servicePath}`));
+      } catch (error) {
+        console.error(chalk.red('Error generating CRUD resource:'), error);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/generate-dto.ts

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const CREATE_DTO_TEMPLATE = `import { IsString, IsOptional } from 'class-validator';
+
+export class Create{{className}}Dto {
+  @IsString()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+`;
+
+const UPDATE_DTO_TEMPLATE = `import { PartialType } from '@hazeljs/core';
+import { Create{{className}}Dto } from './create-{{fileName}}.dto';
+
+export class Update{{className}}Dto extends PartialType(Create{{className}}Dto) {}
+`;
+
+class DtoGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return CREATE_DTO_TEMPLATE;
+  }
+
+  public async generate(options: GeneratorOptions): Promise<void> {
+    // Generate create DTO
+    const createDtoOptions = {
+      ...options,
+      template: CREATE_DTO_TEMPLATE,
+      path: options.path ? `${options.path}/dto` : 'src/dto',
+    };
+    await super.generate(createDtoOptions);
+
+    // Generate update DTO
+    const updateDtoOptions = {
+      ...options,
+      template: UPDATE_DTO_TEMPLATE,
+      path: options.path ? `${options.path}/dto` : 'src/dto',
+    };
+    await super.generate(updateDtoOptions);
+  }
+}
+
+export function generateDto(program: Command): void {
+  program
+    .command('dto <name>')
+    .description('Generate create and update DTOs')
+    .option('-p, --path <path>', 'Path where the DTOs should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new DtoGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+} 

package/src/commands/generate-exception-filter.ts

@@ -0,0 +1,53 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const EXCEPTION_FILTER_TEMPLATE = `import { Catch, ExceptionFilter, ArgumentsHost, HttpError } from '@hazeljs/core';
+import logger from '@hazeljs/core';
+
+@Catch(HttpError)
+export class {{className}}ExceptionFilter implements ExceptionFilter<HttpError> {
+  catch(exception: HttpError, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+
+    const status = exception.statusCode || 500;
+    const message = exception.message || 'Internal server error';
+
+    logger.error(\`[\${request.method}] \${request.url} - \${message} (\${status})\`);
+
+    response.status(status).json({
+      statusCode: status,
+      message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      ...(exception.errors && { errors: exception.errors }),
+    });
+  }
+}
+`;
+
+class ExceptionFilterGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return EXCEPTION_FILTER_TEMPLATE;
+  }
+}
+
+export function generateExceptionFilter(program: Command): void {
+  program
+    .command('filter <name>')
+    .description('Generate a new exception filter')
+    .alias('f')
+    .option('-p, --path <path>', 'Path where the filter should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new ExceptionFilterGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+}
+

package/src/commands/generate-guard.ts

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const GUARD_TEMPLATE = `import { Injectable, CanActivate, ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Guard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    // Add your guard logic here
+    return true;
+  }
+}
+`;
+
+class GuardGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return GUARD_TEMPLATE;
+  }
+}
+
+export function generateGuard(program: Command): void {
+  program
+    .command('guard <name>')
+    .description('Generate a new guard')
+    .option('-p, --path <path>', 'Path where the guard should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new GuardGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+} 

package/src/commands/generate-interceptor.ts

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const INTERCEPTOR_TEMPLATE = `import { Injectable, Interceptor, ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Interceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: () => Promise<unknown>): Promise<unknown> {
+    // Pre-processing logic here (before handler execution)
+    const result = await next();
+    // Post-processing logic here (after handler execution)
+    // Transform the response data here
+    return result;
+  }
+}
+`;
+
+class InterceptorGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return INTERCEPTOR_TEMPLATE;
+  }
+}
+
+export function generateInterceptor(program: Command): void {
+  program
+    .command('interceptor <name>')
+    .description('Generate a new interceptor')
+    .option('-p, --path <path>', 'Path where the interceptor should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new InterceptorGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+} 

package/src/commands/generate-middleware.ts

@@ -0,0 +1,86 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+const middlewareTemplate = `import { Request, Response, NextFunction } from 'express';
+import { Injectable } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Middleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    // Add your middleware logic here
+    console.log(\`[{{className}}Middleware] \${req.method} \${req.path}\`);
+    
+    // Example: Add custom header
+    res.setHeader('X-{{className}}', 'true');
+    
+    // Continue to next middleware
+    next();
+  }
+}
+`;
+
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+function toKebabCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+function renderTemplate(template: string, data: Record<string, string>): string {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] || '');
+}
+
+export function generateMiddleware(command: Command) {
+  command
+    .command('middleware <name>')
+    .alias('mw')
+    .description('Generate a middleware')
+    .option('-p, --path <path>', 'Specify the path', 'src/middleware')
+    .action((name: string, options: { path?: string }) => {
+      const className = toPascalCase(name);
+      const fileName = toKebabCase(name);
+      const filePath = path.join(
+        process.cwd(),
+        options.path || 'src/middleware',
+        `${fileName}.middleware.ts`
+      );
+
+      const data = {
+        className,
+        fileName,
+      };
+
+      try {
+        // Create directory if it doesn't exist
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+
+        // Generate middleware
+        fs.writeFileSync(filePath, renderTemplate(middlewareTemplate, data));
+        console.log(chalk.green(`✓ Generated ${filePath}`));
+
+        console.log(chalk.gray('\nUsage:'));
+        console.log(chalk.gray(`import { ${className}Middleware } from './${options.path?.replace('src/', '') || 'middleware'}/${fileName}.middleware';`));
+        console.log(chalk.gray(`\n// In your module:`));
+        console.log(chalk.gray(`@HazelModule({`));
+        console.log(chalk.gray(`  providers: [${className}Middleware],`));
+        console.log(chalk.gray(`})`));
+        console.log(chalk.gray(`\n// Or apply globally in main.ts:`));
+        console.log(chalk.gray(`app.use(new ${className}Middleware().use);`));
+      } catch (error) {
+        console.error(chalk.red('Error generating middleware:'), error);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/generate-module.ts

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const MODULE_TEMPLATE = `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 {}
+`;
+
+const CONTROLLER_TEMPLATE = `import { Controller, Get, Post, Body } from '../../core/decorators';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+
+@Controller('/{{fileName}}')
+export class {{className}}Controller {
+  constructor(private readonly {{fileName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{fileName}}Service.findAll();
+  }
+
+  @Post()
+  create(@Body() createDto: Create{{className}}Dto) {
+    return this.{{fileName}}Service.create(createDto);
+  }
+}
+`;
+
+const SERVICE_TEMPLATE = `import { Injectable } from '../../core/decorators';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+
+@Injectable()
+export class {{className}}Service {
+  private items = [];
+
+  findAll() {
+    return this.items;
+  }
+
+  create(dto: Create{{className}}Dto) {
+    this.items.push(dto);
+    return dto;
+  }
+}
+`;
+
+const CREATE_DTO_TEMPLATE = `export class Create{{className}}Dto {
+  // Add your properties here
+  name: string;
+}
+`;
+
+const UPDATE_DTO_TEMPLATE = `export class Update{{className}}Dto {
+  // Add your properties here
+  name?: string;
+}
+`;
+
+class FullModuleGenerator extends Generator {
+  async generate(options: GeneratorOptions): Promise<void> {
+    const { name, path: customPath } = options;
+    const className = this.toPascalCase(name);
+    const fileName = this.toKebabCase(name);
+    const baseDir = path.join(process.cwd(), customPath || 'src', fileName);
+
+    // Create module directory and dto subdirectory
+    fs.mkdirSync(baseDir, { recursive: true });
+    fs.mkdirSync(path.join(baseDir, 'dto'), { recursive: true });
+
+    // Generate files
+    fs.writeFileSync(path.join(baseDir, `${fileName}.module.ts`), this.render(MODULE_TEMPLATE, { className, fileName }));
+    fs.writeFileSync(path.join(baseDir, `${fileName}.controller.ts`), this.render(CONTROLLER_TEMPLATE, { className, fileName }));
+    fs.writeFileSync(path.join(baseDir, `${fileName}.service.ts`), this.render(SERVICE_TEMPLATE, { className, fileName }));
+    fs.writeFileSync(path.join(baseDir, 'dto', `create-${fileName}.dto.ts`), this.render(CREATE_DTO_TEMPLATE, { className, fileName }));
+    fs.writeFileSync(path.join(baseDir, 'dto', `update-${fileName}.dto.ts`), this.render(UPDATE_DTO_TEMPLATE, { className, fileName }));
+
+    console.log(`✓ Generated module in ${baseDir}`);
+  }
+
+  render(template: string, data: Record<string, string>) {
+    return template.replace(/{{(\w+)}}/g, (_, key) => data[key] || '');
+  }
+}
+
+export function generateModule(program: Command): void {
+  program
+    .command('module <name>')
+    .description('Generate a new module (with controller, service, DTOs)')
+    .option('-p, --path <path>', 'Path where the module should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new FullModuleGenerator();
+      await generator.generate({ name, path: options.path });
+    });
+} 

package/src/commands/generate-pipe.ts

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const PIPE_TEMPLATE = `import { PipeTransform, RequestContext } from '@hazeljs/core';
+
+export class {{className}}Pipe implements PipeTransform {
+  transform(value: unknown, context: RequestContext): unknown {
+    // Transform logic here
+    return value;
+  }
+}
+`;
+
+class PipeGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return PIPE_TEMPLATE;
+  }
+}
+
+export function generatePipe(program: Command): void {
+  program
+    .command('pipe <name>')
+    .description('Generate a new pipe')
+    .option('-p, --path <path>', 'Path where the pipe should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new PipeGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+}
+

package/src/commands/generate-repository.ts

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const REPOSITORY_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+import { BaseRepository, PrismaService, PrismaModel } from '@hazeljs/prisma';
+
+@Injectable()
+export class {{className}}Repository extends BaseRepository<PrismaModel> {
+  constructor(prisma: PrismaService) {
+    // Replace 'modelName' with your actual Prisma model name
+    super(prisma.modelName as unknown as { findMany: () => Promise<PrismaModel[]>; findUnique: (args: { where: { id?: number } }) => Promise<PrismaModel | null>; create: (args: { data: unknown }) => Promise<PrismaModel>; update: (args: { where: { id?: number }; data: unknown }) => Promise<PrismaModel>; delete: (args: { where: { id?: number } }) => Promise<PrismaModel>; count: (args?: unknown) => Promise<number> });
+  }
+
+  // Add custom repository methods here
+}
+`;
+
+class RepositoryGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return REPOSITORY_TEMPLATE;
+  }
+}
+
+export function generateRepository(program: Command): void {
+  program
+    .command('repository <name>')
+    .description('Generate a new Prisma repository')
+    .alias('repo')
+    .option('-p, --path <path>', 'Path where the repository should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new RepositoryGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+}
+