@biggora/claude-plugins 1.2.2 → 1.3.1

package/src/skills/nest-best-practices/references/cli-overview.md

@@ -0,0 +1,157 @@
+---
+name: cli
+description: NestJS CLI for scaffolding, building, and running applications
+---
+
+# Nest CLI
+
+The Nest CLI helps initialize, develop, and maintain NestJS applications.
+
+## Installation
+
+```bash
+npm install -g @nestjs/cli
+# Or use npx
+npx @nestjs/cli@latest
+```
+
+## Common Commands
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `nest new` | `n` | Create new application |
+| `nest generate` | `g` | Generate components |
+| `nest build` | | Compile application |
+| `nest start` | | Run application |
+| `nest add` | | Add library |
+| `nest info` | `i` | Display system info |
+
+## Creating a New Project
+
+```bash
+nest new my-project
+cd my-project
+npm run start:dev
+```
+
+## Generate Components
+
+```bash
+# Generate a module
+nest g module users
+
+# Generate a controller
+nest g controller users
+
+# Generate a service
+nest g service users
+
+# Generate a complete resource (CRUD)
+nest g resource users
+
+# Generate with specific path
+nest g controller users/admin
+
+# Dry run (preview without creating)
+nest g controller users --dry-run
+```
+
+### Generator Schematics
+
+| Schematic | Alias | Description |
+|-----------|-------|-------------|
+| `module` | `mo` | Module |
+| `controller` | `co` | Controller |
+| `service` | `s` | Service |
+| `provider` | `pr` | Provider |
+| `pipe` | `pi` | Pipe |
+| `guard` | `gu` | Guard |
+| `interceptor` | `itc` | Interceptor |
+| `filter` | `f` | Exception filter |
+| `decorator` | `d` | Custom decorator |
+| `gateway` | `ga` | WebSocket gateway |
+| `middleware` | `mi` | Middleware |
+| `resource` | `res` | CRUD resource |
+| `class` | `cl` | Class |
+| `interface` | `itf` | Interface |
+
+## Build and Run
+
+```bash
+# Development with watch mode
+npm run start:dev
+
+# Production build
+npm run build
+npm run start:prod
+
+# Debug mode
+npm run start:debug
+```
+
+## Project Structure
+
+```
+src/
+├── app.controller.ts      # Root controller
+├── app.controller.spec.ts # Controller tests
+├── app.module.ts          # Root module
+├── app.service.ts         # Root service
+└── main.ts                # Entry point
+```
+
+## nest-cli.json Configuration
+
+```json
+{
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true,
+    "webpack": false,
+    "tsConfigPath": "tsconfig.build.json"
+  },
+  "generateOptions": {
+    "spec": true
+  }
+}
+```
+
+## SWC Compiler (10x Faster)
+
+```bash
+npm install -D @swc/cli @swc/core
+```
+
+```json
+// nest-cli.json
+{
+  "compilerOptions": {
+    "builder": "swc"
+  }
+}
+```
+
+## Monorepo Mode
+
+```bash
+# Convert to monorepo
+nest generate app secondary-app
+
+# Generate library
+nest generate library shared
+```
+
+## Key Points
+
+- Use `--dry-run` or `-d` flag to preview changes
+- Use `--flat` flag to skip creating a subdirectory
+- Use `--no-spec` flag to skip test file generation
+- Use SWC for faster builds in development
+- Generators automatically update module imports
+
+<!--
+Source references:
+- https://docs.nestjs.com/cli/overview
+- https://docs.nestjs.com/cli/usages
+-->

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