Architecture improvements & refactors

backend/app/api/orders.py

@@ -1,61 +1,41 @@
 from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy import asc, desc, func, nullslast, select
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import selectinload
 from typing import Optional
 
 from app.database import get_db
 from app.models.user import User
-from app.models.order import Order
-from app.models.order_state import OrderState
-from app.schemas.order import OrderResponse, OrderDetailResponse, UpdateOrderRequest, LinkOrderRequest, CreateOrderRequest, OrderListResponse, OrderCountsResponse
+from app.schemas.order import (
+    OrderResponse,
+    OrderDetailResponse,
+    UpdateOrderRequest,
+    LinkOrderRequest,
+    CreateOrderRequest,
+    OrderListResponse,
+    OrderCountsResponse,
+)
 from app.api.deps import get_current_user
+from app.services.orders.order_service import (
+    create_order as svc_create_order,
+    list_orders as svc_list_orders,
+    get_order_counts as svc_get_order_counts,
+    get_order_detail as svc_get_order_detail,
+    update_order as svc_update_order,
+    link_orders as svc_link_orders,
+    delete_order as svc_delete_order,
+    OrderNotFoundError,
+    InvalidSortError,
+)
 
 router = APIRouter(prefix="/api/v1/orders", tags=["orders"])
 
-SORTABLE_COLUMNS = {
-    "order_number": Order.order_number,
-    "vendor_name": Order.vendor_name,
-    "carrier": Order.carrier,
-    "status": Order.status,
-    "order_date": Order.order_date,
-    "total_amount": Order.total_amount,
-    "updated_at": Order.updated_at,
-}
-
 
 @router.post("", response_model=OrderResponse, status_code=201)
 async def create_order(
     req: CreateOrderRequest,
     user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
-    order = Order(
-        user_id=user.id,
-        vendor_name=req.vendor_name,
-        order_number=req.order_number,
-        tracking_number=req.tracking_number,
-        carrier=req.carrier,
-        vendor_domain=req.vendor_domain,
-        status=req.status,
-        order_date=req.order_date,
-        total_amount=req.total_amount,
-        currency=req.currency,
-        estimated_delivery=req.estimated_delivery,
-        items=[item.model_dump() for item in req.items] if req.items else None,
-    )
-    db.add(order)
-    await db.flush()
-
-    state = OrderState(
-        order_id=order.id,
-        status=req.status,
-        source_type="manual",
-    )
-    db.add(state)
-    await db.commit()
-    await db.refresh(order)
-    return order
+    return await svc_create_order(db, user.id, req)
 
 
 @router.get("", response_model=OrderListResponse)
@@ -69,39 +49,22 @@ async def list_orders(
     user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
-    query = select(Order).where(Order.user_id == user.id)
-
-    if status:
-        statuses = [s.strip() for s in status.split(",")]
-        query = query.where(Order.status.in_(statuses))
-    if search:
-        search_filter = f"%{search}%"
-        query = query.where(
-            (Order.order_number.ilike(search_filter))
-            | (Order.vendor_name.ilike(search_filter))
-            | (Order.tracking_number.ilike(search_filter))
-            | (Order.carrier.ilike(search_filter))
-            | (Order.vendor_domain.ilike(search_filter))
+    try:
+        result = await svc_list_orders(
+            db, user.id,
+            page=page,
+            per_page=per_page,
+            status=status,
+            search=search,
+            sort_by=sort_by,
+            sort_dir=sort_dir,
         )
-
-    count_query = select(func.count()).select_from(query.subquery())
-    total = (await db.execute(count_query)).scalar() or 0
-
-    if sort_by not in SORTABLE_COLUMNS:
-        raise HTTPException(status_code=422, detail=f"Invalid sort_by. Must be one of: {', '.join(sorted(SORTABLE_COLUMNS))}")
-    if sort_dir not in ("asc", "desc"):
-        raise HTTPException(status_code=422, detail="Invalid sort_dir. Must be 'asc' or 'desc'")
-
-    column = SORTABLE_COLUMNS[sort_by]
-    direction = asc if sort_dir == "asc" else desc
-    query = query.order_by(nullslast(direction(column)))
-    query = query.offset((page - 1) * per_page).limit(per_page)
-    result = await db.execute(query)
-    items = result.scalars().all()
+    except InvalidSortError as e:
+        raise HTTPException(status_code=422, detail=str(e))
 
     return OrderListResponse(
-        items=[OrderResponse.model_validate(i) for i in items],
-        total=total,
+        items=[OrderResponse.model_validate(i) for i in result.items],
+        total=result.total,
         page=page,
         per_page=per_page,
     )
@@ -113,94 +76,56 @@ async def order_counts(
     user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
-    query = select(Order.status, func.count()).where(Order.user_id == user.id)
-
-    if search:
-        search_filter = f"%{search}%"
-        query = query.where(
-            (Order.order_number.ilike(search_filter))
-            | (Order.vendor_name.ilike(search_filter))
-            | (Order.tracking_number.ilike(search_filter))
-            | (Order.carrier.ilike(search_filter))
-            | (Order.vendor_domain.ilike(search_filter))
-        )
-
-    query = query.group_by(Order.status)
-    result = await db.execute(query)
-    counts = dict(result.all())
-
-    total = sum(counts.values())
-    return OrderCountsResponse(
-        total=total,
-        ordered=counts.get("ordered", 0),
-        shipment_preparing=counts.get("shipment_preparing", 0),
-        shipped=counts.get("shipped", 0),
-        in_transit=counts.get("in_transit", 0),
-        out_for_delivery=counts.get("out_for_delivery", 0),
-        delivered=counts.get("delivered", 0),
-    )
+    counts = await svc_get_order_counts(db, user.id, search)
+    return OrderCountsResponse(**counts)
 
 
 @router.get("/{order_id}", response_model=OrderDetailResponse)
-async def get_order(order_id: int, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
-    result = await db.execute(
-        select(Order).where(Order.id == order_id, Order.user_id == user.id).options(selectinload(Order.states))
-    )
-    order = result.scalar_one_or_none()
-    if not order:
+async def get_order(
+    order_id: int,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    try:
+        return await svc_get_order_detail(db, user.id, order_id)
+    except OrderNotFoundError:
         raise HTTPException(status_code=404, detail="Order not found")
-    return order
 
 
 @router.patch("/{order_id}", response_model=OrderResponse)
-async def update_order(order_id: int, req: UpdateOrderRequest, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
-    order = await db.get(Order, order_id)
-    if not order or order.user_id != user.id:
+async def update_order(
+    order_id: int,
+    req: UpdateOrderRequest,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    try:
+        return await svc_update_order(db, user.id, order_id, req)
+    except OrderNotFoundError:
         raise HTTPException(status_code=404, detail="Order not found")
-    old_status = order.status
-    for field, value in req.model_dump(exclude_unset=True).items():
-        setattr(order, field, value)
-
-    # Create OrderState if status changed
-    if req.status and req.status != old_status:
-        state = OrderState(
-            order_id=order.id,
-            status=req.status,
-            source_type="manual",
-        )
-        db.add(state)
-
-    await db.commit()
-    await db.refresh(order)
-    return order
 
 
 @router.post("/{order_id}/link")
-async def link_orders(order_id: int, req: LinkOrderRequest, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
-    source = await db.get(Order, order_id)
-    target = await db.get(Order, req.target_order_id)
-    if not source or source.user_id != user.id or not target or target.user_id != user.id:
+async def link_orders(
+    order_id: int,
+    req: LinkOrderRequest,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    try:
+        source = await svc_link_orders(db, user.id, order_id, req.target_order_id)
+    except OrderNotFoundError:
         raise HTTPException(status_code=404, detail="Order not found")
-    if target.tracking_number and not source.tracking_number:
-        source.tracking_number = target.tracking_number
-    if target.carrier and not source.carrier:
-        source.carrier = target.carrier
-    if target.status and target.status != "ordered":
-        source.status = target.status
-    # Move states from target to source
-    result = await db.execute(select(OrderState).where(OrderState.order_id == target.id))
-    for state in result.scalars().all():
-        state.order_id = source.id
-    await db.delete(target)
-    await db.commit()
-    await db.refresh(source)
     return {"merged_into": source.id}
 
 
 @router.delete("/{order_id}", status_code=204)
-async def delete_order(order_id: int, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
-    order = await db.get(Order, order_id)
-    if not order or order.user_id != user.id:
+async def delete_order(
+    order_id: int,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    try:
+        await svc_delete_order(db, user.id, order_id)
+    except OrderNotFoundError:
         raise HTTPException(status_code=404, detail="Order not found")
-    await db.delete(order)
-    await db.commit()

backend/app/core/module_base.py

@@ -20,3 +20,4 @@ class ModuleInfo:
     is_configured: Callable[[], Awaitable[bool]] | None = None
     status: Callable[[AsyncSession], Awaitable[dict | None]] | None = None
     notify: Callable[[int, str, dict, dict | None, AsyncSession], Awaitable[None]] | None = None
+    analyze: Callable[[dict, AsyncSession], Awaitable[tuple]] | None = None

backend/app/core/module_registry.py

@@ -54,34 +54,44 @@ def discover_modules() -> dict[str, ModuleInfo]:
     return _registered_modules
 
 
-async def has_available_analyser() -> bool:
-    """Return True if at least one analyser module is enabled and configured."""
+async def get_active_analysers() -> list[tuple[str, callable]]:
+    """Return all enabled and configured analyser modules in priority order.
+
+    Returns a list of (module_key, analyze_callable) tuples, ordered by the
+    module priority field. The caller can iterate through them to implement
+    fallback (try the first analyser, fall back to the next on failure, etc.).
+    """
     analyser_modules = get_modules_by_type("analyser")
     if not analyser_modules:
-        return False
+        return []
 
     async with async_session() as db:
         result = await db.execute(
-            select(ModuleConfig).where(
+            select(ModuleConfig)
+            .where(
                 ModuleConfig.module_key.in_(analyser_modules.keys()),
                 ModuleConfig.enabled == True,
             )
+            .order_by(ModuleConfig.priority, ModuleConfig.module_key)
         )
         enabled_configs = result.scalars().all()
 
+    active = []
     for config in enabled_configs:
         info = analyser_modules.get(config.module_key)
-        if info and info.is_configured:
+        if not info or not info.analyze:
+            continue
+        if info.is_configured:
             try:
                 if await info.is_configured():
-                    return True
+                    active.append((config.module_key, info.analyze))
             except Exception:
                 continue
-        elif info:
+        else:
             # Module has no is_configured hook — treat as configured
-            return True
+            active.append((config.module_key, info.analyze))
 
-    return False
+    return active
 
 
 async def sync_module_configs() -> None: