@hazeljs/cli 0.7.9 → 0.8.0

package/dist/commands/add.test.js

@@ -19,7 +19,7 @@ describe('addCommand', () => {
     });
     it('should register the add command', () => {
         (0, add_1.addCommand)(program);
-        const cmd = program.commands.find(c => c.name() === 'add');
+        const cmd = program.commands.find((c) => c.name() === 'add');
         expect(cmd).toBeDefined();
     });
     it('should install a known package', async () => {
@@ -39,8 +39,21 @@ describe('addCommand', () => {
         (0, add_1.addCommand)(program);
         // Test that all documented packages are available
         const expectedPackages = [
-            'ai', 'agent', 'auth', 'cache', 'config', 'cron',
-            'discovery', 'mcp', 'prompts', 'prisma', 'typeorm', 'rag', 'serverless', 'swagger', 'websocket'
+            'ai',
+            'agent',
+            'auth',
+            'cache',
+            'config',
+            'cron',
+            'discovery',
+            'mcp',
+            'prompts',
+            'prisma',
+            'typeorm',
+            'rag',
+            'serverless',
+            'swagger',
+            'websocket',
         ];
         for (const pkg of expectedPackages) {
             mockExecSync.mockClear();

package/dist/commands/generate-app.interactive-packages.test.js

@@ -68,7 +68,8 @@ describe('generateApp interactive package wiring', () => {
             const s = String(p);
             if (s.includes(path_1.default.join('@template')))
                 return true; // template exists
-            if (s.endsWith(path_1.default.join('.', 'my-app')) || s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
+            if (s.endsWith(path_1.default.join('.', 'my-app')) ||
+                s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
                 return false; // dest doesn't exist
             if (s.endsWith(path_1.default.join('my-app', 'package.json')))
                 return true; // updatePackageJson path

package/dist/commands/generate-app.js

@@ -151,9 +151,7 @@ function scaffoldPackageBoilerplate(destPath, packages) {
             moduleImports.push(meta.moduleExpression);
     }
     // Generate the enhanced app.module.ts
-    const importsSection = moduleImports.length > 0
-        ? `\n  imports: [\n    ${moduleImports.join(',\n    ')},\n  ],`
-        : '';
+    const importsSection = moduleImports.length > 0 ? `\n  imports: [\n    ${moduleImports.join(',\n    ')},\n  ],` : '';
     const appModule = `${imports.join('\n')}
 
 @HazelModule({${importsSection}
@@ -235,7 +233,10 @@ function generateApp(program) {
                         type: 'checkbox',
                         name: 'packages',
                         message: 'Select additional HazelJS packages to install:',
-                        choices: packages_registry_1.HAZEL_PACKAGES.map((p) => ({ name: p.label, value: p.npm })),
+                        choices: packages_registry_1.HAZEL_PACKAGES.map((p) => ({
+                            name: p.label,
+                            value: p.npm,
+                        })),
                     },
                 ]);
                 projectConfig = { ...projectConfig, ...answers };

package/dist/commands/generate-app.new-command.test.js

@@ -57,7 +57,9 @@ describe('generateApp (hazel new)', () => {
         });
         const program = new commander_1.Command();
         (0, generate_app_1.generateApp)(program);
-        await program.parseAsync(['new', 'my-app', '--dest', '.', '--skip-install', '--skip-git'], { from: 'user' });
+        await program.parseAsync(['new', 'my-app', '--dest', '.', '--skip-install', '--skip-git'], {
+            from: 'user',
+        });
         expect(mockFs.mkdirSync).toHaveBeenCalled();
         expect(mockFs.writeFileSync).toHaveBeenCalled();
         expect(mockExec).not.toHaveBeenCalled(); // skipped install + git

package/dist/commands/generate-app.skeleton.test.js

@@ -35,7 +35,8 @@ describe('runApp (skeleton app)', () => {
         // destPath doesn't exist; templatePath also doesn't exist -> fallback basic structure
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
-            if (s.endsWith(path_1.default.join('.', 'my-app')) || s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
+            if (s.endsWith(path_1.default.join('.', 'my-app')) ||
+                s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
                 return false;
             if (s.includes('@template'))
                 return false;

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

@@ -24,19 +24,18 @@ describe('generateAuth', () => {
     it('should generate all auth files', async () => {
         (0, generate_auth_1.generateAuth)(program);
         await program.parseAsync(['node', 'test', 'auth']);
-        const writtenFiles = mockFs.writeFileSync.mock.calls.map(call => call[0]);
-        expect(writtenFiles.some(f => f.includes('auth.module.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('auth.service.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('auth.controller.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('jwt-auth.guard.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('register.dto.ts'))).toBe(true);
-        expect(writtenFiles.some(f => f.includes('login.dto.ts'))).toBe(true);
+        const writtenFiles = mockFs.writeFileSync.mock.calls.map((call) => call[0]);
+        expect(writtenFiles.some((f) => f.includes('auth.module.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('auth.service.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('auth.controller.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('jwt-auth.guard.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('register.dto.ts'))).toBe(true);
+        expect(writtenFiles.some((f) => f.includes('login.dto.ts'))).toBe(true);
     });
     it('should use @hazeljs/auth imports in guard', async () => {
         (0, generate_auth_1.generateAuth)(program);
         await program.parseAsync(['node', 'test', 'auth']);
-        const guardContent = mockFs.writeFileSync.mock.calls
-            .find(call => call[0].includes('jwt-auth.guard'))?.[1];
+        const guardContent = mockFs.writeFileSync.mock.calls.find((call) => call[0].includes('jwt-auth.guard'))?.[1];
         expect(guardContent).toContain("from '@hazeljs/auth'");
         expect(guardContent).toContain('JwtService');
     });

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

@@ -24,17 +24,16 @@ describe('generateCrud', () => {
     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);
+        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];
+        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 () => {
@@ -45,8 +44,7 @@ describe('generateCrud', () => {
     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];
+        const controllerContent = mockFs.writeFileSync.mock.calls.find((call) => call[0].includes('controller'))?.[1];
         expect(controllerContent).toContain('api/products');
     });
 });

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

@@ -22,7 +22,7 @@ describe('generateDto', () => {
     });
     it('should register the dto command with alias', () => {
         (0, generate_dto_1.generateDto)(program);
-        const cmd = program.commands.find(c => c.name() === 'dto');
+        const cmd = program.commands.find((c) => c.name() === 'dto');
         expect(cmd).toBeDefined();
         expect(cmd?.alias()).toBe('d');
     });
@@ -30,9 +30,9 @@ describe('generateDto', () => {
         (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);
+        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);

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

@@ -23,27 +23,27 @@ describe('generateModule', () => {
     });
     it('should register the module command with alias', () => {
         (0, generate_module_1.generateModule)(program);
-        const cmd = program.commands.find(c => c.name() === 'module');
+        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);
+        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'));
+        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'));
+        const controllerContent = writtenContents.find((c) => c.includes('Controller'));
         expect(controllerContent).toContain("from '@hazeljs/core'");
     });
     it('should support --dry-run flag', async () => {

package/dist/commands/generate-simple.js

@@ -7,23 +7,165 @@ exports.findSimpleGenerator = findSimpleGenerator;
 const generator_1 = require("../utils/generator");
 const templates_1 = require("./templates");
 exports.SIMPLE_GENERATORS = [
-    { type: 'controller', description: 'REST controller', suffix: 'controller', template: templates_1.CONTROLLER_TEMPLATE, alias: 'c', nameRequired: true },
-    { type: 'service', description: 'Service class', suffix: 'service', template: templates_1.SERVICE_TEMPLATE, alias: 's', nameRequired: true },
-    { type: 'guard', description: 'Guard (e.g. auth)', suffix: 'guard', template: templates_1.GUARD_TEMPLATE, alias: 'gu', nameRequired: true },
-    { type: 'interceptor', description: 'Interceptor', suffix: 'interceptor', template: templates_1.INTERCEPTOR_TEMPLATE, alias: 'i', nameRequired: true },
-    { type: 'middleware', description: 'Middleware', suffix: 'middleware', template: templates_1.MIDDLEWARE_TEMPLATE, alias: 'mw', defaultPath: 'src/middleware', nameRequired: true, nextSteps: ['Import the middleware in your module or apply it globally.'] },
-    { type: 'pipe', description: 'Validation/transform pipe', suffix: 'pipe', template: templates_1.PIPE_TEMPLATE, nameRequired: true },
-    { type: 'filter', description: 'Exception filter', suffix: 'filter', template: templates_1.EXCEPTION_FILTER_TEMPLATE, alias: 'f', nameRequired: true },
-    { type: 'repository', description: 'Prisma repository', suffix: 'repository', template: templates_1.REPOSITORY_TEMPLATE, alias: 'repo', nameRequired: true },
-    { type: 'gateway', description: 'WebSocket gateway', suffix: 'gateway', template: templates_1.WEBSOCKET_GATEWAY_TEMPLATE, alias: 'ws', nameRequired: true },
-    { type: 'ai-service', description: 'AI service with decorators', suffix: 'ai-service', template: templates_1.AI_SERVICE_TEMPLATE, alias: 'ai', nameRequired: true },
-    { type: 'agent', description: 'AI agent with @Agent and @Tool', suffix: 'agent', template: templates_1.AGENT_TEMPLATE, nameRequired: true, extraData: (name) => ({ description: `A ${name} agent` }) },
-    { type: 'cache', description: 'Cache service with decorators', suffix: 'cache', template: templates_1.CACHE_SERVICE_TEMPLATE, nameRequired: true, nextSteps: ['npm install @hazeljs/cache', 'Add CacheModule to your module imports', 'Configure the cache strategy (memory, redis, or multi-tier)'] },
-    { type: 'cron', description: 'Cron/scheduled job service', suffix: 'cron', template: templates_1.CRON_SERVICE_TEMPLATE, alias: 'job', nameRequired: true, nextSteps: ['npm install @hazeljs/cron', 'Add CronModule to your module imports', 'Register this service as a provider'] },
-    { type: 'rag', description: 'RAG (Retrieval-Augmented Generation) service', suffix: 'rag', template: templates_1.RAG_SERVICE_TEMPLATE, nameRequired: true, nextSteps: ['npm install @hazeljs/rag', 'Register this service as a provider in your module', 'Configure your embedding provider and vector store'] },
-    { type: 'discovery', description: 'Service discovery setup', suffix: 'discovery', template: templates_1.DISCOVERY_TEMPLATE, nameRequired: true, nextSteps: ['npm install @hazeljs/discovery', 'Register this service as a provider in your module', 'Configure your discovery backend (memory, redis, consul, or kubernetes)'] },
-    { type: 'config', description: 'Config module setup', suffix: 'config', template: templates_1.CONFIG_TEMPLATE, nameRequired: false, nextSteps: ['npm install @hazeljs/config', 'Add ConfigModule.forRoot({ envFilePath: ".env" }) to your app module imports', 'Create a .env file in your project root'] },
-    { type: 'serverless', description: 'Serverless handler (Lambda or Cloud Function)', suffix: 'handler', template: templates_1.SERVERLESS_LAMBDA_TEMPLATE, alias: 'sls', nameRequired: true, extraOptions: ['platform'] },
+    {
+        type: 'controller',
+        description: 'REST controller',
+        suffix: 'controller',
+        template: templates_1.CONTROLLER_TEMPLATE,
+        alias: 'c',
+        nameRequired: true,
+    },
+    {
+        type: 'service',
+        description: 'Service class',
+        suffix: 'service',
+        template: templates_1.SERVICE_TEMPLATE,
+        alias: 's',
+        nameRequired: true,
+    },
+    {
+        type: 'guard',
+        description: 'Guard (e.g. auth)',
+        suffix: 'guard',
+        template: templates_1.GUARD_TEMPLATE,
+        alias: 'gu',
+        nameRequired: true,
+    },
+    {
+        type: 'interceptor',
+        description: 'Interceptor',
+        suffix: 'interceptor',
+        template: templates_1.INTERCEPTOR_TEMPLATE,
+        alias: 'i',
+        nameRequired: true,
+    },
+    {
+        type: 'middleware',
+        description: 'Middleware',
+        suffix: 'middleware',
+        template: templates_1.MIDDLEWARE_TEMPLATE,
+        alias: 'mw',
+        defaultPath: 'src/middleware',
+        nameRequired: true,
+        nextSteps: ['Import the middleware in your module or apply it globally.'],
+    },
+    {
+        type: 'pipe',
+        description: 'Validation/transform pipe',
+        suffix: 'pipe',
+        template: templates_1.PIPE_TEMPLATE,
+        nameRequired: true,
+    },
+    {
+        type: 'filter',
+        description: 'Exception filter',
+        suffix: 'filter',
+        template: templates_1.EXCEPTION_FILTER_TEMPLATE,
+        alias: 'f',
+        nameRequired: true,
+    },
+    {
+        type: 'repository',
+        description: 'Prisma repository',
+        suffix: 'repository',
+        template: templates_1.REPOSITORY_TEMPLATE,
+        alias: 'repo',
+        nameRequired: true,
+    },
+    {
+        type: 'gateway',
+        description: 'WebSocket gateway',
+        suffix: 'gateway',
+        template: templates_1.WEBSOCKET_GATEWAY_TEMPLATE,
+        alias: 'ws',
+        nameRequired: true,
+    },
+    {
+        type: 'ai-service',
+        description: 'AI service with decorators',
+        suffix: 'ai-service',
+        template: templates_1.AI_SERVICE_TEMPLATE,
+        alias: 'ai',
+        nameRequired: true,
+    },
+    {
+        type: 'agent',
+        description: 'AI agent with @Agent and @Tool',
+        suffix: 'agent',
+        template: templates_1.AGENT_TEMPLATE,
+        nameRequired: true,
+        extraData: (name) => ({ description: `A ${name} agent` }),
+    },
+    {
+        type: 'cache',
+        description: 'Cache service with decorators',
+        suffix: 'cache',
+        template: templates_1.CACHE_SERVICE_TEMPLATE,
+        nameRequired: true,
+        nextSteps: [
+            'npm install @hazeljs/cache',
+            'Add CacheModule to your module imports',
+            'Configure the cache strategy (memory, redis, or multi-tier)',
+        ],
+    },
+    {
+        type: 'cron',
+        description: 'Cron/scheduled job service',
+        suffix: 'cron',
+        template: templates_1.CRON_SERVICE_TEMPLATE,
+        alias: 'job',
+        nameRequired: true,
+        nextSteps: [
+            'npm install @hazeljs/cron',
+            'Add CronModule to your module imports',
+            'Register this service as a provider',
+        ],
+    },
+    {
+        type: 'rag',
+        description: 'RAG (Retrieval-Augmented Generation) service',
+        suffix: 'rag',
+        template: templates_1.RAG_SERVICE_TEMPLATE,
+        nameRequired: true,
+        nextSteps: [
+            'npm install @hazeljs/rag',
+            'Register this service as a provider in your module',
+            'Configure your embedding provider and vector store',
+        ],
+    },
+    {
+        type: 'discovery',
+        description: 'Service discovery setup',
+        suffix: 'discovery',
+        template: templates_1.DISCOVERY_TEMPLATE,
+        nameRequired: true,
+        nextSteps: [
+            'npm install @hazeljs/discovery',
+            'Register this service as a provider in your module',
+            'Configure your discovery backend (memory, redis, consul, or kubernetes)',
+        ],
+    },
+    {
+        type: 'config',
+        description: 'Config module setup',
+        suffix: 'config',
+        template: templates_1.CONFIG_TEMPLATE,
+        nameRequired: false,
+        nextSteps: [
+            'npm install @hazeljs/config',
+            'Add ConfigModule.forRoot({ envFilePath: ".env" }) to your app module imports',
+            'Create a .env file in your project root',
+        ],
+    },
+    {
+        type: 'serverless',
+        description: 'Serverless handler (Lambda or Cloud Function)',
+        suffix: 'handler',
+        template: templates_1.SERVERLESS_LAMBDA_TEMPLATE,
+        alias: 'sls',
+        nameRequired: true,
+        extraOptions: ['platform'],
+    },
 ];
 // ── Runner factory ───────────────────────────────────────────────────────────
 class SimpleGenerator extends generator_1.Generator {
@@ -52,7 +194,7 @@ async function runSimpleGenerator(config, name, options) {
         template = templates_1.SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
     }
     const generator = new SimpleGenerator(config.suffix, template);
-    const effectiveName = config.nameRequired ? name : (name || 'app');
+    const effectiveName = config.nameRequired ? name : name || 'app';
     const result = await generator.generate({
         name: effectiveName,
         path: options.path || config.defaultPath,
@@ -87,7 +229,7 @@ function registerSimpleGenerators(generateCommand) {
         }
         cmd.action(async (nameOrOptions, maybeOptions) => {
             const name = typeof nameOrOptions === 'string' ? nameOrOptions : '';
-            const opts = typeof nameOrOptions === 'string' ? (maybeOptions || {}) : nameOrOptions;
+            const opts = typeof nameOrOptions === 'string' ? maybeOptions || {} : nameOrOptions;
             const result = await runSimpleGenerator(config, name, opts);
             (0, generator_1.printGenerateResult)(result, { json: opts.json });
         });

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

@@ -73,13 +73,19 @@ describe('generate-simple', () => {
         });
         it('handles serverless with cloud-function platform', async () => {
             const config = (0, generate_simple_1.findSimpleGenerator)('serverless');
-            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'api', { dryRun: true, platform: 'cloud-function' });
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'api', {
+                dryRun: true,
+                platform: 'cloud-function',
+            });
             expect(result.ok).toBe(true);
             expect(result.created[0]).toContain('api.handler.ts');
         });
         it('generates with custom path', async () => {
             const config = (0, generate_simple_1.findSimpleGenerator)('service');
-            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'order', { path: 'src/orders', dryRun: true });
+            const result = await (0, generate_simple_1.runSimpleGenerator)(config, 'order', {
+                path: 'src/orders',
+                dryRun: true,
+            });
             expect(result.ok).toBe(true);
             expect(result.created[0]).toContain('src/orders');
         });

package/dist/commands/info.test.js

@@ -47,9 +47,7 @@ describe('infoCommand', () => {
         const program = new commander_1.Command();
         (0, info_1.infoCommand)(program);
         await program.parseAsync(['info'], { from: 'user' });
-        const out = logSpy.mock.calls
-            .map((c) => c.map((x) => String(x)).join(' '))
-            .join('\n');
+        const out = logSpy.mock.calls.map((c) => c.map((x) => String(x)).join(' ')).join('\n');
         expect(out).toContain('Project Information');
         expect(out).toContain('@hazeljs/core');
         expect(out).toContain('@hazeljs/swagger');

package/dist/index.list.test.js

@@ -11,7 +11,13 @@ jest.mock('./commands/generate-auth', () => ({ generateAuth: jest.fn() }));
 jest.mock('./commands/generate-simple', () => ({
     registerSimpleGenerators: jest.fn(),
     SIMPLE_GENERATORS: [
-        { type: 'controller', description: 'REST controller', suffix: 'controller', template: '', nameRequired: true },
+        {
+            type: 'controller',
+            description: 'REST controller',
+            suffix: 'controller',
+            template: '',
+            nameRequired: true,
+        },
     ],
     findSimpleGenerator: jest.fn(),
     runSimpleGenerator: jest.fn(),

package/dist/index.test.js

@@ -17,7 +17,13 @@ jest.mock('./commands/generate-auth');
 jest.mock('./commands/generate-simple', () => ({
     registerSimpleGenerators: jest.fn(),
     SIMPLE_GENERATORS: [
-        { type: 'controller', description: 'REST controller', suffix: 'controller', template: '', nameRequired: true },
+        {
+            type: 'controller',
+            description: 'REST controller',
+            suffix: 'controller',
+            template: '',
+            nameRequired: true,
+        },
     ],
     findSimpleGenerator: jest.fn(),
     runSimpleGenerator: jest.fn(),

package/dist/utils/generator-registry.js

@@ -11,11 +11,25 @@ const generate_app_1 = require("../commands/generate-app");
 const generate_simple_1 = require("../commands/generate-simple");
 /** Complex generators that need their own files (multi-file output or custom logic) */
 const COMPLEX_GENERATORS = [
-    { type: 'app', description: 'Skeleton HazelJS application (minimal template)', nameRequired: true, options: ['path'] },
+    {
+        type: 'app',
+        description: 'Skeleton HazelJS application (minimal template)',
+        nameRequired: true,
+        options: ['path'],
+    },
     { type: 'module', description: 'Module with controller, service, DTOs', nameRequired: true },
     { type: 'dto', description: 'Create and update DTOs', nameRequired: true },
-    { type: 'crud', description: 'Full CRUD resource (controller, service, module, DTOs)', nameRequired: true, options: ['route'] },
-    { type: 'auth', description: 'Auth module (JWT guard, service, controller, DTOs)', nameRequired: false },
+    {
+        type: 'crud',
+        description: 'Full CRUD resource (controller, service, module, DTOs)',
+        nameRequired: true,
+        options: ['route'],
+    },
+    {
+        type: 'auth',
+        description: 'Auth module (JWT guard, service, controller, DTOs)',
+        nameRequired: false,
+    },
 ];
 /** All available generator types and their metadata (for --list). */
 exports.GENERATOR_LIST = [

package/dist/utils/generator.js

@@ -93,7 +93,9 @@ function printGenerateResult(result, options) {
         console.error(chalk_1.default.red(result.error ?? 'Generation failed'));
         return;
     }
-    const prefix = result.dryRun ? chalk_1.default.blue('[dry-run] Would create ') : chalk_1.default.green('✓ Generated ');
+    const prefix = result.dryRun
+        ? chalk_1.default.blue('[dry-run] Would create ')
+        : chalk_1.default.green('✓ Generated ');
     for (const file of result.created) {
         console.log(prefix + file);
     }

package/dist/utils/generator.test.js

@@ -75,7 +75,9 @@ describe('Generator class', () => {
                 path: 'src/test',
                 template: 'test template',
             });
-            expect(mockFs.mkdirSync).toHaveBeenCalledWith(path_1.default.join(process.cwd(), 'src/test'), { recursive: true });
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith(path_1.default.join(process.cwd(), 'src/test'), {
+                recursive: true,
+            });
         });
         it('should write file with rendered template', async () => {
             await generator.generate({

package/dist/utils/packages-registry.js

@@ -31,7 +31,7 @@ exports.HAZEL_PACKAGES = [
         label: 'Audit Logging (@hazeljs/audit)',
         hint: 'import { AuditModule, ConsoleAuditTransport } from "@hazeljs/audit";\n  // AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })',
         moduleImport: "import { AuditModule, ConsoleAuditTransport } from '@hazeljs/audit';",
-        moduleExpression: "AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })",
+        moduleExpression: 'AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })',
         setupTemplate: `import { AuditModule, ConsoleAuditTransport } from '@hazeljs/audit';
 
 // Add AuditModule.forRoot(...) to your HazelModule imports.
@@ -53,7 +53,7 @@ export const auditImports = [AuditModule.forRoot({ transports: [new ConsoleAudit
         label: 'OAuth - Google/Microsoft/GitHub (@hazeljs/oauth)',
         hint: 'import { OAuthModule } from "@hazeljs/oauth";\n  // OAuthModule.forRoot({ providers: { google: {...}, microsoft: {...}, github: {...} } })',
         moduleImport: "import { OAuthModule } from '@hazeljs/oauth';",
-        moduleExpression: "OAuthModule.forRoot({ providers: { google: { clientId: process.env.GOOGLE_CLIENT_ID!, clientSecret: process.env.GOOGLE_CLIENT_SECRET!, redirectUri: process.env.OAUTH_REDIRECT_URI! } } })",
+        moduleExpression: 'OAuthModule.forRoot({ providers: { google: { clientId: process.env.GOOGLE_CLIENT_ID!, clientSecret: process.env.GOOGLE_CLIENT_SECRET!, redirectUri: process.env.OAUTH_REDIRECT_URI! } } })',
         setupTemplate: `import { OAuthModule } from '@hazeljs/oauth';
 
 // Example (Google). Put secrets in env vars:
@@ -154,7 +154,7 @@ export const gatewayImports = [GatewayModule];
         label: 'Guardrails (@hazeljs/guardrails)',
         hint: 'import { GuardrailsModule } from "@hazeljs/guardrails";\n  // GuardrailsModule.forRoot({ redactPIIByDefault: true })',
         moduleImport: "import { GuardrailsModule } from '@hazeljs/guardrails';",
-        moduleExpression: "GuardrailsModule.forRoot({ redactPIIByDefault: true })",
+        moduleExpression: 'GuardrailsModule.forRoot({ redactPIIByDefault: true })',
         setupTemplate: null,
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cli",
-  "version": "0.7.9",
+  "version": "0.8.0",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -70,5 +70,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/hazeljs"
   },
-  "gitHead": "28c21c509aeca3bf2d0878fbee737d906b654c67"
+  "gitHead": "e0ed98ca074dd4f7472816d3c32ef576900dcca6"
 }