@punks/cli 0.1.16 → 1.0.0

package/dist/skills/frameworks/nestjs/nestjs-expert/references/controllers-routing.md

@@ -0,0 +1,111 @@
+# Controllers & Routing
+
+## Controller with Swagger
+
+```typescript
+import {
+  Controller, Get, Post, Patch, Delete,
+  Body, Param, Query, HttpCode, HttpStatus, UseGuards
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery } from '@nestjs/swagger';
+import { ParseUUIDPipe, ParseIntPipe } from '@nestjs/common';
+
+@Controller('users')
+@ApiTags('users')
+@UseGuards(JwtAuthGuard)
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create user' })
+  @ApiResponse({ status: 201, type: UserDto })
+  @ApiResponse({ status: 400, description: 'Validation failed' })
+  create(@Body() dto: CreateUserDto): Promise<UserDto> {
+    return this.usersService.create(dto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Get all users' })
+  @ApiQuery({ name: 'page', required: false, type: Number })
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  findAll(
+    @Query('page', new ParseIntPipe({ optional: true })) page = 1,
+    @Query('limit', new ParseIntPipe({ optional: true })) limit = 20,
+  ): Promise<UserDto[]> {
+    return this.usersService.findAll({ page, limit });
+  }
+
+  @Get(':id')
+  @ApiParam({ name: 'id', type: 'string', format: 'uuid' })
+  @ApiResponse({ status: 200, type: UserDto })
+  @ApiResponse({ status: 404, description: 'User not found' })
+  findOne(@Param('id', ParseUUIDPipe) id: string): Promise<UserDto> {
+    return this.usersService.findOne(id);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: UpdateUserDto,
+  ): Promise<UserDto> {
+    return this.usersService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseUUIDPipe) id: string): Promise<void> {
+    return this.usersService.remove(id);
+  }
+}
+```
+
+## Nested Routes
+
+```typescript
+@Controller('posts/:postId/comments')
+@ApiTags('comments')
+export class CommentsController {
+  @Get()
+  findAll(@Param('postId', ParseUUIDPipe) postId: string) {
+    return this.commentsService.findByPost(postId);
+  }
+
+  @Post()
+  create(
+    @Param('postId', ParseUUIDPipe) postId: string,
+    @Body() dto: CreateCommentDto,
+  ) {
+    return this.commentsService.create(postId, dto);
+  }
+}
+```
+
+## Global Prefix & Versioning
+
+```typescript
+// main.ts
+const app = await NestFactory.create(AppModule);
+app.setGlobalPrefix('api');
+app.enableVersioning({ type: VersioningType.URI });
+
+// controller.ts
+@Controller({ path: 'users', version: '1' })  // /api/v1/users
+export class UsersV1Controller {}
+
+@Controller({ path: 'users', version: '2' })  // /api/v2/users
+export class UsersV2Controller {}
+```
+
+## Quick Reference
+
+| Decorator | Purpose |
+|-----------|---------|
+| `@Controller('path')` | Define route prefix |
+| `@Get()`, `@Post()` | HTTP method |
+| `@Param('name')` | Path parameter |
+| `@Query('name')` | Query parameter |
+| `@Body()` | Request body |
+| `@HttpCode(201)` | Override status code |
+| `@ApiTags()` | Swagger grouping |
+| `@ApiOperation()` | Endpoint description |
+| `@ApiResponse()` | Document response |

package/dist/skills/frameworks/nestjs/nestjs-expert/references/dtos-validation.md

@@ -0,0 +1,153 @@
+# DTOs & Validation
+
+## DTO Patterns
+
+```typescript
+import {
+  IsEmail, IsString, IsOptional, IsBoolean, IsInt,
+  MinLength, MaxLength, Min, Max, IsUUID, IsEnum,
+  IsArray, ArrayMinSize, ValidateNested, Matches
+} from 'class-validator';
+import { Type, Transform } from 'class-transformer';
+import { ApiProperty, ApiPropertyOptional, PartialType, OmitType, PickType } from '@nestjs/swagger';
+
+export class CreateUserDto {
+  @ApiProperty({ example: 'user@example.com' })
+  @IsEmail()
+  email: string;
+
+  @ApiProperty({ minLength: 8 })
+  @IsString()
+  @MinLength(8)
+  @Matches(/^(?=.*[A-Z])(?=.*\d)/, { message: 'Password must contain uppercase and digit' })
+  password: string;
+
+  @ApiProperty()
+  @IsString()
+  @MinLength(2)
+  @MaxLength(50)
+  name: string;
+
+  @ApiPropertyOptional({ enum: UserRole, default: UserRole.USER })
+  @IsOptional()
+  @IsEnum(UserRole)
+  role?: UserRole = UserRole.USER;
+}
+
+// Partial for updates (all fields optional)
+export class UpdateUserDto extends PartialType(
+  OmitType(CreateUserDto, ['password'] as const)
+) {}
+
+// Pick specific fields
+export class LoginDto extends PickType(CreateUserDto, ['email', 'password'] as const) {}
+```
+
+## Nested Validation
+
+```typescript
+export class CreateOrderDto {
+  @ApiProperty({ type: [OrderItemDto] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => OrderItemDto)
+  items: OrderItemDto[];
+
+  @ApiProperty({ type: AddressDto })
+  @ValidateNested()
+  @Type(() => AddressDto)
+  shippingAddress: AddressDto;
+}
+
+export class OrderItemDto {
+  @IsUUID()
+  productId: string;
+
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  quantity: number;
+}
+```
+
+## Custom Validation
+
+```typescript
+import { registerDecorator, ValidationOptions, ValidationArguments } from 'class-validator';
+
+// Custom decorator
+export function IsStrongPassword(options?: ValidationOptions) {
+  return function (object: object, propertyName: string) {
+    registerDecorator({
+      name: 'isStrongPassword',
+      target: object.constructor,
+      propertyName,
+      options,
+      validator: {
+        validate(value: string) {
+          return /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&]).{8,}$/.test(value);
+        },
+        defaultMessage(): string {
+          return 'Password must contain uppercase, lowercase, digit, and special character';
+        },
+      },
+    });
+  };
+}
+
+// Usage
+@IsStrongPassword()
+password: string;
+```
+
+## Transform & Sanitize
+
+```typescript
+export class QueryDto {
+  @Transform(({ value }) => parseInt(value, 10))
+  @IsInt()
+  @Min(1)
+  page: number = 1;
+
+  @Transform(({ value }) => value?.trim().toLowerCase())
+  @IsString()
+  @IsOptional()
+  search?: string;
+
+  @Transform(({ value }) => value === 'true')
+  @IsBoolean()
+  isActive: boolean = true;
+}
+```
+
+## Enable Validation Globally
+
+```typescript
+// main.ts
+app.useGlobalPipes(new ValidationPipe({
+  whitelist: true,           // Strip unknown properties
+  forbidNonWhitelisted: true, // Throw on unknown properties
+  transform: true,            // Auto-transform types
+  transformOptions: {
+    enableImplicitConversion: true,
+  },
+}));
+```
+
+## Quick Reference
+
+| Decorator | Purpose |
+|-----------|---------|
+| `@IsString()` | String type |
+| `@IsEmail()` | Valid email |
+| `@MinLength(n)` | Min string length |
+| `@IsInt()`, `@Min(n)` | Integer validation |
+| `@IsEnum(Enum)` | Enum value |
+| `@IsOptional()` | Optional field |
+| `@ValidateNested()` | Validate nested object |
+| `@Type(() => Class)` | Transform to class |
+| `@Transform()` | Custom transform |
+| `PartialType()` | All fields optional |
+| `OmitType()` | Exclude fields |
+| `PickType()` | Include only fields |