Database

from fastkit_core.database import Base, IntIdMixin, TimestampMixin, SoftDeleteMixin
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy import String

class User(Base, IntIdMixin, TimestampMixin, SoftDeleteMixin):
    # __tablename__ is auto-generated as 'users'
    username:  Mapped[str] = mapped_column(String(50), unique=True)
    email:     Mapped[str] = mapped_column(String(255), unique=True)
    full_name: Mapped[str] = mapped_column(String(200))

from contextlib import asynccontextmanager
from fastapi import FastAPI
from fastkit_core.database import init_database, shutdown_database, get_db_manager
from fastkit_core.config import ConfigManager

@asynccontextmanager
async def lifespan(app: FastAPI):
    config = ConfigManager()
    init_database(config)
    Base.metadata.create_all(get_db_manager().engine)
    yield
    shutdown_database()

app = FastAPI(lifespan=lifespan)

from fastapi import Depends
from fastkit_core.database import Repository, get_db
from sqlalchemy.orm import Session

@app.get("/users")
def list_users(session: Session = Depends(get_db)):
    repo = Repository(User, session)
    return [u.to_dict() for u in repo.get_all(limit=20)]

from fastkit_core.database import Base

class Product(Base):
    name:  Mapped[str]   = mapped_column(String(200))
    price: Mapped[float]

# Auto table names:
# User        → users
# UserProfile → user_profiles
# Category    → categories

# Serialization
product.to_dict()                              # {'id':1, 'name':'Widget', 'price':9.99}
product.to_dict(exclude=['price'])             # {'id':1, 'name':'Widget'}
product.to_dict(include_relationships=True)   # includes related objects
product.update_from_dict({'name': 'New'})
product.update_from_dict(data, allow_only=['name', 'price'])  # safe update

from fastkit_core.database import BaseWithTimestamps

class Article(BaseWithTimestamps):
    title:   Mapped[str]
    content: Mapped[str]
# Automatically has: id, created_at, updated_at

# config/database.py
CONNECTIONS = {
    'default': {
        'driver':   'postgresql',
        'host':     'localhost',
        'port':     5432,
        'database': 'myapp',
        'username': 'user',
        'password': 'secret',
        'pool_size':    5,
        'max_overflow': 10,
    },

    # Read replica — auto-used by get_read_db / read_session()
    'read_replica_1': {
        'driver':   'postgresql',
        'host':     'replica1.example.com',
        'database': 'myapp',
        'username': 'readonly',
        'password': 'secret',
    },

    # Direct URL
    'analytics': {
        'url': 'postgresql://user:pass@analytics-db:5432/analytics'
    },

    # SQLite
    'local': {
        'driver':   'sqlite',
        'database': 'dev.db'
    }
}

init_database(
    config,
    connection_name='default',
    read_replicas=['read_replica_1', 'read_replica_2']
)

from fastkit_core.database import Repository

repo = Repository(User, session)

# ── Create ────────────────────────────────────
user  = repo.create({'name': 'Alice', 'email': 'alice@example.com'})
users = repo.create_many([{'name': 'Bob'}, {'name': 'Carol'}])
user  = repo.create({'name': 'Dave'}, commit=False)  # manual commit

# ── Read ──────────────────────────────────────
user  = repo.get(1)                  # by ID, None if missing
user  = repo.get_or_404(1)           # raises NotFoundException if missing
users = repo.get_all()               # all records
users = repo.get_all(limit=100)
user  = repo.first(email='a@b.com')  # first match
exists = repo.exists(email='a@b.com')
total  = repo.count(status='active')

# ── Update ────────────────────────────────────
user  = repo.update(1, {'name': 'Alice Smith'})
count = repo.update_many(filters={'status': 'pending'}, data={'status': 'active'})

# ── Delete ────────────────────────────────────
repo.delete(1)                  # soft delete if SoftDeleteMixin
repo.delete(1, force=True)      # hard delete always
count = repo.delete_many({'status': 'inactive'})

# ── Transaction control ───────────────────────
repo.commit()
repo.rollback()
repo.flush()

# Simple equality
users = repo.filter(status='active')

# Comparisons
adults = repo.filter(age__gte=18, age__lt=65)

# String patterns
users = repo.filter(email__ilike='%@gmail.com')
users = repo.filter(name__startswith='J')
users = repo.filter(name__contains='doe')

# Lists
users = repo.filter(status__in=['active', 'pending'])
users = repo.filter(role__not_in=['banned', 'deleted'])

# NULL checks
users = repo.filter(verified_at__is_null=True)
users = repo.filter(email__is_not_null=True)

# Range
products = repo.filter(price__between=(10, 100))

# Ordering, limit, offset
users = repo.filter(
    status='active',
    age__gte=18,
    _order_by='-created_at',  # '-' prefix = DESC
    _limit=20,
    _offset=40
)

users, meta = repo.paginate(
    page=2,
    per_page=20,
    _order_by='-created_at',
    status='active',
    age__gte=18
)

print(meta)
# {
#   'page':        2,
#   'per_page':    20,
#   'total':       150,
#   'total_pages': 8,
#   'has_next':    True,
#   'has_prev':    True
# }

from sqlalchemy.orm import selectinload

# ❌ Without eager loading — N+1 problem
users = repo.get_all()          # 1 query
for user in users:
    print(user.posts)           # +1 query per user!

# ✅ With eager loading — 2 queries total
users = repo.get_all(load_relations=[selectinload(User.posts)])
for user in users:
    print(user.posts)           # already loaded

# Multiple relationships
invoice = repo.get(
    invoice_id,
    load_relations=[
        selectinload(Invoice.client),
        selectinload(Invoice.items),
        selectinload(Invoice.payments),
    ]
)

# Nested relationships
invoices = repo.get_all(load_relations=[
    selectinload(Invoice.items)
        .selectinload(InvoiceItem.product)
        .selectinload(Product.category)
])

# Works with all read methods
repo.get(id, load_relations=[...])
repo.get_all(load_relations=[...])
repo.filter(_load_relations=[...], **filters)
repo.paginate(page=1, per_page=20, _load_relations=[...])

from fastkit_core.database import AsyncRepository, get_async_db, get_async_read_db
from sqlalchemy.ext.asyncio import AsyncSession

# Read endpoint using replica
@app.get("/users")
async def list_users(session: AsyncSession = Depends(get_async_read_db)):
    repo = AsyncRepository(User, session)
    users, meta = await repo.paginate(page=1, per_page=20, status='active')
    return {'items': [u.to_dict() for u in users], 'pagination': meta}

# Write endpoint
@app.post("/users")
async def create_user(data: UserCreate, session: AsyncSession = Depends(get_async_db)):
    repo = AsyncRepository(User, session)
    user = await repo.create(data.model_dump())
    return user.to_dict()

# All methods are awaitable
user   = await repo.get(1)
user   = await repo.get_or_404(1)
users  = await repo.get_all(limit=100)
users  = await repo.filter(status='active', _order_by='-created_at')
exists = await repo.exists(email='a@b.com')
count  = await repo.count(status='active')
user   = await repo.update(1, {'name': 'New'})
await repo.delete(1)

from fastkit_core.database import Base, IntIdMixin, TranslatableMixin
from sqlalchemy import JSON

class Article(Base, IntIdMixin, TranslatableMixin):
    __translatable__    = ['title', 'content']   # fields to translate
    __fallback_locale__ = 'en'                   # fallback if locale missing

    title:   Mapped[dict] = mapped_column(JSON)
    content: Mapped[dict] = mapped_column(JSON)
    status:  Mapped[str]  = mapped_column(String(20), default='draft')

# Store translations
article.title = {"en": "Hello World", "es": "Hola Mundo", "fr": "Bonjour le Monde"}

# Get for a specific locale
article.set_locale('es')
print(article.title)                      # "Hola Mundo"
print(article.get_translation('title'))   # "Hola Mundo"

# Get with fallback
article.get_translation('title', locale='de', fallback=True)  # falls back to 'en'

# Serialization with locale
article.to_dict(locale='es')              # all translatable fields in Spanish

# Validation
errors = article.validate_translations(required_locales=['en', 'es'])
# {'title': ['es translation missing'], 'content': []}

# Global locale (e.g. set from request header)
Article.set_global_locale('fr')
print(article.title)  # "Bonjour le Monde"

from fastkit_core.database import set_locale_from_request

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