@hazeljs/cli 0.2.0-beta.53 → 0.2.0-beta.55

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.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

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cli",
-  "version": "0.2.0-beta.53",
+  "version": "0.2.0-beta.55",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -69,5 +69,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/hazeljs"
   },
-  "gitHead": "84311f65083627fa53bf2a22f96cd212c196873c"
+  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
 }