@hazeljs/cli 0.2.0-beta.1

package/src/commands/generate-serverless-handler.ts

@@ -0,0 +1,53 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const SERVERLESS_HANDLER_TEMPLATE = `import { createLambdaHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createLambdaHandler(AppModule);
+`;
+
+const SERVERLESS_CLOUD_FUNCTION_TEMPLATE = `import { createCloudFunctionHandler } from '@hazeljs/serverless';
+import { AppModule } from './app.module';
+
+export const handler = createCloudFunctionHandler(AppModule);
+`;
+
+class ServerlessHandlerGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return SERVERLESS_HANDLER_TEMPLATE;
+  }
+
+  public async generate(options: GeneratorOptions & { platform?: string }): Promise<void> {
+    const { platform = 'lambda', ...restOptions } = options;
+    
+    const template = platform === 'lambda' 
+      ? SERVERLESS_HANDLER_TEMPLATE 
+      : SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
+
+    await super.generate({
+      ...restOptions,
+      template,
+    });
+  }
+}
+
+export function generateServerlessHandler(program: Command): void {
+  program
+    .command('serverless <name>')
+    .description('Generate a serverless handler (Lambda or Cloud Function)')
+    .alias('sls')
+    .option('-p, --path <path>', 'Path where the handler should be generated', 'src')
+    .option('--platform <platform>', 'Platform: lambda or cloud-function', 'lambda')
+    .action(async (name: string, options: { path?: string; platform?: string }) => {
+      const generator = new ServerlessHandlerGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate({ ...finalOptions, platform: options.platform });
+    });
+}
+

package/src/commands/generate-service.ts

@@ -0,0 +1,53 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const SERVICE_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Service {
+  constructor() {}
+
+  async findAll() {
+    return [];
+  }
+
+  async findOne(id: string) {
+    return { id };
+  }
+
+  async create(create{{className}}Dto: any) {
+    return create{{className}}Dto;
+  }
+
+  async update(id: string, update{{className}}Dto: any) {
+    return { id, ...update{{className}}Dto };
+  }
+
+  async remove(id: string) {
+    return { id };
+  }
+}
+`;
+
+class ServiceGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return SERVICE_TEMPLATE;
+  }
+}
+
+export function generateService(program: Command): void {
+  program
+    .command('service <name>')
+    .description('Generate a new service')
+    .option('-p, --path <path>', 'Path where the service should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new ServiceGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+} 

package/src/commands/generate-websocket-gateway.ts

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import { Generator, GeneratorOptions } from '../utils/generator';
+
+const WEBSOCKET_GATEWAY_TEMPLATE = `import { Realtime, OnConnect, OnDisconnect, OnMessage, Subscribe, Client, Data, WebSocketClient } from '@hazeljs/websocket';
+
+@Realtime('/{{fileName}}')
+export class {{className}}Gateway {
+  @OnConnect()
+  handleConnection(@Client() client: WebSocketClient) {
+    console.log('Client connected:', client.id);
+  }
+
+  @OnDisconnect()
+  handleDisconnect(@Client() client: WebSocketClient) {
+    console.log('Client disconnected:', client.id);
+  }
+
+  @Subscribe('message')
+  @OnMessage('message')
+  handleMessage(@Client() client: WebSocketClient, @Data() data: unknown) {
+    console.log('Message received from', client.id, ':', data);
+    // Handle message logic here
+  }
+}
+`;
+
+class WebSocketGatewayGenerator extends Generator {
+  protected getDefaultTemplate(): string {
+    return WEBSOCKET_GATEWAY_TEMPLATE;
+  }
+}
+
+export function generateWebSocketGateway(program: Command): void {
+  program
+    .command('gateway <name>')
+    .description('Generate a new WebSocket gateway')
+    .alias('ws')
+    .option('-p, --path <path>', 'Path where the gateway should be generated')
+    .action(async (name: string, options: { path?: string }) => {
+      const generator = new WebSocketGatewayGenerator();
+      const generatorOptions: Partial<GeneratorOptions> = {
+        name,
+        path: options.path,
+      };
+
+      const finalOptions = await generator.promptForOptions(generatorOptions);
+      await generator.generate(finalOptions);
+    });
+}
+

package/src/commands/info.ts

@@ -0,0 +1,106 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+interface PackageJson {
+  name?: string;
+  version?: string;
+  description?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+export function infoCommand(program: Command) {
+  program
+    .command('info')
+    .description('Display information about the current HazelJS project')
+    .action(() => {
+      try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        
+        if (!fs.existsSync(packageJsonPath)) {
+          console.log(chalk.yellow('⚠ No package.json found in current directory'));
+          console.log(chalk.gray('This does not appear to be a Node.js project'));
+          return;
+        }
+
+        const packageJson: PackageJson = JSON.parse(
+          fs.readFileSync(packageJsonPath, 'utf-8')
+        );
+
+        console.log(chalk.bold.blue('\n📦 Project Information\n'));
+        
+        // Basic info
+        console.log(chalk.bold('Name:'), packageJson.name || 'N/A');
+        console.log(chalk.bold('Version:'), packageJson.version || 'N/A');
+        console.log(chalk.bold('Description:'), packageJson.description || 'N/A');
+
+        // HazelJS packages
+        const hazelPackages: string[] = [];
+        const allDeps = {
+          ...packageJson.dependencies,
+          ...packageJson.devDependencies,
+        };
+
+        Object.keys(allDeps).forEach((dep) => {
+          if (dep.startsWith('@hazeljs/')) {
+            hazelPackages.push(`${dep}@${allDeps[dep]}`);
+          }
+        });
+
+        if (hazelPackages.length > 0) {
+          console.log(chalk.bold('\n🔧 HazelJS Packages:\n'));
+          hazelPackages.forEach((pkg) => {
+            console.log(chalk.green('  ✓'), pkg);
+          });
+        } else {
+          console.log(chalk.yellow('\n⚠ No HazelJS packages found'));
+          console.log(chalk.gray('Install HazelJS packages with: npm install @hazeljs/core'));
+        }
+
+        // Project structure
+        console.log(chalk.bold('\n📁 Project Structure:\n'));
+        const srcPath = path.join(process.cwd(), 'src');
+        if (fs.existsSync(srcPath)) {
+          const items = fs.readdirSync(srcPath);
+          items.forEach((item) => {
+            const itemPath = path.join(srcPath, item);
+            const stat = fs.statSync(itemPath);
+            const icon = stat.isDirectory() ? '📁' : '📄';
+            console.log(`  ${icon} ${item}`);
+          });
+        } else {
+          console.log(chalk.gray('  No src directory found'));
+        }
+
+        // Environment
+        console.log(chalk.bold('\n🌍 Environment:\n'));
+        console.log(chalk.bold('Node:'), process.version);
+        console.log(chalk.bold('Platform:'), process.platform);
+        console.log(chalk.bold('Architecture:'), process.arch);
+
+        // Config files
+        console.log(chalk.bold('\n⚙️  Configuration Files:\n'));
+        const configFiles = [
+          'tsconfig.json',
+          '.env',
+          '.env.example',
+          '.eslintrc.js',
+          '.prettierrc',
+          'jest.config.js',
+        ];
+
+        configFiles.forEach((file) => {
+          const exists = fs.existsSync(path.join(process.cwd(), file));
+          const icon = exists ? chalk.green('✓') : chalk.gray('✗');
+          console.log(`  ${icon} ${file}`);
+        });
+
+        console.log('');
+      } catch (error) {
+        console.error(chalk.red('Error reading project information:'), error);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/start.ts

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+
+export function startCommand(program: Command) {
+  program
+    .command('start')
+    .description('Start the HazelJS application')
+    .option('-d, --dev', 'Start in development mode')
+    .option('-p, --port <port>', 'Specify port')
+    .action((options: { dev?: boolean; port?: string }) => {
+      try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+        if (!fs.existsSync(packageJsonPath)) {
+          console.log(chalk.red('✗ No package.json found'));
+          console.log(chalk.gray('Run this command from your project root'));
+          process.exit(1);
+        }
+
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+        let command: string;
+
+        if (options.dev) {
+          if (!packageJson.scripts?.dev) {
+            console.log(chalk.yellow('⚠ No dev script found in package.json'));
+            console.log(chalk.gray('\nAdd a dev script to your package.json:'));
+            console.log(chalk.gray('  "scripts": {'));
+            console.log(chalk.gray('    "dev": "ts-node-dev --respawn src/index.ts"'));
+            console.log(chalk.gray('  }'));
+            process.exit(1);
+          }
+          command = 'npm run dev';
+          console.log(chalk.blue('🚀 Starting in development mode...\n'));
+        } else {
+          if (!packageJson.scripts?.start) {
+            console.log(chalk.yellow('⚠ No start script found in package.json'));
+            console.log(chalk.gray('\nAdd a start script to your package.json:'));
+            console.log(chalk.gray('  "scripts": {'));
+            console.log(chalk.gray('    "start": "node dist/index.js"'));
+            console.log(chalk.gray('  }'));
+            process.exit(1);
+          }
+          command = 'npm start';
+          console.log(chalk.blue('🚀 Starting application...\n'));
+        }
+
+        if (options.port) {
+          process.env.PORT = options.port;
+        }
+
+        execSync(command, { stdio: 'inherit' });
+      } catch {
+        console.error(chalk.red('\n✗ Failed to start application'));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/test.ts

@@ -0,0 +1,70 @@
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+
+export function testCommand(program: Command) {
+  program
+    .command('test [pattern]')
+    .description('Run tests')
+    .option('-w, --watch', 'Watch mode')
+    .option('-c, --coverage', 'Generate coverage report')
+    .option('--ci', 'Run in CI mode')
+    .action((pattern?: string, options?: { watch?: boolean; coverage?: boolean; ci?: boolean }) => {
+      try {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+        if (!fs.existsSync(packageJsonPath)) {
+          console.log(chalk.red('✗ No package.json found'));
+          console.log(chalk.gray('Run this command from your project root'));
+          process.exit(1);
+        }
+
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+        if (!packageJson.scripts?.test) {
+          console.log(chalk.yellow('⚠ No test script found in package.json'));
+          console.log(chalk.gray('\nAdd a test script to your package.json:'));
+          console.log(chalk.gray('  "scripts": {'));
+          console.log(chalk.gray('    "test": "jest"'));
+          console.log(chalk.gray('  }'));
+          process.exit(1);
+        }
+
+        console.log(chalk.blue('🧪 Running tests...\n'));
+
+        let command = 'npm test';
+        const args: string[] = [];
+
+        if (pattern) {
+          args.push(pattern);
+        }
+
+        if (options?.watch) {
+          args.push('--watch');
+        }
+
+        if (options?.coverage) {
+          args.push('--coverage');
+        }
+
+        if (options?.ci) {
+          command = packageJson.scripts['test:ci'] ? 'npm run test:ci' : 'npm test -- --ci';
+        }
+
+        if (args.length > 0 && !options?.ci) {
+          command += ' -- ' + args.join(' ');
+        }
+
+        execSync(command, { stdio: 'inherit' });
+
+        if (!options?.watch) {
+          console.log(chalk.green('\n✓ Tests completed'));
+        }
+      } catch {
+        console.error(chalk.red('\n✗ Tests failed'));
+        process.exit(1);
+      }
+    });
+}

package/src/index.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { generateModule } from './commands/generate-module';
+import { generateApp } from './commands/generate-app';
+import { generateController } from './commands/generate-controller';
+import { generateService } from './commands/generate-service';
+import { generateDto } from './commands/generate-dto';
+import { generateGuard } from './commands/generate-guard';
+import { generateInterceptor } from './commands/generate-interceptor';
+import { generateWebSocketGateway } from './commands/generate-websocket-gateway';
+import { generateExceptionFilter } from './commands/generate-exception-filter';
+import { generatePipe } from './commands/generate-pipe';
+import { generateRepository } from './commands/generate-repository';
+import { generateAIService } from './commands/generate-ai-service';
+import { generateAgent } from './commands/generate-agent';
+import { generateServerlessHandler } from './commands/generate-serverless-handler';
+import { generateCrud } from './commands/generate-crud';
+import { generateMiddleware } from './commands/generate-middleware';
+import { infoCommand } from './commands/info';
+import { addCommand } from './commands/add';
+import { buildCommand } from './commands/build';
+import { startCommand } from './commands/start';
+import { testCommand } from './commands/test';
+
+const program = new Command();
+
+program
+  .name('hazel')
+  .description('CLI for generating HazelJS components and applications')
+  .version('0.2.0');
+
+// New app command
+generateApp(program);
+
+// Utility commands
+infoCommand(program);
+addCommand(program);
+buildCommand(program);
+startCommand(program);
+testCommand(program);
+
+// Generate command group
+const generateCommand = program
+  .command('generate')
+  .description('Generate HazelJS components')
+  .alias('g');
+
+// Core components
+generateController(generateCommand);
+generateService(generateCommand);
+generateModule(generateCommand);
+generateDto(generateCommand);
+generateGuard(generateCommand);
+generateInterceptor(generateCommand);
+generateMiddleware(generateCommand);
+
+// Advanced generators
+generateCrud(generateCommand);
+generateWebSocketGateway(generateCommand);
+generateExceptionFilter(generateCommand);
+generatePipe(generateCommand);
+generateRepository(generateCommand);
+generateAIService(generateCommand);
+generateAgent(generateCommand);
+generateServerlessHandler(generateCommand);
+
+program.parse(process.argv); 

package/src/utils/generator.ts

@@ -0,0 +1,93 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import mustache from 'mustache';
+
+export interface GeneratorOptions {
+  name: string;
+  path?: string;
+  template?: string;
+  data?: Record<string, unknown>;
+}
+
+export class Generator {
+  public async generate(options: GeneratorOptions): Promise<void> {
+    const { name, path: customPath, template, data = {} } = options;
+
+    // Get the template
+    const templateContent = template || this.getDefaultTemplate();
+
+    // Prepare the data
+    const templateData = {
+      name,
+      className: this.toPascalCase(name),
+      fileName: this.toKebabCase(name),
+      ...data,
+    };
+
+    // Render the template
+    const content = mustache.render(templateContent, templateData);
+
+    // Determine the file path
+    const filePath = this.getFilePath(name, customPath);
+
+    // Create directory if it doesn't exist
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Write the file
+    fs.writeFileSync(filePath, content);
+
+    console.log(chalk.green(`✓ Generated ${filePath}`));
+  }
+
+  protected toPascalCase(str: string): string {
+    return str
+      .split(/[-_]/)
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join('');
+  }
+
+  protected toKebabCase(str: string): string {
+    return str
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .replace(/[\s_]+/g, '-')
+      .toLowerCase();
+  }
+
+  protected getFilePath(name: string, customPath?: string): string {
+    const fileName = this.toKebabCase(name);
+    const basePath = customPath || 'src';
+    return path.join(process.cwd(), basePath, `${fileName}.ts`);
+  }
+
+  protected getDefaultTemplate(): string {
+    return '';
+  }
+
+  public async promptForOptions(options: Partial<GeneratorOptions>): Promise<GeneratorOptions> {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'What is the name of the component?',
+        when: !options.name,
+      },
+      {
+        type: 'input',
+        name: 'path',
+        message: 'Where should the component be generated?',
+        default: 'src',
+        when: !options.path,
+      },
+    ]);
+
+    return {
+      ...options,
+      ...answers,
+    };
+  }
+}