@hazeljs/cli 0.2.0-alpha.1

package/dist/commands/generate-app.js

@@ -0,0 +1,448 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApp = generateApp;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+function copyRecursiveSync(src, dest) {
+    if (fs_1.default.existsSync(src)) {
+        fs_1.default.mkdirSync(dest, { recursive: true });
+        for (const entry of fs_1.default.readdirSync(src)) {
+            const srcPath = path_1.default.join(src, entry);
+            const destPath = path_1.default.join(dest, entry);
+            if (fs_1.default.lstatSync(srcPath).isDirectory()) {
+                copyRecursiveSync(srcPath, destPath);
+            }
+            else {
+                fs_1.default.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}
+function updatePackageJson(destPath, appName, description) {
+    const packageJsonPath = path_1.default.join(destPath, 'package.json');
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        packageJson.name = appName;
+        packageJson.description = description;
+        packageJson.version = '0.1.0';
+        fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+}
+function scaffoldPackageBoilerplate(destPath, packages) {
+    const srcPath = path_1.default.join(destPath, 'src');
+    // Build up enhanced app.module.ts imports based on selected packages
+    const imports = ["import { HazelModule } from '@hazeljs/core';"];
+    const moduleImports = [];
+    const controllers = [];
+    // Always include the default HelloController
+    imports.push("import { HelloController } from './hello.controller';");
+    controllers.push('HelloController');
+    if (packages.includes('@hazeljs/config')) {
+        imports.push("import { ConfigModule } from '@hazeljs/config';");
+        moduleImports.push("ConfigModule.forRoot({ envFilePath: '.env' })");
+        // Create .env file
+        fs_1.default.writeFileSync(path_1.default.join(destPath, '.env'), 'PORT=3000\nNODE_ENV=development\n');
+        fs_1.default.writeFileSync(path_1.default.join(destPath, '.env.example'), 'PORT=3000\nNODE_ENV=development\n');
+        console.log(chalk_1.default.green('  ✓ Created .env and .env.example'));
+    }
+    if (packages.includes('@hazeljs/swagger')) {
+        imports.push("import { SwaggerModule } from '@hazeljs/swagger';");
+        moduleImports.push('SwaggerModule');
+    }
+    if (packages.includes('@hazeljs/prisma')) {
+        imports.push("import { PrismaModule } from '@hazeljs/prisma';");
+        moduleImports.push('PrismaModule');
+    }
+    if (packages.includes('@hazeljs/typeorm')) {
+        imports.push("import { TypeOrmModule } from '@hazeljs/typeorm';");
+        moduleImports.push('TypeOrmModule');
+    }
+    if (packages.includes('@hazeljs/audit')) {
+        imports.push("import { AuditModule, ConsoleAuditTransport } from '@hazeljs/audit';");
+        moduleImports.push("AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })");
+    }
+    if (packages.includes('@hazeljs/auth')) {
+        imports.push("import { JwtModule } from '@hazeljs/auth';");
+        moduleImports.push("JwtModule.forRoot({ secret: process.env.JWT_SECRET || 'change-me', expiresIn: '1d' })");
+    }
+    if (packages.includes('@hazeljs/oauth')) {
+        imports.push("import { OAuthModule } from '@hazeljs/oauth';");
+        moduleImports.push("OAuthModule.forRoot({ providers: { google: { clientId: process.env.GOOGLE_CLIENT_ID!, clientSecret: process.env.GOOGLE_CLIENT_SECRET!, redirectUri: process.env.OAUTH_REDIRECT_URI! } } })");
+    }
+    if (packages.includes('@hazeljs/cache')) {
+        imports.push("import { CacheModule } from '@hazeljs/cache';");
+        moduleImports.push('CacheModule');
+    }
+    if (packages.includes('@hazeljs/cron')) {
+        imports.push("import { CronModule } from '@hazeljs/cron';");
+        moduleImports.push('CronModule');
+    }
+    if (packages.includes('@hazeljs/websocket')) {
+        imports.push("import { WebSocketModule } from '@hazeljs/websocket';");
+        moduleImports.push('WebSocketModule');
+    }
+    if (packages.includes('@hazeljs/ai')) {
+        imports.push("import { AIModule } from '@hazeljs/ai';");
+        moduleImports.push('AIModule');
+    }
+    if (packages.includes('@hazeljs/agent')) {
+        imports.push("import { AgentModule } from '@hazeljs/agent';");
+        moduleImports.push('AgentModule');
+    }
+    if (packages.includes('@hazeljs/rag')) {
+        imports.push("import { RAGModule } from '@hazeljs/rag';");
+        moduleImports.push('RAGModule');
+    }
+    if (packages.includes('@hazeljs/discovery')) {
+        // Discovery uses ServiceRegistry/DiscoveryClient programmatically - no module import
+    }
+    if (packages.includes('@hazeljs/prompts')) {
+        // Prompts is a library (PromptTemplate, PromptRegistry) - no module import
+    }
+    if (packages.includes('@hazeljs/mcp')) {
+        // MCP uses createMcpServer() programmatically - no module import
+    }
+    if (packages.includes('@hazeljs/pdf-to-audio')) {
+        imports.push("import { PdfToAudioModule } from '@hazeljs/pdf-to-audio';");
+        moduleImports.push('PdfToAudioModule');
+    }
+    if (packages.includes('@hazeljs/data')) {
+        imports.push("import { DataModule } from '@hazeljs/data';");
+        moduleImports.push('DataModule.forRoot()');
+    }
+    if (packages.includes('@hazeljs/event-emitter')) {
+        imports.push("import { EventEmitterModule } from '@hazeljs/event-emitter';");
+        moduleImports.push('EventEmitterModule.forRoot()');
+    }
+    if (packages.includes('@hazeljs/gateway')) {
+        imports.push("import { GatewayModule } from '@hazeljs/gateway';");
+        moduleImports.push('GatewayModule');
+    }
+    if (packages.includes('@hazeljs/graphql')) {
+        imports.push("import { GraphQLModule } from '@hazeljs/graphql';");
+        moduleImports.push('GraphQLModule');
+    }
+    if (packages.includes('@hazeljs/grpc')) {
+        imports.push("import { GrpcModule } from '@hazeljs/grpc';");
+        moduleImports.push('GrpcModule');
+    }
+    if (packages.includes('@hazeljs/kafka')) {
+        imports.push("import { KafkaModule } from '@hazeljs/kafka';");
+        moduleImports.push('KafkaModule');
+    }
+    if (packages.includes('@hazeljs/messaging')) {
+        imports.push("import { MessagingModule } from '@hazeljs/messaging';");
+        moduleImports.push('MessagingModule');
+    }
+    if (packages.includes('@hazeljs/ml')) {
+        imports.push("import { MLModule } from '@hazeljs/ml';");
+        moduleImports.push('MLModule.forRoot()');
+    }
+    if (packages.includes('@hazeljs/queue')) {
+        imports.push("import { QueueModule } from '@hazeljs/queue';");
+        moduleImports.push('QueueModule');
+    }
+    if (packages.includes('@hazeljs/resilience')) {
+        // Resilience is a library of decorators, not a module - no import needed in app.module
+        // User can import { CircuitBreaker, WithRetry } in their services
+    }
+    // Generate the enhanced app.module.ts
+    const importsSection = moduleImports.length > 0
+        ? `\n  imports: [\n    ${moduleImports.join(',\n    ')},\n  ],`
+        : '';
+    const appModule = `${imports.join('\n')}
+
+@HazelModule({${importsSection}
+  controllers: [${controllers.join(', ')}],
+})
+export class AppModule {}
+`;
+    fs_1.default.writeFileSync(path_1.default.join(srcPath, 'app.module.ts'), appModule);
+    console.log(chalk_1.default.green('  ✓ Updated app.module.ts with package imports'));
+    // Update index.ts / main.ts if swagger is selected
+    if (packages.includes('@hazeljs/swagger')) {
+        const mainContent = `import 'reflect-metadata';
+import { HazelApp } from '@hazeljs/core';
+import { SwaggerModule } from '@hazeljs/swagger';
+import { AppModule } from './app.module';
+
+async function bootstrap(): Promise<void> {
+  // Setup Swagger documentation (must be called before app creation)
+  SwaggerModule.setRootModule(AppModule);
+
+  const app = new HazelApp(AppModule);
+
+  // Enable CORS
+  app.enableCors({
+    origin: '*',
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+  });
+
+  const port = parseInt(process.env.PORT || '3000', 10);
+  await app.listen(port);
+}
+
+bootstrap();
+`;
+        fs_1.default.writeFileSync(path_1.default.join(srcPath, 'index.ts'), mainContent);
+        console.log(chalk_1.default.green('  ✓ Updated index.ts with Swagger setup'));
+    }
+}
+function generateApp(program) {
+    program
+        .command('new <appName>')
+        .description('Create a new HazelJS application')
+        .option('-d, --dest <destPath>', 'Destination path', '.')
+        .option('--skip-install', 'Skip npm install')
+        .option('--skip-git', 'Skip git initialization')
+        .option('-i, --interactive', 'Interactive setup')
+        .action(async (appName, options) => {
+        try {
+            let projectConfig = {
+                name: appName,
+                description: `A HazelJS application`,
+                author: '',
+                license: 'Apache-2.0',
+                packages: [],
+            };
+            // Interactive setup
+            if (options.interactive) {
+                console.log(chalk_1.default.blue('\n🚀 Welcome to HazelJS project setup!\n'));
+                const answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'description',
+                        message: 'Project description:',
+                        default: projectConfig.description,
+                    },
+                    {
+                        type: 'input',
+                        name: 'author',
+                        message: 'Author:',
+                    },
+                    {
+                        type: 'list',
+                        name: 'license',
+                        message: 'License:',
+                        choices: ['MIT', 'Apache-2.0', 'GPL-3.0', 'BSD-3-Clause', 'ISC'],
+                        default: 'Apache-2.0',
+                    },
+                    {
+                        type: 'checkbox',
+                        name: 'packages',
+                        message: 'Select additional HazelJS packages to install:',
+                        choices: [
+                            { name: 'AI Integration (@hazeljs/ai)', value: '@hazeljs/ai' },
+                            { name: 'AI Agents (@hazeljs/agent)', value: '@hazeljs/agent' },
+                            { name: 'Audit Logging (@hazeljs/audit)', value: '@hazeljs/audit' },
+                            { name: 'Authentication (@hazeljs/auth)', value: '@hazeljs/auth' },
+                            { name: 'OAuth - Google/Microsoft/GitHub (@hazeljs/oauth)', value: '@hazeljs/oauth' },
+                            { name: 'Caching (@hazeljs/cache)', value: '@hazeljs/cache' },
+                            { name: 'Configuration (@hazeljs/config)', value: '@hazeljs/config' },
+                            { name: 'Cron Jobs (@hazeljs/cron)', value: '@hazeljs/cron' },
+                            { name: 'Data/ETL (@hazeljs/data)', value: '@hazeljs/data' },
+                            { name: 'Service Discovery (@hazeljs/discovery)', value: '@hazeljs/discovery' },
+                            { name: 'Event Emitter (@hazeljs/event-emitter)', value: '@hazeljs/event-emitter' },
+                            { name: 'API Gateway (@hazeljs/gateway)', value: '@hazeljs/gateway' },
+                            { name: 'GraphQL (@hazeljs/graphql)', value: '@hazeljs/graphql' },
+                            { name: 'gRPC (@hazeljs/grpc)', value: '@hazeljs/grpc' },
+                            { name: 'Kafka (@hazeljs/kafka)', value: '@hazeljs/kafka' },
+                            { name: 'Messaging - WhatsApp/Telegram (@hazeljs/messaging)', value: '@hazeljs/messaging' },
+                            { name: 'Machine Learning (@hazeljs/ml)', value: '@hazeljs/ml' },
+                            { name: 'MCP - Model Context Protocol (@hazeljs/mcp)', value: '@hazeljs/mcp' },
+                            { name: 'PDF to Audio (@hazeljs/pdf-to-audio)', value: '@hazeljs/pdf-to-audio' },
+                            { name: 'Prompts - typed templates (@hazeljs/prompts)', value: '@hazeljs/prompts' },
+                            { name: 'Prisma ORM (@hazeljs/prisma)', value: '@hazeljs/prisma' },
+                            { name: 'TypeORM (@hazeljs/typeorm)', value: '@hazeljs/typeorm' },
+                            { name: 'Queue/BullMQ (@hazeljs/queue)', value: '@hazeljs/queue' },
+                            { name: 'RAG/Vector Search (@hazeljs/rag)', value: '@hazeljs/rag' },
+                            { name: 'Resilience - Circuit Breaker (@hazeljs/resilience)', value: '@hazeljs/resilience' },
+                            { name: 'Serverless (@hazeljs/serverless)', value: '@hazeljs/serverless' },
+                            { name: 'Swagger/OpenAPI (@hazeljs/swagger)', value: '@hazeljs/swagger' },
+                            { name: 'WebSocket (@hazeljs/websocket)', value: '@hazeljs/websocket' },
+                        ],
+                    },
+                ]);
+                projectConfig = { ...projectConfig, ...answers };
+            }
+            const destPath = path_1.default.join(process.cwd(), options.dest || '.', appName);
+            console.log(chalk_1.default.blue('\n📦 Creating new HazelJS project...\n'));
+            console.log(chalk_1.default.gray(`Project: ${projectConfig.name}`));
+            console.log(chalk_1.default.gray(`Location: ${destPath}\n`));
+            // Check if destination exists
+            if (fs_1.default.existsSync(destPath)) {
+                console.error(chalk_1.default.red(`✗ Destination already exists: ${destPath}`));
+                process.exit(1);
+            }
+            // Use local template
+            const templatePath = path_1.default.join(__dirname, '../../@template');
+            if (fs_1.default.existsSync(templatePath)) {
+                console.log(chalk_1.default.blue('📋 Copying template files...'));
+                copyRecursiveSync(templatePath, destPath);
+                // Update package.json
+                updatePackageJson(destPath, projectConfig.name, projectConfig.description);
+                console.log(chalk_1.default.green('✓ Template files copied'));
+            }
+            else {
+                console.log(chalk_1.default.yellow('⚠ Local template not found, creating basic structure...'));
+                // Create basic structure
+                fs_1.default.mkdirSync(destPath, { recursive: true });
+                fs_1.default.mkdirSync(path_1.default.join(destPath, 'src'), { recursive: true });
+                // Create package.json
+                const packageJson = {
+                    name: projectConfig.name,
+                    version: '0.1.0',
+                    description: projectConfig.description,
+                    main: 'dist/index.js',
+                    scripts: {
+                        build: 'tsc',
+                        start: 'node dist/index.js',
+                        dev: 'ts-node-dev --respawn --transpile-only src/index.ts',
+                        test: 'jest',
+                        lint: 'eslint "src/**/*.ts"',
+                        'lint:fix': 'eslint "src/**/*.ts" --fix',
+                        format: 'prettier --write "src/**/*.ts"',
+                    },
+                    dependencies: {
+                        '@hazeljs/core': '^0.2.0',
+                        'reflect-metadata': '^0.2.2',
+                    },
+                    devDependencies: {
+                        '@types/jest': '^29.5.12',
+                        '@types/node': '^20.0.0',
+                        '@typescript-eslint/eslint-plugin': '^8.18.2',
+                        '@typescript-eslint/parser': '^8.18.2',
+                        'eslint': '^8.56.0',
+                        'eslint-config-prettier': '^9.1.0',
+                        'eslint-plugin-prettier': '^5.1.3',
+                        'jest': '^29.7.0',
+                        'prettier': '^3.2.5',
+                        'ts-jest': '^29.1.2',
+                        'ts-node-dev': '^2.0.0',
+                        'typescript': '^5.3.3',
+                    },
+                    author: projectConfig.author,
+                    license: projectConfig.license,
+                };
+                fs_1.default.writeFileSync(path_1.default.join(destPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+                // Create basic index.ts
+                const indexContent = `import 'reflect-metadata';
+import { HazelApp, HazelModule, Controller, Get } from '@hazeljs/core';
+
+@Controller('/')
+export class AppController {
+  @Get()
+  hello() {
+    return { message: 'Hello from HazelJS!' };
+  }
+}
+
+@HazelModule({
+  controllers: [AppController],
+})
+export class AppModule {}
+
+async function bootstrap() {
+  const app = new HazelApp(AppModule);
+
+  app.enableCors({
+    origin: '*',
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+  });
+
+  const port = parseInt(process.env.PORT || '3000', 10);
+  await app.listen(port);
+}
+
+bootstrap();
+`;
+                fs_1.default.writeFileSync(path_1.default.join(destPath, 'src', 'index.ts'), indexContent);
+                // Create tsconfig.json
+                const tsConfig = {
+                    compilerOptions: {
+                        target: 'ES2020',
+                        module: 'commonjs',
+                        lib: ['ES2020'],
+                        outDir: './dist',
+                        rootDir: './src',
+                        strict: true,
+                        esModuleInterop: true,
+                        skipLibCheck: true,
+                        forceConsistentCasingInFileNames: true,
+                        experimentalDecorators: true,
+                        emitDecoratorMetadata: true,
+                    },
+                    include: ['src/**/*'],
+                    exclude: ['node_modules', 'dist'],
+                };
+                fs_1.default.writeFileSync(path_1.default.join(destPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
+                console.log(chalk_1.default.green('✓ Basic structure created'));
+            }
+            // Initialize git
+            if (!options.skipGit) {
+                try {
+                    console.log(chalk_1.default.blue('\n📝 Initializing git repository...'));
+                    (0, child_process_1.execSync)('git init', { cwd: destPath, stdio: 'ignore' });
+                    // Create .gitignore
+                    const gitignore = `node_modules/
+dist/
+.env
+.DS_Store
+coverage/
+*.log
+`;
+                    fs_1.default.writeFileSync(path_1.default.join(destPath, '.gitignore'), gitignore);
+                    console.log(chalk_1.default.green('✓ Git initialized'));
+                }
+                catch {
+                    console.log(chalk_1.default.yellow('⚠ Git initialization skipped'));
+                }
+            }
+            // Install dependencies
+            if (!options.skipInstall) {
+                console.log(chalk_1.default.blue('\n📦 Installing dependencies...\n'));
+                try {
+                    (0, child_process_1.execSync)('npm install', { cwd: destPath, stdio: 'inherit' });
+                    // Install additional packages
+                    if (projectConfig.packages.length > 0) {
+                        console.log(chalk_1.default.blue('\n📦 Installing additional packages...\n'));
+                        (0, child_process_1.execSync)(`npm install ${projectConfig.packages.join(' ')}`, {
+                            cwd: destPath,
+                            stdio: 'inherit',
+                        });
+                    }
+                    console.log(chalk_1.default.green('\n✓ Dependencies installed'));
+                }
+                catch {
+                    console.log(chalk_1.default.yellow('\n⚠ Dependency installation failed'));
+                    console.log(chalk_1.default.gray('You can install them manually with: npm install'));
+                }
+            }
+            // Scaffold boilerplate for selected packages
+            if (projectConfig.packages.length > 0) {
+                console.log(chalk_1.default.blue('\n📝 Scaffolding boilerplate for selected packages...\n'));
+                scaffoldPackageBoilerplate(destPath, projectConfig.packages);
+            }
+            // Success message
+            console.log(chalk_1.default.green.bold('\n✨ Project created successfully!\n'));
+            console.log(chalk_1.default.gray('Next steps:'));
+            console.log(chalk_1.default.gray(`  cd ${appName}`));
+            if (options.skipInstall) {
+                console.log(chalk_1.default.gray('  npm install'));
+            }
+            console.log(chalk_1.default.gray('  npm run dev'));
+            console.log(chalk_1.default.gray('\nDocumentation: https://hazeljs.com/docs'));
+            console.log(chalk_1.default.gray('Discord: https://discord.com/channels/1448263814238965833/1448263814859456575\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('\n✗ Failed to create project:'), error);
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/commands/generate-auth.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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';
+import { AuthService } from './auth.service';
+import { JwtAuthGuard } from './jwt-auth.guard';
+
+@HazelModule({
+  controllers: [AuthController],
+  providers: [AuthService, JwtAuthGuard],
+  exports: [AuthService, JwtAuthGuard],
+})
+export class AuthModule {}
+`;
+const AUTH_SERVICE_TEMPLATE = `import { Service, BadRequestError, UnauthorizedError } from '@hazeljs/core';
+import { JwtService } from '@hazeljs/auth';
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+
+@Service()
+export class AuthService {
+  constructor(
+    private readonly jwtService: JwtService,
+  ) {}
+
+  async register(registerDto: RegisterDto) {
+    // TODO: Check if user already exists in your database
+
+    // TODO: Hash the password (e.g., with bcryptjs)
+    // const hashedPassword = await bcrypt.hash(registerDto.password, 10);
+
+    // TODO: Create the user in your database
+    const user = {
+      id: Date.now().toString(),
+      name: registerDto.name,
+      email: registerDto.email,
+    };
+
+    const accessToken = this.jwtService.sign({
+      sub: user.id,
+      email: user.email,
+    });
+
+    return { user, accessToken };
+  }
+
+  async login(loginDto: LoginDto) {
+    // TODO: Find user by email in your database
+    // TODO: Verify password with bcrypt.compare()
+
+    const user = { id: '1', name: 'User', email: loginDto.email };
+
+    const accessToken = this.jwtService.sign({
+      sub: user.id,
+      email: user.email,
+    });
+
+    return { user, accessToken };
+  }
+}
+`;
+const AUTH_CONTROLLER_TEMPLATE = `import { Controller, Post, Body } from '@hazeljs/core';
+import { AuthService } from './auth.service';
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+
+@Controller('/auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('/register')
+  async register(@Body() registerDto: RegisterDto) {
+    return this.authService.register(registerDto);
+  }
+
+  @Post('/login')
+  async login(@Body() loginDto: LoginDto) {
+    return this.authService.login(loginDto);
+  }
+}
+`;
+const JWT_GUARD_TEMPLATE = `import { Injectable, type CanActivate, type ExecutionContext, UnauthorizedError } from '@hazeljs/core';
+import { JwtService } from '@hazeljs/auth';
+
+@Injectable()
+export class JwtAuthGuard implements CanActivate {
+  constructor(private readonly jwtService: JwtService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const authHeader = request.headers?.authorization;
+
+    if (!authHeader) {
+      throw new UnauthorizedError('Missing Authorization header');
+    }
+
+    const [type, token] = authHeader.split(' ');
+    if (type !== 'Bearer' || !token) {
+      throw new UnauthorizedError('Invalid Authorization header');
+    }
+
+    try {
+      const payload = this.jwtService.verify(token);
+      (request as any).user = payload;
+      return true;
+    } catch {
+      throw new UnauthorizedError('Invalid or expired token');
+    }
+  }
+}
+`;
+const REGISTER_DTO_TEMPLATE = `import { IsString, IsEmail, IsNotEmpty, MinLength } from 'class-validator';
+
+export class RegisterDto {
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @IsEmail()
+  @IsNotEmpty()
+  email: string;
+
+  @IsString()
+  @MinLength(6)
+  password: string;
+}
+`;
+const LOGIN_DTO_TEMPLATE = `import { IsEmail, IsNotEmpty, IsString } from 'class-validator';
+
+export class LoginDto {
+  @IsEmail()
+  @IsNotEmpty()
+  email: string;
+
+  @IsString()
+  @IsNotEmpty()
+  password: string;
+}
+`;
+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);
+        }
+    });
+}

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

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