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

package/README.md

@@ -675,4 +675,4 @@ Apache 2.0 © [HazelJS](https://hazeljs.com)
 - [Documentation](https://hazeljs.com/docs/packages/cli)
 - [GitHub](https://github.com/hazel-js/hazeljs)
 - [Issues](https://github.com/hazel-js/hazeljs/issues)
-- [Discord](https://discord.gg/hazeljs)
+- [Discord](https://discord.com/channels/1448263814238965833/1448263814859456575)

package/dist/commands/add.test.d.ts

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

package/dist/commands/add.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const add_1 = require("./add");
+jest.mock('child_process');
+jest.mock('inquirer');
+describe('addCommand', () => {
+    const mockExecSync = child_process_1.execSync;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExecSync.mockImplementation(() => Buffer.from(''));
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the add command', () => {
+        (0, add_1.addCommand)(program);
+        const cmd = program.commands.find(c => c.name() === 'add');
+        expect(cmd).toBeDefined();
+    });
+    it('should install a known package', async () => {
+        (0, add_1.addCommand)(program);
+        await program.parseAsync(['node', 'test', 'add', 'auth']);
+        expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('@hazeljs/auth'), expect.objectContaining({ stdio: 'inherit' }));
+    });
+    it('should handle unknown packages gracefully', async () => {
+        const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        (0, add_1.addCommand)(program);
+        await program.parseAsync(['node', 'test', 'add', 'unknown-package']);
+        expect(mockExecSync).not.toHaveBeenCalled();
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown package'));
+        consoleSpy.mockRestore();
+    });
+    it('should include all hazeljs packages', async () => {
+        (0, add_1.addCommand)(program);
+        // Test that all documented packages are available
+        const expectedPackages = [
+            'ai', 'agent', 'auth', 'cache', 'config', 'cron',
+            'discovery', 'prisma', 'typeorm', 'rag', 'serverless', 'swagger', 'websocket'
+        ];
+        for (const pkg of expectedPackages) {
+            mockExecSync.mockClear();
+            await program.parseAsync(['node', 'test', 'add', pkg]);
+            expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining(`@hazeljs/${pkg}`), expect.any(Object));
+        }
+    });
+});

package/dist/commands/generate-agent.test.d.ts

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

package/dist/commands/generate-agent.test.js

@@ -0,0 +1,36 @@
+"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 commander_1 = require("commander");
+const generate_agent_1 = require("./generate-agent");
+jest.mock('fs');
+describe('generateAgent', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate an agent file with correct suffix', async () => {
+        (0, generate_agent_1.generateAgent)(program);
+        await program.parseAsync(['node', 'test', 'agent', 'research']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('research.agent.ts'), expect.stringContaining('ResearchAgent'));
+    });
+    it('should import from @hazeljs/agent', async () => {
+        (0, generate_agent_1.generateAgent)(program);
+        await program.parseAsync(['node', 'test', 'agent', 'research']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/agent'");
+        expect(writtenContent).toContain('@Agent');
+        expect(writtenContent).toContain('@Tool');
+    });
+});

package/dist/commands/generate-ai-service.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAIService = generateAIService;
 const generator_1 = require("../utils/generator");
-const AI_SERVICE_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+const AI_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';
 
-@Injectable()
+@Service()
 export class {{className}}AIService {
   constructor(private readonly aiService: AIService) {}
 

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

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

package/dist/commands/generate-ai-service.test.js

@@ -0,0 +1,41 @@
+"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 commander_1 = require("commander");
+const generate_ai_service_1 = require("./generate-ai-service");
+jest.mock('fs');
+describe('generateAIService', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the ai-service command with alias', () => {
+        (0, generate_ai_service_1.generateAIService)(program);
+        const cmd = program.commands.find(c => c.name() === 'ai-service');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('ai');
+    });
+    it('should generate an AI service file with correct suffix', async () => {
+        (0, generate_ai_service_1.generateAIService)(program);
+        await program.parseAsync(['node', 'test', 'ai-service', 'chat']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('chat.ai-service.ts'), expect.stringContaining('ChatAIService'));
+    });
+    it('should import from @hazeljs/ai', async () => {
+        (0, generate_ai_service_1.generateAIService)(program);
+        await program.parseAsync(['node', 'test', 'ai-service', 'chat']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/ai'");
+        expect(writtenContent).toContain('AIFunction');
+    });
+});

package/dist/commands/generate-app.js

@@ -430,7 +430,7 @@ coverage/
             }
             console.log(chalk_1.default.gray('  npm run dev'));
             console.log(chalk_1.default.gray('\nDocumentation: https://hazeljs.com/docs'));
-            console.log(chalk_1.default.gray('Discord: https://discord.gg/hazeljs\n'));
+            console.log(chalk_1.default.gray('Discord: https://discord.com/channels/1448263814238965833/1448263814859456575\n'));
         }
         catch (error) {
             console.error(chalk_1.default.red('\n✗ Failed to create project:'), error);

package/dist/commands/generate-auth.js

@@ -20,12 +20,12 @@ import { JwtAuthGuard } from './jwt-auth.guard';
 })
 export class AuthModule {}
 `;
-const AUTH_SERVICE_TEMPLATE = `import { Injectable, BadRequestError, UnauthorizedError } from '@hazeljs/core';
+const AUTH_SERVICE_TEMPLATE = `import { Service, BadRequestError, UnauthorizedError } from '@hazeljs/core';
 import { JwtService } from '@hazeljs/auth';
 import { RegisterDto } from './dto/register.dto';
 import { LoginDto } from './dto/login.dto';
 
-@Injectable()
+@Service()
 export class AuthService {
   constructor(
     private readonly jwtService: JwtService,

package/dist/commands/generate-auth.test.d.ts

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

package/dist/commands/generate-auth.test.js

@@ -0,0 +1,48 @@
+"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 commander_1 = require("commander");
+const generate_auth_1 = require("./generate-auth");
+jest.mock('fs');
+describe('generateAuth', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(false);
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate all auth files', async () => {
+        (0, generate_auth_1.generateAuth)(program);
+        await program.parseAsync(['node', 'test', 'auth']);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
+        expect(writtenFiles.some(f => f.includes('auth.module.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('auth.service.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('auth.controller.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('jwt-auth.guard.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('register.dto.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('login.dto.ts'))).toBe(true);
+    });
+    it('should use @hazeljs/auth imports in guard', async () => {
+        (0, generate_auth_1.generateAuth)(program);
+        await program.parseAsync(['node', 'test', 'auth']);
+        const guardContent = mockFs.writeFileSync.mock.calls
+            .find(call => call[0].includes('jwt-auth.guard'))?.[1];
+        expect(guardContent).toContain("from '@hazeljs/auth'");
+        expect(guardContent).toContain('JwtService');
+    });
+    it('should support --dry-run flag', async () => {
+        (0, generate_auth_1.generateAuth)(program);
+        await program.parseAsync(['node', 'test', 'auth', '--dry-run']);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/generate-cache.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCache = generateCache;
 const generator_1 = require("../utils/generator");
 const chalk_1 = __importDefault(require("chalk"));
-const CACHE_SERVICE_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+const CACHE_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';
 
-@Injectable()
+@Service()
 export class {{className}}CacheService {
   constructor(private readonly cacheService: CacheService) {}
 

package/dist/commands/generate-cache.test.d.ts

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

package/dist/commands/generate-cache.test.js

@@ -0,0 +1,36 @@
+"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 commander_1 = require("commander");
+const generate_cache_1 = require("./generate-cache");
+jest.mock('fs');
+describe('generateCache', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate a cache service file', async () => {
+        (0, generate_cache_1.generateCache)(program);
+        await program.parseAsync(['node', 'test', 'cache', 'product']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('product.cache.ts'), expect.stringContaining('ProductCacheService'));
+    });
+    it('should import from @hazeljs/cache', async () => {
+        (0, generate_cache_1.generateCache)(program);
+        await program.parseAsync(['node', 'test', 'cache', 'product']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/cache'");
+        expect(writtenContent).toContain('@Cacheable');
+        expect(writtenContent).toContain('@CacheEvict');
+    });
+});

package/dist/commands/generate-config.test.d.ts

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

package/dist/commands/generate-config.test.js

@@ -0,0 +1,35 @@
+"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 commander_1 = require("commander");
+const generate_config_1 = require("./generate-config");
+jest.mock('fs');
+describe('generateConfig', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate a config module file', async () => {
+        (0, generate_config_1.generateConfig)(program);
+        await program.parseAsync(['node', 'test', 'config']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('app.config.ts'), expect.stringContaining('ConfigModule'));
+    });
+    it('should import from @hazeljs/config', async () => {
+        (0, generate_config_1.generateConfig)(program);
+        await program.parseAsync(['node', 'test', 'config']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/config'");
+        expect(writtenContent).toContain('ConfigService');
+    });
+});

package/dist/commands/generate-controller.test.d.ts

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

package/dist/commands/generate-controller.test.js

@@ -0,0 +1,48 @@
+"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 commander_1 = require("commander");
+const generate_controller_1 = require("./generate-controller");
+jest.mock('fs');
+describe('generateController', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the controller command with alias', () => {
+        (0, generate_controller_1.generateController)(program);
+        const cmd = program.commands.find(c => c.name() === 'controller');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('c');
+    });
+    it('should generate a controller file with correct suffix', async () => {
+        (0, generate_controller_1.generateController)(program);
+        await program.parseAsync(['node', 'test', 'controller', 'user']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('user.controller.ts'), expect.stringContaining('UserController'));
+    });
+    it('should include proper imports from @hazeljs/core', async () => {
+        (0, generate_controller_1.generateController)(program);
+        await program.parseAsync(['node', 'test', 'controller', 'user']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/core'");
+        expect(writtenContent).toContain('Controller');
+        expect(writtenContent).toContain('Get');
+        expect(writtenContent).toContain('Post');
+    });
+    it('should support --dry-run flag', async () => {
+        (0, generate_controller_1.generateController)(program);
+        await program.parseAsync(['node', 'test', 'controller', 'user', '--dry-run']);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/generate-cron.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCron = generateCron;
 const generator_1 = require("../utils/generator");
 const chalk_1 = __importDefault(require("chalk"));
-const CRON_SERVICE_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+const CRON_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { Cron, CronExpression } from '@hazeljs/cron';
 
-@Injectable()
+@Service()
 export class {{className}}CronService {
   @Cron(CronExpression.EVERY_MINUTE)
   handleEveryMinute() {

package/dist/commands/generate-cron.test.d.ts

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

package/dist/commands/generate-cron.test.js

@@ -0,0 +1,42 @@
+"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 commander_1 = require("commander");
+const generate_cron_1 = require("./generate-cron");
+jest.mock('fs');
+describe('generateCron', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the cron command with alias', () => {
+        (0, generate_cron_1.generateCron)(program);
+        const cmd = program.commands.find(c => c.name() === 'cron');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('job');
+    });
+    it('should generate a cron service file', async () => {
+        (0, generate_cron_1.generateCron)(program);
+        await program.parseAsync(['node', 'test', 'cron', 'cleanup']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('cleanup.cron.ts'), expect.stringContaining('CleanupCronService'));
+    });
+    it('should import from @hazeljs/cron', async () => {
+        (0, generate_cron_1.generateCron)(program);
+        await program.parseAsync(['node', 'test', 'cron', 'cleanup']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/cron'");
+        expect(writtenContent).toContain('@Cron');
+        expect(writtenContent).toContain('CronExpression');
+    });
+});

package/dist/commands/generate-crud.js

@@ -42,10 +42,10 @@ export class {{className}}Controller {
   }
 }
 `;
-const serviceTemplate = `import { Injectable } from '@hazeljs/core';
+const serviceTemplate = `import { Service } from '@hazeljs/core';
 import { Create{{className}}Dto, Update{{className}}Dto } from './dto/{{fileName}}.dto';
 
-@Injectable()
+@Service()
 export class {{className}}Service {
   private {{camelName}}s: any[] = [];
 

package/dist/commands/generate-crud.test.d.ts

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

package/dist/commands/generate-crud.test.js

@@ -0,0 +1,52 @@
+"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 commander_1 = require("commander");
+const generate_crud_1 = require("./generate-crud");
+jest.mock('fs');
+describe('generateCrud', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(false);
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate all CRUD files', async () => {
+        (0, generate_crud_1.generateCrud)(program);
+        await program.parseAsync(['node', 'test', 'crud', 'product']);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
+        expect(writtenFiles.some(f => f.includes('product.controller.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('product.service.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('product.dto.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('product.module.ts'))).toBe(true);
+    });
+    it('should use @hazeljs/core imports', async () => {
+        (0, generate_crud_1.generateCrud)(program);
+        await program.parseAsync(['node', 'test', 'crud', 'product']);
+        const controllerContent = mockFs.writeFileSync.mock.calls
+            .find(call => call[0].includes('controller'))?.[1];
+        expect(controllerContent).toContain("from '@hazeljs/core'");
+    });
+    it('should support --dry-run flag', async () => {
+        (0, generate_crud_1.generateCrud)(program);
+        await program.parseAsync(['node', 'test', 'crud', 'product', '--dry-run']);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('should support custom route path', async () => {
+        (0, generate_crud_1.generateCrud)(program);
+        await program.parseAsync(['node', 'test', 'crud', 'product', '-r', 'api/products']);
+        const controllerContent = mockFs.writeFileSync.mock.calls
+            .find(call => call[0].includes('controller'))?.[1];
+        expect(controllerContent).toContain('api/products');
+    });
+});

package/dist/commands/generate-discovery.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDiscovery = generateDiscovery;
 const generator_1 = require("../utils/generator");
 const chalk_1 = __importDefault(require("chalk"));
-const DISCOVERY_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+const DISCOVERY_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';
 
-@Injectable()
+@Service()
 export class {{className}}DiscoveryService {
   constructor(
     private readonly registry: ServiceRegistry,

package/dist/commands/generate-discovery.test.d.ts

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

package/dist/commands/generate-discovery.test.js

@@ -0,0 +1,36 @@
+"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 commander_1 = require("commander");
+const generate_discovery_1 = require("./generate-discovery");
+jest.mock('fs');
+describe('generateDiscovery', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should generate a discovery service file', async () => {
+        (0, generate_discovery_1.generateDiscovery)(program);
+        await program.parseAsync(['node', 'test', 'discovery', 'app']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('app.discovery.ts'), expect.stringContaining('AppDiscoveryService'));
+    });
+    it('should import from @hazeljs/discovery', async () => {
+        (0, generate_discovery_1.generateDiscovery)(program);
+        await program.parseAsync(['node', 'test', 'discovery', 'app']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/discovery'");
+        expect(writtenContent).toContain('ServiceRegistry');
+        expect(writtenContent).toContain('DiscoveryClient');
+    });
+});

package/dist/commands/generate-dto.test.d.ts

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

package/dist/commands/generate-dto.test.js

@@ -0,0 +1,44 @@
+"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 commander_1 = require("commander");
+const generate_dto_1 = require("./generate-dto");
+jest.mock('fs');
+describe('generateDto', () => {
+    const mockFs = fs_1.default;
+    let program;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.writeFileSync.mockImplementation(() => { });
+        jest.spyOn(console, 'log').mockImplementation();
+        program = new commander_1.Command();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should register the dto command with alias', () => {
+        (0, generate_dto_1.generateDto)(program);
+        const cmd = program.commands.find(c => c.name() === 'dto');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('d');
+    });
+    it('should generate both create and update DTOs', async () => {
+        (0, generate_dto_1.generateDto)(program);
+        await program.parseAsync(['node', 'test', 'dto', 'user']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledTimes(2);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
+        expect(writtenFiles.some(f => f.includes('user.dto.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('update-user.dto.ts'))).toBe(true);
+    });
+    it('should include class-validator decorators', async () => {
+        (0, generate_dto_1.generateDto)(program);
+        await program.parseAsync(['node', 'test', 'dto', 'user']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain('class-validator');
+        expect(writtenContent).toContain('IsString');
+    });
+});

package/dist/commands/generate-exception-filter.test.d.ts

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