@hazeljs/cli 0.2.0-beta.1

package/dist/commands/generate-serverless-handler.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateServerlessHandler = generateServerlessHandler;
+const generator_1 = require("../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_1.Generator {
+    getDefaultTemplate() {
+        return SERVERLESS_HANDLER_TEMPLATE;
+    }
+    async generate(options) {
+        const { platform = 'lambda', ...restOptions } = options;
+        const template = platform === 'lambda'
+            ? SERVERLESS_HANDLER_TEMPLATE
+            : SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
+        await super.generate({
+            ...restOptions,
+            template,
+        });
+    }
+}
+function generateServerlessHandler(program) {
+    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, options) => {
+        const generator = new ServerlessHandlerGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate({ ...finalOptions, platform: options.platform });
+    });
+}

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

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

package/dist/commands/generate-service.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateService = generateService;
+const generator_1 = require("../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_1.Generator {
+    getDefaultTemplate() {
+        return SERVICE_TEMPLATE;
+    }
+}
+function generateService(program) {
+    program
+        .command('service <name>')
+        .description('Generate a new service')
+        .option('-p, --path <path>', 'Path where the service should be generated')
+        .action(async (name, options) => {
+        const generator = new ServiceGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/generate-websocket-gateway.d.ts

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

package/dist/commands/generate-websocket-gateway.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWebSocketGateway = generateWebSocketGateway;
+const generator_1 = require("../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_1.Generator {
+    getDefaultTemplate() {
+        return WEBSOCKET_GATEWAY_TEMPLATE;
+    }
+}
+function generateWebSocketGateway(program) {
+    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, options) => {
+        const generator = new WebSocketGatewayGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/info.d.ts

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

package/dist/commands/info.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infoCommand = infoCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function infoCommand(program) {
+    program
+        .command('info')
+        .description('Display information about the current HazelJS project')
+        .action(() => {
+        try {
+            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+            if (!fs_1.default.existsSync(packageJsonPath)) {
+                console.log(chalk_1.default.yellow('⚠ No package.json found in current directory'));
+                console.log(chalk_1.default.gray('This does not appear to be a Node.js project'));
+                return;
+            }
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            console.log(chalk_1.default.bold.blue('\n📦 Project Information\n'));
+            // Basic info
+            console.log(chalk_1.default.bold('Name:'), packageJson.name || 'N/A');
+            console.log(chalk_1.default.bold('Version:'), packageJson.version || 'N/A');
+            console.log(chalk_1.default.bold('Description:'), packageJson.description || 'N/A');
+            // HazelJS packages
+            const hazelPackages = [];
+            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_1.default.bold('\n🔧 HazelJS Packages:\n'));
+                hazelPackages.forEach((pkg) => {
+                    console.log(chalk_1.default.green('  ✓'), pkg);
+                });
+            }
+            else {
+                console.log(chalk_1.default.yellow('\n⚠ No HazelJS packages found'));
+                console.log(chalk_1.default.gray('Install HazelJS packages with: npm install @hazeljs/core'));
+            }
+            // Project structure
+            console.log(chalk_1.default.bold('\n📁 Project Structure:\n'));
+            const srcPath = path_1.default.join(process.cwd(), 'src');
+            if (fs_1.default.existsSync(srcPath)) {
+                const items = fs_1.default.readdirSync(srcPath);
+                items.forEach((item) => {
+                    const itemPath = path_1.default.join(srcPath, item);
+                    const stat = fs_1.default.statSync(itemPath);
+                    const icon = stat.isDirectory() ? '📁' : '📄';
+                    console.log(`  ${icon} ${item}`);
+                });
+            }
+            else {
+                console.log(chalk_1.default.gray('  No src directory found'));
+            }
+            // Environment
+            console.log(chalk_1.default.bold('\n🌍 Environment:\n'));
+            console.log(chalk_1.default.bold('Node:'), process.version);
+            console.log(chalk_1.default.bold('Platform:'), process.platform);
+            console.log(chalk_1.default.bold('Architecture:'), process.arch);
+            // Config files
+            console.log(chalk_1.default.bold('\n⚙️  Configuration Files:\n'));
+            const configFiles = [
+                'tsconfig.json',
+                '.env',
+                '.env.example',
+                '.eslintrc.js',
+                '.prettierrc',
+                'jest.config.js',
+            ];
+            configFiles.forEach((file) => {
+                const exists = fs_1.default.existsSync(path_1.default.join(process.cwd(), file));
+                const icon = exists ? chalk_1.default.green('✓') : chalk_1.default.gray('✗');
+                console.log(`  ${icon} ${file}`);
+            });
+            console.log('');
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error reading project information:'), error);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/start.d.ts

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

package/dist/commands/start.js

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

package/dist/commands/test.d.ts

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

package/dist/commands/test.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testCommand = testCommand;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function testCommand(program) {
+    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, options) => {
+        try {
+            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+            if (!fs_1.default.existsSync(packageJsonPath)) {
+                console.log(chalk_1.default.red('✗ No package.json found'));
+                console.log(chalk_1.default.gray('Run this command from your project root'));
+                process.exit(1);
+            }
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            if (!packageJson.scripts?.test) {
+                console.log(chalk_1.default.yellow('⚠ No test script found in package.json'));
+                console.log(chalk_1.default.gray('\nAdd a test script to your package.json:'));
+                console.log(chalk_1.default.gray('  "scripts": {'));
+                console.log(chalk_1.default.gray('    "test": "jest"'));
+                console.log(chalk_1.default.gray('  }'));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.blue('🧪 Running tests...\n'));
+            let command = 'npm test';
+            const args = [];
+            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(' ');
+            }
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+            if (!options?.watch) {
+                console.log(chalk_1.default.green('\n✓ Tests completed'));
+            }
+        }
+        catch {
+            console.error(chalk_1.default.red('\n✗ Tests failed'));
+            process.exit(1);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const generate_module_1 = require("./commands/generate-module");
+const generate_app_1 = require("./commands/generate-app");
+const generate_controller_1 = require("./commands/generate-controller");
+const generate_service_1 = require("./commands/generate-service");
+const generate_dto_1 = require("./commands/generate-dto");
+const generate_guard_1 = require("./commands/generate-guard");
+const generate_interceptor_1 = require("./commands/generate-interceptor");
+const generate_websocket_gateway_1 = require("./commands/generate-websocket-gateway");
+const generate_exception_filter_1 = require("./commands/generate-exception-filter");
+const generate_pipe_1 = require("./commands/generate-pipe");
+const generate_repository_1 = require("./commands/generate-repository");
+const generate_ai_service_1 = require("./commands/generate-ai-service");
+const generate_agent_1 = require("./commands/generate-agent");
+const generate_serverless_handler_1 = require("./commands/generate-serverless-handler");
+const generate_crud_1 = require("./commands/generate-crud");
+const generate_middleware_1 = require("./commands/generate-middleware");
+const info_1 = require("./commands/info");
+const add_1 = require("./commands/add");
+const build_1 = require("./commands/build");
+const start_1 = require("./commands/start");
+const test_1 = require("./commands/test");
+const program = new commander_1.Command();
+program
+    .name('hazel')
+    .description('CLI for generating HazelJS components and applications')
+    .version('0.2.0');
+// New app command
+(0, generate_app_1.generateApp)(program);
+// Utility commands
+(0, info_1.infoCommand)(program);
+(0, add_1.addCommand)(program);
+(0, build_1.buildCommand)(program);
+(0, start_1.startCommand)(program);
+(0, test_1.testCommand)(program);
+// Generate command group
+const generateCommand = program
+    .command('generate')
+    .description('Generate HazelJS components')
+    .alias('g');
+// Core components
+(0, generate_controller_1.generateController)(generateCommand);
+(0, generate_service_1.generateService)(generateCommand);
+(0, generate_module_1.generateModule)(generateCommand);
+(0, generate_dto_1.generateDto)(generateCommand);
+(0, generate_guard_1.generateGuard)(generateCommand);
+(0, generate_interceptor_1.generateInterceptor)(generateCommand);
+(0, generate_middleware_1.generateMiddleware)(generateCommand);
+// Advanced generators
+(0, generate_crud_1.generateCrud)(generateCommand);
+(0, generate_websocket_gateway_1.generateWebSocketGateway)(generateCommand);
+(0, generate_exception_filter_1.generateExceptionFilter)(generateCommand);
+(0, generate_pipe_1.generatePipe)(generateCommand);
+(0, generate_repository_1.generateRepository)(generateCommand);
+(0, generate_ai_service_1.generateAIService)(generateCommand);
+(0, generate_agent_1.generateAgent)(generateCommand);
+(0, generate_serverless_handler_1.generateServerlessHandler)(generateCommand);
+program.parse(process.argv);

package/dist/utils/generator.d.ts

@@ -0,0 +1,14 @@
+export interface GeneratorOptions {
+    name: string;
+    path?: string;
+    template?: string;
+    data?: Record<string, unknown>;
+}
+export declare class Generator {
+    generate(options: GeneratorOptions): Promise<void>;
+    protected toPascalCase(str: string): string;
+    protected toKebabCase(str: string): string;
+    protected getFilePath(name: string, customPath?: string): string;
+    protected getDefaultTemplate(): string;
+    promptForOptions(options: Partial<GeneratorOptions>): Promise<GeneratorOptions>;
+}

package/dist/utils/generator.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const mustache_1 = __importDefault(require("mustache"));
+class Generator {
+    async generate(options) {
+        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_1.default.render(templateContent, templateData);
+        // Determine the file path
+        const filePath = this.getFilePath(name, customPath);
+        // Create directory if it doesn't exist
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        // Write the file
+        fs_1.default.writeFileSync(filePath, content);
+        console.log(chalk_1.default.green(`✓ Generated ${filePath}`));
+    }
+    toPascalCase(str) {
+        return str
+            .split(/[-_]/)
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+    toKebabCase(str) {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    }
+    getFilePath(name, customPath) {
+        const fileName = this.toKebabCase(name);
+        const basePath = customPath || 'src';
+        return path_1.default.join(process.cwd(), basePath, `${fileName}.ts`);
+    }
+    getDefaultTemplate() {
+        return '';
+    }
+    async promptForOptions(options) {
+        const answers = await inquirer_1.default.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,
+        };
+    }
+}
+exports.Generator = Generator;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@hazeljs/cli",
+  "version": "0.2.0-beta.1",
+  "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "hazel": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.6",
+    "mustache": "^4.2.0",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.6",
+    "@types/jest": "^29.5.12",
+    "@types/mustache": "^4.2.4",
+    "@types/node": "^20.11.24",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "hazeljs",
+    "cli",
+    "generator",
+    "scaffolding",
+    "code-generator",
+    "typescript",
+    "framework"
+  ],
+  "author": "Muhammad Arslan <marslan@hazeljs.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/hazeljs"
+  }
+}