@punks/cli 0.1.16 → 1.0.0

package/dist/skills/frameworks/nestjs/nestjs-best-practices/rules/di-use-interfaces-tokens.md

@@ -0,0 +1,101 @@
+---
+title: Use Injection Tokens for Interfaces
+impact: HIGH
+impactDescription: Enables interface-based DI at runtime
+tags: dependency-injection, tokens, interfaces
+---
+
+## Use Injection Tokens for Interfaces
+
+TypeScript interfaces are erased at compile time and can't be used as injection tokens. Use string tokens, symbols, or abstract classes when you want to inject implementations of interfaces. This enables swapping implementations for testing or different environments.
+
+**Incorrect (interface can't be used as token):**
+
+```typescript
+// Interface can't be used as injection token
+interface PaymentGateway {
+  charge(amount: number): Promise<PaymentResult>;
+}
+
+@Injectable()
+export class StripeService implements PaymentGateway {
+  charge(amount: number) { /* ... */ }
+}
+
+@Injectable()
+export class OrdersService {
+  // This WON'T work - PaymentGateway doesn't exist at runtime
+  constructor(private payment: PaymentGateway) {}
+}
+```
+
+**Correct (symbol tokens or abstract classes):**
+
+```typescript
+// Option 1: String/Symbol tokens (most flexible)
+export const PAYMENT_GATEWAY = Symbol('PAYMENT_GATEWAY');
+
+export interface PaymentGateway {
+  charge(amount: number): Promise<PaymentResult>;
+}
+
+@Injectable()
+export class StripeService implements PaymentGateway {
+  async charge(amount: number): Promise<PaymentResult> {
+    // Stripe implementation
+  }
+}
+
+@Injectable()
+export class MockPaymentService implements PaymentGateway {
+  async charge(amount: number): Promise<PaymentResult> {
+    return { success: true, id: 'mock-id' };
+  }
+}
+
+// Module registration
+@Module({
+  providers: [
+    {
+      provide: PAYMENT_GATEWAY,
+      useClass: process.env.NODE_ENV === 'test'
+        ? MockPaymentService
+        : StripeService,
+    },
+  ],
+  exports: [PAYMENT_GATEWAY],
+})
+export class PaymentModule {}
+
+// Injection
+@Injectable()
+export class OrdersService {
+  constructor(
+    @Inject(PAYMENT_GATEWAY) private payment: PaymentGateway,
+  ) {}
+
+  async createOrder(dto: CreateOrderDto) {
+    await this.payment.charge(dto.amount);
+  }
+}
+
+// Option 2: Abstract class (carries runtime type info)
+export abstract class PaymentGateway {
+  abstract charge(amount: number): Promise<PaymentResult>;
+}
+
+@Injectable()
+export class StripeService extends PaymentGateway {
+  async charge(amount: number): Promise<PaymentResult> {
+    // Implementation
+  }
+}
+
+// No @Inject needed with abstract class
+@Injectable()
+export class OrdersService {
+  constructor(private payment: PaymentGateway) {}
+}
+```
+
+Reference: [NestJS Custom Providers](https://docs.nestjs.com/fundamentals/custom-providers)

package/dist/skills/frameworks/nestjs/nestjs-best-practices/rules/error-handle-async-errors.md

@@ -0,0 +1,125 @@
+---
+title: Handle Async Errors Properly
+impact: HIGH
+impactDescription: Prevents process crashes from unhandled rejections
+tags: error-handling, async, promises
+---
+
+## Handle Async Errors Properly
+
+NestJS automatically catches errors from async route handlers, but errors from background tasks, event handlers, and manually created promises can crash your application. Always handle async errors explicitly and use global handlers as a safety net.
+
+**Incorrect (fire-and-forget without error handling):**
+
+```typescript
+// Fire-and-forget without error handling
+@Injectable()
+export class UsersService {
+  async createUser(dto: CreateUserDto): Promise<User> {
+    const user = await this.repo.save(dto);
+
+    // Fire and forget - if this fails, error is unhandled!
+    this.emailService.sendWelcome(user.email);
+
+    return user;
+  }
+}
+
+// Unhandled promise in event handler
+@Injectable()
+export class OrdersService {
+  @OnEvent('order.created')
+  handleOrderCreated(event: OrderCreatedEvent) {
+    // This returns a promise but it's not awaited!
+    this.processOrder(event);
+    // Errors will crash the process
+  }
+
+  private async processOrder(event: OrderCreatedEvent): Promise<void> {
+    await this.inventoryService.reserve(event.items);
+    await this.notificationService.send(event.userId);
+  }
+}
+
+// Missing try-catch in scheduled tasks
+@Cron('0 0 * * *')
+async dailyCleanup(): Promise<void> {
+  await this.cleanupService.run();
+  // If this throws, no error handling
+}
+```
+
+**Correct (explicit async error handling):**
+
+```typescript
+// Handle fire-and-forget with explicit catch
+@Injectable()
+export class UsersService {
+  private readonly logger = new Logger(UsersService.name);
+
+  async createUser(dto: CreateUserDto): Promise<User> {
+    const user = await this.repo.save(dto);
+
+    // Explicitly catch and log errors
+    this.emailService.sendWelcome(user.email).catch((error) => {
+      this.logger.error('Failed to send welcome email', error.stack);
+      // Optionally queue for retry
+    });
+
+    return user;
+  }
+}
+
+// Properly handle async event handlers
+@Injectable()
+export class OrdersService {
+  private readonly logger = new Logger(OrdersService.name);
+
+  @OnEvent('order.created')
+  async handleOrderCreated(event: OrderCreatedEvent): Promise<void> {
+    try {
+      await this.processOrder(event);
+    } catch (error) {
+      this.logger.error('Failed to process order', { event, error });
+      // Don't rethrow - would crash the process
+      await this.deadLetterQueue.add('order.created', event);
+    }
+  }
+}
+
+// Safe scheduled tasks
+@Injectable()
+export class CleanupService {
+  private readonly logger = new Logger(CleanupService.name);
+
+  @Cron('0 0 * * *')
+  async dailyCleanup(): Promise<void> {
+    try {
+      await this.cleanupService.run();
+      this.logger.log('Daily cleanup completed');
+    } catch (error) {
+      this.logger.error('Daily cleanup failed', error.stack);
+      // Alert or retry logic
+    }
+  }
+}
+
+// Global unhandled rejection handler in main.ts
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  const logger = new Logger('Bootstrap');
+
+  process.on('unhandledRejection', (reason, promise) => {
+    logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  });
+
+  process.on('uncaughtException', (error) => {
+    logger.error('Uncaught Exception:', error);
+    process.exit(1);
+  });
+
+  await app.listen(3000);
+}
+```
+
+Reference: [Node.js Unhandled Rejections](https://nodejs.org/api/process.html#event-unhandledrejection)

package/dist/skills/frameworks/nestjs/nestjs-best-practices/rules/error-throw-http-exceptions.md

@@ -0,0 +1,114 @@
+---
+title: Throw HTTP Exceptions from Services
+impact: HIGH
+impactDescription: Keeps controllers thin and simplifies error handling
+tags: error-handling, exceptions, services
+---
+
+## Throw HTTP Exceptions from Services
+
+It's acceptable (and often preferable) to throw `HttpException` subclasses from services in HTTP applications. This keeps controllers thin and allows services to communicate appropriate error states. For truly layer-agnostic services, use domain exceptions that map to HTTP status codes.
+
+**Incorrect (return error objects instead of throwing):**
+
+```typescript
+// Return error objects instead of throwing
+@Injectable()
+export class UsersService {
+  async findById(id: string): Promise<{ user?: User; error?: string }> {
+    const user = await this.repo.findOne({ where: { id } });
+    if (!user) {
+      return { error: 'User not found' }; // Controller must check this
+    }
+    return { user };
+  }
+}
+
+@Controller('users')
+export class UsersController {
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    const result = await this.usersService.findById(id);
+    if (result.error) {
+      throw new NotFoundException(result.error);
+    }
+    return result.user;
+  }
+}
+```
+
+**Correct (throw exceptions directly from service):**
+
+```typescript
+// Throw exceptions directly from service
+@Injectable()
+export class UsersService {
+  constructor(private readonly repo: UserRepository) {}
+
+  async findById(id: string): Promise<User> {
+    const user = await this.repo.findOne({ where: { id } });
+    if (!user) {
+      throw new NotFoundException(`User #${id} not found`);
+    }
+    return user;
+  }
+
+  async create(dto: CreateUserDto): Promise<User> {
+    const existing = await this.repo.findOne({
+      where: { email: dto.email },
+    });
+    if (existing) {
+      throw new ConflictException('Email already registered');
+    }
+    return this.repo.save(dto);
+  }
+
+  async update(id: string, dto: UpdateUserDto): Promise<User> {
+    const user = await this.findById(id); // Throws if not found
+    Object.assign(user, dto);
+    return this.repo.save(user);
+  }
+}
+
+// Controller stays thin
+@Controller('users')
+export class UsersController {
+  @Get(':id')
+  findOne(@Param('id') id: string): Promise<User> {
+    return this.usersService.findById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateUserDto): Promise<User> {
+    return this.usersService.create(dto);
+  }
+}
+
+// For layer-agnostic services, use domain exceptions
+export class EntityNotFoundException extends Error {
+  constructor(
+    public readonly entity: string,
+    public readonly id: string,
+  ) {
+    super(`${entity} with ID "${id}" not found`);
+  }
+}
+
+// Map to HTTP in exception filter
+@Catch(EntityNotFoundException)
+export class EntityNotFoundFilter implements ExceptionFilter {
+  catch(exception: EntityNotFoundException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+
+    response.status(404).json({
+      statusCode: 404,
+      message: exception.message,
+      entity: exception.entity,
+      id: exception.id,
+    });
+  }
+}
+```
+
+Reference: [NestJS Exception Filters](https://docs.nestjs.com/exception-filters)

package/dist/skills/frameworks/nestjs/nestjs-best-practices/rules/error-use-exception-filters.md

@@ -0,0 +1,140 @@
+---
+title: Use Exception Filters for Error Handling
+impact: HIGH
+impactDescription: Consistent, centralized error handling
+tags: error-handling, exception-filters, consistency
+---
+
+## Use Exception Filters for Error Handling
+
+Never catch exceptions and manually format error responses in controllers. Use NestJS exception filters to handle errors consistently across your application. Create custom exception filters for specific error types and a global filter for unhandled exceptions.
+
+**Incorrect (manual error handling in controllers):**
+
+```typescript
+// Manual error handling in controllers
+@Controller('users')
+export class UsersController {
+  @Get(':id')
+  async findOne(@Param('id') id: string, @Res() res: Response) {
+    try {
+      const user = await this.usersService.findById(id);
+      if (!user) {
+        return res.status(404).json({
+          statusCode: 404,
+          message: 'User not found',
+        });
+      }
+      return res.json(user);
+    } catch (error) {
+      console.error(error);
+      return res.status(500).json({
+        statusCode: 500,
+        message: 'Internal server error',
+      });
+    }
+  }
+}
+```
+
+**Correct (exception filters with consistent handling):**
+
+```typescript
+// Use built-in and custom exceptions
+@Controller('users')
+export class UsersController {
+  @Get(':id')
+  async findOne(@Param('id') id: string): Promise<User> {
+    const user = await this.usersService.findById(id);
+    if (!user) {
+      throw new NotFoundException(`User #${id} not found`);
+    }
+    return user;
+  }
+}
+
+// Custom domain exception
+export class UserNotFoundException extends NotFoundException {
+  constructor(userId: string) {
+    super({
+      statusCode: 404,
+      error: 'Not Found',
+      message: `User with ID "${userId}" not found`,
+      code: 'USER_NOT_FOUND',
+    });
+  }
+}
+
+// Custom exception filter for domain errors
+@Catch(DomainException)
+export class DomainExceptionFilter implements ExceptionFilter {
+  catch(exception: DomainException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    const status = exception.getStatus?.() || 400;
+
+    response.status(status).json({
+      statusCode: status,
+      code: exception.code,
+      message: exception.message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}
+
+// Global exception filter for unhandled errors
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  constructor(private readonly logger: Logger) {}
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    const message =
+      exception instanceof HttpException
+        ? exception.message
+        : 'Internal server error';
+
+    this.logger.error(
+      `${request.method} ${request.url}`,
+      exception instanceof Error ? exception.stack : exception,
+    );
+
+    response.status(status).json({
+      statusCode: status,
+      message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}
+
+// Register globally in main.ts
+app.useGlobalFilters(
+  new AllExceptionsFilter(app.get(Logger)),
+  new DomainExceptionFilter(),
+);
+
+// Or via module
+@Module({
+  providers: [
+    {
+      provide: APP_FILTER,
+      useClass: AllExceptionsFilter,
+    },
+  ],
+})
+export class AppModule {}
+```
+
+Reference: [NestJS Exception Filters](https://docs.nestjs.com/exception-filters)

package/dist/skills/frameworks/nestjs/nestjs-best-practices/rules/micro-use-health-checks.md

@@ -0,0 +1,226 @@
+---
+title: Implement Health Checks for Microservices
+impact: MEDIUM-HIGH
+impactDescription: Health checks enable orchestrators to manage service lifecycle
+tags: microservices, health-checks, terminus, kubernetes
+---
+
+## Implement Health Checks for Microservices
+
+Implement liveness and readiness probes using `@nestjs/terminus`. Liveness checks determine if the service should be restarted. Readiness checks determine if the service can accept traffic. Proper health checks enable Kubernetes and load balancers to route traffic correctly.
+
+**Incorrect (simple ping that doesn't check dependencies):**
+
+```typescript
+// Simple ping that doesn't check dependencies
+@Controller('health')
+export class HealthController {
+  @Get()
+  check(): string {
+    return 'OK'; // Service might be unhealthy but returns OK
+  }
+}
+
+// Health check that blocks on slow dependencies
+@Controller('health')
+export class HealthController {
+  @Get()
+  async check(): Promise<string> {
+    // If database is slow, health check times out
+    await this.userRepo.findOne({ where: { id: '1' } });
+    await this.redis.ping();
+    await this.externalApi.healthCheck();
+    return 'OK';
+  }
+}
+```
+
+**Correct (use @nestjs/terminus for comprehensive health checks):**
+
+```typescript
+// Use @nestjs/terminus for comprehensive health checks
+import {
+  HealthCheckService,
+  HttpHealthIndicator,
+  TypeOrmHealthIndicator,
+  HealthCheck,
+  DiskHealthIndicator,
+  MemoryHealthIndicator,
+} from '@nestjs/terminus';
+
+@Controller('health')
+export class HealthController {
+  constructor(
+    private health: HealthCheckService,
+    private http: HttpHealthIndicator,
+    private db: TypeOrmHealthIndicator,
+    private disk: DiskHealthIndicator,
+    private memory: MemoryHealthIndicator,
+  ) {}
+
+  // Liveness probe - is the service alive?
+  @Get('live')
+  @HealthCheck()
+  liveness() {
+    return this.health.check([
+      // Basic checks only
+      () => this.memory.checkHeap('memory_heap', 200 * 1024 * 1024), // 200MB
+    ]);
+  }
+
+  // Readiness probe - can the service handle traffic?
+  @Get('ready')
+  @HealthCheck()
+  readiness() {
+    return this.health.check([
+      () => this.db.pingCheck('database'),
+      () =>
+        this.http.pingCheck('redis', 'http://redis:6379', { timeout: 1000 }),
+      () =>
+        this.disk.checkStorage('disk', { path: '/', thresholdPercent: 0.9 }),
+    ]);
+  }
+
+  // Deep health check for debugging
+  @Get('deep')
+  @HealthCheck()
+  deepCheck() {
+    return this.health.check([
+      () => this.db.pingCheck('database'),
+      () => this.memory.checkHeap('memory_heap', 200 * 1024 * 1024),
+      () => this.memory.checkRSS('memory_rss', 300 * 1024 * 1024),
+      () =>
+        this.disk.checkStorage('disk', { path: '/', thresholdPercent: 0.9 }),
+      () =>
+        this.http.pingCheck('external-api', 'https://api.example.com/health'),
+    ]);
+  }
+}
+
+// Custom indicator for business-specific health
+@Injectable()
+export class QueueHealthIndicator extends HealthIndicator {
+  constructor(private queueService: QueueService) {
+    super();
+  }
+
+  async isHealthy(key: string): Promise<HealthIndicatorResult> {
+    const queueStats = await this.queueService.getStats();
+
+    const isHealthy = queueStats.failedCount < 100;
+    const result = this.getStatus(key, isHealthy, {
+      waiting: queueStats.waitingCount,
+      active: queueStats.activeCount,
+      failed: queueStats.failedCount,
+    });
+
+    if (!isHealthy) {
+      throw new HealthCheckError('Queue unhealthy', result);
+    }
+
+    return result;
+  }
+}
+
+// Redis health indicator
+@Injectable()
+export class RedisHealthIndicator extends HealthIndicator {
+  constructor(@InjectRedis() private redis: Redis) {
+    super();
+  }
+
+  async isHealthy(key: string): Promise<HealthIndicatorResult> {
+    try {
+      const pong = await this.redis.ping();
+      return this.getStatus(key, pong === 'PONG');
+    } catch (error) {
+      throw new HealthCheckError('Redis check failed', this.getStatus(key, false));
+    }
+  }
+}
+
+// Use custom indicators
+@Get('ready')
+@HealthCheck()
+readiness() {
+  return this.health.check([
+    () => this.db.pingCheck('database'),
+    () => this.redis.isHealthy('redis'),
+    () => this.queue.isHealthy('job-queue'),
+  ]);
+}
+
+// Graceful shutdown handling
+@Injectable()
+export class GracefulShutdownService implements OnApplicationShutdown {
+  private isShuttingDown = false;
+
+  isShutdown(): boolean {
+    return this.isShuttingDown;
+  }
+
+  async onApplicationShutdown(signal: string): Promise<void> {
+    this.isShuttingDown = true;
+    console.log(`Shutting down on ${signal}`);
+
+    // Wait for in-flight requests
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+  }
+}
+
+// Health check respects shutdown state
+@Get('ready')
+@HealthCheck()
+readiness() {
+  if (this.shutdownService.isShutdown()) {
+    throw new ServiceUnavailableException('Shutting down');
+  }
+
+  return this.health.check([
+    () => this.db.pingCheck('database'),
+  ]);
+}
+```
+
+### Kubernetes Configuration
+
+```yaml
+# Kubernetes deployment with probes
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: api-service
+spec:
+  template:
+    spec:
+      containers:
+        - name: api
+          image: api-service:latest
+          ports:
+            - containerPort: 3000
+          livenessProbe:
+            httpGet:
+              path: /health/live
+              port: 3000
+            initialDelaySeconds: 30
+            periodSeconds: 10
+            timeoutSeconds: 5
+            failureThreshold: 3
+          readinessProbe:
+            httpGet:
+              path: /health/ready
+              port: 3000
+            initialDelaySeconds: 5
+            periodSeconds: 5
+            timeoutSeconds: 3
+            failureThreshold: 3
+          startupProbe:
+            httpGet:
+              path: /health/live
+              port: 3000
+            initialDelaySeconds: 0
+            periodSeconds: 5
+            failureThreshold: 30
+```
+
+Reference: [NestJS Terminus](https://docs.nestjs.com/recipes/terminus)