@biggora/claude-plugins 1.2.2 → 1.3.1

package/src/skills/nest-best-practices/references/security-encryption-hashing.md

@@ -0,0 +1,93 @@
+---
+name: encryption-hashing
+description: Encryption and password hashing (bcrypt, argon2) for NestJS
+---
+
+# Encryption and Hashing
+
+Nest uses Node.js built-in `crypto` for encryption. For password hashing, use bcrypt or argon2.
+
+## Encryption (crypto)
+
+```typescript
+import { createCipheriv, createDecipheriv, randomBytes, scrypt } from 'node:crypto';
+import { promisify } from 'node:util';
+
+const iv = randomBytes(16);
+const key = (await promisify(scrypt)(password, 'salt', 32)) as Buffer;
+
+// Encrypt
+const cipher = createCipheriv('aes-256-ctr', key, iv);
+const encrypted = Buffer.concat([
+  cipher.update(textToEncrypt),
+  cipher.final(),
+]);
+
+// Decrypt
+const decipher = createDecipheriv('aes-256-ctr', key, iv);
+const decrypted = Buffer.concat([
+  decipher.update(encrypted),
+  decipher.final(),
+]);
+```
+
+## Hashing (bcrypt)
+
+```bash
+npm i bcrypt
+npm i -D @types/bcrypt
+```
+
+```typescript
+import * as bcrypt from 'bcrypt';
+
+// Hash password
+const saltOrRounds = 10;
+const hash = await bcrypt.hash(password, saltOrRounds);
+
+// Generate salt
+const salt = await bcrypt.genSalt();
+
+// Verify
+const isMatch = await bcrypt.compare(password, hash);
+```
+
+## Hashing (argon2)
+
+```bash
+npm i argon2
+```
+
+```typescript
+import * as argon2 from 'argon2';
+
+const hash = await argon2.hash(password);
+const isMatch = await argon2.verify(hash, password);
+```
+
+## Injectable Hashing Service
+
+```typescript
+@Injectable()
+export class HashingService {
+  async hash(password: string): Promise<string> {
+    return bcrypt.hash(password, 10);
+  }
+
+  async compare(password: string, hash: string): Promise<boolean> {
+    return bcrypt.compare(password, hash);
+  }
+}
+```
+
+## Key Points
+
+- Use bcrypt or argon2 for passwords (argon2 preferred for new apps)
+- Node.js `crypto` for encryption/decryption
+- Never store plain passwords
+- Use strong salts; bcrypt handles salt internally
+
+<!--
+Source references:
+- https://docs.nestjs.com/security/encryption-and-hashing
+-->

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

@@ -0,0 +1,142 @@
+---
+name: caching
+description: Caching with @nestjs/cache-manager and Redis integration
+---
+
+# Caching
+
+Caching improves performance by storing frequently accessed data for quick retrieval.
+
+## Installation
+
+```bash
+npm install @nestjs/cache-manager cache-manager
+```
+
+## Basic Setup
+
+```typescript
+import { Module } from '@nestjs/common';
+import { CacheModule } from '@nestjs/cache-manager';
+
+@Module({
+  imports: [CacheModule.register()],
+})
+export class AppModule {}
+```
+
+## Interacting with Cache
+
+Inject the cache manager:
+
+```typescript
+import { Injectable, Inject } from '@nestjs/common';
+import { CACHE_MANAGER, Cache } from '@nestjs/cache-manager';
+
+@Injectable()
+export class CatsService {
+  constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
+
+  async getCats() {
+    // Get from cache
+    const cached = await this.cacheManager.get('cats');
+    if (cached) return cached;
+
+    const cats = await this.fetchCats();
+    
+    // Set with TTL (milliseconds)
+    await this.cacheManager.set('cats', cats, 60000);
+    return cats;
+  }
+
+  async clearCache() {
+    await this.cacheManager.del('cats');
+    // Or clear all
+    await this.cacheManager.clear();
+  }
+}
+```
+
+## Auto-caching Responses
+
+Use `CacheInterceptor` for automatic GET endpoint caching:
+
+```typescript
+import { Controller, Get, UseInterceptors } from '@nestjs/common';
+import { CacheInterceptor, CacheKey, CacheTTL } from '@nestjs/cache-manager';
+
+@Controller('cats')
+@UseInterceptors(CacheInterceptor)
+export class CatsController {
+  @Get()
+  @CacheKey('all-cats')
+  @CacheTTL(30000)
+  findAll() {
+    return this.catsService.findAll();
+  }
+}
+```
+
+Global cache interceptor:
+
+```typescript
+@Module({
+  providers: [
+    { provide: APP_INTERCEPTOR, useClass: CacheInterceptor },
+  ],
+})
+export class AppModule {}
+```
+
+## Configuration
+
+```typescript
+CacheModule.register({
+  ttl: 5000,        // Default TTL in milliseconds
+  isGlobal: true,   // Available everywhere without importing
+});
+```
+
+## Redis Integration
+
+Install Redis adapter:
+
+```bash
+npm install @keyv/redis
+```
+
+Configure multiple stores:
+
+```typescript
+import { CacheModule } from '@nestjs/cache-manager';
+import KeyvRedis from '@keyv/redis';
+import { Keyv } from 'keyv';
+import { CacheableMemory } from 'cacheable';
+
+@Module({
+  imports: [
+    CacheModule.registerAsync({
+      useFactory: async () => ({
+        stores: [
+          new Keyv({ store: new CacheableMemory({ ttl: 60000 }) }),
+          new KeyvRedis('redis://localhost:6379'),
+        ],
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## Key Points
+
+- Only GET endpoints are auto-cached
+- `CacheInterceptor` doesn't work with GraphQL field resolvers
+- Use `@CacheKey()` for custom cache keys
+- Set `ttl: 0` for no expiration
+- Works with WebSockets and Microservices
+
+<!--
+Source references:
+- https://docs.nestjs.com/techniques/caching
+-->

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
+-->