@hazeljs/cli 0.2.0-alpha.1

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

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

package/dist/commands/generate-discovery.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 { Service } from '@hazeljs/core';
+import { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';
+
+@Service()
+export class {{className}}DiscoveryService {
+  constructor(
+    private readonly registry: ServiceRegistry,
+    private readonly client: DiscoveryClient,
+  ) {}
+
+  async registerService() {
+    await this.registry.register({
+      name: '{{fileName}}-service',
+      host: 'localhost',
+      port: 3000,
+      metadata: {
+        version: '1.0.0',
+      },
+    });
+  }
+
+  async discoverService(serviceName: string) {
+    const instances = await this.client.getInstances(serviceName);
+    return instances;
+  }
+}
+`;
+class DiscoveryGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'discovery';
+    }
+    getDefaultTemplate() {
+        return DISCOVERY_TEMPLATE;
+    }
+}
+function generateDiscovery(command) {
+    command
+        .command('discovery <name>')
+        .description('Generate a service discovery setup')
+        .option('-p, --path <path>', 'Specify the path')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new DiscoveryGenerator();
+        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/discovery'));
+            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 discovery backend (memory, redis, consul, or kubernetes)'));
+        }
+    });
+}

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

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

package/dist/commands/generate-dto.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDto = generateDto;
+const generator_1 = require("../utils/generator");
+const CREATE_DTO_TEMPLATE = `import { IsString, IsOptional } from 'class-validator';
+
+export class Create{{className}}Dto {
+  @IsString()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+`;
+const UPDATE_DTO_TEMPLATE = `import { IsString, IsOptional } from 'class-validator';
+
+export class Update{{className}}Dto {
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+`;
+class DtoGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'dto';
+    }
+    getDefaultTemplate() {
+        return CREATE_DTO_TEMPLATE;
+    }
+    async generate(options) {
+        // Generate create DTO
+        await super.generate({
+            ...options,
+            template: CREATE_DTO_TEMPLATE,
+            path: options.path ? `${options.path}/dto` : 'src/dto',
+        });
+        // Generate update DTO — use a different file name
+        const origSuffix = this.suffix;
+        this.suffix = 'dto';
+        const updateOptions = {
+            ...options,
+            name: `update-${options.name}`,
+            template: UPDATE_DTO_TEMPLATE,
+            path: options.path ? `${options.path}/dto` : 'src/dto',
+        };
+        // Override suffix for the update variant — we prepend "update-" to the name
+        // so the file is update-<name>.dto.ts rather than <name>.dto.ts (which would conflict)
+        await super.generate(updateOptions);
+        this.suffix = origSuffix;
+    }
+}
+function generateDto(program) {
+    program
+        .command('dto <name>')
+        .description('Generate create and update DTOs')
+        .alias('d')
+        .option('-p, --path <path>', 'Path where the DTOs should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new DtoGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExceptionFilter = generateExceptionFilter;
+const generator_1 = require("../utils/generator");
+const EXCEPTION_FILTER_TEMPLATE = `import { Catch, type ExceptionFilter, type ArgumentsHost, HttpError, logger } from '@hazeljs/core';
+
+@Catch(HttpError)
+export class {{className}}ExceptionFilter implements ExceptionFilter<HttpError> {
+  catch(exception: HttpError, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+
+    const status = exception.statusCode || 500;
+    const message = exception.message || 'Internal server error';
+
+    logger.error(\`[\${request.method}] \${request.url} - \${message} (\${status})\`);
+
+    response.status(status).json({
+      statusCode: status,
+      message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}
+`;
+class ExceptionFilterGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'filter';
+    }
+    getDefaultTemplate() {
+        return EXCEPTION_FILTER_TEMPLATE;
+    }
+}
+function generateExceptionFilter(program) {
+    program
+        .command('filter <name>')
+        .description('Generate a new exception filter')
+        .alias('f')
+        .option('-p, --path <path>', 'Path where the filter should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new ExceptionFilterGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

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

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

package/dist/commands/generate-guard.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGuard = generateGuard;
+const generator_1 = require("../utils/generator");
+const GUARD_TEMPLATE = `import { Injectable, type CanActivate, type ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Guard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    // Add your guard logic here
+    return true;
+  }
+}
+`;
+class GuardGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'guard';
+    }
+    getDefaultTemplate() {
+        return GUARD_TEMPLATE;
+    }
+}
+function generateGuard(program) {
+    program
+        .command('guard <name>')
+        .description('Generate a new guard')
+        .alias('gu')
+        .option('-p, --path <path>', 'Path where the guard should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new GuardGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

package/dist/commands/generate-interceptor.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterceptor = generateInterceptor;
+const generator_1 = require("../utils/generator");
+const INTERCEPTOR_TEMPLATE = `import { Injectable, Interceptor, type ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Interceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: () => Promise<unknown>): Promise<unknown> {
+    // Pre-processing logic here (before handler execution)
+    const result = await next();
+    // Post-processing logic here (after handler execution)
+    return result;
+  }
+}
+`;
+class InterceptorGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'interceptor';
+    }
+    getDefaultTemplate() {
+        return INTERCEPTOR_TEMPLATE;
+    }
+}
+function generateInterceptor(program) {
+    program
+        .command('interceptor <name>')
+        .description('Generate a new interceptor')
+        .alias('i')
+        .option('-p, --path <path>', 'Path where the interceptor should be generated')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new InterceptorGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+    });
+}

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

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

package/dist/commands/generate-middleware.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMiddleware = generateMiddleware;
+const generator_1 = require("../utils/generator");
+const chalk_1 = __importDefault(require("chalk"));
+const MIDDLEWARE_TEMPLATE = `import { Injectable, type MiddlewareHandler, type Request, type Response, type NextFunction } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Middleware implements MiddlewareHandler {
+  use(req: Request, res: Response, next: NextFunction) {
+    // Add your middleware logic here
+    console.log(\`[{{className}}Middleware] \${req.method} \${req.url}\`);
+    
+    // Continue to next middleware
+    next();
+  }
+}
+`;
+class MiddlewareGenerator extends generator_1.Generator {
+    constructor() {
+        super(...arguments);
+        this.suffix = 'middleware';
+    }
+    getDefaultTemplate() {
+        return MIDDLEWARE_TEMPLATE;
+    }
+}
+function generateMiddleware(command) {
+    command
+        .command('middleware <name>')
+        .alias('mw')
+        .description('Generate a middleware')
+        .option('-p, --path <path>', 'Specify the path', 'src/middleware')
+        .option('--dry-run', 'Preview files without writing them')
+        .action(async (name, options) => {
+        const generator = new MiddlewareGenerator();
+        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        if (!options.dryRun) {
+            console.log(chalk_1.default.gray('\nUsage:'));
+            console.log(chalk_1.default.gray(`  Import the middleware in your module or apply it globally.`));
+        }
+    });
+}

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

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