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

package/dist/commands/generate-exception-filter.test.js

@@ -0,0 +1,43 @@
+"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_exception_filter_1 = require("./generate-exception-filter");
+jest.mock('fs');
+describe('generateExceptionFilter', () => {
+    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 filter command with alias', () => {
+        (0, generate_exception_filter_1.generateExceptionFilter)(program);
+        const cmd = program.commands.find(c => c.name() === 'filter');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('f');
+    });
+    it('should generate a filter file with correct suffix', async () => {
+        (0, generate_exception_filter_1.generateExceptionFilter)(program);
+        await program.parseAsync(['node', 'test', 'filter', 'http']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('http.filter.ts'), expect.stringContaining('HttpExceptionFilter'));
+    });
+    it('should import correctly from @hazeljs/core', async () => {
+        (0, generate_exception_filter_1.generateExceptionFilter)(program);
+        await program.parseAsync(['node', 'test', 'filter', 'http']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/core'");
+        expect(writtenContent).toContain('Catch');
+        expect(writtenContent).toContain('logger');
+        expect(writtenContent).not.toContain("import logger from");
+    });
+});

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

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

package/dist/commands/generate-guard.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_guard_1 = require("./generate-guard");
+jest.mock('fs');
+describe('generateGuard', () => {
+    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 guard command with alias', () => {
+        (0, generate_guard_1.generateGuard)(program);
+        const cmd = program.commands.find(c => c.name() === 'guard');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('gu');
+    });
+    it('should generate a guard file with correct suffix', async () => {
+        (0, generate_guard_1.generateGuard)(program);
+        await program.parseAsync(['node', 'test', 'guard', 'auth']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('auth.guard.ts'), expect.stringContaining('AuthGuard'));
+    });
+    it('should include CanActivate interface', async () => {
+        (0, generate_guard_1.generateGuard)(program);
+        await program.parseAsync(['node', 'test', 'guard', 'auth']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain('CanActivate');
+        expect(writtenContent).toContain('canActivate');
+    });
+});

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

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

package/dist/commands/generate-interceptor.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_interceptor_1 = require("./generate-interceptor");
+jest.mock('fs');
+describe('generateInterceptor', () => {
+    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 interceptor command with alias', () => {
+        (0, generate_interceptor_1.generateInterceptor)(program);
+        const cmd = program.commands.find(c => c.name() === 'interceptor');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('i');
+    });
+    it('should generate an interceptor file with correct suffix', async () => {
+        (0, generate_interceptor_1.generateInterceptor)(program);
+        await program.parseAsync(['node', 'test', 'interceptor', 'logging']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('logging.interceptor.ts'), expect.stringContaining('LoggingInterceptor'));
+    });
+    it('should implement the Interceptor interface', async () => {
+        (0, generate_interceptor_1.generateInterceptor)(program);
+        await program.parseAsync(['node', 'test', 'interceptor', 'logging']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain('implements Interceptor');
+        expect(writtenContent).toContain('intercept');
+    });
+});

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

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

package/dist/commands/generate-middleware.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_middleware_1 = require("./generate-middleware");
+jest.mock('fs');
+describe('generateMiddleware', () => {
+    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 middleware command with alias', () => {
+        (0, generate_middleware_1.generateMiddleware)(program);
+        const cmd = program.commands.find(c => c.name() === 'middleware');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('mw');
+    });
+    it('should generate a middleware file with correct suffix', async () => {
+        (0, generate_middleware_1.generateMiddleware)(program);
+        await program.parseAsync(['node', 'test', 'middleware', 'logger']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('logger.middleware.ts'), expect.stringContaining('LoggerMiddleware'));
+    });
+    it('should import from @hazeljs/core not express', async () => {
+        (0, generate_middleware_1.generateMiddleware)(program);
+        await program.parseAsync(['node', 'test', 'middleware', 'logger']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/core'");
+        expect(writtenContent).not.toContain("from 'express'");
+    });
+});

package/dist/commands/generate-module.js

@@ -37,10 +37,10 @@ export class {{className}}Controller {
   }
 }
 `;
-const SERVICE_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+const SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
 
-@Injectable()
+@Service()
 export class {{className}}Service {
   private items: any[] = [];
 

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

@@ -6,10 +6,10 @@ 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 { Injectable } from '@hazeljs/core';
+const RAG_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';
 
-@Injectable()
+@Service()
 export class {{className}}RagService {
   private pipeline: RAGPipeline;
 

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

@@ -2,14 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRepository = generateRepository;
 const generator_1 = require("../utils/generator");
-const REPOSITORY_TEMPLATE = `import { Injectable } from '@hazeljs/core';
-import { BaseRepository, PrismaService } from '@hazeljs/prisma';
+const REPOSITORY_TEMPLATE = `import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';
 
-@Injectable()
+// @Repository implies @Injectable() — no need for both decorators
+@Repository({ model: '{{modelName}}' })
 export class {{className}}Repository extends BaseRepository<any> {
   constructor(prisma: PrismaService) {
-    // Replace 'modelName' with your actual Prisma model name (e.g., prisma.user)
-    super(prisma.client.modelName);
+    super(prisma, '{{modelName}}');
   }
 
   // Add custom repository methods here

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

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateService = generateService;
 const generator_1 = require("../utils/generator");
-const SERVICE_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+const SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 
-@Injectable()
+@Service()
 export class {{className}}Service {
   constructor() {}
 

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.test.d.ts

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

package/dist/commands/generate-websocket-gateway.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_websocket_gateway_1 = require("./generate-websocket-gateway");
+jest.mock('fs');
+describe('generateWebSocketGateway', () => {
+    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 gateway command with alias', () => {
+        (0, generate_websocket_gateway_1.generateWebSocketGateway)(program);
+        const cmd = program.commands.find(c => c.name() === 'gateway');
+        expect(cmd).toBeDefined();
+        expect(cmd?.alias()).toBe('ws');
+    });
+    it('should generate a gateway file with correct suffix', async () => {
+        (0, generate_websocket_gateway_1.generateWebSocketGateway)(program);
+        await program.parseAsync(['node', 'test', 'gateway', 'chat']);
+        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('chat.gateway.ts'), expect.stringContaining('ChatGateway'));
+    });
+    it('should import from @hazeljs/websocket', async () => {
+        (0, generate_websocket_gateway_1.generateWebSocketGateway)(program);
+        await program.parseAsync(['node', 'test', 'gateway', 'chat']);
+        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
+        expect(writtenContent).toContain("from '@hazeljs/websocket'");
+        expect(writtenContent).toContain('@Realtime');
+    });
+});

package/dist/index.test.d.ts

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