interloper-api 0.2.0__py3-none-any.whl

interloper_api/routes/organisations.py

@@ -0,0 +1,278 @@
+"""Organisation routes — CRUD, membership, and invitation management."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from uuid import UUID
+
+from fastapi import APIRouter, Cookie, Depends, HTTPException, Request
+from interloper_db import Profile, Store
+from pydantic import BaseModel
+
+from interloper_api.dependencies import get_current_user, get_org_id, get_store, require_admin, require_viewer
+from interloper_api.email import send_invite_email
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/organisations", tags=["organisations"])
+
+
+# -- Response / Request models ------------------------------------------------
+
+
+class OrganisationResponse(BaseModel):
+    """Organisation summary."""
+
+    id: UUID
+    name: str
+    created_at: datetime | None = None
+
+
+class CreateOrganisationRequest(BaseModel):
+    """Request body for creating an organisation."""
+
+    name: str
+
+
+class MemberResponse(BaseModel):
+    """Organisation member."""
+
+    id: UUID
+    email: str
+    name: str | None = None
+    avatar_url: str | None = None
+    role: str
+
+
+class InviteRequest(BaseModel):
+    """Request body for inviting a user."""
+
+    email: str
+    role: str = "viewer"
+
+
+class InvitationResponse(BaseModel):
+    """Pending invitation."""
+
+    id: UUID
+    email: str
+    role: str
+    created_at: datetime | None = None
+    expires_at: datetime
+
+
+# -- Helpers ------------------------------------------------------------------
+
+
+def _get_smtp_config() -> object | None:
+    """Return the SMTP config if available, without raising."""
+    from interloper_api.dependencies import get_smtp_config
+
+    return get_smtp_config()
+
+
+def _send_invitation_email(
+    request: Request,
+    smtp_config: object,
+    invitation: object,
+    org_name: str,
+    inviter_name: str,
+) -> None:
+    """Send the invitation email, logging errors without failing the request.
+
+    Args:
+        request: The FastAPI request (for building the invite URL).
+        smtp_config: SmtpConfig instance.
+        invitation: Invitation row with .token and .email.
+        org_name: Organisation name.
+        inviter_name: Inviter display name.
+    """
+    token = invitation.token  # type: ignore[attr-defined]
+    email = invitation.email  # type: ignore[attr-defined]
+    base_url = str(request.base_url).rstrip("/")
+    invite_url = f"{base_url}/invite/{token}"
+
+    try:
+        send_invite_email(
+            smtp_config=smtp_config,
+            to=email,
+            org_name=org_name,
+            inviter_name=inviter_name,
+            invite_url=invite_url,
+        )
+    except Exception:
+        logger.exception("Failed to send invitation email to %s", email)
+
+
+# -- Organisation CRUD -------------------------------------------------------
+
+
+@router.post("", status_code=201)
+def create_organisation(
+    body: CreateOrganisationRequest,
+    user: Profile = Depends(get_current_user),
+    store: Store = Depends(get_store),
+    session_token: str | None = Cookie(default=None),
+) -> OrganisationResponse:
+    """Create a new organisation. The creating user becomes its admin."""
+    org = store.create_organisation(name=body.name, creator_id=user.id)  # type: ignore[arg-type]
+
+    # Set as active org in session
+    if session_token:
+        store.set_session_org(session_token, org.id, user_id=user.id)  # type: ignore[arg-type]
+
+    return OrganisationResponse.model_validate(org, from_attributes=True)
+
+
+@router.get("")
+def list_organisations(
+    user: Profile = Depends(get_current_user),
+    store: Store = Depends(get_store),
+) -> list[OrganisationResponse]:
+    """List all organisations the user belongs to."""
+    orgs = store.list_user_organisations(user.id)  # type: ignore[arg-type]
+    return [OrganisationResponse.model_validate(o, from_attributes=True) for o in orgs]
+
+
+# -- Members ------------------------------------------------------------------
+
+
+@router.get("/members")
+def list_members(
+    user: Profile = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[MemberResponse]:
+    """List all members of the current organisation."""
+    members = store.list_org_members(org_id)
+    return [
+        MemberResponse(
+            id=profile.id,  # type: ignore[arg-type]
+            email=profile.email,
+            name=profile.name,
+            avatar_url=profile.avatar_url,
+            role=role,
+        )
+        for profile, role in members
+    ]
+
+
+@router.delete("/members/{user_id}")
+def remove_member(
+    user_id: UUID,
+    user: Profile = Depends(require_admin),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> dict[str, str]:
+    """Remove a member from the organisation. Requires admin role."""
+    if user_id == user.id:
+        raise HTTPException(status_code=400, detail="Cannot remove yourself")
+
+    if not store.remove_org_member(org_id, user_id):
+        raise HTTPException(status_code=404, detail="Member not found")
+
+    return {"status": "ok"}
+
+
+# -- Invitations --------------------------------------------------------------
+
+
+@router.get("/invitations")
+def list_invitations(
+    user: Profile = Depends(require_admin),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[InvitationResponse]:
+    """List pending invitations for the current organisation. Requires admin role."""
+    invitations = store.list_invitations(org_id)
+    return [
+        InvitationResponse(
+            id=inv.id,  # type: ignore[arg-type]
+            email=inv.email,
+            role=inv.role,
+            created_at=inv.created_at,
+            expires_at=inv.expires_at,
+        )
+        for inv in invitations
+    ]
+
+
+@router.post("/invite", status_code=201)
+def invite_member(
+    body: InviteRequest,
+    request: Request,
+    user: Profile = Depends(require_admin),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> InvitationResponse:
+    """Invite a user to the organisation by email. Requires admin role."""
+    invitation = store.create_invitation(
+        org_id=org_id,
+        email=body.email.strip(),
+        role=body.role,
+        invited_by=user.id,  # type: ignore[arg-type]
+    )
+
+    # Send invitation email if SMTP is configured
+    smtp_config = _get_smtp_config()
+    if smtp_config and smtp_config.enabled:  # type: ignore[attr-defined]
+        org = store.get_organisation(org_id)
+        org_name = org.name if org else "Unknown"
+        inviter_name = user.name or user.email
+        _send_invitation_email(request, smtp_config, invitation, org_name, inviter_name)
+
+    return InvitationResponse(
+        id=invitation.id,  # type: ignore[arg-type]
+        email=invitation.email,
+        role=invitation.role,
+        created_at=invitation.created_at,
+        expires_at=invitation.expires_at,
+    )
+
+
+@router.delete("/invitations/{invitation_id}")
+def cancel_invitation(
+    invitation_id: UUID,
+    user: Profile = Depends(require_admin),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> dict[str, str]:
+    """Cancel a pending invitation. Requires admin role."""
+    if not store.delete_invitation(invitation_id):
+        raise HTTPException(status_code=404, detail="Invitation not found")
+
+    return {"status": "ok"}
+
+
+@router.post("/invitations/{invitation_id}/resend")
+def resend_invitation(
+    invitation_id: UUID,
+    request: Request,
+    user: Profile = Depends(require_admin),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> dict[str, str]:
+    """Resend an invitation (recreates with fresh expiry). Requires admin role."""
+    invitations = store.list_invitations(org_id)
+    target = next((inv for inv in invitations if inv.id == invitation_id), None)
+    if not target:
+        raise HTTPException(status_code=404, detail="Invitation not found")
+
+    store.delete_invitation(invitation_id)
+    new_invitation = store.create_invitation(
+        org_id=org_id,
+        email=target.email,
+        role=target.role,
+        invited_by=user.id,  # type: ignore[arg-type]
+    )
+
+    # Send invitation email if SMTP is configured
+    smtp_config = _get_smtp_config()
+    if smtp_config and smtp_config.enabled:  # type: ignore[attr-defined]
+        org = store.get_organisation(org_id)
+        org_name = org.name if org else "Unknown"
+        inviter_name = user.name or user.email
+        _send_invitation_email(request, smtp_config, new_invitation, org_name, inviter_name)
+
+    return {"status": "ok"}

interloper_api/routes/resources.py

@@ -0,0 +1,180 @@
+"""Resources API: CRUD for typed, optionally encrypted resources."""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from interloper.errors import NotFoundError
+from interloper_db import Profile, Store
+from pydantic import BaseModel
+
+from interloper_api.dependencies import get_catalog, get_org_id, get_store, require_editor, require_viewer
+
+router = APIRouter()
+
+# Kinds that are not resource kinds — top-level component categories.
+_NON_RESOURCE_KINDS = {"source", "asset", "destination"}
+
+
+class ResourceCreateRequest(BaseModel):
+    """Request body for creating or updating a resource."""
+
+    kind: str
+    key: str
+    name: str
+    data: dict[str, Any]
+    encrypted: bool = False
+
+
+class ResourceResponse(BaseModel):
+    """Response body for a resource."""
+
+    id: UUID
+    org_id: UUID
+    kind: str
+    key: str
+    name: str
+    encrypted: bool
+    created_at: str | None = None
+    updated_at: str | None = None
+
+
+class ResourceDetailResponse(ResourceResponse):
+    """Response body for a single resource, including its data payload."""
+
+    data: dict[str, Any] = {}
+
+
+@router.get("/kinds")
+def list_resource_kinds(
+    catalog: dict[str, Any] = Depends(get_catalog),
+) -> list[str]:
+    """Return distinct resource kinds from the catalog.
+
+    Resource kinds are all component kinds except the top-level categories
+    (source, asset, destination). Currently this yields kinds like
+    ``connection`` and ``config``.
+    """
+    kinds = {defn["kind"] for defn in catalog.values() if defn.get("kind") and defn["kind"] not in _NON_RESOURCE_KINDS}
+    return sorted(kinds)
+
+
+@router.get("/")
+def list_resources(
+    kind: str | None = None,
+    user: Profile = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[ResourceResponse]:
+    """List resources for the current organisation, optionally filtered by kind."""
+    resources = store.list_resources(org_id, kind=kind)
+    return [
+        ResourceResponse(
+            id=r.id,  # type: ignore[arg-type]
+            org_id=r.org_id,
+            kind=r.kind,
+            key=r.key,
+            name=r.name,
+            encrypted=r.encrypted,
+            created_at=str(r.created_at) if r.created_at else None,
+            updated_at=str(r.updated_at) if r.updated_at else None,
+        )
+        for r in resources
+    ]
+
+
+@router.get("/{resource_id}")
+def get_resource(
+    resource_id: UUID,
+    user: Profile = Depends(require_viewer),
+    store: Store = Depends(get_store),
+) -> ResourceDetailResponse:
+    """Get a single resource by ID, including its data payload."""
+    try:
+        r = store.load_resource(resource_id)
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Resource {resource_id} not found")
+
+    return ResourceDetailResponse(
+        id=r.id,  # type: ignore[arg-type]
+        org_id=r.org_id,
+        kind=r.kind,
+        key=r.key,
+        name=r.name,
+        encrypted=r.encrypted,
+        data=store.decode_resource_data(r),
+        created_at=str(r.created_at) if r.created_at else None,
+        updated_at=str(r.updated_at) if r.updated_at else None,
+    )
+
+
+@router.post("/")
+def create_resource(
+    body: ResourceCreateRequest,
+    user: Profile = Depends(require_editor),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> ResourceResponse:
+    """Create a new resource."""
+    resource = store.create_resource(
+        org_id,
+        kind=body.kind,
+        key=body.key,
+        name=body.name,
+        data=body.data,
+        encrypted=body.encrypted,
+    )
+    return ResourceResponse(
+        id=resource.id,  # type: ignore[arg-type]
+        org_id=resource.org_id,
+        kind=resource.kind,
+        key=resource.key,
+        name=resource.name,
+        encrypted=resource.encrypted,
+        created_at=str(resource.created_at) if resource.created_at else None,
+        updated_at=str(resource.updated_at) if resource.updated_at else None,
+    )
+
+
+@router.put("/{resource_id}")
+def update_resource(
+    resource_id: UUID,
+    body: ResourceCreateRequest,
+    user: Profile = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> ResourceResponse:
+    """Update an existing resource."""
+    try:
+        resource = store.update_resource(
+            resource_id,
+            kind=body.kind,
+            key=body.key,
+            name=body.name,
+            data=body.data,
+            encrypted=body.encrypted,
+        )
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Resource {resource_id} not found")
+    return ResourceResponse(
+        id=resource.id,  # type: ignore[arg-type]
+        org_id=resource.org_id,
+        kind=resource.kind,
+        key=resource.key,
+        name=resource.name,
+        encrypted=resource.encrypted,
+        created_at=str(resource.created_at) if resource.created_at else None,
+        updated_at=str(resource.updated_at) if resource.updated_at else None,
+    )
+
+
+@router.delete("/{resource_id}")
+def delete_resource(
+    resource_id: UUID,
+    user: Profile = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> dict[str, str]:
+    """Delete a resource."""
+    store.delete_resource(resource_id)
+    return {"status": "deleted"}

interloper_api/routes/runs.py

@@ -0,0 +1,177 @@
+"""Runs API: read endpoints for runs and their events."""
+
+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 Event, Run
+from pydantic import BaseModel
+
+from interloper_api.dependencies import get_org_id, get_store, require_viewer
+
+router = APIRouter()
+
+
+class RunResponse(BaseModel):
+    """Response body for a run."""
+
+    id: UUID
+    org_id: UUID
+    job_id: UUID | None
+    backfill_id: UUID | None
+    partition_date: dt.date | None
+    status: str
+    started_at: str | None = None
+    completed_at: str | None = None
+    created_at: str | None = None
+
+
+class AssetExecutionResponse(BaseModel):
+    """Response body for an asset execution (from the asset_executions view)."""
+
+    run_id: UUID
+    org_id: UUID
+    asset_id: UUID | None = None
+    asset_key: str
+    status: str
+    started_at: str | None = None
+    completed_at: str | None = None
+    created_at: str | None = None
+
+
+class EventResponse(BaseModel):
+    """Response body for an event."""
+
+    id: UUID
+    org_id: UUID
+    run_id: UUID | None
+    event_type: str
+    asset_id: UUID | None = None
+    asset_key: str | None
+    partition_or_window: str | None
+    error: str | None
+    traceback: str | None
+    message: str | None
+    timestamp: str
+
+
+def _run_to_response(run: Run) -> RunResponse:
+    """Convert a DB Run to a RunResponse.
+
+    Args:
+        run: The DB Run row.
+
+    Returns:
+        The response model.
+    """
+    return RunResponse(
+        id=run.id,  # type: ignore[arg-type]
+        org_id=run.org_id,
+        job_id=run.job_id,
+        backfill_id=run.backfill_id,
+        partition_date=run.partition_date,
+        status=run.status,
+        started_at=str(run.started_at) if run.started_at else None,
+        completed_at=str(run.completed_at) if run.completed_at else None,
+        created_at=str(run.created_at) if run.created_at else None,
+    )
+
+
+def _event_to_response(event: Event) -> EventResponse:
+    """Convert a DB Event to an EventResponse.
+
+    Args:
+        event: The DB Event row.
+
+    Returns:
+        The response model.
+    """
+    return EventResponse(
+        id=event.id,  # type: ignore[arg-type]
+        org_id=event.org_id,
+        run_id=event.run_id,
+        event_type=event.event_type,
+        asset_id=event.asset_id,
+        asset_key=event.asset_key,
+        partition_or_window=event.partition_or_window,
+        error=event.error,
+        traceback=event.traceback,
+        message=event.message,
+        timestamp=str(event.timestamp),
+    )
+
+
+@router.get("/")
+def list_runs(
+    job_id: UUID | None = None,
+    backfill_id: UUID | None = None,
+    status: str | None = None,
+    limit: int = 50,
+    offset: int = 0,
+    user: Profile = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[RunResponse]:
+    """List runs with optional filters."""
+    runs = store.list_runs(
+        org_id,
+        job_id=job_id,
+        backfill_id=backfill_id,
+        status=status,
+        limit=limit,
+        offset=offset,
+    )
+    return [_run_to_response(r) for r in runs]
+
+
+@router.get("/{run_id}")
+def get_run(
+    run_id: UUID,
+    user: Profile = Depends(require_viewer),
+    store: Store = Depends(get_store),
+) -> RunResponse:
+    """Get a single run by ID."""
+    try:
+        run = store.get_run(run_id)
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
+    return _run_to_response(run)
+
+
+@router.get("/{run_id}/asset-executions")
+def list_asset_executions(
+    run_id: UUID,
+    user: Profile = Depends(require_viewer),
+    store: Store = Depends(get_store),
+) -> list[AssetExecutionResponse]:
+    """List asset executions for a run."""
+    rows = store.list_asset_executions(run_id)
+    return [
+        AssetExecutionResponse(
+            run_id=row["run_id"],
+            org_id=row["org_id"],
+            asset_id=row.get("asset_id"),
+            asset_key=row["asset_key"],
+            status=row["status"],
+            started_at=str(row["started_at"]) if row.get("started_at") else None,
+            completed_at=str(row["completed_at"]) if row.get("completed_at") else None,
+            created_at=str(row["created_at"]) if row.get("created_at") else None,
+        )
+        for row in rows
+    ]
+
+
+@router.get("/{run_id}/events")
+def list_run_events(
+    run_id: UUID,
+    limit: int = 100,
+    user: Profile = Depends(require_viewer),
+    store: Store = Depends(get_store),
+) -> list[EventResponse]:
+    """List events for a run."""
+    events = store.list_events(run_id=run_id, limit=limit)
+    return [_event_to_response(e) for e in events]