@hazeljs/cli 0.2.0-alpha.1

package/dist/index.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const generate_controller_1 = require("./commands/generate-controller");
+const generate_service_1 = require("./commands/generate-service");
+const generate_module_1 = require("./commands/generate-module");
+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_middleware_1 = require("./commands/generate-middleware");
+const generate_crud_1 = require("./commands/generate-crud");
+const generate_auth_1 = require("./commands/generate-auth");
+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_config_1 = require("./commands/generate-config");
+const generate_cache_1 = require("./commands/generate-cache");
+const generate_cron_1 = require("./commands/generate-cron");
+const generate_rag_1 = require("./commands/generate-rag");
+const generate_discovery_1 = require("./commands/generate-discovery");
+jest.mock('./commands/generate-controller');
+jest.mock('./commands/generate-service');
+jest.mock('./commands/generate-module');
+jest.mock('./commands/generate-dto');
+jest.mock('./commands/generate-guard');
+jest.mock('./commands/generate-interceptor');
+jest.mock('./commands/generate-middleware');
+jest.mock('./commands/generate-crud');
+jest.mock('./commands/generate-auth');
+jest.mock('./commands/generate-websocket-gateway');
+jest.mock('./commands/generate-exception-filter');
+jest.mock('./commands/generate-pipe');
+jest.mock('./commands/generate-repository');
+jest.mock('./commands/generate-ai-service');
+jest.mock('./commands/generate-agent');
+jest.mock('./commands/generate-serverless-handler');
+jest.mock('./commands/generate-config');
+jest.mock('./commands/generate-cache');
+jest.mock('./commands/generate-cron');
+jest.mock('./commands/generate-rag');
+jest.mock('./commands/generate-discovery');
+let exitSpy;
+beforeAll(() => {
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+});
+afterAll(() => {
+    exitSpy.mockRestore();
+});
+describe('CLI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should register all generator commands', () => {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('./index');
+        // Core generators
+        expect(generate_controller_1.generateController).toHaveBeenCalled();
+        expect(generate_service_1.generateService).toHaveBeenCalled();
+        expect(generate_module_1.generateModule).toHaveBeenCalled();
+        expect(generate_dto_1.generateDto).toHaveBeenCalled();
+        expect(generate_guard_1.generateGuard).toHaveBeenCalled();
+        expect(generate_interceptor_1.generateInterceptor).toHaveBeenCalled();
+        expect(generate_middleware_1.generateMiddleware).toHaveBeenCalled();
+        // Advanced generators
+        expect(generate_crud_1.generateCrud).toHaveBeenCalled();
+        expect(generate_auth_1.generateAuth).toHaveBeenCalled();
+        expect(generate_websocket_gateway_1.generateWebSocketGateway).toHaveBeenCalled();
+        expect(generate_exception_filter_1.generateExceptionFilter).toHaveBeenCalled();
+        expect(generate_pipe_1.generatePipe).toHaveBeenCalled();
+        expect(generate_repository_1.generateRepository).toHaveBeenCalled();
+        expect(generate_ai_service_1.generateAIService).toHaveBeenCalled();
+        expect(generate_agent_1.generateAgent).toHaveBeenCalled();
+        expect(generate_serverless_handler_1.generateServerlessHandler).toHaveBeenCalled();
+        expect(generate_config_1.generateConfig).toHaveBeenCalled();
+        expect(generate_cache_1.generateCache).toHaveBeenCalled();
+        expect(generate_cron_1.generateCron).toHaveBeenCalled();
+        expect(generate_rag_1.generateRag).toHaveBeenCalled();
+        expect(generate_discovery_1.generateDiscovery).toHaveBeenCalled();
+    });
+    it('should have generate command with alias g', () => {
+        const program = new commander_1.Command();
+        program.name('hazel').description('CLI for generating HazelJS components').version('0.2.0');
+        const generate = program.command('generate').description('Generate a new component').alias('g');
+        (0, generate_controller_1.generateController)(generate);
+        (0, generate_service_1.generateService)(generate);
+        (0, generate_module_1.generateModule)(generate);
+        expect(generate.alias()).toBe('g');
+    });
+});

package/dist/utils/generator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared string transformation utilities
+ */
+export declare function toPascalCase(str: string): string;
+export declare function toKebabCase(str: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function renderTemplate(template: string, data: Record<string, string>): string;
+export interface GeneratorOptions {
+    name: string;
+    path?: string;
+    template?: string;
+    data?: Record<string, unknown>;
+    dryRun?: boolean;
+}
+export declare class Generator {
+    /**
+     * File suffix appended before .ts (e.g. 'controller' -> name.controller.ts)
+     * Override in subclasses.
+     */
+    protected suffix: string;
+    generate(options: GeneratorOptions): Promise<void>;
+    protected getFilePath(name: string, customPath?: string): string;
+    protected getDefaultTemplate(): string;
+    promptForOptions(options: Partial<GeneratorOptions>): Promise<GeneratorOptions>;
+}

package/dist/utils/generator.js

@@ -0,0 +1,107 @@
+"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;
+exports.toPascalCase = toPascalCase;
+exports.toKebabCase = toKebabCase;
+exports.toCamelCase = toCamelCase;
+exports.renderTemplate = renderTemplate;
+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"));
+/**
+ * Shared string transformation utilities
+ */
+function toPascalCase(str) {
+    return str
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+function toCamelCase(str) {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function renderTemplate(template, data) {
+    return mustache_1.default.render(template, data);
+}
+class Generator {
+    constructor() {
+        /**
+         * File suffix appended before .ts (e.g. 'controller' -> name.controller.ts)
+         * Override in subclasses.
+         */
+        this.suffix = '';
+    }
+    async generate(options) {
+        const { name, path: customPath, template, data = {}, dryRun = false } = options;
+        // Get the template
+        const templateContent = template || this.getDefaultTemplate();
+        // Prepare the data
+        const templateData = {
+            name,
+            className: toPascalCase(name),
+            fileName: toKebabCase(name),
+            camelName: toCamelCase(name),
+            ...data,
+        };
+        // Render the template
+        const content = mustache_1.default.render(templateContent, templateData);
+        // Determine the file path
+        const filePath = this.getFilePath(name, customPath);
+        if (dryRun) {
+            console.log(chalk_1.default.blue(`[dry-run] Would create ${filePath}`));
+            console.log(chalk_1.default.gray(content));
+            return;
+        }
+        // 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}`));
+    }
+    getFilePath(name, customPath) {
+        const fileName = toKebabCase(name);
+        const basePath = customPath || 'src';
+        const suffix = this.suffix ? `.${this.suffix}` : '';
+        return path_1.default.join(process.cwd(), basePath, `${fileName}${suffix}.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/dist/utils/generator.test.d.ts

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

package/dist/utils/generator.test.js

@@ -0,0 +1,137 @@
+"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 path_1 = __importDefault(require("path"));
+const generator_1 = require("./generator");
+const inquirer_1 = __importDefault(require("inquirer"));
+jest.mock('fs');
+jest.mock('inquirer');
+describe('Generator utilities', () => {
+    describe('toPascalCase', () => {
+        it('should convert kebab-case', () => {
+            expect((0, generator_1.toPascalCase)('test-name')).toBe('TestName');
+        });
+        it('should convert snake_case', () => {
+            expect((0, generator_1.toPascalCase)('test_name')).toBe('TestName');
+        });
+        it('should handle single word', () => {
+            expect((0, generator_1.toPascalCase)('test')).toBe('Test');
+        });
+    });
+    describe('toKebabCase', () => {
+        it('should convert camelCase', () => {
+            expect((0, generator_1.toKebabCase)('testName')).toBe('test-name');
+        });
+        it('should convert PascalCase', () => {
+            expect((0, generator_1.toKebabCase)('TestName')).toBe('test-name');
+        });
+        it('should convert snake_case', () => {
+            expect((0, generator_1.toKebabCase)('test_name')).toBe('test-name');
+        });
+        it('should handle single word', () => {
+            expect((0, generator_1.toKebabCase)('test')).toBe('test');
+        });
+    });
+    describe('toCamelCase', () => {
+        it('should convert kebab-case', () => {
+            expect((0, generator_1.toCamelCase)('test-name')).toBe('testName');
+        });
+        it('should convert snake_case', () => {
+            expect((0, generator_1.toCamelCase)('test_name')).toBe('testName');
+        });
+        it('should handle single word', () => {
+            expect((0, generator_1.toCamelCase)('test')).toBe('test');
+        });
+    });
+    describe('renderTemplate', () => {
+        it('should replace mustache variables', () => {
+            const result = (0, generator_1.renderTemplate)('Hello {{name}}!', { name: 'World' });
+            expect(result).toBe('Hello World!');
+        });
+        it('should handle multiple variables', () => {
+            const result = (0, generator_1.renderTemplate)('{{className}} at {{fileName}}', {
+                className: 'Test',
+                fileName: 'test',
+            });
+            expect(result).toBe('Test at test');
+        });
+    });
+});
+describe('Generator class', () => {
+    let generator;
+    const mockFs = fs_1.default;
+    const mockInquirer = inquirer_1.default;
+    beforeEach(() => {
+        generator = new generator_1.Generator();
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+    });
+    describe('generate', () => {
+        it('should create directory if it does not exist', async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            await generator.generate({
+                name: 'test',
+                path: 'src/test',
+                template: 'test template',
+            });
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith(path_1.default.join(process.cwd(), 'src/test'), { recursive: true });
+        });
+        it('should write file with rendered template', async () => {
+            await generator.generate({
+                name: 'test',
+                path: 'src/test',
+                template: 'Hello {{name}}!',
+                data: { name: 'World' },
+            });
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('test.ts'), 'Hello World!');
+        });
+        it('should include className and fileName in template data', async () => {
+            await generator.generate({
+                name: 'my-widget',
+                path: 'src',
+                template: '{{className}} {{fileName}} {{camelName}}',
+            });
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.any(String), 'MyWidget my-widget myWidget');
+        });
+        it('should not write files in dry-run mode', async () => {
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            await generator.generate({
+                name: 'test',
+                template: 'content',
+                dryRun: true,
+            });
+            expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[dry-run]'));
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('promptForOptions', () => {
+        it('should prompt for missing options', async () => {
+            mockInquirer.prompt.mockResolvedValue({
+                name: 'test',
+                path: 'src/test',
+            });
+            const result = await generator.promptForOptions({});
+            expect(mockInquirer.prompt).toHaveBeenCalled();
+            expect(result).toEqual({
+                name: 'test',
+                path: 'src/test',
+            });
+        });
+        it('should not prompt for provided options', async () => {
+            mockInquirer.prompt.mockResolvedValue({});
+            const result = await generator.promptForOptions({
+                name: 'test',
+                path: 'src/test',
+            });
+            expect(result).toEqual({
+                name: 'test',
+                path: 'src/test',
+            });
+        });
+    });
+});

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@hazeljs/cli",
+  "version": "0.2.0-alpha.1",
+  "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "@template"
+  ],
+  "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",
+    "form-data": "^4.0.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 <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "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"
+  },
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}