Validation

from fastkit_core.validation import BaseSchema, min_length, PasswordValidatorMixin
from pydantic import EmailStr

class UserCreate(BaseSchema, PasswordValidatorMixin):
    username: str = min_length(3)
    email:    EmailStr
    password: str    # validated by PasswordValidatorMixin
    age:      int | None = None

{
  "success": false,
  "message": "Validation failed",
  "errors": {
    "username": ["The username must be at least 3 characters"],
    "email":    ["The email must be a valid email address"],
    "password": [
      "Password must be at least 8 characters",
      "Password must contain at least one uppercase letter"
    ]
  }
}

from fastkit_core.validation import BaseSchema
from pydantic import ValidationError

class ProductCreate(BaseSchema):
    name:  str
    price: float

try:
    ProductCreate(name="", price=-10)
except ValidationError as e:
    errors = ProductCreate.format_errors(e)
    # {
    #   "name":  ["String should have at least 1 character"],
    #   "price": ["Input should be greater than 0"]
    # }

from fastkit_core.validation import (
    BaseSchema,
    min_length, max_length, length,
    min_value, max_value, between,
    pattern
)

class ProductCreate(BaseSchema):
    name:      str   = min_length(3)          # at least 3 chars
    sku:       str   = max_length(20)         # at most 20 chars
    excerpt:   str   = length(10, 200)        # between 10–200 chars
    price:     float = min_value(0.01)        # at least 0.01
    stock:     int   = max_value(10_000)      # at most 10,000
    rating:    float = between(1.0, 5.0)      # between 1.0 and 5.0
    hex_color: str   = pattern(r'^#[0-9A-Fa-f]{6}$')

from fastapi import Header, Depends
from fastkit_core.i18n import set_locale

async def detect_language(accept_language: str = Header(default='en')):
    locale = accept_language.split(',')[0].split('-')[0]
    set_locale(locale)

# Apply to individual routes
@app.post("/users", dependencies=[Depends(detect_language)])
def create_user(user: UserCreate): ...

# Or apply globally via middleware
@app.middleware("http")
async def locale_middleware(request: Request, call_next):
    locale = request.headers.get('Accept-Language', 'en')[:2]
    set_locale(locale)
    return await call_next(request)

from fastkit_core.validation import BaseSchema
from fastkit_core.i18n import _
from pydantic import field_validator

class UserCreate(BaseSchema):
    username: str
    bio:      str

    @field_validator('username')
    @classmethod
    def validate_username(cls, v: str) -> str:
        if len(v) < 3:
            raise ValueError(_('validation.username.min_length', min=3))
        if not v.isalnum():
            raise ValueError(_('validation.username.format'))
        return v

    @field_validator('bio')
    @classmethod
    def clean_bio(cls, v: str) -> str:
        v = ' '.join(v.split())           # collapse whitespace
        if len(v) > 500:
            raise ValueError(_('validation.string_too_long', field='bio', max_length=500))
        return v

from pydantic import model_validator
from datetime import date

class EventCreate(BaseSchema):
    title:      str
    start_date: date
    end_date:   date

    @model_validator(mode='after')
    def validate_dates(self):
        if self.end_date < self.start_date:
            raise ValueError(_('validation.end_date_before_start'))
        return self

import re
from typing import ClassVar
from pydantic import field_validator
from fastkit_core.i18n import _

class PhoneValidatorMixin:
    PHONE_PATTERN: ClassVar[str] = r'^\+?1?\d{9,15}$'

    @field_validator('phone')
    @classmethod
    def validate_phone(cls, v: str) -> str:
        if not re.match(cls.PHONE_PATTERN, v):
            raise ValueError(_('validation.phone.format'))
        return v

# Usage — just mix in
class UserCreate(BaseSchema, PhoneValidatorMixin):
    name:  str
    phone: str    # validated automatically

from fastkit_core.validation.errors import raise_validation_error

def create_user(email: str):
    if user_exists(email):
        raise_validation_error('email', 'Email already exists', email)
        # → raises ValidationError for the 'email' field

from fastkit_core.validation.errors import raise_multiple_validation_errors

def validate_transfer(from_account, to_account, amount):
    errors = []

    if not account_exists(from_account):
        errors.append(('from_account', 'Account not found', from_account))

    if not account_exists(to_account):
        errors.append(('to_account', 'Account not found', to_account))

    if amount <= 0:
        errors.append(('amount', 'Amount must be positive', amount))

    if errors:
        raise_multiple_validation_errors(errors)
        # → raises ValidationError with all three fields at once

from fastapi import Request
from fastapi.exceptions import RequestValidationError
from fastkit_core.validation.errors import format_validation_errors
from fastkit_core.http import error_response

@app.exception_handler(RequestValidationError)
async def validation_handler(request: Request, exc: RequestValidationError):
    return error_response(
        message="Validation failed",
        errors=format_validation_errors(exc.errors()),
        status_code=422
    )