@hazeljs/cli 0.5.4 → 0.6.5

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

@@ -1,41 +0,0 @@
-"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-cache.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runCache(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateCache(command: Command): void;

package/dist/commands/generate-cache.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCache = runCache;
-exports.generateCache = generateCache;
-const generator_1 = require("../utils/generator");
-const CACHE_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
-import { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';
-
-@Service()
-export class {{className}}CacheService {
-  constructor(private readonly cacheService: CacheService) {}
-
-  @Cacheable({ key: '{{fileName}}:all', ttl: 60 })
-  async findAll() {
-    // This result will be cached for 60 seconds
-    return [];
-  }
-
-  @Cacheable({ key: '{{fileName}}:{{=<% %>=}}#{id}<%={{ }}=%>', ttl: 300 })
-  async findOne(id: string) {
-    // This result will be cached for 5 minutes
-    return { id };
-  }
-
-  @CacheEvict({ key: '{{fileName}}:all' })
-  async create(data: any) {
-    // Creating a new item evicts the list cache
-    return data;
-  }
-
-  async clearAll() {
-    await this.cacheService.clear();
-  }
-}
-`;
-class CacheServiceGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'cache';
-    }
-    getDefaultTemplate() {
-        return CACHE_SERVICE_TEMPLATE;
-    }
-}
-async function runCache(name, options) {
-    const generator = new CacheServiceGenerator();
-    const result = await generator.generate({ name, path: options.path, dryRun: options.dryRun });
-    result.nextSteps = [
-        'npm install @hazeljs/cache',
-        'Add CacheModule to your module imports',
-        'Configure the cache strategy (memory, redis, or multi-tier)',
-    ];
-    return result;
-}
-function generateCache(command) {
-    command
-        .command('cache <name>')
-        .description('Generate a cache service with decorators')
-        .option('-p, --path <path>', 'Specify the path')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runCache(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

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

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

@@ -1,36 +0,0 @@
-"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.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runConfig(_name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateConfig(command: Command): void;

package/dist/commands/generate-config.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runConfig = runConfig;
-exports.generateConfig = generateConfig;
-const generator_1 = require("../utils/generator");
-const CONFIG_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
-import { ConfigModule, ConfigService } from '@hazeljs/config';
-
-// Import ConfigModule.forRoot() in your app module:
-//
-// @HazelModule({
-//   imports: [
-//     ConfigModule.forRoot({
-//       envFilePath: '.env',
-//     }),
-//   ],
-// })
-//
-// Then inject ConfigService wherever you need it:
-//
-// constructor(private readonly config: ConfigService) {}
-//
-// Usage:
-//   this.config.get('DATABASE_URL');
-//   this.config.get('PORT', '3000');  // with default value
-
-export { ConfigModule, ConfigService };
-`;
-class ConfigGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'config';
-    }
-    getDefaultTemplate() {
-        return CONFIG_TEMPLATE;
-    }
-}
-async function runConfig(_name, options) {
-    const generator = new ConfigGenerator();
-    const result = await generator.generate({ name: 'app', path: options.path, dryRun: options.dryRun });
-    result.nextSteps = [
-        'npm install @hazeljs/config',
-        'Add ConfigModule.forRoot({ envFilePath: ".env" }) to your app module imports',
-        'Create a .env file in your project root',
-    ];
-    return result;
-}
-function generateConfig(command) {
-    command
-        .command('config')
-        .description('Generate a config module setup')
-        .option('-p, --path <path>', 'Specify the path', 'src')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (options) => {
-        const result = await runConfig('app', options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

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

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

@@ -1,35 +0,0 @@
-"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.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runController(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateController(program: Command): void;

package/dist/commands/generate-controller.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runController = runController;
-exports.generateController = generateController;
-const generator_1 = require("../utils/generator");
-const CONTROLLER_TEMPLATE = `import { Controller, Get, Post, Body, Param, Delete, Put } from '@hazeljs/core';
-import { {{className}}Service } from './{{fileName}}.service';
-import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
-import { Update{{className}}Dto } from './dto/update-{{fileName}}.dto';
-
-@Controller('{{fileName}}')
-export class {{className}}Controller {
-  constructor(private readonly {{camelName}}Service: {{className}}Service) {}
-
-  @Get()
-  findAll() {
-    return this.{{camelName}}Service.findAll();
-  }
-
-  @Get(':id')
-  findOne(@Param('id') id: string) {
-    return this.{{camelName}}Service.findOne(id);
-  }
-
-  @Post()
-  create(@Body(Create{{className}}Dto) createDto: Create{{className}}Dto) {
-    return this.{{camelName}}Service.create(createDto);
-  }
-
-  @Put(':id')
-  update(@Param('id') id: string, @Body(Update{{className}}Dto) updateDto: Update{{className}}Dto) {
-    return this.{{camelName}}Service.update(id, updateDto);
-  }
-
-  @Delete(':id')
-  remove(@Param('id') id: string) {
-    return this.{{camelName}}Service.remove(id);
-  }
-}
-`;
-class ControllerGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'controller';
-    }
-    getDefaultTemplate() {
-        return CONTROLLER_TEMPLATE;
-    }
-}
-async function runController(name, options) {
-    const generator = new ControllerGenerator();
-    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
-}
-function generateController(program) {
-    program
-        .command('controller <name>')
-        .description('Generate a new controller')
-        .alias('c')
-        .option('-p, --path <path>', 'Path where the controller should be generated')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runController(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

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

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

@@ -1,48 +0,0 @@
-"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.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runCron(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateCron(command: Command): void;

package/dist/commands/generate-cron.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCron = runCron;
-exports.generateCron = generateCron;
-const generator_1 = require("../utils/generator");
-const CRON_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
-import { Cron, CronExpression } from '@hazeljs/cron';
-
-@Service()
-export class {{className}}CronService {
-  @Cron(CronExpression.EVERY_MINUTE)
-  handleEveryMinute() {
-    console.log('[{{className}}Cron] Running every minute...');
-    // Add your cron job logic here
-  }
-
-  @Cron('0 0 * * *')  // Every day at midnight
-  handleDaily() {
-    console.log('[{{className}}Cron] Running daily task...');
-    // Add your daily task logic here
-  }
-
-  @Cron(CronExpression.EVERY_HOUR)
-  handleHourly() {
-    console.log('[{{className}}Cron] Running hourly cleanup...');
-    // Add your hourly task logic here
-  }
-}
-`;
-class CronServiceGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'cron';
-    }
-    getDefaultTemplate() {
-        return CRON_SERVICE_TEMPLATE;
-    }
-}
-async function runCron(name, options) {
-    const generator = new CronServiceGenerator();
-    const result = await generator.generate({ name, path: options.path, dryRun: options.dryRun });
-    result.nextSteps = [
-        'npm install @hazeljs/cron',
-        'Add CronModule to your module imports',
-        'Register this service as a provider',
-    ];
-    return result;
-}
-function generateCron(command) {
-    command
-        .command('cron <name>')
-        .description('Generate a cron/scheduled job service')
-        .alias('job')
-        .option('-p, --path <path>', 'Specify the path')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runCron(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

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

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

@@ -1,42 +0,0 @@
-"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-discovery.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runDiscovery(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateDiscovery(command: Command): void;

package/dist/commands/generate-discovery.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runDiscovery = runDiscovery;
-exports.generateDiscovery = generateDiscovery;
-const generator_1 = require("../utils/generator");
-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;
-    }
-}
-async function runDiscovery(name, options) {
-    const generator = new DiscoveryGenerator();
-    const result = await generator.generate({ name, path: options.path, dryRun: options.dryRun });
-    result.nextSteps = [
-        'npm install @hazeljs/discovery',
-        'Register this service as a provider in your module',
-        'Configure your discovery backend (memory, redis, consul, or kubernetes)',
-    ];
-    return result;
-}
-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')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runDiscovery(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

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

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

@@ -1,36 +0,0 @@
-"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-exception-filter.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runExceptionFilter(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateExceptionFilter(program: Command): void;