@biggora/claude-plugins 1.2.2 → 1.3.0

package/src/skills/nest-best-practices/SKILL.md

@@ -0,0 +1,251 @@
+---
+name: nest-best-practices
+description: NestJS framework best practices and production patterns. Use whenever working with NestJS — creating modules, controllers, services, DTOs, guards, interceptors, pipes, middleware, or building REST/GraphQL/microservice APIs. Also use when setting up authentication, authorization, validation, queues, health checks, WebSockets, caching, or any @nestjs/* package. Even for simple NestJS tasks, this skill ensures correct import paths, proper decorator usage, and production-ready patterns. Covers NestJS v11 with Express v5, native JWT auth, Zod validation, Keyv caching, and Suites testing.
+---
+
+NestJS is a progressive Node.js framework for building efficient and scalable server-side applications. It uses TypeScript by default, supports both Express and Fastify, and provides an out-of-the-box application architecture inspired by Angular. NestJS combines elements of OOP, FP, and FRP, making it ideal for building enterprise-grade applications.
+
+> Skill based on NestJS documentation, updated 2026-03-28. Covers NestJS v11 with Express v5.
+
+## How to Use This Skill
+
+When generating NestJS code, read the relevant reference files below for the specific topic. The references contain current API patterns, correct import paths, and production-ready examples.
+
+**Always apply the production best practices below** — these are patterns that matter in production and are easy to miss without explicit guidance.
+
+## NestJS v11 Breaking Changes
+
+Be aware of these when generating code for NestJS v11+:
+
+### Node.js v20+ Required
+Node.js v16 and v18 are no longer supported. Always target Node.js v20+.
+
+### Express v5 Route Matching
+NestJS v11 uses Express v5 by default. Route patterns have changed:
+
+| Express v4 (Old) | Express v5 (New) | Notes |
+|---|---|---|
+| `@Get('users/*')` | `@Get('users/*splat')` | Wildcards must be named |
+| `forRoutes('*')` | `forRoutes('{*splat}')` | Braces make path optional (matches root) |
+| `?` optional character | Not supported | Use braces `{}` instead |
+| Regex in routes | Not supported | Regex characters no longer work |
+
+### CacheModule Migration to Keyv
+The `CacheModule` now uses Keyv adapters instead of `cache-manager` stores:
+
+```typescript
+// OLD (pre-v11) — no longer works
+CacheModule.register({ store: redisStore, host: 'localhost', port: 6379 });
+
+// NEW (v11+) — uses @keyv/redis
+import { KeyvRedis } from '@keyv/redis';
+CacheModule.registerAsync({
+  useFactory: async () => ({
+    stores: [new KeyvRedis('redis://localhost:6379')],
+  }),
+});
+```
+
+## Production Best Practices
+
+### Bootstrap & Application Setup
+Configure `ValidationPipe` globally in `main.ts` — this is a security-critical step:
+```typescript
+app.useGlobalPipes(new ValidationPipe({
+  whitelist: true,           // strips unknown properties
+  forbidNonWhitelisted: true, // rejects requests with unknown properties (400)
+  transform: true,            // enables automatic type coercion for params
+}));
+```
+
+### Entity & Schema Discipline
+- Use explicit column lengths: `@Column({ length: 255 })`, not bare `@Column()`
+- Name tables explicitly: `@Entity('books')` to avoid surprises with naming conventions
+- Use `@CreateDateColumn()` and `@UpdateDateColumn()` for automatic timestamps
+- Use specialized validators like `@IsISBN()`, `@IsEmail()`, `@IsUUID()` — not just `@IsString()`
+- Align nullability between entity and DTO: if `@Column({ nullable: true })`, the DTO field should be `@IsOptional()`
+
+### DTO Patterns
+- Import `PartialType` from `@nestjs/swagger` (not `@nestjs/mapped-types`) when using Swagger — this preserves API documentation metadata on partial fields
+- Zod validation is now an officially supported alternative to `class-validator` — use `ZodValidationPipe` with `z.infer<typeof schema>` for schema-first validation with type inference
+
+### Guards & Auth
+NestJS v11 documents two auth approaches:
+1. **Native JWT** (recommended for simpler cases): Use `@nestjs/jwt` directly with a custom `CanActivate` guard that calls `JwtService.verifyAsync()`. No Passport dependency needed.
+2. **Passport-based** (for complex strategies like OAuth2, SAML): Use `@nestjs/passport` with `PassportStrategy`. Now documented under "recipes" rather than primary auth docs.
+
+Regardless of approach:
+- Guard ordering matters: `@UseGuards(JwtAuthGuard, RolesGuard)` — JWT guard must run first to populate `request.user` before RolesGuard reads it
+- Use `Reflector.getAllAndOverride()` (not just `.get()`) so roles can be set at both handler and class level with handler taking precedence
+- RolesGuard must throw `ForbiddenException` with a descriptive message when the user lacks the required role — do NOT just return `false` from `canActivate()`. The generic 403 provides no diagnostic value. Include context: `throw new ForbiddenException(\`Requires roles: \${requiredRoles.join(', ')}\`)`
+- Never hardcode JWT secrets — use `JwtModule.registerAsync()` with `ConfigService`
+- Define a `Role` enum rather than raw strings for type safety
+- In `JwtStrategy.validate()` (or native guard), validate the presence of required payload fields (`sub`, `username`, `roles`) before returning the user object. Define a `JwtPayload` interface for type safety.
+
+### Error Messages
+All thrown exceptions (`ForbiddenException`, `UnauthorizedException`, `NotFoundException`, etc.) should include descriptive messages that identify what was expected, what was found, and what action the consumer should take. Do not rely on framework default messages in production code.
+
+### Microservices & Queues
+- For hybrid apps (HTTP + microservice), use `NestFactory.create()` + `app.connectMicroservice()` pattern
+- Always call `app.enableShutdownHooks()` when using Terminus health checks for graceful shutdown
+- Use `@nestjs/bullmq` (not `@nestjs/bull`) — it wraps the newer `bullmq` library. Config uses `connection` key (not `redis`):
+  ```typescript
+  BullModule.forRoot({ connection: { host: 'localhost', port: 6379 } })
+  ```
+- Use `BullModule.forRootAsync()` with `ConfigService` injection for production config
+- BullMQ consumers extend `WorkerHost` and implement `process()` — do NOT use the `@Process()` decorator (that's the older `@nestjs/bull` API)
+- Register `@OnWorkerEvent('completed')` and `@OnWorkerEvent('failed')` lifecycle hooks for observability
+- Set `removeOnComplete: true` and configure retry with `backoff: { type: 'exponential' }` on jobs
+- Capture and log `job.id` from `queue.add()` return value for traceability
+- Use `job.updateProgress()` for long-running jobs to enable monitoring dashboards
+- Define and export TypeScript interfaces for all event payloads (e.g., `OrderCreatedEvent`, `UserRegisteredEvent`) for type safety across service boundaries
+
+### Health Checks
+- Don't just check one thing — include multiple indicators: service connectivity (Redis/DB), memory (heap + RSS), and disk usage
+- Use `MicroserviceHealthIndicator` for transport checks, `MemoryHealthIndicator` for heap/RSS, `DiskHealthIndicator` for storage
+- Configure graceful shutdown timeout: `TerminusModule.forRoot({ gracefulShutdownTimeoutMs: 1000 })`
+
+### OpenAPI / Swagger
+The `@nestjs/swagger` CLI plugin can eliminate most manual `@ApiProperty()` annotations. Add to `nest-cli.json`:
+```json
+{
+  "compilerOptions": {
+    "plugins": [{
+      "name": "@nestjs/swagger",
+      "options": { "classValidatorShim": true, "introspectComments": true }
+    }]
+  }
+}
+```
+With the plugin enabled, TypeScript types, default values, optional markers, and JSDoc comments are automatically inferred — you only need explicit `@ApiProperty()` for edge cases.
+
+### Testing
+- `@suites/unit` is now a recommended testing library for NestJS:
+  - `TestBed.solitary(Service).compile()` — all dependencies auto-mocked
+  - `TestBed.sociable(Service).expose(RealDep).compile()` — selected real deps
+  - `Mocked<T>` type for full IntelliSense on mock methods
+  - Supports Jest, Vitest, and Sinon
+- For e2e testing, use `@nestjs/testing` with `Test.createTestingModule()` and `supertest`
+
+### Custom Decorators
+- For NestJS 10+, prefer `Reflector.createDecorator<Role[]>()` over `SetMetadata` for custom decorators — it provides better type inference and eliminates the need for a separate metadata key constant
+- The `SetMetadata` pattern still works and is fine for simple cases
+
+## CLI
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| CLI Overview | Scaffolding, building, and running applications | [cli-overview](references/cli-overview.md) |
+| Monorepo & Libraries | Workspaces, apps, shared libraries | [cli-monorepo](references/cli-monorepo.md) |
+
+## Core References
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Controllers | Route handlers, HTTP methods, request/response handling | [core-controllers](references/core-controllers.md) |
+| Modules | Application structure, feature modules, shared modules, dynamic modules | [core-modules](references/core-modules.md) |
+| Providers | Services, dependency injection, custom providers | [core-providers](references/core-providers.md) |
+| Dependency Injection | DI fundamentals, custom providers, scopes | [core-dependency-injection](references/core-dependency-injection.md) |
+| Middleware | Request/response middleware, functional middleware | [core-middleware](references/core-middleware.md) |
+
+## Fundamentals
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Pipes | Data transformation and validation pipes | [fundamentals-pipes](references/fundamentals-pipes.md) |
+| Guards | Authorization guards, role-based access control | [fundamentals-guards](references/fundamentals-guards.md) |
+| Interceptors | Aspect-oriented programming, response transformation | [fundamentals-interceptors](references/fundamentals-interceptors.md) |
+| Exception Filters | Error handling, custom exception filters | [fundamentals-exception-filters](references/fundamentals-exception-filters.md) |
+| Custom Decorators | Creating custom parameter decorators | [fundamentals-custom-decorators](references/fundamentals-custom-decorators.md) |
+| Dynamic Modules | Configurable modules, module configuration | [fundamentals-dynamic-modules](references/fundamentals-dynamic-modules.md) |
+| Execution Context | Accessing request context, metadata reflection | [fundamentals-execution-context](references/fundamentals-execution-context.md) |
+| Provider Scopes | Singleton, request-scoped, transient providers | [fundamentals-provider-scopes](references/fundamentals-provider-scopes.md) |
+| Lifecycle Events | Application and provider lifecycle hooks | [fundamentals-lifecycle-events](references/fundamentals-lifecycle-events.md) |
+| Lazy Loading | Loading modules on-demand for serverless | [fundamentals-lazy-loading](references/fundamentals-lazy-loading.md) |
+| Circular Dependency | Resolving circular dependencies with forwardRef | [fundamentals-circular-dependency](references/fundamentals-circular-dependency.md) |
+| Module Reference | Accessing providers dynamically with ModuleRef | [fundamentals-module-reference](references/fundamentals-module-reference.md) |
+| Testing | Unit testing and e2e testing with @nestjs/testing | [fundamentals-testing](references/fundamentals-testing.md) |
+
+## Techniques
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Validation | ValidationPipe, class-validator, Zod validation | [techniques-validation](references/techniques-validation.md) |
+| Configuration | Environment variables, ConfigModule, configuration management | [techniques-configuration](references/techniques-configuration.md) |
+| Database | TypeORM, Prisma, MongoDB integration | [techniques-database](references/techniques-database.md) |
+| Caching | Keyv-based cache manager, Redis integration | [techniques-caching](references/techniques-caching.md) |
+| Logging | Built-in logger, custom loggers, JSON logging | [techniques-logging](references/techniques-logging.md) |
+| File Upload | File upload handling with multer, validation | [techniques-file-upload](references/techniques-file-upload.md) |
+| Versioning | URI, header, and media type API versioning | [techniques-versioning](references/techniques-versioning.md) |
+| Serialization | Response serialization with class-transformer | [techniques-serialization](references/techniques-serialization.md) |
+| Queues | Background job processing with BullMQ | [techniques-queues](references/techniques-queues.md) |
+| Task Scheduling | Cron jobs, intervals, and timeouts | [techniques-task-scheduling](references/techniques-task-scheduling.md) |
+| Events | Event-driven architecture with EventEmitter | [techniques-events](references/techniques-events.md) |
+| HTTP Module | Making HTTP requests with Axios | [techniques-http-module](references/techniques-http-module.md) |
+| Fastify | Using Fastify for better performance | [techniques-fastify](references/techniques-fastify.md) |
+| Sessions & Cookies | HTTP sessions and cookies for stateful apps | [techniques-sessions-cookies](references/techniques-sessions-cookies.md) |
+| Streaming & SSE | Compression, file streaming, Server-Sent Events | [techniques-compression-streaming-sse](references/techniques-compression-streaming-sse.md) |
+| MVC & Serve Static | Template rendering (Handlebars) and SPA static serving | [techniques-mvc-serve-static](references/techniques-mvc-serve-static.md) |
+
+## Security
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Authentication | Native JWT auth and Passport integration | [recipes-authentication](references/recipes-authentication.md) |
+| Authorization | RBAC, claims-based, CASL integration | [security-authorization](references/security-authorization.md) |
+| CORS & Rate Limiting | CORS, Helmet, ThrottlerModule | [security-cors-helmet-rate-limiting](references/security-cors-helmet-rate-limiting.md) |
+| Encryption & Hashing | bcrypt, argon2, password hashing | [security-encryption-hashing](references/security-encryption-hashing.md) |
+
+## OpenAPI
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Swagger | OpenAPI documentation generation, CLI plugin | [openapi-swagger](references/openapi-swagger.md) |
+
+## WebSockets
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Gateways | Real-time communication with Socket.IO/ws | [websockets-gateways](references/websockets-gateways.md) |
+| Guards & Exception Filters | WsException, BaseWsExceptionFilter, interceptors, pipes | [websockets-advanced](references/websockets-advanced.md) |
+
+## Microservices
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Overview | Transport layers, message patterns, events | [microservices-overview](references/microservices-overview.md) |
+| gRPC | Protocol Buffers, streaming, metadata, reflection | [microservices-grpc](references/microservices-grpc.md) |
+| Transports | Redis, Kafka, NATS, RabbitMQ configuration | [microservices-transports](references/microservices-transports.md) |
+
+## GraphQL
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Overview | Code-first and schema-first approaches | [graphql-overview](references/graphql-overview.md) |
+| Resolvers & Mutations | Queries, mutations, field resolvers | [graphql-resolvers-mutations](references/graphql-resolvers-mutations.md) |
+| Subscriptions | Real-time subscriptions with PubSub | [graphql-subscriptions](references/graphql-subscriptions.md) |
+| Scalars, Unions & Enums | Interfaces, scalars, union types, enums | [graphql-scalars-unions-enums](references/graphql-scalars-unions-enums.md) |
+
+## Recipes
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| CRUD Generator | Nest CLI resource generator | [recipes-crud-generator](references/recipes-crud-generator.md) |
+| Documentation | OpenAPI/Swagger integration | [recipes-documentation](references/recipes-documentation.md) |
+| TypeORM | TypeORM integration and usage | [recipes-typeorm](references/recipes-typeorm.md) |
+| Prisma | Prisma ORM integration | [recipes-prisma](references/recipes-prisma.md) |
+| Mongoose | MongoDB with Mongoose ODM | [recipes-mongoose](references/recipes-mongoose.md) |
+| CQRS | Command Query Responsibility Segregation | [recipes-cqrs](references/recipes-cqrs.md) |
+| Terminus | Health checks and readiness/liveness probes | [recipes-terminus](references/recipes-terminus.md) |
+
+## FAQ
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Raw Body & Hybrid | Webhook signature verification, HTTP + microservices | [faq-raw-body-hybrid](references/faq-raw-body-hybrid.md) |
+
+## Best Practices
+
+| Topic | Description | Reference |
+|-------|-------------|-----------|
+| Request Lifecycle | Understanding execution order and flow | [best-practices-request-lifecycle](references/best-practices-request-lifecycle.md) |

package/src/skills/nest-best-practices/references/best-practices-request-lifecycle.md

@@ -0,0 +1,158 @@
+---
+name: request-lifecycle
+description: Understanding the request processing flow in NestJS
+---
+
+# Request Lifecycle
+
+Understanding execution order helps debug and optimize NestJS applications.
+
+## Lifecycle Flow
+
+```
+1. Incoming Request
+    ↓
+2. Middleware
+    ├── 2.1 Global middleware
+    └── 2.2 Module middleware
+    ↓
+3. Guards
+    ├── 3.1 Global guards
+    ├── 3.2 Controller guards
+    └── 3.3 Route guards
+    ↓
+4. Interceptors (pre-controller)
+    ├── 4.1 Global interceptors
+    ├── 4.2 Controller interceptors
+    └── 4.3 Route interceptors
+    ↓
+5. Pipes
+    ├── 5.1 Global pipes
+    ├── 5.2 Controller pipes
+    ├── 5.3 Route pipes
+    └── 5.4 Route parameter pipes
+    ↓
+6. Controller (method handler)
+    ↓
+7. Service
+    ↓
+8. Interceptors (post-request)
+    ├── 8.1 Route interceptors
+    ├── 8.2 Controller interceptors
+    └── 8.3 Global interceptors
+    ↓
+9. Exception Filters (on error)
+    ├── 9.1 Route filters
+    ├── 9.2 Controller filters
+    └── 9.3 Global filters
+    ↓
+10. Server Response
+```
+
+## Middleware
+
+- **Global first**: `app.use()` runs before module-bound middleware
+- **Sequential**: Runs in order of binding
+- **Module order**: Follows module import order in `AppModule`
+
+## Guards
+
+- Execute in order: Global → Controller → Route
+- Within same level: Order of decorator parameters
+
+```typescript
+@UseGuards(Guard1, Guard2)
+@Controller('cats')
+export class CatsController {
+  @UseGuards(Guard3)
+  @Get()
+  findAll() {}
+}
+// Execution: Guard1 → Guard2 → Guard3
+```
+
+## Interceptors
+
+- **Pre-controller**: Global → Controller → Route
+- **Post-request**: Route → Controller → Global (reverse order)
+- Uses RxJS Observables (first in, last out)
+
+## Pipes
+
+- Execute: Global → Controller → Route → Parameters
+- **Parameters**: Last parameter first
+
+```typescript
+@UsePipes(GeneralPipe)
+@Controller()
+export class CatsController {
+  @UsePipes(RoutePipe)
+  @Patch(':id')
+  update(
+    @Body() body,      // Processed third
+    @Param() params,   // Processed second
+    @Query() query,    // Processed first
+  ) {}
+}
+// GeneralPipe runs on query → params → body
+// Then RoutePipe on query → params → body
+```
+
+## Exception Filters
+
+- **Unique behavior**: Lowest level first (opposite of others)
+- Route → Controller → Global
+- Only one filter handles the exception (no chaining)
+
+```typescript
+@UseFilters(GlobalFilter)
+@Controller()
+@UseFilters(ControllerFilter)
+export class CatsController {
+  @UseFilters(RouteFilter)
+  @Get()
+  findAll() {}
+}
+// If exception: RouteFilter catches first
+// If no route filter: ControllerFilter catches
+// If no controller filter: GlobalFilter catches
+```
+
+## Best Practices
+
+### Middleware
+- Use for logging, authentication setup
+- Modify request/response objects
+- Call `next()` to continue
+
+### Guards
+- Authorization and authentication checks
+- Return `true`/`false` or throw exception
+- Access `ExecutionContext`
+
+### Interceptors
+- Transform response data
+- Add extra logic before/after handler
+- Handle timeouts, caching
+
+### Pipes
+- Validate and transform input data
+- Use `ValidationPipe` for DTOs
+- Throw `BadRequestException` on failure
+
+### Exception Filters
+- Catch and handle errors
+- Format error responses
+- Log errors
+
+## Debugging Tips
+
+1. Add logging at each layer to trace flow
+2. Check guard order if authorization fails
+3. Verify pipe order for validation issues
+4. Use `try/catch` carefully (bypasses filters)
+
+<!--
+Source references:
+- https://docs.nestjs.com/faq/request-lifecycle
+-->

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

@@ -0,0 +1,106 @@
+---
+name: cli-monorepo
+description: NestJS monorepo mode, workspaces, and libraries
+---
+
+# Monorepo and Libraries
+
+## Enable Monorepo
+
+```bash
+nest new my-project
+cd my-project
+nest generate app my-app
+```
+
+This converts to monorepo mode: apps move under `apps/`, shared config at root.
+
+## Structure
+
+```
+apps/
+  my-app/
+    src/
+    tsconfig.app.json
+  my-project/    # default project
+    src/
+    tsconfig.app.json
+nest-cli.json
+package.json
+tsconfig.json
+```
+
+## Generate Library
+
+```bash
+nest generate library shared
+# Or: nest g lib shared
+```
+
+Creates `libs/shared/` with module, service, index. Use `--no-build` to skip build config.
+
+## Library Structure
+
+```
+libs/
+  shared/
+    src/
+      shared.module.ts
+      shared.service.ts
+      index.ts
+```
+
+## Using Library
+
+```typescript
+import { SharedModule } from '@shared';
+
+@Module({
+  imports: [SharedModule],
+})
+export class AppModule {}
+```
+
+Path alias `@shared` is configured in `tsconfig.json` (paths) and `nest-cli.json`.
+
+## Library Options
+
+```bash
+nest g lib shared --prefix=@app
+# Creates @app/shared import path
+```
+
+## Default Project
+
+In monorepo, `nest build` and `nest start` target the default project. Set in `nest-cli.json`:
+
+```json
+{
+  "projects": {
+    "my-app": { "type": "application", ... },
+    "my-project": { "type": "application", "root": "apps/my-project", "entryFile": "main" }
+  },
+  "defaultProject": "my-project"
+}
+```
+
+## Target Specific Project
+
+```bash
+nest build my-app
+nest start my-app
+nest start my-app --watch
+```
+
+## Key Points
+
+- Monorepo: shared `node_modules`, config, build pipeline
+- Library: reusable modules, no `main.ts`
+- Path aliases auto-configured for libraries
+- Default project used when none specified
+
+<!--
+Source references:
+- https://docs.nestjs.com/cli/monorepo
+- https://docs.nestjs.com/cli/libraries
+-->

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