@biggora/claude-plugins 1.2.2 → 1.3.0

package/src/skills/nest-best-practices/references/techniques-compression-streaming-sse.md

@@ -0,0 +1,194 @@
+---
+name: compression-streaming-sse
+description: Response compression, file streaming, and Server-Sent Events
+---
+
+# Compression, Streaming & SSE
+
+## Compression
+
+For high-traffic production sites, offload compression to a reverse proxy (Nginx).
+
+### Express
+
+```bash
+npm install compression
+npm install -D @types/compression
+```
+
+```typescript
+import * as compression from 'compression';
+
+app.use(compression());
+```
+
+### Fastify
+
+```bash
+npm install @fastify/compress
+```
+
+```typescript
+import compression from '@fastify/compress';
+
+const app = await NestFactory.create<NestFastifyApplication>(
+  AppModule,
+  new FastifyAdapter(),
+);
+await app.register(compression);
+```
+
+Configure compression quality:
+
+```typescript
+import { constants } from 'node:zlib';
+
+await app.register(compression, {
+  brotliOptions: {
+    params: { [constants.BROTLI_PARAM_QUALITY]: 4 },
+  },
+});
+
+// Or prefer faster encodings
+await app.register(compression, {
+  encodings: ['gzip', 'deflate'],
+});
+```
+
+## File Streaming
+
+Use `StreamableFile` to return file streams while keeping interceptor support:
+
+```typescript
+import { Controller, Get, StreamableFile } from '@nestjs/common';
+import { createReadStream } from 'node:fs';
+import { join } from 'node:path';
+
+@Controller('files')
+export class FilesController {
+  @Get()
+  getFile(): StreamableFile {
+    const file = createReadStream(join(process.cwd(), 'package.json'));
+    return new StreamableFile(file);
+  }
+}
+```
+
+With custom headers:
+
+```typescript
+@Get()
+getFile(): StreamableFile {
+  const file = createReadStream(join(process.cwd(), 'report.pdf'));
+  return new StreamableFile(file, {
+    type: 'application/pdf',
+    disposition: 'attachment; filename="report.pdf"',
+  });
+}
+```
+
+Or using response object:
+
+```typescript
+@Get()
+getFile(@Res({ passthrough: true }) res: Response): StreamableFile {
+  const file = createReadStream(join(process.cwd(), 'image.png'));
+  res.set({
+    'Content-Type': 'image/png',
+    'Content-Disposition': 'inline; filename="image.png"',
+  });
+  return new StreamableFile(file);
+}
+```
+
+Using `@Header()` decorator:
+
+```typescript
+@Get()
+@Header('Content-Type', 'application/pdf')
+@Header('Content-Disposition', 'attachment; filename="report.pdf"')
+getFile(): StreamableFile {
+  const file = createReadStream(join(process.cwd(), 'report.pdf'));
+  return new StreamableFile(file);
+}
+```
+
+## Server-Sent Events (SSE)
+
+SSE enables server-to-client push over HTTP.
+
+```typescript
+import { Controller, Sse, MessageEvent } from '@nestjs/common';
+import { Observable, interval, map } from 'rxjs';
+
+@Controller()
+export class EventsController {
+  @Sse('sse')
+  sse(): Observable<MessageEvent> {
+    return interval(1000).pipe(
+      map(() => ({
+        data: { timestamp: new Date().toISOString() },
+      })),
+    );
+  }
+}
+```
+
+MessageEvent interface:
+
+```typescript
+interface MessageEvent {
+  data: string | object;  // Event data
+  id?: string;            // Event ID for reconnection
+  type?: string;          // Event type
+  retry?: number;         // Reconnection interval (ms)
+}
+```
+
+Client-side usage:
+
+```javascript
+const eventSource = new EventSource('/sse');
+
+eventSource.onmessage = ({ data }) => {
+  console.log('New message:', JSON.parse(data));
+};
+
+// Named events
+eventSource.addEventListener('update', (event) => {
+  console.log('Update:', JSON.parse(event.data));
+});
+
+// Close connection
+eventSource.close();
+```
+
+SSE with typed events:
+
+```typescript
+@Sse('notifications')
+notifications(): Observable<MessageEvent> {
+  return this.notificationsService.getStream().pipe(
+    map((notification) => ({
+      data: notification,
+      type: 'notification',
+      id: notification.id,
+    })),
+  );
+}
+```
+
+## Key Points
+
+- SSE routes must return an `Observable` stream
+- `StreamableFile` works with both Express and Fastify
+- Default content type for StreamableFile is `application/octet-stream`
+- SSE maintains persistent HTTP connection
+- Compression should be disabled for SSE endpoints
+
+<!--
+Source references:
+- https://docs.nestjs.com/techniques/compression
+- https://docs.nestjs.com/techniques/streaming-files
+- https://docs.nestjs.com/techniques/server-sent-events
+-->

package/src/skills/nest-best-practices/references/techniques-configuration.md

@@ -0,0 +1,132 @@
+---
+name: techniques-configuration
+description: Configuration management with ConfigModule in NestJS
+---
+
+# Configuration
+
+NestJS provides `@nestjs/config` package for managing application configuration across different environments.
+
+## Installation
+
+```bash
+npm i --save @nestjs/config
+```
+
+## Basic Setup
+
+```typescript
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+
+@Module({
+  imports: [ConfigModule.forRoot()],
+})
+export class AppModule {}
+```
+
+## Custom .env Path
+
+```typescript
+ConfigModule.forRoot({
+  envFilePath: '.development.env',
+});
+```
+
+## Multiple .env Files
+
+```typescript
+ConfigModule.forRoot({
+  envFilePath: ['.env.development.local', '.env.development'],
+});
+```
+
+## Global ConfigModule
+
+```typescript
+ConfigModule.forRoot({
+  isGlobal: true,
+});
+```
+
+## Using ConfigService
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class AppService {
+  constructor(private configService: ConfigService) {}
+
+  getDatabaseUrl() {
+    return this.configService.get<string>('DATABASE_URL');
+  }
+
+  getPort() {
+    return this.configService.get<number>('PORT', 3000);
+  }
+}
+```
+
+## Custom Configuration Files
+
+```typescript
+export default () => ({
+  port: parseInt(process.env.PORT, 10) || 3000,
+  database: {
+    host: process.env.DATABASE_HOST,
+    port: parseInt(process.env.DATABASE_PORT, 10) || 5432,
+  },
+});
+```
+
+Register:
+
+```typescript
+ConfigModule.forRoot({
+  load: [configuration],
+});
+```
+
+## Schema Validation
+
+```typescript
+import * as Joi from 'joi';
+
+ConfigModule.forRoot({
+  validationSchema: Joi.object({
+    NODE_ENV: Joi.string()
+      .valid('development', 'production', 'test')
+      .default('development'),
+    PORT: Joi.number().default(3000),
+  }),
+});
+```
+
+## Async Configuration
+
+```typescript
+ConfigModule.forRootAsync({
+  imports: [HttpModule],
+  useFactory: async (httpService: HttpService) => {
+    const response = await httpService.get('/config').toPromise();
+    return response.data;
+  },
+  inject: [HttpService],
+});
+```
+
+## Key Points
+
+- Use `ConfigModule.forRoot()` for basic setup
+- `ConfigService` provides typed access to configuration
+- Use custom configuration files for complex setups
+- Validate configuration with Joi schemas
+- Make ConfigModule global to avoid repeated imports
+- Environment variables take precedence over .env files
+
+<!--
+Source references:
+- https://docs.nestjs.com/techniques/configuration
+-->

package/src/skills/nest-best-practices/references/techniques-database.md

@@ -0,0 +1,153 @@
+---
+name: techniques-database
+description: Database integration with TypeORM, Prisma, and MongoDB in NestJS
+---
+
+# Database Integration
+
+NestJS supports multiple database solutions including TypeORM, Prisma, Sequelize, and MongoDB.
+
+## TypeORM
+
+### Installation
+
+```bash
+npm install --save @nestjs/typeorm typeorm mysql2
+```
+
+### Basic Setup
+
+```typescript
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'mysql',
+      host: 'localhost',
+      port: 3306,
+      username: 'root',
+      password: 'root',
+      database: 'test',
+      entities: [User],
+      synchronize: true,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Feature Module
+
+```typescript
+@Module({
+  imports: [TypeOrmModule.forFeature([User])],
+  providers: [UsersService],
+  controllers: [UsersController],
+})
+export class UsersModule {}
+```
+
+### Using Repository
+
+```typescript
+@Injectable()
+export class UsersService {
+  constructor(
+    @InjectRepository(User)
+    private usersRepository: Repository<User>,
+  ) {}
+
+  async findAll(): Promise<User[]> {
+    return this.usersRepository.find();
+  }
+}
+```
+
+## Prisma
+
+### Installation
+
+```bash
+npm install --save @prisma/client
+npm install --save-dev prisma
+```
+
+### Setup
+
+```typescript
+import { PrismaService } from './prisma.service';
+
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}
+```
+
+### Using Prisma Service
+
+```typescript
+@Injectable()
+export class UsersService {
+  constructor(private prisma: PrismaService) {}
+
+  async findAll() {
+    return this.prisma.user.findMany();
+  }
+}
+```
+
+## MongoDB
+
+### Installation
+
+```bash
+npm install --save @nestjs/mongoose mongoose
+```
+
+### Setup
+
+```typescript
+import { MongooseModule } from '@nestjs/mongoose';
+
+@Module({
+  imports: [
+    MongooseModule.forRoot('mongodb://localhost/nest'),
+  ],
+})
+export class AppModule {}
+```
+
+### Schema Definition
+
+```typescript
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+@Schema()
+export class Cat {
+  @Prop()
+  name: string;
+
+  @Prop()
+  age: number;
+}
+
+export const CatSchema = SchemaFactory.createForClass(Cat);
+```
+
+## Key Points
+
+- TypeORM provides repository pattern
+- Prisma offers type-safe database access
+- Mongoose for MongoDB integration
+- Use feature modules to organize database code
+- Configure connection in root module
+- Use repositories/services for data access
+
+<!--
+Source references:
+- https://docs.nestjs.com/techniques/database
+- https://docs.nestjs.com/recipes/prisma
+- https://docs.nestjs.com/techniques/mongodb
+-->

package/src/skills/nest-best-practices/references/techniques-events.md

@@ -0,0 +1,163 @@
+---
+name: events
+description: Event-driven architecture with @nestjs/event-emitter
+---
+
+# Events
+
+The `@nestjs/event-emitter` package provides event-driven architecture for decoupled application design.
+
+## Installation
+
+```bash
+npm install @nestjs/event-emitter
+```
+
+## Setup
+
+```typescript
+import { Module } from '@nestjs/common';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+
+@Module({
+  imports: [EventEmitterModule.forRoot()],
+})
+export class AppModule {}
+```
+
+## Dispatching Events
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+
+@Injectable()
+export class OrdersService {
+  constructor(private eventEmitter: EventEmitter2) {}
+
+  createOrder(data: CreateOrderDto) {
+    const order = this.ordersRepository.create(data);
+    
+    this.eventEmitter.emit('order.created', new OrderCreatedEvent({
+      orderId: order.id,
+      userId: data.userId,
+    }));
+
+    return order;
+  }
+}
+```
+
+## Listening to Events
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+
+@Injectable()
+export class NotificationsListener {
+  @OnEvent('order.created')
+  handleOrderCreated(event: OrderCreatedEvent) {
+    // Send notification to user
+    console.log(`Order ${event.orderId} created`);
+  }
+
+  @OnEvent('order.created', { async: true })
+  async sendEmailNotification(event: OrderCreatedEvent) {
+    await this.emailService.send(event);
+  }
+}
+```
+
+## Wildcard Listeners
+
+Enable wildcards in configuration:
+
+```typescript
+EventEmitterModule.forRoot({
+  wildcard: true,
+  delimiter: '.',
+})
+```
+
+Use wildcards:
+
+```typescript
+@OnEvent('order.*')
+handleAllOrderEvents(event: any) {
+  // Handles order.created, order.updated, order.shipped, etc.
+}
+
+@OnEvent('**')
+handleAllEvents(event: any) {
+  // Handles all events
+}
+```
+
+## Configuration Options
+
+```typescript
+EventEmitterModule.forRoot({
+  wildcard: false,              // Enable wildcard patterns
+  delimiter: '.',               // Namespace delimiter
+  newListener: false,           // Emit newListener event
+  removeListener: false,        // Emit removeListener event
+  maxListeners: 10,            // Max listeners per event
+  verboseMemoryLeak: false,    // Show event name in leak warning
+  ignoreErrors: false,         // Don't throw on unhandled errors
+});
+```
+
+## Listener Options
+
+```typescript
+@OnEvent('order.created', {
+  async: true,          // Handle asynchronously
+  prependListener: true, // Add to beginning of listener array
+  suppressErrors: true,  // Don't throw errors
+})
+handleOrderCreated(event: OrderCreatedEvent) {}
+```
+
+## Event Class Pattern
+
+```typescript
+export class OrderCreatedEvent {
+  constructor(
+    public readonly orderId: string,
+    public readonly userId: string,
+    public readonly createdAt: Date = new Date(),
+  ) {}
+}
+```
+
+## Preventing Event Loss
+
+Events emitted before `onApplicationBootstrap` may be missed:
+
+```typescript
+@Injectable()
+export class MyService implements OnApplicationBootstrap {
+  constructor(
+    private eventEmitter: EventEmitter2,
+    private eventEmitterReadinessWatcher: EventEmitterReadinessWatcher,
+  ) {}
+
+  async onApplicationBootstrap() {
+    await this.eventEmitterReadinessWatcher.waitUntilReady();
+    this.eventEmitter.emit('app.ready', {});
+  }
+}
+```
+
+## Key Points
+
+- Event subscribers cannot be request-scoped
+- Multiple listeners can subscribe to the same event
+- Events are great for decoupling modules
+- Use async: true for non-blocking event handling
+
+<!--
+Source references:
+- https://docs.nestjs.com/techniques/events
+-->