@hazeljs/cli 0.2.0-alpha.1

package/dist/commands/generate-module.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModule = generateModule;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const generator_1 = require("../utils/generator");
+const MODULE_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
+import { {{className}}Controller } from './{{fileName}}.controller';
+import { {{className}}Service } from './{{fileName}}.service';
+
+@HazelModule({
+  controllers: [{{className}}Controller],
+  providers: [{{className}}Service],
+})
+export class {{className}}Module {}
+`;
+const CONTROLLER_TEMPLATE = `import { Controller, Get, Post, Body } from '@hazeljs/core';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+
+@Controller('/{{fileName}}')
+export class {{className}}Controller {
+  constructor(private readonly {{camelName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{camelName}}Service.findAll();
+  }
+
+  @Post()
+  create(@Body() createDto: Create{{className}}Dto) {
+    return this.{{camelName}}Service.create(createDto);
+  }
+}
+`;
+const SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+
+@Service()
+export class {{className}}Service {
+  private items: any[] = [];
+
+  findAll() {
+    return this.items;
+  }
+
+  create(dto: Create{{className}}Dto) {
+    this.items.push(dto);
+    return dto;
+  }
+}
+`;
+const CREATE_DTO_TEMPLATE = `export class Create{{className}}Dto {
+  // Add your properties here
+  name: string;
+}
+`;
+const UPDATE_DTO_TEMPLATE = `export class Update{{className}}Dto {
+  // Add your properties here
+  name?: string;
+}
+`;
+function generateModule(program) {
+    program
+        .command('module <name>')
+        .description('Generate a new module (with controller, service, DTOs)')
+        .alias('m')
+        .option('-p, --path <path>', 'Path where the module should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const className = (0, generator_1.toPascalCase)(name);
+        const fileName = (0, generator_1.toKebabCase)(name);
+        const camelName = fileName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        const baseDir = path_1.default.join(process.cwd(), options.path || 'src', fileName);
+        const data = { className, fileName, camelName };
+        const files = [
+            { file: `${fileName}.module.ts`, template: MODULE_TEMPLATE },
+            { file: `${fileName}.controller.ts`, template: CONTROLLER_TEMPLATE },
+            { file: `${fileName}.service.ts`, template: SERVICE_TEMPLATE },
+            { file: `dto/create-${fileName}.dto.ts`, template: CREATE_DTO_TEMPLATE },
+            { file: `dto/update-${fileName}.dto.ts`, template: UPDATE_DTO_TEMPLATE },
+        ];
+        for (const { file, template } of files) {
+            const filePath = path_1.default.join(baseDir, file);
+            if (options.dryRun) {
+                console.log(chalk_1.default.blue(`[dry-run] Would create ${filePath}`));
+                continue;
+            }
+            const dir = path_1.default.dirname(filePath);
+            if (!fs_1.default.existsSync(dir)) {
+                fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+            fs_1.default.writeFileSync(filePath, (0, generator_1.renderTemplate)(template, data));
+            console.log(chalk_1.default.green(`✓ Generated ${filePath}`));
+        }
+        if (!options.dryRun) {
+            console.log(chalk_1.default.blue(`\n📦 Module generated in ${baseDir}`));
+            console.log(chalk_1.default.gray(`\nNext steps:`));
+            console.log(chalk_1.default.gray(`  Import ${className}Module in your app module.`));
+        }
+    });
+}

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

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

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

@@ -0,0 +1,54 @@
+"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_module_1 = require("./generate-module");
+jest.mock('fs');
+describe('generateModule', () => {
+    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 register the module command with alias', () => {
+        (0, generate_module_1.generateModule)(program);
+        const cmd = program.commands.find(c => c.name() === 'module');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('m');
+    });
+    it('should generate all module files', async () => {
+        (0, generate_module_1.generateModule)(program);
+        await program.parseAsync(['node', 'test', 'module', 'user']);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
+        expect(writtenFiles.some(f => f.includes('user.module.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('user.controller.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('user.service.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('create-user.dto.ts'))).toBe(true);
+        expect(writtenFiles.some(f => f.includes('update-user.dto.ts'))).toBe(true);
+    });
+    it('should use @hazeljs/core imports in all generated files', async () => {
+        (0, generate_module_1.generateModule)(program);
+        await program.parseAsync(['node', 'test', 'module', 'user']);
+        const writtenContents = mockFs.writeFileSync.mock.calls.map(call => call[1]);
+        const moduleContent = writtenContents.find(c => c.includes('HazelModule'));
+        expect(moduleContent).toContain("from '@hazeljs/core'");
+        const controllerContent = writtenContents.find(c => c.includes('Controller'));
+        expect(controllerContent).toContain("from '@hazeljs/core'");
+    });
+    it('should support --dry-run flag', async () => {
+        (0, generate_module_1.generateModule)(program);
+        await program.parseAsync(['node', 'test', 'module', 'user', '--dry-run']);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+});

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

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

package/dist/commands/generate-pipe.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePipe = generatePipe;
+const generator_1 = require("../utils/generator");
+const PIPE_TEMPLATE = `import { type PipeTransform, type RequestContext } from '@hazeljs/core';
+
+export class {{className}}Pipe implements PipeTransform {
+  transform(value: unknown, context: RequestContext): unknown {
+    // Transform logic here
+    return value;
+  }
+}
+`;
+class PipeGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'pipe';
+    }
+    getDefaultTemplate() {
+        return PIPE_TEMPLATE;
+    }
+}
+function generatePipe(program) {
+    program
+        .command('pipe <name>')
+        .description('Generate a new pipe')
+        .option('-p, --path <path>', 'Path where the pipe should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new PipeGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

package/dist/commands/generate-pipe.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_pipe_1 = require("./generate-pipe");
+jest.mock('fs');
+describe('generatePipe', () => {
+    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 pipe file with correct suffix', async () => {
+        (0, generate_pipe_1.generatePipe)(program);
+        await program.parseAsync(['node', 'test', 'pipe', 'validation']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('validation.pipe.ts'), expect.stringContaining('ValidationPipe'));
+    });
+    it('should implement PipeTransform interface', async () => {
+        (0, generate_pipe_1.generatePipe)(program);
+        await program.parseAsync(['node', 'test', 'pipe', 'validation']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain('PipeTransform');
+        expect(writtenContent).toContain('transform');
+    });
+});

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

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

package/dist/commands/generate-rag.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRag = generateRag;
+const generator_1 = require("../utils/generator");
+const chalk_1 = __importDefault(require("chalk"));
+const RAG_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+import { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';
+
+@Service()
+export class {{className}}RagService {
+  private pipeline: RAGPipeline;
+
+  constructor() {
+    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)
+    const vectorStore = new MemoryVectorStore();
+
+    this.pipeline = new RAGPipeline({
+      vectorStore,
+      topK: 5,
+    });
+  }
+
+  async addDocument(content: string, metadata?: Record<string, unknown>) {
+    // Add a document to the vector store for retrieval
+    await this.pipeline.addDocument({
+      content,
+      metadata: metadata || {},
+    });
+  }
+
+  async query(question: string) {
+    // Retrieve relevant documents and generate a response
+    const results = await this.pipeline.query(question);
+    return results;
+  }
+}
+`;
+class RagServiceGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'rag';
+    }
+    getDefaultTemplate() {
+        return RAG_SERVICE_TEMPLATE;
+    }
+}
+function generateRag(command) {
+    command
+        .command('rag <name>')
+        .description('Generate a RAG (Retrieval-Augmented Generation) service')
+        .option('-p, --path <path>', 'Specify the path')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new RagServiceGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        if (!options.dryRun) {
+            console.log(chalk_1.default.gray('\nNext steps:'));
+            console.log(chalk_1.default.gray('  1. npm install @hazeljs/rag'));
+            console.log(chalk_1.default.gray('  2. Register this service as a provider in your module'));
+            console.log(chalk_1.default.gray('  3. Configure your embedding provider and vector store'));
+        }
+    });
+}

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

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

package/dist/commands/generate-rag.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_rag_1 = require("./generate-rag");
+jest.mock('fs');
+describe('generateRag', () => {
+    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 RAG service file', async () => {
+        (0, generate_rag_1.generateRag)(program);
+        await program.parseAsync(['node', 'test', 'rag', 'knowledge']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('knowledge.rag.ts'), expect.stringContaining('KnowledgeRagService'));
+    });
+    it('should import from @hazeljs/rag', async () => {
+        (0, generate_rag_1.generateRag)(program);
+        await program.parseAsync(['node', 'test', 'rag', 'knowledge']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/rag'");
+        expect(writtenContent).toContain('RAGPipeline');
+    });
+});

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

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

package/dist/commands/generate-repository.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRepository = generateRepository;
+const generator_1 = require("../utils/generator");
+const REPOSITORY_TEMPLATE = `import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';
+
+// @Repository implies @Injectable() — no need for both decorators
+@Repository({ model: '{{modelName}}' })
+export class {{className}}Repository extends BaseRepository<any> {
+  constructor(prisma: PrismaService) {
+    super(prisma, '{{modelName}}');
+  }
+
+  // Add custom repository methods here
+  async findByName(name: string) {
+    return this.findMany({ where: { name } });
+  }
+}
+`;
+class RepositoryGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'repository';
+    }
+    getDefaultTemplate() {
+        return REPOSITORY_TEMPLATE;
+    }
+}
+function generateRepository(program) {
+    program
+        .command('repository <name>')
+        .description('Generate a new Prisma repository')
+        .alias('repo')
+        .option('-p, --path <path>', 'Path where the repository should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new RepositoryGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

package/dist/commands/generate-repository.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_repository_1 = require("./generate-repository");
+jest.mock('fs');
+describe('generateRepository', () => {
+    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 repository command with alias', () => {
+        (0, generate_repository_1.generateRepository)(program);
+        const cmd = program.commands.find(c => c.name() === 'repository');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('repo');
+    });
+    it('should generate a repository file with correct suffix', async () => {
+        (0, generate_repository_1.generateRepository)(program);
+        await program.parseAsync(['node', 'test', 'repository', 'user']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('user.repository.ts'), expect.stringContaining('UserRepository'));
+    });
+    it('should import from @hazeljs/prisma', async () => {
+        (0, generate_repository_1.generateRepository)(program);
+        await program.parseAsync(['node', 'test', 'repository', 'user']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/prisma'");
+        expect(writtenContent).toContain('BaseRepository');
+    });
+});

package/dist/commands/generate-serverless-handler.d.ts

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

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_LAMBDA_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 {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'handler';
+    }
+    getDefaultTemplate() {
+        return SERVERLESS_LAMBDA_TEMPLATE;
+    }
+    async generate(options) {
+        const { platform = 'lambda', ...restOptions } = options;
+        const template = platform === 'lambda'
+            ? SERVERLESS_LAMBDA_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')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new ServerlessHandlerGenerator();
+        await generator.generate({ name, path: options.path, platform: options.platform, dryRun: options.dryRun });
+    });
+}

package/dist/commands/generate-serverless-handler.test.d.ts

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

package/dist/commands/generate-serverless-handler.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_serverless_handler_1 = require("./generate-serverless-handler");
+jest.mock('fs');
+describe('generateServerlessHandler', () => {
+    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 serverless command with alias', () => {
+        (0, generate_serverless_handler_1.generateServerlessHandler)(program);
+        const cmd = program.commands.find(c => c.name() === 'serverless');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('sls');
+    });
+    it('should generate a lambda handler by default', async () => {
+        (0, generate_serverless_handler_1.generateServerlessHandler)(program);
+        await program.parseAsync(['node', 'test', 'serverless', 'api']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain('createLambdaHandler');
+        expect(writtenContent).toContain("from '@hazeljs/serverless'");
+    });
+    it('should generate a cloud function handler', async () => {
+        (0, generate_serverless_handler_1.generateServerlessHandler)(program);
+        await program.parseAsync(['node', 'test', 'serverless', 'api', '--platform', 'cloud-function']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain('createCloudFunctionHandler');
+    });
+});

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,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateService = generateService;
+const generator_1 = require("../utils/generator");
+const SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
+
+@Service()
+export class {{className}}Service {
+  constructor() {}
+
+  async findAll() {
+    return [];
+  }
+
+  async findOne(id: string) {
+    return { id };
+  }
+
+  async create(createDto: any) {
+    return createDto;
+  }
+
+  async update(id: string, updateDto: any) {
+    return { id, ...updateDto };
+  }
+
+  async remove(id: string) {
+    return { id };
+  }
+}
+`;
+class ServiceGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'service';
+    }
+    getDefaultTemplate() {
+        return SERVICE_TEMPLATE;
+    }
+}
+function generateService(program) {
+    program
+        .command('service <name>')
+        .description('Generate a new service')
+        .alias('s')
+        .option('-p, --path <path>', 'Path where the service should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new ServiceGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

package/dist/commands/generate-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_service_1 = require("./generate-service");
+jest.mock('fs');
+describe('generateService', () => {
+    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 service command with alias', () => {
+        (0, generate_service_1.generateService)(program);
+        const cmd = program.commands.find(c => c.name() === 'service');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('s');
+    });
+    it('should generate a service file with correct suffix', async () => {
+        (0, generate_service_1.generateService)(program);
+        await program.parseAsync(['node', 'test', 'service', 'user']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('user.service.ts'), expect.stringContaining('UserService'));
+    });
+    it('should include Service decorator', async () => {
+        (0, generate_service_1.generateService)(program);
+        await program.parseAsync(['node', 'test', 'service', 'user']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain('@Service()');
+        expect(writtenContent).toContain("from '@hazeljs/core'");
+    });
+});

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

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