interloper-api 0.2.0__py3-none-any.whl

interloper_api/routes/assets.py

@@ -0,0 +1,304 @@
+"""Assets API: CRUD endpoints for assets and dependencies."""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from interloper.errors import DataNotFoundError, NotFoundError
+from interloper_db import Profile, Store
+from interloper_db.models import Asset, AssetResource, Destination, DestinationResource
+from pydantic import BaseModel
+from sqlmodel import Session, select
+
+from interloper_api.dependencies import get_org_id, get_store, require_editor, require_viewer
+
+router = APIRouter()
+
+
+# -- Request/Response models --------------------------------------------------
+
+
+class AssetCreateRequest(BaseModel):
+    """Request body for creating a standalone asset."""
+
+    key: str
+    config: dict[str, Any] | None = None
+    resources: dict[str, str] | None = None
+    destination_ids: list[str] | None = None
+
+
+class AssetUpdateRequest(BaseModel):
+    """Request body for updating an asset."""
+
+    materializable: bool | None = None
+    config: dict[str, Any] | None = None
+    resources: dict[str, str] | None = None
+    destination_ids: list[str] | None = None
+
+
+class DestinationResponse(BaseModel):
+    """Nested destination in asset response."""
+
+    id: UUID
+    key: str
+    name: str | None = None
+    config: dict[str, Any] | None = None
+    resources: dict[str, str] = {}
+    created_at: str | None = None
+
+
+class AssetResponse(BaseModel):
+    """Response body for an asset."""
+
+    id: UUID
+    source_id: UUID | None
+    org_id: UUID
+    key: str
+    materializable: bool
+    config: dict[str, Any] | None = None
+    resources: dict[str, str] = {}
+    destinations: list[DestinationResponse] = []
+    created_at: str | None = None
+
+
+class DependencyResponse(BaseModel):
+    """Response body for an asset dependency edge."""
+
+    asset_id: UUID
+    upstream_asset_id: UUID
+
+
+class AddDependencyRequest(BaseModel):
+    """Request body for adding an asset dependency."""
+
+    upstream_asset_id: UUID
+    param_name: str
+
+
+class PartitionRowCountItem(BaseModel):
+    """A single partition row count entry."""
+
+    partition: str
+    row_count: int
+
+
+class PartitionRowCountsResponse(BaseModel):
+    """Response body for partition row counts."""
+
+    asset_key: str
+    partition_column: str
+    counts: list[PartitionRowCountItem]
+
+
+# -- Helpers ------------------------------------------------------------------
+
+
+def _resource_map(junction_cls: type, fk_column: str, fk_value: UUID) -> dict[str, str]:
+    """Build a {slot_key: resource_id} map from junction rows."""
+    from interloper_db.engine import get_engine
+
+    col = getattr(junction_cls, fk_column)
+    with Session(get_engine()) as s:
+        rows = s.exec(select(junction_cls).where(col == fk_value)).all()
+    return {r.key: str(r.resource_id) for r in rows}
+
+
+def _dest_to_response(dest: Destination) -> DestinationResponse:
+    return DestinationResponse(
+        id=dest.id,  # type: ignore[arg-type]
+        key=dest.key,
+        name=dest.name,
+        config=dest.config,
+        resources=_resource_map(DestinationResource, "destination_id", dest.id),  # type: ignore[arg-type]
+        created_at=str(dest.created_at) if dest.created_at else None,
+    )
+
+
+def _asset_to_response(asset: Asset) -> AssetResponse:
+    """Convert a DB Asset to an AssetResponse."""
+    return AssetResponse(
+        id=asset.id,  # type: ignore[arg-type]
+        source_id=asset.source_id,
+        org_id=asset.org_id,
+        key=asset.key,
+        materializable=asset.materializable,
+        config=asset.config,
+        resources=_resource_map(AssetResource, "asset_id", asset.id),  # type: ignore[arg-type]
+        destinations=[_dest_to_response(d) for d in asset.destinations],
+        created_at=str(asset.created_at) if asset.created_at else None,
+    )
+
+
+# -- CRUD endpoints -----------------------------------------------------------
+
+
+@router.get("/")
+def list_assets(
+    user: Profile = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[AssetResponse]:
+    """List all assets for the current organisation."""
+    assets = store.list_assets(org_id)
+    return [_asset_to_response(a) for a in assets]
+
+
+@router.post("/", status_code=201)
+def create_asset(
+    body: AssetCreateRequest,
+    user: Profile = Depends(require_editor),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> AssetResponse:
+    """Create a standalone asset."""
+    asset = store.create_asset(
+        org_id,
+        key=body.key,
+        config=body.config,
+        resources=body.resources,
+        destination_ids=body.destination_ids,
+    )
+    return _asset_to_response(asset)
+
+
+@router.get("/dependencies")
+def list_dependencies(
+    user: Profile = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[DependencyResponse]:
+    """List all asset dependency edges for the current organisation."""
+    deps = store.list_dependencies(org_id)
+    return [
+        DependencyResponse(
+            asset_id=d.asset_id,
+            upstream_asset_id=d.upstream_asset_id,
+        )
+        for d in deps
+    ]
+
+
+@router.get("/{asset_id}")
+def get_asset(
+    asset_id: UUID,
+    user: Profile = Depends(require_viewer),
+    store: Store = Depends(get_store),
+) -> AssetResponse:
+    """Get a single asset by ID."""
+    try:
+        asset = store.get_asset(asset_id)
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Asset {asset_id} not found")
+    return _asset_to_response(asset)
+
+
+@router.put("/{asset_id}")
+def update_asset(
+    asset_id: UUID,
+    body: AssetUpdateRequest,
+    user: Profile = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> AssetResponse:
+    """Update an asset's configuration, resources, or destinations."""
+    try:
+        asset = store.update_asset(
+            asset_id,
+            materializable=body.materializable,
+            config=body.config,
+            resources=body.resources,
+            destination_ids=body.destination_ids,
+        )
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Asset {asset_id} not found")
+    return _asset_to_response(asset)
+
+
+@router.delete("/{asset_id}")
+def delete_asset(
+    asset_id: UUID,
+    user: Profile = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> dict[str, str]:
+    """Delete a standalone asset."""
+    try:
+        store.delete_asset(asset_id)
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Asset {asset_id} not found")
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    return {"status": "deleted"}
+
+
+# -- Dependency endpoints -----------------------------------------------------
+
+
+@router.post("/{asset_id}/dependencies", status_code=201)
+def add_dependency(
+    asset_id: UUID,
+    body: AddDependencyRequest,
+    user: Profile = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> DependencyResponse:
+    """Add a dependency between two assets."""
+    try:
+        dep = store.add_dependency(asset_id, body.upstream_asset_id, body.param_name)
+    except NotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    return DependencyResponse(
+        asset_id=dep.asset_id,
+        upstream_asset_id=dep.upstream_asset_id,
+    )
+
+
+@router.delete("/{asset_id}/dependencies/{upstream_asset_id}", status_code=204)
+def remove_dependency(
+    asset_id: UUID,
+    upstream_asset_id: UUID,
+    user: Profile = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> None:
+    """Remove an asset dependency."""
+    try:
+        store.remove_dependency(asset_id, upstream_asset_id)
+    except NotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+# -- Partition endpoint -------------------------------------------------------
+
+
+@router.get("/{asset_id}/partition-row-counts")
+def get_partition_row_counts(
+    asset_id: UUID,
+    user: Profile = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> PartitionRowCountsResponse:
+    """Get row counts grouped by partition for an asset."""
+    try:
+        il_asset = store.load_asset(asset_id)
+    except NotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+    if not il_asset.partitioning:
+        raise HTTPException(status_code=400, detail="Asset is not partitioned")
+
+    try:
+        counts = il_asset.partition_row_counts()
+    except NotImplementedError:
+        raise HTTPException(status_code=400, detail="Destination does not support partition row counts")
+    except DataNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    return PartitionRowCountsResponse(
+        asset_key=il_asset.key,
+        partition_column=il_asset.partitioning.column,
+        counts=[
+            PartitionRowCountItem(partition=str(k), row_count=v)
+            for k, v in sorted(counts.items())
+        ],
+    )

interloper_api/routes/auth.py

@@ -0,0 +1,241 @@
+"""Authentication routes — Google OAuth, session management."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from urllib.parse import urlencode
+from uuid import UUID
+
+import httpx
+from fastapi import APIRouter, Cookie, Depends, HTTPException, Response
+from fastapi.responses import RedirectResponse
+from interloper_db import Organisation, Profile, Store
+from pydantic import BaseModel
+
+from interloper_api.dependencies import get_auth_config, get_current_user, get_store
+
+GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth"
+GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token"
+GOOGLE_USERINFO_URL = "https://www.googleapis.com/oauth2/v2/userinfo"
+
+router = APIRouter(prefix="/auth", tags=["auth"])
+
+
+class OrganisationResponse(BaseModel):
+    """Organisation summary for auth responses."""
+
+    id: UUID
+    name: str
+    created_at: datetime | None = None
+
+
+class AuthUserResponse(BaseModel):
+    """Current user with active organisation context."""
+
+    id: UUID
+    email: str
+    name: str | None = None
+    avatar_url: str | None = None
+    role: str
+    organisation: OrganisationResponse | None = None
+    last_organisation_id: UUID | None = None
+
+
+@router.get("/google")
+def google_login(
+    redirect: str | None = None,
+    auth_config: object = Depends(get_auth_config),
+) -> RedirectResponse:
+    """Redirect user to Google's OAuth consent screen."""
+    client_id = auth_config.google_client_id  # type: ignore[attr-defined]
+    redirect_uri = auth_config.google_redirect_uri  # type: ignore[attr-defined]
+
+    if not client_id:
+        raise HTTPException(status_code=500, detail="Google OAuth not configured")
+
+    params = urlencode(
+        {
+            "client_id": client_id,
+            "redirect_uri": redirect_uri,
+            "response_type": "code",
+            "scope": "openid email profile",
+            "access_type": "offline",
+            "prompt": "consent",
+            "state": redirect or "/",
+        }
+    )
+    return RedirectResponse(url=f"{GOOGLE_AUTH_URL}?{params}")
+
+
+@router.get("/google/callback")
+def google_callback(
+    code: str,
+    state: str | None = None,
+    store: Store = Depends(get_store),
+    auth_config: object = Depends(get_auth_config),
+) -> RedirectResponse:
+    """Exchange Google authorization code for tokens, upsert profile, create session."""
+    client_id = auth_config.google_client_id  # type: ignore[attr-defined]
+    client_secret = auth_config.google_client_secret  # type: ignore[attr-defined]
+    redirect_uri = auth_config.google_redirect_uri  # type: ignore[attr-defined]
+    cookie_secure: bool = auth_config.cookie_secure  # type: ignore[attr-defined]
+    session_expiry_days: int = auth_config.session_expiry_days  # type: ignore[attr-defined]
+
+    if not client_id or not client_secret:
+        raise HTTPException(status_code=500, detail="Google OAuth not configured")
+
+    # Exchange code for tokens
+    token_resp = httpx.post(
+        GOOGLE_TOKEN_URL,
+        data={
+            "code": code,
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "redirect_uri": redirect_uri,
+            "grant_type": "authorization_code",
+        },
+    )
+    if token_resp.status_code != 200:
+        raise HTTPException(status_code=401, detail="Failed to exchange authorization code")
+
+    tokens = token_resp.json()
+    access_token = tokens.get("access_token")
+    if not access_token:
+        raise HTTPException(status_code=401, detail="No access token in response")
+
+    # Fetch user info
+    userinfo_resp = httpx.get(
+        GOOGLE_USERINFO_URL,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    if userinfo_resp.status_code != 200:
+        raise HTTPException(status_code=401, detail="Failed to fetch user info")
+
+    userinfo = userinfo_resp.json()
+    google_id = userinfo.get("id")
+    email = userinfo.get("email")
+    name = userinfo.get("name")
+    avatar_url = userinfo.get("picture")
+
+    if not google_id or not email:
+        raise HTTPException(status_code=401, detail="Incomplete user info from Google")
+
+    # Upsert profile
+    profile = store.upsert_profile(
+        google_id=google_id,
+        email=email,
+        name=name,
+        avatar_url=avatar_url,
+    )
+
+    # Create session (no org context — frontend resolves org after login)
+    token = store.create_session(user_id=profile.id)  # type: ignore[arg-type]
+
+    redirect_url = state if state and state.startswith("/") else "/"
+    response = RedirectResponse(url=redirect_url, status_code=302)
+    response.set_cookie(
+        key="session_token",
+        value=token,
+        httponly=True,
+        samesite="lax",
+        secure=cookie_secure,
+        max_age=session_expiry_days * 86400,
+        path="/",
+    )
+    return response
+
+
+@router.post("/logout")
+def logout(
+    response: Response,
+    user: Profile = Depends(get_current_user),
+    store: Store = Depends(get_store),
+) -> dict[str, str]:
+    """Delete all sessions for the current user and clear the cookie."""
+    store.delete_user_sessions(user.id)  # type: ignore[arg-type]
+    response.delete_cookie("session_token", path="/")
+    return {"status": "ok"}
+
+
+@router.get("/me")
+def get_me(
+    store: Store = Depends(get_store),
+    session_token: str | None = Cookie(default=None),
+) -> AuthUserResponse:
+    """Return the current user and their active organisation (if any)."""
+    if not session_token:
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    result = store.resolve_session(session_token)
+    if not result:
+        raise HTTPException(status_code=401, detail="Invalid or expired session")
+
+    profile, session_row = result
+    org: Organisation | None = None
+    role = "viewer"
+
+    if session_row.organisation_id:
+        org = store.get_organisation(session_row.organisation_id)
+
+    if org and profile.id:
+        user_role = store.get_user_role(profile.id, org.id)  # type: ignore[arg-type]
+        if user_role:
+            role = user_role
+
+    return AuthUserResponse(
+        id=profile.id,  # type: ignore[arg-type]
+        email=profile.email,
+        name=profile.name,
+        avatar_url=profile.avatar_url,
+        role=role,
+        organisation=OrganisationResponse.model_validate(org, from_attributes=True) if org else None,
+        last_organisation_id=profile.last_organisation_id,
+    )
+
+
+class SwitchOrgRequest(BaseModel):
+    """Request body for switching the active organisation."""
+
+    organisation_id: UUID
+
+
+@router.post("/switch-org")
+def switch_org(
+    body: SwitchOrgRequest,
+    user: Profile = Depends(get_current_user),
+    store: Store = Depends(get_store),
+    session_token: str | None = Cookie(default=None),
+) -> dict[str, str]:
+    """Switch the session's active organisation. User must be a member."""
+    role = store.get_user_role(user.id, body.organisation_id)  # type: ignore[arg-type]
+    if not role:
+        raise HTTPException(status_code=403, detail="Not a member of this organisation")
+
+    if session_token:
+        store.set_session_org(session_token, body.organisation_id, user_id=user.id)  # type: ignore[arg-type]
+    return {"status": "ok"}
+
+
+class AcceptInviteRequest(BaseModel):
+    """Request body for accepting an invitation."""
+
+    token: str
+
+
+@router.post("/accept-invite")
+def accept_invite(
+    body: AcceptInviteRequest,
+    user: Profile = Depends(get_current_user),
+    store: Store = Depends(get_store),
+    session_token: str | None = Cookie(default=None),
+) -> dict[str, str]:
+    """Accept an organisation invitation using its token."""
+    org = store.accept_invitation(body.token, user.id)  # type: ignore[arg-type]
+    if not org:
+        raise HTTPException(status_code=400, detail="Invalid or expired invitation")
+
+    # Switch to the new org
+    if session_token:
+        store.set_session_org(session_token, org.id, user_id=user.id)  # type: ignore[arg-type]
+
+    return {"status": "ok"}

interloper_api/routes/backfills.py

@@ -0,0 +1,87 @@
+"""Backfills API: read endpoints for backfill state."""
+
+from __future__ import annotations
+
+import datetime as dt
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from interloper.errors import NotFoundError
+from interloper_db import Profile, Store
+from interloper_db.models import Backfill
+from pydantic import BaseModel
+
+from interloper_api.dependencies import get_org_id, get_store, require_viewer
+
+router = APIRouter()
+
+
+class BackfillResponse(BaseModel):
+    """Response body for a backfill."""
+
+    id: UUID
+    org_id: UUID
+    job_id: UUID | None
+    status: str
+    start_date: dt.date
+    end_date: dt.date
+    concurrency: int
+    fail_fast: bool
+    partitions: int
+    started_at: str | None = None
+    completed_at: str | None = None
+    created_at: str | None = None
+
+
+def _backfill_to_response(backfill: Backfill) -> BackfillResponse:
+    """Convert a DB Backfill to a BackfillResponse.
+
+    Args:
+        backfill: The DB Backfill row.
+
+    Returns:
+        The response model.
+    """
+    return BackfillResponse(
+        id=backfill.id,  # type: ignore[arg-type]
+        org_id=backfill.org_id,
+        job_id=backfill.job_id,
+        status=backfill.status,
+        start_date=backfill.start_date,
+        end_date=backfill.end_date,
+        concurrency=backfill.concurrency,
+        fail_fast=backfill.fail_fast,
+        partitions=backfill.partitions,
+        started_at=str(backfill.started_at) if backfill.started_at else None,
+        completed_at=str(backfill.completed_at) if backfill.completed_at else None,
+        created_at=str(backfill.created_at) if backfill.created_at else None,
+    )
+
+
+@router.get("/")
+def list_backfills(
+    active_only: bool = False,
+    user: Profile = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[BackfillResponse]:
+    """List backfills for the current organisation."""
+    if active_only:
+        backfills = store.list_active_backfills(org_id)
+    else:
+        backfills = store.list_backfills(org_id)
+    return [_backfill_to_response(b) for b in backfills]
+
+
+@router.get("/{backfill_id}")
+def get_backfill(
+    backfill_id: UUID,
+    user: Profile = Depends(require_viewer),
+    store: Store = Depends(get_store),
+) -> BackfillResponse:
+    """Get a single backfill by ID."""
+    try:
+        backfill = store.get_backfill(backfill_id)
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Backfill {backfill_id} not found")
+    return _backfill_to_response(backfill)

interloper_api/routes/catalog.py

@@ -0,0 +1,46 @@
+"""Catalog API: serves component definitions for frontend consumption."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends
+
+from interloper_api.dependencies import get_catalog
+
+router = APIRouter()
+
+
+@router.get("/")
+def list_catalog(catalog: dict[str, Any] = Depends(get_catalog)) -> dict[str, Any]:
+    """Return the full catalog."""
+    return catalog
+
+
+@router.get("/{key}")
+def get_definition(key: str, catalog: dict[str, Any] = Depends(get_catalog)) -> dict[str, Any]:
+    """Return a single component definition by key.
+
+    Args:
+        key: The component key.
+        catalog: Injected catalog.
+
+    Raises:
+        HTTPException: If the key is not found.
+    """
+    from fastapi import HTTPException
+
+    if key not in catalog:
+        raise HTTPException(status_code=404, detail=f"Component '{key}' not found in catalog")
+    return catalog[key]
+
+
+@router.get("/kind/{kind}")
+def list_by_kind(kind: str, catalog: dict[str, Any] = Depends(get_catalog)) -> dict[str, Any]:
+    """Return all catalog entries matching a kind (source, asset, resource, destination).
+
+    Args:
+        kind: The component kind to filter by.
+        catalog: Injected catalog.
+    """
+    return {k: v for k, v in catalog.items() if v.get("kind") == kind}