@hazeljs/cli 0.6.0 → 0.6.5

package/dist/commands/generate-simple.js

@@ -5,390 +5,25 @@ exports.runSimpleGenerator = runSimpleGenerator;
 exports.registerSimpleGenerators = registerSimpleGenerators;
 exports.findSimpleGenerator = findSimpleGenerator;
 const generator_1 = require("../utils/generator");
-// ── Templates ────────────────────────────────────────────────────────────────
-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);
-  }
-}
-`;
-const SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
-
-@Service()
-export class {{className}}Service {
-  constructor() {}
-
-  async findAll() {
-    return [];
-  }
-
-  async findOne(id: string) {
-    return { id };
-  }
-
-  async create(createDto: any) {
-    return createDto;
-  }
-
-  async update(id: string, updateDto: any) {
-    return { id, ...updateDto };
-  }
-
-  async remove(id: string) {
-    return { id };
-  }
-}
-`;
-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;
-  }
-}
-`;
-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;
-  }
-}
-`;
-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();
-  }
-}
-`;
-const PIPE_TEMPLATE = `import { type PipeTransform, type RequestContext } from '@hazeljs/core';
-
-export class {{className}}Pipe implements PipeTransform {
-  transform(value: unknown, context: RequestContext): unknown {
-    // Transform logic here
-    return value;
-  }
-}
-`;
-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,
-    });
-  }
-}
-`;
-const REPOSITORY_TEMPLATE = `import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';
-
-// @Repository implies @Injectable() — no need for both decorators
-@Repository({ model: '{{modelName}}' })
-export class {{className}}Repository extends BaseRepository<any> {
-  constructor(prisma: PrismaService) {
-    super(prisma, '{{modelName}}');
-  }
-
-  // Add custom repository methods here
-  async findByName(name: string) {
-    return this.findMany({ where: { name } });
-  }
-}
-`;
-const WEBSOCKET_GATEWAY_TEMPLATE = `import { Realtime, OnConnect, OnDisconnect, OnMessage, Subscribe, Client, Data, WebSocketClient } from '@hazeljs/websocket';
-
-@Realtime('/{{fileName}}')
-export class {{className}}Gateway {
-  @OnConnect()
-  handleConnection(@Client() client: WebSocketClient) {
-    console.log('Client connected:', client.id);
-  }
-
-  @OnDisconnect()
-  handleDisconnect(@Client() client: WebSocketClient) {
-    console.log('Client disconnected:', client.id);
-  }
-
-  @Subscribe('message')
-  @OnMessage('message')
-  handleMessage(@Client() client: WebSocketClient, @Data() data: unknown) {
-    console.log('Message received from', client.id, ':', data);
-    // Handle message logic here
-  }
-}
-`;
-const AI_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
-import { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';
-
-@Service()
-export class {{className}}AIService {
-  constructor(private readonly aiService: AIService) {}
-
-  @AIFunction({
-    provider: 'openai',
-    model: 'gpt-4',
-    streaming: false,
-  })
-  async {{camelName}}Task(@AIPrompt() prompt: string): Promise<unknown> {
-    const result = await this.aiService.complete({
-      provider: 'openai',
-      model: 'gpt-4',
-      messages: [{ role: 'user', content: prompt }],
-    });
-
-    return result;
-  }
-}
-`;
-const AGENT_TEMPLATE = `import { Agent, Tool } from '@hazeljs/agent';
-
-@Agent({
-  name: '{{fileName}}',
-  description: '{{description}}',
-  systemPrompt: 'You are a helpful {{className}} agent.',
-  enableMemory: true,
-  enableRAG: true,
-})
-export class {{className}}Agent {
-  @Tool({
-    description: 'Example tool for {{fileName}}',
-    parameters: [
-      {
-        name: 'input',
-        type: 'string',
-        description: 'Input parameter',
-        required: true,
-      },
-    ],
-  })
-  async exampleTool(input: { input: string }): Promise<{ result: string }> {
-    // Implement your tool logic here
-    return {
-      result: \`Processed: \${input.input}\`,
-    };
-  }
-}
-`;
-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();
-  }
-}
-`;
-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
-  }
-}
-`;
-const RAG_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
-import { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';
-
-@Service()
-export class {{className}}RagService {
-  private pipeline: RAGPipeline;
-
-  constructor() {
-    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)
-    const vectorStore = new MemoryVectorStore();
-
-    this.pipeline = new RAGPipeline({
-      vectorStore,
-      topK: 5,
-    });
-  }
-
-  async addDocument(content: string, metadata?: Record<string, unknown>) {
-    // Add a document to the vector store for retrieval
-    await this.pipeline.addDocument({
-      content,
-      metadata: metadata || {},
-    });
-  }
-
-  async query(question: string) {
-    // Retrieve relevant documents and generate a response
-    const results = await this.pipeline.query(question);
-    return results;
-  }
-}
-`;
-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;
-  }
-}
-`;
-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 };
-`;
-const SERVERLESS_LAMBDA_TEMPLATE = `import { createLambdaHandler } from '@hazeljs/serverless';
-import { AppModule } from './app.module';
-
-export const handler = createLambdaHandler(AppModule);
-`;
-const SERVERLESS_CLOUD_FUNCTION_TEMPLATE = `import { createCloudFunctionHandler } from '@hazeljs/serverless';
-import { AppModule } from './app.module';
-
-export const handler = createCloudFunctionHandler(AppModule);
-`;
+const templates_1 = require("./templates");
 exports.SIMPLE_GENERATORS = [
-    { type: 'controller', description: 'REST controller', suffix: 'controller', template: CONTROLLER_TEMPLATE, alias: 'c', nameRequired: true },
-    { type: 'service', description: 'Service class', suffix: 'service', template: SERVICE_TEMPLATE, alias: 's', nameRequired: true },
-    { type: 'guard', description: 'Guard (e.g. auth)', suffix: 'guard', template: GUARD_TEMPLATE, alias: 'gu', nameRequired: true },
-    { type: 'interceptor', description: 'Interceptor', suffix: 'interceptor', template: INTERCEPTOR_TEMPLATE, alias: 'i', nameRequired: true },
-    { type: 'middleware', description: 'Middleware', suffix: 'middleware', template: 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: PIPE_TEMPLATE, nameRequired: true },
-    { type: 'filter', description: 'Exception filter', suffix: 'filter', template: EXCEPTION_FILTER_TEMPLATE, alias: 'f', nameRequired: true },
-    { type: 'repository', description: 'Prisma repository', suffix: 'repository', template: REPOSITORY_TEMPLATE, alias: 'repo', nameRequired: true },
-    { type: 'gateway', description: 'WebSocket gateway', suffix: 'gateway', template: WEBSOCKET_GATEWAY_TEMPLATE, alias: 'ws', nameRequired: true },
-    { type: 'ai-service', description: 'AI service with decorators', suffix: 'ai-service', template: AI_SERVICE_TEMPLATE, alias: 'ai', nameRequired: true },
-    { type: 'agent', description: 'AI agent with @Agent and @Tool', suffix: 'agent', template: AGENT_TEMPLATE, nameRequired: true, extraData: (name) => ({ description: `A ${name} agent` }) },
-    { type: 'cache', description: 'Cache service with decorators', suffix: 'cache', template: 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: 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: 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: 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: 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: 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 {
@@ -402,11 +37,19 @@ class SimpleGenerator extends generator_1.Generator {
         return this._template;
     }
 }
+/**
+ * Execute a simple generator given its config, a name, and CLI options.
+ *
+ * @param config  - The SimpleGeneratorConfig entry (from SIMPLE_GENERATORS)
+ * @param name    - User-provided name (e.g. 'users') — used for file and class names
+ * @param options - Standard CLI options (--path, --dry-run, --json, --platform)
+ * @returns A GenerateResult with created file paths and optional next steps
+ */
 async function runSimpleGenerator(config, name, options) {
     // Handle serverless platform option
     let template = config.template;
     if (config.type === 'serverless' && options.platform === 'cloud-function') {
-        template = SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
+        template = templates_1.SERVERLESS_CLOUD_FUNCTION_TEMPLATE;
     }
     const generator = new SimpleGenerator(config.suffix, template);
     const effectiveName = config.nameRequired ? name : (name || 'app');
@@ -421,7 +64,15 @@ async function runSimpleGenerator(config, name, options) {
     }
     return result;
 }
-/** Register all simple generators as sub-commands of the generate command */
+/**
+ * Register all simple generators as sub-commands of the `hazel generate` command.
+ *
+ * Iterates over SIMPLE_GENERATORS and creates a Commander sub-command for each,
+ * wiring up aliases, options (--path, --dry-run, --json, plus any extraOptions),
+ * and the action handler that calls runSimpleGenerator.
+ *
+ * @param generateCommand - The Commander `generate` parent command to attach sub-commands to
+ */
 function registerSimpleGenerators(generateCommand) {
     for (const config of exports.SIMPLE_GENERATORS) {
         const cmdStr = config.nameRequired ? `${config.type} <name>` : config.type;
@@ -442,7 +93,12 @@ function registerSimpleGenerators(generateCommand) {
         });
     }
 }
-/** Lookup a simple generator config by type */
+/**
+ * Look up a SimpleGeneratorConfig by its type name (e.g. 'controller', 'agent').
+ *
+ * @param type - The generator type to find
+ * @returns The matching config, or undefined if no simple generator matches
+ */
 function findSimpleGenerator(type) {
     return exports.SIMPLE_GENERATORS.find((g) => g.type === type);
 }

package/dist/commands/info.d.ts

@@ -1,2 +1,14 @@
 import { Command } from 'commander';
+/**
+ * Register the `hazel info` command.
+ *
+ * Reads the current directory's package.json and displays:
+ * - Project name, version, description
+ * - Installed @hazeljs/* packages with versions
+ * - src/ directory listing
+ * - Node.js version, platform, architecture
+ * - Detected configuration files (tsconfig, .env, eslint, etc.)
+ *
+ * @param program - The root Commander program instance
+ */
 export declare function infoCommand(program: Command): void;

package/dist/commands/info.js

@@ -7,6 +7,18 @@ exports.infoCommand = infoCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Register the `hazel info` command.
+ *
+ * Reads the current directory's package.json and displays:
+ * - Project name, version, description
+ * - Installed @hazeljs/* packages with versions
+ * - src/ directory listing
+ * - Node.js version, platform, architecture
+ * - Detected configuration files (tsconfig, .env, eslint, etc.)
+ *
+ * @param program - The root Commander program instance
+ */
 function infoCommand(program) {
     program
         .command('info')

package/dist/commands/templates.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Mustache templates for all simple (single-file) generators.
+ *
+ * Each template uses three standard variables provided by the Generator base class:
+ *   - {{className}}  — PascalCase name (e.g. "Users")
+ *   - {{fileName}}   — kebab-case name (e.g. "users")
+ *   - {{camelName}}  — camelCase name (e.g. "users")
+ *
+ * Some templates accept additional data via `extraData` in SimpleGeneratorConfig:
+ *   - AGENT_TEMPLATE       — {{description}}
+ *   - REPOSITORY_TEMPLATE  — {{modelName}} (defaults to fileName)
+ *
+ * Templates are imported by generate-simple.ts and referenced in the
+ * SIMPLE_GENERATORS config array. To add a new generator, create a template
+ * here and add a config entry in generate-simple.ts.
+ */
+export declare const CONTROLLER_TEMPLATE = "import { Controller, Get, Post, Body, Param, Delete, Put } from '@hazeljs/core';\nimport { {{className}}Service } from './{{fileName}}.service';\nimport { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';\nimport { Update{{className}}Dto } from './dto/update-{{fileName}}.dto';\n\n@Controller('{{fileName}}')\nexport class {{className}}Controller {\n  constructor(private readonly {{camelName}}Service: {{className}}Service) {}\n\n  @Get()\n  findAll() {\n    return this.{{camelName}}Service.findAll();\n  }\n\n  @Get(':id')\n  findOne(@Param('id') id: string) {\n    return this.{{camelName}}Service.findOne(id);\n  }\n\n  @Post()\n  create(@Body(Create{{className}}Dto) createDto: Create{{className}}Dto) {\n    return this.{{camelName}}Service.create(createDto);\n  }\n\n  @Put(':id')\n  update(@Param('id') id: string, @Body(Update{{className}}Dto) updateDto: Update{{className}}Dto) {\n    return this.{{camelName}}Service.update(id, updateDto);\n  }\n\n  @Delete(':id')\n  remove(@Param('id') id: string) {\n    return this.{{camelName}}Service.remove(id);\n  }\n}\n";
+export declare const SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\n\n@Service()\nexport class {{className}}Service {\n  constructor() {}\n\n  async findAll() {\n    return [];\n  }\n\n  async findOne(id: string) {\n    return { id };\n  }\n\n  async create(createDto: any) {\n    return createDto;\n  }\n\n  async update(id: string, updateDto: any) {\n    return { id, ...updateDto };\n  }\n\n  async remove(id: string) {\n    return { id };\n  }\n}\n";
+export declare const GUARD_TEMPLATE = "import { Injectable, type CanActivate, type ExecutionContext } from '@hazeljs/core';\n\n@Injectable()\nexport class {{className}}Guard implements CanActivate {\n  canActivate(context: ExecutionContext): boolean {\n    const request = context.switchToHttp().getRequest();\n    // Add your guard logic here\n    return true;\n  }\n}\n";
+export declare const INTERCEPTOR_TEMPLATE = "import { Injectable, Interceptor, type ExecutionContext } from '@hazeljs/core';\n\n@Injectable()\nexport class {{className}}Interceptor implements Interceptor {\n  async intercept(context: ExecutionContext, next: () => Promise<unknown>): Promise<unknown> {\n    // Pre-processing logic here (before handler execution)\n    const result = await next();\n    // Post-processing logic here (after handler execution)\n    return result;\n  }\n}\n";
+export declare const MIDDLEWARE_TEMPLATE = "import { Injectable, type MiddlewareHandler, type Request, type Response, type NextFunction } from '@hazeljs/core';\n\n@Injectable()\nexport class {{className}}Middleware implements MiddlewareHandler {\n  use(req: Request, res: Response, next: NextFunction) {\n    // Add your middleware logic here\n    console.log(`[{{className}}Middleware] ${req.method} ${req.url}`);\n    \n    // Continue to next middleware\n    next();\n  }\n}\n";
+export declare const PIPE_TEMPLATE = "import { type PipeTransform, type RequestContext } from '@hazeljs/core';\n\nexport class {{className}}Pipe implements PipeTransform {\n  transform(value: unknown, context: RequestContext): unknown {\n    // Transform logic here\n    return value;\n  }\n}\n";
+export declare const EXCEPTION_FILTER_TEMPLATE = "import { Catch, type ExceptionFilter, type ArgumentsHost, HttpError, logger } from '@hazeljs/core';\n\n@Catch(HttpError)\nexport class {{className}}ExceptionFilter implements ExceptionFilter<HttpError> {\n  catch(exception: HttpError, host: ArgumentsHost): void {\n    const ctx = host.switchToHttp();\n    const response = ctx.getResponse();\n    const request = ctx.getRequest();\n\n    const status = exception.statusCode || 500;\n    const message = exception.message || 'Internal server error';\n\n    logger.error(`[${request.method}] ${request.url} - ${message} (${status})`);\n\n    response.status(status).json({\n      statusCode: status,\n      message,\n      timestamp: new Date().toISOString(),\n      path: request.url,\n    });\n  }\n}\n";
+export declare const REPOSITORY_TEMPLATE = "import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';\n\n// @Repository implies @Injectable() \u2014 no need for both decorators\n@Repository({ model: '{{modelName}}' })\nexport class {{className}}Repository extends BaseRepository<any> {\n  constructor(prisma: PrismaService) {\n    super(prisma, '{{modelName}}');\n  }\n\n  // Add custom repository methods here\n  async findByName(name: string) {\n    return this.findMany({ where: { name } });\n  }\n}\n";
+export declare const WEBSOCKET_GATEWAY_TEMPLATE = "import { Realtime, OnConnect, OnDisconnect, OnMessage, Subscribe, Client, Data, WebSocketClient } from '@hazeljs/websocket';\n\n@Realtime('/{{fileName}}')\nexport class {{className}}Gateway {\n  @OnConnect()\n  handleConnection(@Client() client: WebSocketClient) {\n    console.log('Client connected:', client.id);\n  }\n\n  @OnDisconnect()\n  handleDisconnect(@Client() client: WebSocketClient) {\n    console.log('Client disconnected:', client.id);\n  }\n\n  @Subscribe('message')\n  @OnMessage('message')\n  handleMessage(@Client() client: WebSocketClient, @Data() data: unknown) {\n    console.log('Message received from', client.id, ':', data);\n    // Handle message logic here\n  }\n}\n";
+export declare const AI_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';\n\n@Service()\nexport class {{className}}AIService {\n  constructor(private readonly aiService: AIService) {}\n\n  @AIFunction({\n    provider: 'openai',\n    model: 'gpt-4',\n    streaming: false,\n  })\n  async {{camelName}}Task(@AIPrompt() prompt: string): Promise<unknown> {\n    const result = await this.aiService.complete({\n      provider: 'openai',\n      model: 'gpt-4',\n      messages: [{ role: 'user', content: prompt }],\n    });\n\n    return result;\n  }\n}\n";
+export declare const AGENT_TEMPLATE = "import { Agent, Tool } from '@hazeljs/agent';\n\n@Agent({\n  name: '{{fileName}}',\n  description: '{{description}}',\n  systemPrompt: 'You are a helpful {{className}} agent.',\n  enableMemory: true,\n  enableRAG: true,\n})\nexport class {{className}}Agent {\n  @Tool({\n    description: 'Example tool for {{fileName}}',\n    parameters: [\n      {\n        name: 'input',\n        type: 'string',\n        description: 'Input parameter',\n        required: true,\n      },\n    ],\n  })\n  async exampleTool(input: { input: string }): Promise<{ result: string }> {\n    // Implement your tool logic here\n    return {\n      result: `Processed: ${input.input}`,\n    };\n  }\n}\n";
+export declare const CACHE_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { CacheService, Cacheable, CacheEvict } from '@hazeljs/cache';\n\n@Service()\nexport class {{className}}CacheService {\n  constructor(private readonly cacheService: CacheService) {}\n\n  @Cacheable({ key: '{{fileName}}:all', ttl: 60 })\n  async findAll() {\n    // This result will be cached for 60 seconds\n    return [];\n  }\n\n  @Cacheable({ key: '{{fileName}}:{{=<% %>=}}#{id}<%={{ }}=%>', ttl: 300 })\n  async findOne(id: string) {\n    // This result will be cached for 5 minutes\n    return { id };\n  }\n\n  @CacheEvict({ key: '{{fileName}}:all' })\n  async create(data: any) {\n    // Creating a new item evicts the list cache\n    return data;\n  }\n\n  async clearAll() {\n    await this.cacheService.clear();\n  }\n}\n";
+export declare const CRON_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { Cron, CronExpression } from '@hazeljs/cron';\n\n@Service()\nexport class {{className}}CronService {\n  @Cron(CronExpression.EVERY_MINUTE)\n  handleEveryMinute() {\n    console.log('[{{className}}Cron] Running every minute...');\n    // Add your cron job logic here\n  }\n\n  @Cron('0 0 * * *')  // Every day at midnight\n  handleDaily() {\n    console.log('[{{className}}Cron] Running daily task...');\n    // Add your daily task logic here\n  }\n\n  @Cron(CronExpression.EVERY_HOUR)\n  handleHourly() {\n    console.log('[{{className}}Cron] Running hourly cleanup...');\n    // Add your hourly task logic here\n  }\n}\n";
+export declare const RAG_SERVICE_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';\n\n@Service()\nexport class {{className}}RagService {\n  private pipeline: RAGPipeline;\n\n  constructor() {\n    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)\n    const vectorStore = new MemoryVectorStore();\n\n    this.pipeline = new RAGPipeline({\n      vectorStore,\n      topK: 5,\n    });\n  }\n\n  async addDocument(content: string, metadata?: Record<string, unknown>) {\n    // Add a document to the vector store for retrieval\n    await this.pipeline.addDocument({\n      content,\n      metadata: metadata || {},\n    });\n  }\n\n  async query(question: string) {\n    // Retrieve relevant documents and generate a response\n    const results = await this.pipeline.query(question);\n    return results;\n  }\n}\n";
+export declare const DISCOVERY_TEMPLATE = "import { Service } from '@hazeljs/core';\nimport { ServiceRegistry, DiscoveryClient } from '@hazeljs/discovery';\n\n@Service()\nexport class {{className}}DiscoveryService {\n  constructor(\n    private readonly registry: ServiceRegistry,\n    private readonly client: DiscoveryClient,\n  ) {}\n\n  async registerService() {\n    await this.registry.register({\n      name: '{{fileName}}-service',\n      host: 'localhost',\n      port: 3000,\n      metadata: {\n        version: '1.0.0',\n      },\n    });\n  }\n\n  async discoverService(serviceName: string) {\n    const instances = await this.client.getInstances(serviceName);\n    return instances;\n  }\n}\n";
+export declare const CONFIG_TEMPLATE = "import { HazelModule } from '@hazeljs/core';\nimport { ConfigModule, ConfigService } from '@hazeljs/config';\n\n// Import ConfigModule.forRoot() in your app module:\n//\n// @HazelModule({\n//   imports: [\n//     ConfigModule.forRoot({\n//       envFilePath: '.env',\n//     }),\n//   ],\n// })\n//\n// Then inject ConfigService wherever you need it:\n//\n// constructor(private readonly config: ConfigService) {}\n//\n// Usage:\n//   this.config.get('DATABASE_URL');\n//   this.config.get('PORT', '3000');  // with default value\n\nexport { ConfigModule, ConfigService };\n";
+export declare const SERVERLESS_LAMBDA_TEMPLATE = "import { createLambdaHandler } from '@hazeljs/serverless';\nimport { AppModule } from './app.module';\n\nexport const handler = createLambdaHandler(AppModule);\n";
+export declare const SERVERLESS_CLOUD_FUNCTION_TEMPLATE = "import { createCloudFunctionHandler } from '@hazeljs/serverless';\nimport { AppModule } from './app.module';\n\nexport const handler = createCloudFunctionHandler(AppModule);\n";