@hazeljs/cli 0.2.0-rc.7 → 0.2.0

package/dist/commands/generate-auth.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuth = runAuth;
 exports.generateAuth = generateAuth;
 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 AUTH_MODULE_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
 import { AuthController } from './auth.controller';
@@ -145,50 +145,49 @@ export class LoginDto {
   password: string;
 }
 `;
+async function runAuth(_name, options) {
+    const basePath = path_1.default.join(process.cwd(), options.path || 'src/auth');
+    const data = {};
+    const files = [
+        { file: 'auth.module.ts', template: AUTH_MODULE_TEMPLATE },
+        { file: 'auth.service.ts', template: AUTH_SERVICE_TEMPLATE },
+        { file: 'auth.controller.ts', template: AUTH_CONTROLLER_TEMPLATE },
+        { file: 'jwt-auth.guard.ts', template: JWT_GUARD_TEMPLATE },
+        { file: 'dto/register.dto.ts', template: REGISTER_DTO_TEMPLATE },
+        { file: 'dto/login.dto.ts', template: LOGIN_DTO_TEMPLATE },
+    ];
+    const created = [];
+    for (const { file, template } of files) {
+        const filePath = path_1.default.join(basePath, file);
+        created.push(filePath);
+        if (options.dryRun)
+            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));
+    }
+    return {
+        ok: true,
+        created,
+        dryRun: options.dryRun,
+        nextSteps: [
+            'Import AuthModule in your app module',
+            'Configure JwtModule.forRoot() in your app module: JwtModule.forRoot({ secret: "your-secret", expiresIn: "1d" })',
+            'Install bcryptjs: npm install bcryptjs @types/bcryptjs',
+            'Implement database integration in AuthService',
+        ],
+    };
+}
 function generateAuth(command) {
     command
         .command('auth')
         .description('Generate an auth module with JWT guard, service, controller, and DTOs')
         .option('-p, --path <path>', 'Specify the path', 'src/auth')
         .option('--dry-run', 'Preview files without writing them')
-        .action((options) => {
-        const basePath = path_1.default.join(process.cwd(), options.path || 'src/auth');
-        const data = {};
-        const files = [
-            { file: 'auth.module.ts', template: AUTH_MODULE_TEMPLATE },
-            { file: 'auth.service.ts', template: AUTH_SERVICE_TEMPLATE },
-            { file: 'auth.controller.ts', template: AUTH_CONTROLLER_TEMPLATE },
-            { file: 'jwt-auth.guard.ts', template: JWT_GUARD_TEMPLATE },
-            { file: 'dto/register.dto.ts', template: REGISTER_DTO_TEMPLATE },
-            { file: 'dto/login.dto.ts', template: LOGIN_DTO_TEMPLATE },
-        ];
-        try {
-            for (const { file, template } of files) {
-                const filePath = path_1.default.join(basePath, 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(`\u2713 Generated ${filePath}`));
-            }
-            if (!options.dryRun) {
-                console.log(chalk_1.default.blue('\n\uD83D\uDD10 Auth module generated successfully!'));
-                console.log(chalk_1.default.gray('\nNext steps:'));
-                console.log(chalk_1.default.gray('  1. Import AuthModule in your app module'));
-                console.log(chalk_1.default.gray('  2. Configure JwtModule.forRoot() in your app module:'));
-                console.log(chalk_1.default.gray('     JwtModule.forRoot({ secret: "your-secret", expiresIn: "1d" })'));
-                console.log(chalk_1.default.gray('  3. Install bcryptjs: npm install bcryptjs @types/bcryptjs'));
-                console.log(chalk_1.default.gray('  4. Implement database integration in AuthService'));
-            }
-        }
-        catch (error) {
-            console.error(chalk_1.default.red('Error generating auth module:'), error);
-            process.exit(1);
-        }
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        const result = await runAuth('auth', options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 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,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCache = runCache;
 exports.generateCache = generateCache;
 const generator_1 = require("../utils/generator");
-const chalk_1 = __importDefault(require("chalk"));
 const CACHE_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';
 
@@ -45,20 +42,25 @@ class CacheServiceGenerator extends generator_1.Generator {
         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 generator = new CacheServiceGenerator();
-        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/cache'));
-            console.log(chalk_1.default.gray('  2. Add CacheModule to your module imports'));
-            console.log(chalk_1.default.gray('  3. Configure the cache strategy (memory, redis, or multi-tier)'));
-        }
+        const result = await runCache(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 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,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConfig = runConfig;
 exports.generateConfig = generateConfig;
 const generator_1 = require("../utils/generator");
-const chalk_1 = __importDefault(require("chalk"));
 const CONFIG_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
 import { ConfigModule, ConfigService } from '@hazeljs/config';
 
@@ -38,20 +35,25 @@ class ConfigGenerator extends generator_1.Generator {
         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 generator = new ConfigGenerator();
-        await generator.generate({ name: 'app', 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/config'));
-            console.log(chalk_1.default.gray('  2. Add ConfigModule.forRoot({ envFilePath: ".env" }) to your app module imports'));
-            console.log(chalk_1.default.gray('  3. Create a .env file in your project root'));
-        }
+        const result = await runConfig('app', options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 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,5 +1,6 @@
 "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';
@@ -46,6 +47,10 @@ class ControllerGenerator extends generator_1.Generator {
         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>')
@@ -53,8 +58,9 @@ function generateController(program) {
         .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 generator = new ControllerGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runController(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 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,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCron = runCron;
 exports.generateCron = generateCron;
 const generator_1 = require("../utils/generator");
-const chalk_1 = __importDefault(require("chalk"));
 const CRON_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
 import { Cron, CronExpression } from '@hazeljs/cron';
 
@@ -39,6 +36,16 @@ class CronServiceGenerator extends generator_1.Generator {
         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>')
@@ -46,14 +53,9 @@ function generateCron(command) {
         .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 generator = new CronServiceGenerator();
-        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/cron'));
-            console.log(chalk_1.default.gray('  2. Add CronModule to your module imports'));
-            console.log(chalk_1.default.gray('  3. Register this service as a provider'));
-        }
+        const result = await runCron(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

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

package/dist/commands/generate-crud.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCrud = runCrud;
 exports.generateCrud = generateCrud;
 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 controllerTemplate = `import { Controller, Get, Post, Put, Delete, Body, Param } from '@hazeljs/core';
 import { {{className}}Service } from './{{fileName}}.service';
@@ -127,14 +127,8 @@ import { {{className}}Service } from './{{fileName}}.service';
 })
 export class {{className}}Module {}
 `;
-function generateCrud(command) {
-    command
-        .command('crud <name>')
-        .description('Generate a complete CRUD resource (controller, service, module, DTOs)')
-        .option('-p, --path <path>', 'Specify the path', 'src')
-        .option('-r, --route <route>', 'Specify the route path')
-        .option('--dry-run', 'Preview files without writing them')
-        .action((name, options) => {
+async function runCrud(name, options) {
+    try {
         const className = (0, generator_1.toPascalCase)(name);
         const fileName = (0, generator_1.toKebabCase)(name);
         const camelName = (0, generator_1.toCamelCase)(name);
@@ -147,31 +141,48 @@ function generateCrud(command) {
             { file: `dto/${fileName}.dto.ts`, template: dtoTemplate },
             { file: `${fileName}.module.ts`, template: moduleTemplate },
         ];
-        try {
-            for (const { file, template } of files) {
-                const filePath = path_1.default.join(basePath, 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(`\u2713 Generated ${filePath}`));
-            }
-            if (!options.dryRun) {
-                console.log(chalk_1.default.blue('\n\uD83D\uDCE6 CRUD resource generated successfully!'));
-                console.log(chalk_1.default.gray(`\nNext steps:`));
-                console.log(chalk_1.default.gray(`1. Import ${className}Module in your app module`));
-                console.log(chalk_1.default.gray(`2. Customize the DTOs`));
-                console.log(chalk_1.default.gray(`3. Implement your business logic in the service`));
-            }
+        const created = [];
+        for (const { file, template } of files) {
+            const filePath = path_1.default.join(basePath, file);
+            created.push(filePath);
+            if (options.dryRun)
+                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));
         }
-        catch (error) {
-            console.error(chalk_1.default.red('Error generating CRUD resource:'), error);
+        return {
+            ok: true,
+            created,
+            dryRun: options.dryRun,
+            nextSteps: [
+                `Import ${className}Module in your app module`,
+                'Customize the DTOs',
+                'Implement your business logic in the service',
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            created: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function generateCrud(command) {
+    command
+        .command('crud <name>')
+        .description('Generate a complete CRUD resource (controller, service, module, DTOs)')
+        .option('-p, --path <path>', 'Specify the path', 'src')
+        .option('-r, --route <route>', 'Specify the route path')
+        .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
+        .action(async (name, options) => {
+        const result = await runCrud(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
+        if (!result.ok)
             process.exit(1);
-        }
     });
 }

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

@@ -1,2 +1,4 @@
 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,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDiscovery = runDiscovery;
 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';
 
@@ -42,20 +39,25 @@ class DiscoveryGenerator extends generator_1.Generator {
         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 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)'));
-        }
+        const result = await runDiscovery(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

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

package/dist/commands/generate-dto.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDto = runDto;
 exports.generateDto = generateDto;
 const generator_1 = require("../utils/generator");
 const CREATE_DTO_TEMPLATE = `import { IsString, IsOptional } from 'class-validator';
@@ -35,7 +36,7 @@ class DtoGenerator extends generator_1.Generator {
     }
     async generate(options) {
         // Generate create DTO
-        await super.generate({
+        const r1 = await super.generate({
             ...options,
             template: CREATE_DTO_TEMPLATE,
             path: options.path ? `${options.path}/dto` : 'src/dto',
@@ -49,12 +50,19 @@ class DtoGenerator extends generator_1.Generator {
             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);
+        const r2 = await super.generate(updateOptions);
         this.suffix = origSuffix;
+        return {
+            ok: r1.ok && r2.ok,
+            created: [...(r1.created ?? []), ...(r2.created ?? [])],
+            dryRun: r1.dryRun ?? r2.dryRun,
+        };
     }
 }
+async function runDto(name, options) {
+    const generator = new DtoGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateDto(program) {
     program
         .command('dto <name>')
@@ -62,8 +70,9 @@ function generateDto(program) {
         .alias('d')
         .option('-p, --path <path>', 'Path where the DTOs should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new DtoGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runDto(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

@@ -1,2 +1,4 @@
 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;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runExceptionFilter = runExceptionFilter;
 exports.generateExceptionFilter = generateExceptionFilter;
 const generator_1 = require("../utils/generator");
 const EXCEPTION_FILTER_TEMPLATE = `import { Catch, type ExceptionFilter, type ArgumentsHost, HttpError, logger } from '@hazeljs/core';
@@ -34,6 +35,10 @@ class ExceptionFilterGenerator extends generator_1.Generator {
         return EXCEPTION_FILTER_TEMPLATE;
     }
 }
+async function runExceptionFilter(name, options) {
+    const generator = new ExceptionFilterGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateExceptionFilter(program) {
     program
         .command('filter <name>')
@@ -41,8 +46,9 @@ function generateExceptionFilter(program) {
         .alias('f')
         .option('-p, --path <path>', 'Path where the filter should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new ExceptionFilterGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runExceptionFilter(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

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

package/dist/commands/generate-guard.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGuard = runGuard;
 exports.generateGuard = generateGuard;
 const generator_1 = require("../utils/generator");
 const GUARD_TEMPLATE = `import { Injectable, type CanActivate, type ExecutionContext } from '@hazeljs/core';
@@ -22,6 +23,10 @@ class GuardGenerator extends generator_1.Generator {
         return GUARD_TEMPLATE;
     }
 }
+async function runGuard(name, options) {
+    const generator = new GuardGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateGuard(program) {
     program
         .command('guard <name>')
@@ -29,8 +34,9 @@ function generateGuard(program) {
         .alias('gu')
         .option('-p, --path <path>', 'Path where the guard should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new GuardGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runGuard(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

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

package/dist/commands/generate-interceptor.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInterceptor = runInterceptor;
 exports.generateInterceptor = generateInterceptor;
 const generator_1 = require("../utils/generator");
 const INTERCEPTOR_TEMPLATE = `import { Injectable, Interceptor, type ExecutionContext } from '@hazeljs/core';
@@ -23,6 +24,10 @@ class InterceptorGenerator extends generator_1.Generator {
         return INTERCEPTOR_TEMPLATE;
     }
 }
+async function runInterceptor(name, options) {
+    const generator = new InterceptorGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateInterceptor(program) {
     program
         .command('interceptor <name>')
@@ -30,8 +35,9 @@ function generateInterceptor(program) {
         .alias('i')
         .option('-p, --path <path>', 'Path where the interceptor should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new InterceptorGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runInterceptor(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

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

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