@biggora/claude-plugins 1.2.2 → 1.3.0

package/src/skills/nest-best-practices/references/core-controllers.md

@@ -0,0 +1,165 @@
+---
+name: core-controllers
+description: NestJS controllers for handling HTTP requests and responses
+---
+
+# Controllers
+
+Controllers are responsible for handling incoming HTTP requests and sending responses back to the client. They use decorators to define routes and handle different HTTP methods.
+
+## Basic Controller
+
+```typescript
+import { Controller, Get } from '@nestjs/common';
+
+@Controller('cats')
+export class CatsController {
+  @Get()
+  findAll(): string {
+    return 'This action returns all cats';
+  }
+}
+```
+
+## HTTP Method Decorators
+
+Nest provides decorators for all standard HTTP methods:
+
+```typescript
+@Controller('cats')
+export class CatsController {
+  @Get()
+  findAll() {
+    return 'All cats';
+  }
+
+  @Post()
+  create() {
+    return 'Create cat';
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string) {
+    return `Update cat ${id}`;
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return `Remove cat ${id}`;
+  }
+
+  @Patch(':id')
+  patch(@Param('id') id: string) {
+    return `Patch cat ${id}`;
+  }
+}
+```
+
+## Request Parameters
+
+Use decorators to extract request data:
+
+```typescript
+@Controller('cats')
+export class CatsController {
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return `Cat ${id}`;
+  }
+
+  @Post()
+  create(@Body() createCatDto: CreateCatDto) {
+    return this.catsService.create(createCatDto);
+  }
+
+  @Get()
+  findAll(@Query('breed') breed?: string) {
+    return this.catsService.findAll(breed);
+  }
+
+  @Get()
+  findWithHeaders(@Headers('authorization') auth: string) {
+    return this.catsService.find(auth);
+  }
+}
+```
+
+## Available Parameter Decorators
+
+- `@Request()`, `@Req()` - Request object
+- `@Response()`, `@Res()` - Response object (use with caution)
+- `@Param(key?: string)` - Route parameters
+- `@Body(key?: string)` - Request body
+- `@Query(key?: string)` - Query parameters
+- `@Headers(name?: string)` - Request headers
+- `@Ip()` - Client IP address
+- `@HostParam()` - Host parameters
+- `@Session()` - Session object
+
+## Status Codes and Headers
+
+```typescript
+@Post()
+@HttpCode(204)
+@Header('Cache-Control', 'no-store')
+create() {
+  return 'Created';
+}
+
+@Get()
+@Redirect('https://nestjs.com', 301)
+redirect() {
+  return;
+}
+```
+
+## Route Wildcards
+
+```typescript
+@Get('abcd/*')
+findAll() {
+  return 'Wildcard route';
+}
+```
+
+## Sub-domain Routing
+
+```typescript
+@Controller({ host: 'admin.example.com' })
+export class AdminController {
+  @Get()
+  index(): string {
+    return 'Admin page';
+  }
+}
+```
+
+## Async Handlers
+
+Controllers can return Promises or Observables:
+
+```typescript
+@Get()
+async findAll(): Promise<Cat[]> {
+  return this.catsService.findAll();
+}
+
+@Get()
+findAll(): Observable<Cat[]> {
+  return of([]);
+}
+```
+
+## Key Points
+
+- Controllers must be registered in a module's `controllers` array
+- Use DTOs (Data Transfer Objects) for request body validation
+- Prefer returning values over using `@Res()` for better compatibility
+- Route parameters should be declared after static paths
+- Use `@HttpCode()` to set custom status codes
+- Use `@Header()` to set custom response headers
+
+<!--
+Source references:
+- https://docs.nestjs.com/controllers
+-->

package/src/skills/nest-best-practices/references/core-dependency-injection.md

@@ -0,0 +1,179 @@
+---
+name: core-dependency-injection
+description: NestJS dependency injection system and custom providers
+---
+
+# Dependency Injection
+
+NestJS uses dependency injection (DI) to manage dependencies between components. The DI container automatically resolves and injects dependencies.
+
+## How DI Works
+
+1. Provider is marked with `@Injectable()`
+2. Consumer declares dependency in constructor
+3. Provider is registered in module's `providers` array
+
+```typescript
+// 1. Define provider
+@Injectable()
+export class CatsService {
+  findAll() {
+    return [];
+  }
+}
+
+// 2. Inject in consumer
+@Controller('cats')
+export class CatsController {
+  constructor(private catsService: CatsService) {}
+}
+
+// 3. Register in module
+@Module({
+  providers: [CatsService],
+  controllers: [CatsController],
+})
+export class CatsModule {}
+```
+
+## Standard Providers
+
+Short-hand syntax:
+
+```typescript
+providers: [CatsService]
+```
+
+Is equivalent to:
+
+```typescript
+providers: [
+  {
+    provide: CatsService,
+    useClass: CatsService,
+  },
+]
+```
+
+## Custom Provider Types
+
+### Value Providers
+
+Inject constant values or mocks:
+
+```typescript
+const mockCatsService = {
+  findAll: () => ['test'],
+};
+
+@Module({
+  providers: [
+    {
+      provide: CatsService,
+      useValue: mockCatsService,
+    },
+  ],
+})
+export class AppModule {}
+```
+
+### Class Providers
+
+Dynamically select implementation:
+
+```typescript
+const configServiceProvider = {
+  provide: ConfigService,
+  useClass: process.env.NODE_ENV === 'development'
+    ? DevelopmentConfigService
+    : ProductionConfigService,
+};
+```
+
+### Factory Providers
+
+Create providers dynamically:
+
+```typescript
+const connectionProvider = {
+  provide: 'CONNECTION',
+  useFactory: (optionsProvider: OptionsProvider, optional?: string) => {
+    const options = optionsProvider.get();
+    return new DatabaseConnection(options);
+  },
+  inject: [OptionsProvider, { token: 'SomeOptionalProvider', optional: true }],
+};
+```
+
+### Alias Providers
+
+Create aliases for existing providers:
+
+```typescript
+const loggerAliasProvider = {
+  provide: 'AliasedLoggerService',
+  useExisting: LoggerService,
+};
+```
+
+## Non-class Tokens
+
+Use strings, symbols, or enums as tokens:
+
+```typescript
+@Module({
+  providers: [
+    {
+      provide: 'CONNECTION',
+      useValue: connection,
+    },
+  ],
+})
+export class AppModule {}
+```
+
+Inject with `@Inject()`:
+
+```typescript
+@Injectable()
+export class CatsRepository {
+  constructor(@Inject('CONNECTION') connection: Connection) {}
+}
+```
+
+## Exporting Custom Providers
+
+Export by token:
+
+```typescript
+@Module({
+  providers: [connectionFactory],
+  exports: ['CONNECTION'],
+})
+export class AppModule {}
+```
+
+Or export the full provider object:
+
+```typescript
+@Module({
+  providers: [connectionFactory],
+  exports: [connectionFactory],
+})
+export class AppModule {}
+```
+
+## Key Points
+
+- DI container resolves dependencies automatically
+- Dependencies are resolved transitively
+- Use `@Inject()` for non-class tokens
+- Factory providers can inject other providers
+- Providers are cached as singletons by default
+- Use `NEST_DEBUG` environment variable for DI debugging
+
+<!--
+Source references:
+- https://docs.nestjs.com/fundamentals/custom-providers
+- https://docs.nestjs.com/providers#dependency-injection
+-->

package/src/skills/nest-best-practices/references/core-middleware.md

@@ -0,0 +1,139 @@
+---
+name: core-middleware
+description: NestJS middleware for request/response processing
+---
+
+# Middleware
+
+Middleware functions are called before route handlers. They have access to request and response objects and can modify them or end the request-response cycle.
+
+## Class-based Middleware
+
+```typescript
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+
+@Injectable()
+export class LoggerMiddleware implements NestMiddleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    console.log('Request...');
+    next();
+  }
+}
+```
+
+## Functional Middleware
+
+For simple middleware without dependencies:
+
+```typescript
+import { Request, Response, NextFunction } from 'express';
+
+export function logger(req: Request, res: Response, next: NextFunction) {
+  console.log('Request...');
+  next();
+}
+```
+
+## Applying Middleware
+
+Use `configure()` method in module:
+
+```typescript
+import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
+import { LoggerMiddleware } from './common/middleware/logger.middleware';
+import { CatsModule } from './cats/cats.module';
+
+@Module({
+  imports: [CatsModule],
+})
+export class AppModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(LoggerMiddleware)
+      .forRoutes('cats');
+  }
+}
+```
+
+## Route-specific Middleware
+
+Apply to specific routes:
+
+```typescript
+consumer
+  .apply(LoggerMiddleware)
+  .forRoutes({ path: 'cats', method: RequestMethod.GET });
+```
+
+## Controller-based Middleware
+
+Apply to entire controller:
+
+```typescript
+consumer
+  .apply(LoggerMiddleware)
+  .forRoutes(CatsController);
+```
+
+## Excluding Routes
+
+Exclude specific routes:
+
+```typescript
+consumer
+  .apply(LoggerMiddleware)
+  .exclude(
+    { path: 'cats', method: RequestMethod.GET },
+    { path: 'cats', method: RequestMethod.POST },
+    'cats/{*splat}',
+  )
+  .forRoutes(CatsController);
+```
+
+## Multiple Middleware
+
+Apply multiple middleware sequentially:
+
+```typescript
+consumer
+  .apply(cors(), helmet(), logger)
+  .forRoutes(CatsController);
+```
+
+## Global Middleware
+
+Apply to all routes:
+
+```typescript
+const app = await NestFactory.create(AppModule);
+app.use(logger);
+await app.listen(3000);
+```
+
+## Route Wildcards
+
+Use wildcards in routes:
+
+```typescript
+consumer
+  .apply(LoggerMiddleware)
+  .forRoutes({
+    path: 'abcd/*splat',
+    method: RequestMethod.ALL,
+  });
+```
+
+## Key Points
+
+- Middleware runs before route handlers
+- Use functional middleware when no dependencies needed
+- Class middleware supports dependency injection
+- Middleware can be route-specific or global
+- Use `exclude()` to skip certain routes
+- Global middleware cannot access DI container
+
+<!--
+Source references:
+- https://docs.nestjs.com/middleware
+-->

package/src/skills/nest-best-practices/references/core-modules.md

@@ -0,0 +1,138 @@
+---
+name: core-modules
+description: NestJS modules for organizing application structure
+---
+
+# Modules
+
+Modules are classes annotated with `@Module()` decorator that organize application components. Every Nest application has at least one root module.
+
+## Basic Module
+
+```typescript
+import { Module } from '@nestjs/common';
+import { CatsController } from './cats.controller';
+import { CatsService } from './cats.service';
+
+@Module({
+  controllers: [CatsController],
+  providers: [CatsService],
+})
+export class CatsModule {}
+```
+
+## Module Properties
+
+- `providers` - Services that can be injected
+- `controllers` - Controllers in this module
+- `imports` - Other modules to import
+- `exports` - Providers to make available to other modules
+
+## Feature Modules
+
+Group related functionality:
+
+```typescript
+@Module({
+  controllers: [CatsController],
+  providers: [CatsService],
+})
+export class CatsModule {}
+```
+
+## Shared Modules
+
+Export providers to share across modules:
+
+```typescript
+@Module({
+  providers: [CatsService],
+  exports: [CatsService],
+})
+export class CatsModule {}
+```
+
+## Global Modules
+
+Make providers available everywhere:
+
+```typescript
+import { Module, Global } from '@nestjs/common';
+
+@Global()
+@Module({
+  providers: [CatsService],
+  exports: [CatsService],
+})
+export class CatsModule {}
+```
+
+## Dynamic Modules
+
+Create configurable modules:
+
+```typescript
+@Module({
+  providers: [Connection],
+  exports: [Connection],
+})
+export class DatabaseModule {
+  static forRoot(entities = [], options?): DynamicModule {
+    const providers = createDatabaseProviders(options, entities);
+    return {
+      module: DatabaseModule,
+      providers: providers,
+      exports: providers,
+    };
+  }
+}
+```
+
+Usage:
+
+```typescript
+@Module({
+  imports: [DatabaseModule.forRoot([User])],
+})
+export class AppModule {}
+```
+
+## Module Re-exporting
+
+Re-export imported modules:
+
+```typescript
+@Module({
+  imports: [CommonModule],
+  exports: [CommonModule],
+})
+export class CoreModule {}
+```
+
+## Module Dependency Injection
+
+Modules can inject providers:
+
+```typescript
+@Module({
+  providers: [CatsService],
+})
+export class CatsModule {
+  constructor(private catsService: CatsService) {}
+}
+```
+
+## Key Points
+
+- Modules encapsulate providers by default
+- Export providers to make them available to other modules
+- Use `@Global()` sparingly - prefer explicit imports
+- Dynamic modules allow runtime configuration
+- Modules are singletons by default
+- Module classes cannot be injected as providers
+
+<!--
+Source references:
+- https://docs.nestjs.com/modules
+- https://docs.nestjs.com/fundamentals/dynamic-modules
+-->