Cursor Composer 多文件重构实战：从混乱到干净的蜕变

วิธีแก้ไขด้วย Cursor Composer

# คำสั่งสำหรับ Cursor Composer
วิเคราะห์โครงสร้างโปรเจกต์ทั้งหมด

Analyze the entire codebase structure. Identify:
1. Duplicate functions across multiple files
2. Inconsistent error handling patterns
3. Hardcoded values that should be configurable
4. Functions that violate single responsibility principle

Focus on: /src/api/, /src/services/, /src/utils/

# ผลลัพธ์จาก AI - โค้ดที่重构แล้ว:
src/api/client.py

import httpx
from typing import Optional, Dict, Any
from functools import lru_cache

class HolySheepAPIClient:
    """
    Centralized API client ที่จัดการทุกอย่าง
    - Automatic retry with exponential backoff
    - Token refresh handling
    - Comprehensive error logging
    """
    
    def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url.rstrip('/')
        self._session = httpx.AsyncClient(
            timeout=30.0,
            limits=httpx.Limits(max_keepalive_connections=20)
        )
    
    async def request(
        self,
        method: str,
        endpoint: str,
        data: Optional[Dict[str, Any]] = None,
        retry_count: int = 3
    ) -> Dict[str, Any]:
        """Universal request method with retry logic"""
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        for attempt in range(retry_count):
            try:
                response = await self._session.request(
                    method=method,
                    url=url,
                    json=data,
                    headers=headers
                )
                response.raise_for_status()
                return response.json()
                
            except httpx.TimeoutException:
                if attempt == retry_count - 1:
                    raise ConnectionError(f"Timeout after {retry_count} attempts")
                    
            except httpx.HTTPStatusError as e:
                if e.response.status_code == 401:
                    raise PermissionError("Invalid API key - please check YOUR_HOLYSHEEP_API_KEY")
                raise

การสร้าง System Prompt สำหรับการ重构

# .cursor/system-prompt-refactor.md

Refactoring Guidelines

Principles
1. **DRY (Don't Repeat Yourself)**: Extract duplicate code to shared modules
2. **Single Responsibility**: Each function/module does one thing well
3. **Type Safety**: Use TypeScript types or Python type hints everywhere
4. **Error Handling**: Always handle errors gracefully with meaningful messages

Code Standards
- Use async/await for all I/O operations
- Implement retry logic with exponential backoff
- Log errors with context (user_id, timestamp, stack trace)
- Never hardcode sensitive values - use environment variables

File Organization
src/
├── api/           # API clients only
├── services/      # Business logic
├── utils/         # Pure utility functions
├── types/         # Type definitions
└── config/        # Configuration management


Error Patterns to Fix
❌ No error handling → ✅ Try/catch with specific exceptions
❌ Hardcoded URLs → ✅ Configurable base URLs
❌ Duplicate code → ✅ Extract to shared modules
❌ Magic numbers → ✅ Named constants

การจัดการ Multiple Files พร้อมกัน

# คำสั่งสำหรับการ重构หลายไฟล์:

Refactor all API-related files to use the new HolySheepAPIClient:

1. Update /src/api/users.py to use the centralized client
2. Update /src/api/orders.py to use the centralized client  
3. Update /src/api/products.py to use the centralized client
4. Create /src/config/api_config.py for API configuration

Ensure:
- All files import from the same client module
- Remove duplicate code from each file
- Add proper TypeScript/Python type hints
- Update all error handling to use the unified pattern

ผลลัพธ์หลังการ重构

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. ConnectionError: Timeout หลังจาก Retry หลายครั้ง

# ❌ สาเหตุ: ไม่มีการตั้งค่า timeout ที่เหมาะสม
response = requests.get(url)

✅ แก้ไข: กำหนด timeout ทั้ง connect และ read
response = httpx.get(
    url,
    timeout=httpx.Timeout(10.0, connect=5.0)
)

หรือใช้ retry logic ที่ถูกต้อง
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
async def fetch_with_retry(url: str):
    async with httpx.AsyncClient() as client:
        return await client.get(url)

2. 401 Unauthorized - API Key ไม่ถูกต้อง

# ❌ สาเหตุ: API key ไม่ได้รับการตรวจสอบก่อนใช้งาน
headers = {"Authorization": f"Bearer {api_key}"}

✅ แก้ไข: ตรวจสอบ key format และ validate ก่อน
def validate_api_key(api_key: str) -> bool:
    if not api_key:
        raise ValueError("API key is required")
    if not api_key.startswith("hs_"):
        raise ValueError("Invalid API key format - must start with 'hs_'")
    if len(api_key) < 32:
        raise ValueError("API key too short")
    return True

ใช้ใน client initialization
self.api_key = YOUR_HOLYSHEEP_API_KEY  # จาก environment variable
validate_api_key(self.api_key)

3. Memory Leak จาก AsyncClient ไม่ถูกปิด

# ❌ สาเหตุ: ไม่ปิด session หลังใช้งาน
async def bad_example():
    client = httpx.AsyncClient()
    response = await client.get(url)
    # client never closed - memory leak!

✅ แก้ไข: ใช้ context manager หรือ explicit close
async def good_example():
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        return response.json()
    # client automatically closed

หรือ explicit cleanup
async def explicit_cleanup():
    client = httpx.AsyncClient()
    try:
        response = await client.get(url)
        return response.json()
    finally:
        await client.aclose()

4. Rate Limit Exceeded

# ❌ สาเหตุ: ส่ง request มากเกินไปโดยไม่มีการจำกัด
for item in items:
    await client.post("/process", data=item)

✅ แก้ไข: ใช้ semaphore เพื่อจำกัด concurrency
import asyncio

async def limited_requests(items: list, max_concurrent: int = 5):
    semaphore = asyncio.Semaphore(max_concurrent)
    
    async def bounded_request(item):
        async with semaphore:
            return await client.post("/process", data=item)
    
    tasks = [bounded_request(item) for item in items]
    return await asyncio.gather(*tasks)

สรุป