Pagination, Filter, File Upload, Error

import base64
import json
from datetime import datetime
from pydantic import BaseModel


def encode_cursor(updated_at: datetime, note_id: int) -> str:
    raw = json.dumps({"u": updated_at.isoformat(), "i": note_id})
    return base64.urlsafe_b64encode(raw.encode()).decode()


def decode_cursor(cursor: str) -> tuple[datetime, int]:
    data = json.loads(base64.urlsafe_b64decode(cursor.encode()))
    return datetime.fromisoformat(data["u"]), data["i"]


class CursorPage(BaseModel):
    items: list[NoteOut]
    next_cursor: str | None          # None মানে শেষ


async def list_after(self, user_id: int, limit: int, cursor: str | None) -> CursorPage:
    stmt = select(Note).where(Note.owner_id == user_id, Note.deleted_at.is_(None))
    if cursor:
        u, i = decode_cursor(cursor)
        # (updated_at, id) জোড়া দিয়ে তুলনা: সমান সময়ের note থাকলেও কিছু বাদ পড়বে না
        stmt = stmt.where(tuple_(Note.updated_at, Note.id) < (u, i))
    stmt = stmt.order_by(Note.updated_at.desc(), Note.id.desc()).limit(limit + 1)  # একটা বেশি আনো
    rows = list(await self.db.scalars(stmt))
    has_more = len(rows) > limit
    rows = rows[:limit]
    next_cursor = encode_cursor(rows[-1].updated_at, rows[-1].id) if has_more else None
    return CursorPage(items=rows, next_cursor=next_cursor)

from enum import StrEnum
from fastapi import Query


class NoteSort(StrEnum):
    UPDATED_DESC = "-updated_at"
    UPDATED_ASC = "updated_at"
    TITLE_ASC = "title"


SORT_MAP = {
    NoteSort.UPDATED_DESC: Note.updated_at.desc(),
    NoteSort.UPDATED_ASC: Note.updated_at.asc(),
    NoteSort.TITLE_ASC: Note.title.asc(),
}


@router.get("")
async def list_notes(
    user: CurrentUser,
    svc: ServiceDep,
    pinned: bool | None = None,
    created_after: datetime | None = None,
    sort: NoteSort = NoteSort.UPDATED_DESC,
): ...

from fastapi import UploadFile, File
import uuid

ALLOWED = {"image/jpeg": ".jpg", "image/png": ".png", "image/webp": ".webp"}
MAX_BYTES = 5 * 1024 * 1024     # ৫ MB


@router.post("/{note_id}/image")
async def upload_image(note_id: int, user: CurrentUser, svc: ServiceDep, file: UploadFile = File(...)):
    if file.content_type not in ALLOWED:
        raise ValidationAppError("শুধু JPG, PNG, WebP")
    data = await file.read(MAX_BYTES + 1)
    if len(data) > MAX_BYTES:
        raise ValidationAppError("ছবি ৫ MB এর বেশি হতে পারবে না")
    # আসল ধরন যাচাই: শুধু content_type বিশ্বাস করো না, file এর প্রথম কয়েক byte দেখো
    key = f"notes/{user.id}/{uuid.uuid4()}{ALLOWED[file.content_type]}"   # নিজের বানানো নাম
    await storage.put(key, data, content_type=file.content_type)
    return await svc.set_image(user.id, note_id, key)

@router.post("/uploads/presign")
async def presign(data: PresignIn, user: CurrentUser):
    key = f"uploads/{user.id}/{uuid.uuid4()}.{data.ext}"
    url = s3.generate_presigned_url(
        "put_object",
        Params={"Bucket": BUCKET, "Key": key, "ContentType": data.content_type},
        ExpiresIn=600,
    )
    return {"upload_url": url, "key": key}

from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException


def register_error_handlers(app: FastAPI) -> None:
    @app.exception_handler(AppError)
    async def app_error(request, exc: AppError):
        return JSONResponse(status_code=exc.status_code,
                            content={"error": {"code": exc.code, "message": exc.message}})

    @app.exception_handler(RequestValidationError)
    async def validation_error(request, exc: RequestValidationError):
        fields = {".".join(str(p) for p in e["loc"][1:]): e["msg"] for e in exc.errors()}
        return JSONResponse(status_code=422,
                            content={"error": {"code": "VALIDATION_ERROR", "message": "তথ্য ঠিক নেই", "fields": fields}})

    @app.exception_handler(StarletteHTTPException)
    async def http_error(request, exc):
        return JSONResponse(status_code=exc.status_code,
                            content={"error": {"code": f"HTTP_{exc.status_code}", "message": str(exc.detail)}})

    @app.exception_handler(Exception)
    async def unhandled(request, exc):
        logger.exception("Unhandled error")          # পুরো traceback log এ
        return JSONResponse(status_code=500,          # কিন্তু client কে ভেতরের কিছু না
                            content={"error": {"code": "INTERNAL_ERROR", "message": "সাময়িক সমস্যা, একটু পরে চেষ্টা করুন"}})

{"error": {"code": "VALIDATION_ERROR", "message": "তথ্য ঠিক নেই",
           "fields": {"title": "String should have at least 1 character"}}}

@router.post("/orders", status_code=201)
async def create_order(
    data: OrderCreate,
    user: CurrentUser,
    svc: OrderServiceDep,
    idempotency_key: str = Header(..., alias="Idempotency-Key", min_length=16, max_length=64),
):
    return await svc.create_idempotent(user.id, idempotency_key, data)

async def create_idempotent(self, user_id: int, key: str, data: OrderCreate) -> Order:
    existing = await self.repo.find_by_idempotency(user_id, key)
    if existing:
        return existing                           # আগে হয়ে গেছে, একই ফল ফেরত
    order = Order(user_id=user_id, idempotency_key=key, **...)
    self.db.add(order)
    try:
        await self.db.commit()                    # (user_id, idempotency_key) এ UNIQUE constraint
    except IntegrityError:
        await self.db.rollback()                  # একসাথে দুইটা এলে দ্বিতীয়টা এখানে
        return await self.repo.find_by_idempotency(user_id, key)
    return order

import uuid
from contextvars import ContextVar

request_id_var: ContextVar[str] = ContextVar("request_id", default="-")


@app.middleware("http")
async def add_request_id(request: Request, call_next):
    rid = request.headers.get("X-Request-ID") or uuid.uuid4().hex[:16]
    request_id_var.set(rid)
    response = await call_next(request)
    response.headers["X-Request-ID"] = rid
    return response