코딩용 프롬프트

Django REST Framework로 전자상거래 주문 관리 API를 개발 중입니다.

# 현재 상황
- Django 4.2, DRF 3.14
- PostgreSQL 데이터베이스
- 동시 접속자 수: 평균 500명, 피크 2000명
- 주문 데이터는 일 평균 1만 건 생성

# 요청사항
Order 모델에 대한 ViewSet을 작성해주세요.

# 요구사항
1. 주문 생성 시 재고 확인 및 차감 (트랜잭션 처리)
2. 페이지네이션 (페이지당 20개)
3. 필터링: 주문 상태, 날짜 범위, 사용자
4. 권한: 본인 주문만 조회 가능 (관리자는 전체 조회)
5. 주문 생성 후 Celery 태스크로 이메일 발송

# 제약사항
- N+1 쿼리 문제 방지 (select_related, prefetch_related 활용)
- 주문 생성 API 응답 시간 < 500ms

# 프로젝트 환경
- 언어: TypeScript 5.3
- 런타임: Node.js 22 LTS
- 프레임워크: Next.js 15 (App Router)
- 스타일링: Tailwind CSS 3.4
- 상태관리: Zustand 4.4
- HTTP 클라이언트: Axios 1.6
- 테스트: Vitest 1.0, Testing Library

# 코드 규칙
- ESLint + Prettier (Airbnb 스타일)
- React Server Components 우선 사용
- Client Component는 "use client" 명시적 선언

Python pandas로 고객 데이터 정제 함수를 작성해주세요.

# 입력 데이터
- CSV 파일: customers.csv
- 컬럼: id, name, email, phone, registration_date, status

# 정제 규칙
1. email: 소문자 변환, 공백 제거, 유효성 검증 (정규식)
2. phone: 숫자만 추출, 10자리 또는 11자리 체크
3. registration_date: 'YYYY-MM-DD' 형식으로 통일
4. 중복 제거: email 기준
5. 결측치 처리:
   - name: 결측 시 행 제거
   - phone: 결측 시 '미등록'으로 채움
   - status: 결측 시 'active'로 채움

# 출력
- 정제된 DataFrame 반환
- 정제 통계 출력 (원본 행 수, 제거된 행 수, 수정된 행 수)

# 성능 요구사항
- 100만 행 처리 시간 < 30초
- 메모리 효율적 처리 (청크 단위 읽기)

TypeScript로 GitHub API 응답을 파싱하는 타입 안전한 함수를 작성해주세요.

// API 엔드포인트
GET https://api.github.com/repos/{owner}/{repo}

// 요구사항
1. Zod 스키마로 응답 검증
2. 필요한 필드만 추출:
   - name, description, stargazers_count, forks_count
   - owner.login, owner.avatar_url
   - created_at, updated_at, pushed_at
3. 날짜는 Date 객체로 변환
4. 에러 처리:
   - 네트워크 에러
   - 응답 스키마 불일치
   - Rate Limit 초과

// 타입 정의
interface RepoInfo {
  name: string;
  description: string | null;
  stars: number;
  forks: number;
  owner: {
    username: string;
    avatarUrl: string;
  };
  dates: {
    created: Date;
    updated: Date;
    pushed: Date;
  };
}

Express.js + TypeScript로 블로그 포스트 CRUD API를 작성해주세요.

// 기술 스택
- Express 4.21
- TypeScript 5.5
- Prisma ORM 6.x (PostgreSQL)
- JWT 인증 (jsonwebtoken)

// 엔드포인트
POST   /api/posts          // 포스트 작성 (인증 필요)
GET    /api/posts          // 포스트 목록 (페이지네이션)
GET    /api/posts/:id      // 포스트 상세
PUT    /api/posts/:id      // 포스트 수정 (본인만 가능)
DELETE /api/posts/:id      // 포스트 삭제 (본인만 가능)

// 비즈니스 로직
1. 작성: 제목(1-200자), 본문(필수), 태그(선택, 최대 5개)
2. 목록: 페이지당 20개, 최신순 정렬, 쿼리 파라미터 필터링
   - tag: 태그로 필터링
   - search: 제목/본문 검색
   - author: 작성자 ID
3. 수정: 부분 수정 지원 (PATCH 의미론)
4. 삭제: soft delete (deletedAt 필드 사용)

// 에러 응답 형식
{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "제목은 1-200자여야 합니다",
    "field": "title"
  }
}

Apollo Server로 GraphQL 스키마와 리졸버를 작성해주세요.

# 스키마
type User {
  id: ID!
  username: String!
  email: String!
  posts: [Post!]!
  createdAt: DateTime!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
  tags: [String!]!
  publishedAt: DateTime
}

type Query {
  user(id: ID!): User
  posts(limit: Int, offset: Int, tag: String): [Post!]!
}

type Mutation {
  createPost(input: CreatePostInput!): Post!
}

# 요구사항
1. DataLoader로 N+1 쿼리 문제 해결
2. 인증: context에서 JWT 토큰 검증
3. 에러 처리: Apollo Server Error 클래스 사용
4. 페이지네이션: limit 기본값 20, 최대 100

React + TypeScript로 데이터 페칭 커스텀 훅을 작성해주세요.

// 기능
- API 호출 상태 관리 (loading, error, data)
- 자동 재시도 (exponential backoff)
- 캐싱 (SWR 패턴)
- 폴링 (선택적)
- AbortController로 요청 취소

// 사용 예시
const { data, error, isLoading, refetch } = useFetch<User[]>({
  url: '/api/users',
  options: {
    retry: 3,
    retryDelay: 1000,
    cache: true,
    cacheTime: 5 * 60 * 1000, // 5분
    poll: 10000, // 10초마다 폴링
  },
});

// 타입 정의
interface UseFetchOptions {
  retry?: number;
  retryDelay?: number;
  cache?: boolean;
  cacheTime?: number;
  poll?: number;
  onSuccess?: (data: any) => void;
  onError?: (error: Error) => void;
}

// 요구사항
- 컴포넌트 언마운트 시 진행 중인 요청 취소
- 캐시는 메모리 기반, LRU 정책 (최대 50개)
- 에러 재시도는 지수 백오프 (1초 → 2초 → 4초)

Vue 3 Composition API로 폼 유효성 검증 컴포저블을 작성해주세요.

// 사용 예시
const { values, errors, validate, reset } = useForm({
  initialValues: {
    email: '',
    password: '',
  },
  validators: {
    email: [
      required('이메일을 입력하세요'),
      email('유효한 이메일을 입력하세요'),
    ],
    password: [
      required('비밀번호를 입력하세요'),
      minLength(8, '8자 이상 입력하세요'),
    ],
  },
});

// 기능
1. 실시간 유효성 검증 (debounce 300ms)
2. 제출 시 전체 필드 검증
3. 필드별 에러 메시지
4. 터치 상태 관리 (blur 시 에러 표시)
5. 비동기 검증 지원 (예: 이메일 중복 확인)

// 내장 밸리데이터
- required, email, minLength, maxLength
- pattern (정규식), custom (사용자 정의)

// 타입 안전성
- TypeScript 제네릭으로 폼 데이터 타입 추론
- 밸리데이터 함수 타입 정의

Python으로 대용량 텍스트에서 패턴 검색 알고리즘을 구현해주세요.

# 알고리즘
Boyer-Moore 알고리즘 또는 KMP 알고리즘 사용

# 요구사항
1. 대소문자 구분 옵션
2. 전체 일치 / 부분 일치 모드
3. 모든 매칭 위치 반환
4. 유니코드 지원

# 함수 시그니처
def search_pattern(
    text: str,
    pattern: str,
    case_sensitive: bool = True,
    whole_word: bool = False
) -> List[int]:
    """패턴 매칭 위치 리스트 반환"""
    pass

# 성능 목표
- 10MB 텍스트 파일에서 100자 패턴 검색 < 1초
- 시간 복잡도: O(n + m) where n=text length, m=pattern length
- 공간 복잡도: O(m)

# 테스트 케이스 포함
- 빈 문자열 처리
- 패턴이 텍스트보다 긴 경우
- 중복 패턴
- 유니코드 문자 (한글, 이모지)

TypeScript로 LRU (Least Recently Used) 캐시를 구현해주세요.

// 요구사항
1. 제네릭 타입 지원
2. O(1) get/put 연산
3. TTL (Time To Live) 지원
4. 메모리 제한 (바이트 단위)
5. 통계 정보 (hit rate, miss rate)

// 인터페이스
interface CacheOptions {
  maxSize: number;        // 최대 항목 수
  maxMemory?: number;     // 최대 메모리 (bytes)
  ttl?: number;           // 기본 TTL (ms)
}

class LRUCache<K, V> {
  constructor(options: CacheOptions);
  get(key: K): V | undefined;
  set(key: K, value: V, ttl?: number): void;
  delete(key: K): boolean;
  clear(): void;
  getStats(): CacheStats;
}

// 구현 힌트
- 내부 자료구조: Map + Doubly Linked List
- TTL 체크: get 시점에 만료 확인
- 메모리 계산: JSON.stringify(value).length 근사치 사용

pytest로 비동기 함수 테스트 코드를 작성해주세요.

# 테스트 대상 함수
async def fetch_user_data(user_id: int) -> Dict:
    """외부 API에서 사용자 데이터 조회"""
    pass

# 테스트 요구사항
1. httpx.AsyncClient 모킹 (respx 라이브러리)
2. 성공 케이스: 정상 응답 검증
3. 실패 케이스:
   - 네트워크 에러 (httpx.NetworkError)
   - 타임아웃 (httpx.TimeoutException)
   - 404 응답
   - 500 응답
4. 재시도 로직 검증 (3회 재시도)
5. 캐싱 동작 검증

# 테스트 구조
- Arrange-Act-Assert 패턴
- Fixture로 공통 설정 분리
- parametrize로 여러 입력값 테스트
- 비동기 테스트: pytest-asyncio 사용

# 커버리지 목표
- Line coverage: 100%
- Branch coverage: 95% 이상

Playwright로 로그인 플로우 E2E 테스트를 작성해주세요.

// 테스트 시나리오
1. 로그인 페이지 접속
2. 이메일/비밀번호 입력
3. "로그인" 버튼 클릭
4. 대시보드로 리다이렉트 확인
5. 사용자 이름 표시 확인

// 요구사항
- Page Object Model 패턴 사용
- 환경변수로 테스트 계정 관리
- 스크린샷 캡처 (실패 시)
- 테스트 격리 (각 테스트 전 로그아웃)
- 모바일 뷰포트 테스트 포함

// Page Object 클래스
class LoginPage {
  constructor(private page: Page) {}

  async goto() { ... }
  async login(email: string, password: string) { ... }
  async getErrorMessage(): Promise<string> { ... }
}

// 에러 케이스
- 잘못된 이메일 형식
- 잘못된 비밀번호
- 빈 필드 제출
- 네트워크 오류 시뮬레이션

[언어]로 [기능]을 구현하는 함수를 작성해주세요.

# 함수 시그니처
def function_name(param1: Type1, param2: Type2) -> ReturnType:
    """함수 설명"""
    pass

# 요구사항
1. [요구사항 1]
2. [요구사항 2]
3. [요구사항 3]

# 제약사항
- [제약사항 1]
- [제약사항 2]

# 예제 입출력
입력: [예제 입력]
출력: [예제 출력]

# 에러 처리
- [예외 상황 1]: [처리 방법]
- [예외 상황 2]: [처리 방법]

[언어]로 [개념/엔티티]를 표현하는 클래스를 작성해주세요.

# 책임 (Responsibility)
이 클래스는 [주요 책임]을 담당합니다.

# 속성 (Attributes)
- [속성1]: [타입] - [설명]
- [속성2]: [타입] - [설명]

# 메서드 (Methods)
- [메서드1]: [설명]
- [메서드2]: [설명]

# 설계 원칙
- SOLID 원칙 준수
- [특정 디자인 패턴] 적용
- 불변성/가변성 여부

# 사용 예시
[코드 예시]

[프레임워크]로 [리소스] [작업] API를 작성해주세요.

# HTTP 메서드 및 경로
[METHOD] /api/[resource]/[path]

# 요청 (Request)
Headers:
  - Authorization: Bearer [token]
  - Content-Type: application/json

Body:
{
  "field1": "value1",
  "field2": "value2"
}

# 응답 (Response)
Success (200):
{
  "data": { ... },
  "message": "success"
}

Error (4xx/5xx):
{
  "error": {
    "code": "ERROR_CODE",
    "message": "에러 메시지"
  }
}

# 비즈니스 로직
1. [검증 규칙]
2. [처리 단계]
3. [부수 효과]

# 권한
- 필요 역할: [role]
- 리소스 소유권 확인: [예/아니오]

다음 코드를 [목표]를 위해 리팩토링해주세요.

# 현재 코드
[기존 코드]

# 문제점
1. [문제점 1]
2. [문제점 2]

# 리팩토링 목표
- [목표 1]: [측정 가능한 기준]
- [목표 2]: [측정 가능한 기준]

# 제약사항
- 기존 API/인터페이스 유지
- 하위 호환성 보장
- [추가 제약사항]

# 적용할 패턴/원칙
- [디자인 패턴 또는 리팩토링 기법]

다음 코드의 버그를 찾아 수정해주세요.

# 문제 코드
[버그가 있는 코드]

# 증상
- 예상 동작: [기대하는 결과]
- 실제 동작: [실제 발생하는 결과]
- 에러 메시지: [에러 메시지 또는 "없음"]

# 재현 방법
1. [단계 1]
2. [단계 2]
3. [단계 3]

# 환경
- [언어/프레임워크] 버전: [버전]
- OS: [운영체제]
- 기타 의존성: [관련 라이브러리]

# 요청사항
1. 버그 원인 설명
2. 수정된 코드
3. 재발 방지 방법 (테스트, 코드 리뷰 포인트 등)

다음 코드의 성능을 최적화해주세요.

# 현재 코드
[최적화 대상 코드]

# 성능 문제
- 현재 성능: [측정값] (예: 10초, 1000 QPS)
- 목표 성능: [목표값]
- 병목 지점: [프로파일링 결과 또는 추정]

# 최적화 제약사항
- 메모리 제한: [제한사항]
- 정확도 유지: [필수/근사 허용]
- 코드 복잡도: [유지보수성 고려사항]

# 최적화 방향
- 알고리즘 개선 (시간 복잡도 감소)
- 데이터 구조 변경
- 캐싱 전략
- 병렬 처리
- [기타 방향]

# 벤치마크 방법
[성능 측정 코드 또는 방법]

[데이터베이스/ORM]로 [작업]을 수행하는 쿼리를 작성해주세요.

# 스키마
Table: users
  - id: INTEGER PRIMARY KEY
  - username: VARCHAR(50)
  - created_at: TIMESTAMP

Table: posts
  - id: INTEGER PRIMARY KEY
  - user_id: INTEGER FOREIGN KEY
  - title: VARCHAR(200)
  - created_at: TIMESTAMP

# 요구사항
[구체적인 쿼리 요구사항]

# 조건
- 필터: [조건]
- 정렬: [정렬 기준]
- 페이지네이션: [있음/없음]
- 집계: [필요한 집계 함수]

# 성능 고려사항
- N+1 쿼리 방지
- 인덱스 활용
- 실행 계획 (EXPLAIN) 포함
- 예상 데이터 크기: [행 수]

[테스트 프레임워크]로 [대상]에 대한 테스트 코드를 작성해주세요.

# 테스트 대상
[함수/클래스/API 코드]

# 테스트 케이스
1. Happy Path:
   - [정상 동작 시나리오]

2. Edge Cases:
   - [경계값 테스트]

3. Error Cases:
   - [예외 상황]

# 테스트 구조
- Arrange: [초기 설정]
- Act: [실행]
- Assert: [검증]

# 모킹
- [모킹 대상]: [모킹 방법]

# 커버리지 목표
- Line coverage: [목표 %]
- Branch coverage: [목표 %]

[언어/프레임워크]로 [비동기 작업]을 구현해주세요.

# 작업 내용
[구체적인 비동기 작업 설명]

# 동시성 모델
- async/await
- Promise/Future
- Callback
- [기타 모델]

# 에러 처리
- 재시도 전략: [exponential backoff 등]
- 타임아웃: [시간 제한]
- 실패 시 폴백: [대체 동작]

# 동시 실행
- 병렬 실행: [여러 작업 동시 실행]
- 순차 실행: [의존성 있는 작업]
- 동시성 제한: [최대 N개]

# 취소 처리
- AbortController/CancellationToken 사용
- 정리 작업 (cleanup)

[서비스/라이브러리]를 [프로젝트]에 통합하는 코드를 작성해주세요.

# 통합 대상
- 서비스: [외부 서비스명] (예: Stripe, SendGrid)
- SDK/라이브러리: [이름 및 버전]

# 통합 목표
[통합을 통해 달성하려는 기능]

# 요구사항
1. 인증: [API 키, OAuth 등]
2. 환경별 설정: [dev/staging/prod]
3. 에러 처리: [재시도, 로깅, 알림]
4. 레이트 리밋 대응: [제한 초과 시 처리]

# 설정 관리
- 환경 변수로 민감 정보 관리
- 설정 파일 구조

# 테스트
- 모킹을 통한 유닛 테스트
- 샌드박스 환경 통합 테스트

## 1단계: 가독성 개선
다음 코드의 가독성을 개선해주세요:
- 변수명을 의미 있게 변경
- 매직 넘버를 상수로 추출
- 복잡한 조건문을 함수로 분리

[코드]

## 2단계: 성능 최적화
1단계에서 개선된 코드의 성능을 최적화해주세요:
- O(n²) → O(n log n) 알고리즘 개선
- 불필요한 루프 제거
- 메모이제이션 적용

## 3단계: 테스트 추가
최종 코드에 대한 유닛 테스트를 작성해주세요:
- 엣지 케이스 포함
- 100% 브랜치 커버리지 목표

이미지 업로드 기능을 구현해주세요.

# 기능 제약사항
- 최대 파일 크기: 10MB
- 지원 형식: JPEG, PNG, WebP
- 최대 동시 업로드: 5개
- 업로드 진행률 표시 필수

# 기술 제약사항
- 프론트엔드: React 18, TypeScript
- 백엔드: AWS S3 직접 업로드 (presigned URL)
- 브라우저: Chrome/Firefox/Safari 최신 2버전

# 성능 제약사항
- 10MB 파일 업로드 시간 < 30초 (일반 인터넷 속도)
- 썸네일 생성: 서버사이드 (Lambda)
- 이미지 최적화: 자동 WebP 변환

# 보안 제약사항
- 파일 타입 검증 (MIME type + 매직 바이트)
- 악성 파일 스캔 (ClamAV)
- CORS 설정
- presigned URL 유효시간: 15분

날짜 범위를 파싱하는 함수를 작성해주세요.

# 예제 1
입력: "2024-01-01 to 2024-01-31"
출력: { start: new Date("2024-01-01"), end: new Date("2024-01-31") }

# 예제 2
입력: "last 7 days"
출력: { start: "7일 전 날짜", end: "오늘 날짜" }

# 예제 3
입력: "this month"
출력: { start: "이번 달 1일", end: "이번 달 마지막 날" }

# 예제 4 (에러)
입력: "invalid date"
출력: throw new Error("Invalid date range format")

# 지원할 형식
- "YYYY-MM-DD to YYYY-MM-DD"
- "last N days/weeks/months"
- "this week/month/year"
- "yesterday/today/tomorrow"

# Step 1: 개발자가 테스트 먼저 작성
# test_email_validator.py
def test_valid_email():
    assert validate_email("user@example.com") == True

def test_missing_at():
    assert validate_email("userexample.com") == False

def test_empty_string():
    assert validate_email("") == False

def test_special_characters():
    assert validate_email("user+tag@example.com") == True

# Step 2: 위 테스트를 AI에게 전달
# "다음 테스트를 모두 통과하는 validate_email 함수를 작성해주세요.
#  빈 문자열과 None 입력에 대한 처리도 포함하세요."

# Step 3: 테스트 실행 후 실패 시 AI에게 피드백
# "test_unicode_domain에서 실패했습니다.
#  결과: AssertionError - 예상 True, 실제 False
#  이 테스트를 통과하도록 수정해주세요."

사용자 검색 기능을 구현해주세요.

# 보안 요구사항 (OWASP Top 10 준수)
1. SQL 주입 방지:
   - 파라미터화된 쿼리 사용 (문자열 연결 금지)
   - ORM 사용 시 raw query 금지
2. XSS 방지:
   - 사용자 입력 이스케이프 처리
   - innerHTML 사용 금지, textContent 사용
3. 인증/권한:
   - API 키 검증 미들웨어
   - rate limiting (분당 100회)
4. 입력 검증:
   - Pydantic/Zod 스키마 검증
   - 최대 길이 제한 (검색어: 200자)
   - 허용 문자만 허용 (정규식)
5. 에러 정보 유출 방지:
   - 스택 트레이스를 로그에만 기록
   - 사용자에게는 일반 에러 메시지만 반환

다음 코드를 리뷰해주세요. 각 항목별로 점수(1-5)와 개선 제안을 포함하세요.

# 리뷰 항목
1. 보안: SQL 주입, XSS, 인증 우회 가능성
2. 성능: N+1 쿼리, 불필요한 리렌더링, 메모리 누수
3. 가독성: 네이밍, 함수 길이, 복잡도
4. 에러 처리: 예외 누락, 에러 메시지 품질
5. 테스트 가능성: 의존성 주입, 모킹 용이성
6. 유지보수성: SOLID 원칙, 결합도/응집도

# 출력 형식
| 항목 | 점수 | 이슈 | 개선 제안 |
|------|------|------|----------|
| 보안 | ... | ... | ... |

[리뷰 대상 코드]

# ✅ 좋은 전략: 핵심 컨텍스트 선별
# 1. 관련 함수/클래스만 포함 (전체 파일 X)
# 2. 인터페이스/타입 정의 먼저 제공
# 3. 기존 코드 패턴을 예시로 제시

다음 인터페이스를 구현해주세요:

# 기존 코드 패턴 (참고용)
interface Repository<T> {
  findAll(filter: Partial<T>): Promise<T[]>;
  findById(id: string): Promise<T | null>;
  create(data: Omit<T, 'id'>): Promise<T>;
}

# ❌ 나쁜 전략: 전체 코드베이스 붙여넣기
# (컨텍스트에 잡음이 섞여 정확도 저하)

"React로 컴포넌트 만들어줘"

"React 18.2 함수형 컴포넌트로 만들어줘 (Hooks 사용)"

# Python 프로젝트
- 모듈/패키지: lowercase_with_underscores
- 클래스: PascalCase
- 함수/변수: snake_case
- 상수: UPPER_SNAKE_CASE
- Private: _leading_underscore

# TypeScript 프로젝트
- 파일명: kebab-case.ts
- 컴포넌트: PascalCase
- 함수/변수: camelCase
- 상수: UPPER_SNAKE_CASE
- 타입/인터페이스: PascalCase
- Enum: PascalCase (값은 UPPER_SNAKE_CASE)

파일 업로드 함수에 다음 에러 처리를 적용해주세요:

# 에러 타입별 처리
1. FileNotFoundError: 사용자에게 "파일을 찾을 수 없습니다" 메시지
2. FileSizeExceeded: "파일 크기는 10MB를 초과할 수 없습니다"
3. InvalidFileType: "지원하지 않는 파일 형식입니다"
4. NetworkError: 3회 재시도 (1초, 2초, 4초 대기)
5. UnknownError: 로그 기록 후 일반 에러 메시지

# 로깅
- 모든 에러는 structlog로 기록
- 에러 레벨: ERROR
- 포함 정보: user_id, file_name, error_type, stack_trace

# 사용자 피드백
- 에러 메시지는 한국어
- 기술적 세부사항은 숨김
- 해결 방법 제시 (가능한 경우)