initial commit

backend/app/routers/libraries.py

@@ -0,0 +1,102 @@
+import os
+from pathlib import Path
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.database import get_db
+from app.models import Library, MediaItem
+from app.schemas import LibraryCreate, LibraryOut, BrowseResult, BrowseEntry
+from app.services import scanner, watcher as watcher_service
+
+router = APIRouter(prefix="/libraries", tags=["libraries"])
+
+
+@router.get("", response_model=list[LibraryOut])
+async def list_libraries(db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(Library))
+    return result.scalars().all()
+
+
+@router.post("", response_model=LibraryOut, status_code=201)
+async def create_library(body: LibraryCreate, db: AsyncSession = Depends(get_db)):
+    path = Path(body.path)
+    if not path.is_dir():
+        raise HTTPException(400, f"Path does not exist or is not a directory: {body.path}")
+
+    existing = await db.execute(select(Library).where(Library.path == str(path)))
+    if existing.scalars().first():
+        raise HTTPException(409, "A library with this path already exists")
+
+    lib = Library(name=body.name, path=str(path))
+    db.add(lib)
+    await db.flush()
+    await db.refresh(lib)
+    lib_id = lib.id
+    lib_path = lib.path
+    await db.commit()
+
+    await scanner.scan_library(lib_id, lib_path, db)
+    watcher_service.start_watcher(lib_id, lib_path)
+
+    async with db.begin():
+        pass
+    result = await db.execute(select(Library).where(Library.id == lib_id))
+    return result.scalars().first()
+
+
+@router.delete("/{library_id}", status_code=204)
+async def delete_library(library_id: int, db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(Library).where(Library.id == library_id))
+    lib = result.scalars().first()
+    if not lib:
+        raise HTTPException(404, "Library not found")
+    watcher_service.stop_watcher(library_id)
+    await db.delete(lib)
+    await db.commit()
+
+
+@router.get("/{library_id}/browse", response_model=BrowseResult)
+async def browse_library(library_id: int, path: str = "", db: AsyncSession = Depends(get_db)):
+    result = await db.execute(select(Library).where(Library.id == library_id))
+    lib = result.scalars().first()
+    if not lib:
+        raise HTTPException(404, "Library not found")
+
+    root = Path(lib.path)
+    target = (root / path).resolve()
+
+    # Path traversal guard
+    if not str(target).startswith(str(root)):
+        raise HTTPException(400, "Invalid path")
+    if not target.is_dir():
+        raise HTTPException(404, "Directory not found")
+
+    # Load all media items in this directory (non-recursive)
+    rel_prefix = path.strip("/")
+    items_result = await db.execute(
+        select(MediaItem).where(
+            MediaItem.library_id == library_id,
+            MediaItem.missing == False,  # noqa: E712
+        )
+    )
+    db_items: dict[str, MediaItem] = {}
+    for item in items_result.scalars().all():
+        db_items[item.rel_path] = item
+
+    entries: list[BrowseEntry] = []
+
+    for entry in sorted(target.iterdir(), key=lambda e: (e.is_file(), e.name.lower())):
+        rel_entry = str(entry.relative_to(root))
+        if entry.is_dir():
+            entries.append(BrowseEntry(name=entry.name, type="dir", rel_path=rel_entry))
+        elif entry.is_file() and rel_entry in db_items:
+            item = db_items[rel_entry]
+            entries.append(BrowseEntry(
+                name=entry.name,
+                type=item.media_type,
+                rel_path=rel_entry,
+                media_item_id=item.id,
+            ))
+
+    return BrowseResult(path=path, entries=entries)