interloper-api 0.30.1__tar.gz → 0.32.0__tar.gz

{interloper_api-0.30.1 → interloper_api-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: interloper-api
-Version: 0.30.1
+Version: 0.32.0
 Summary: Interloper FastAPI routes
 Author: Guillaume Onfroy
 Author-email: Guillaume Onfroy <guillaume@digitlcloud.com>

{interloper_api-0.30.1 → interloper_api-0.32.0}/pyproject.toml

@@ -3,7 +3,7 @@
 # ###############
 [project]
 name = "interloper-api"
-version = "0.30.1"
+version = "0.32.0"
 description = "Interloper FastAPI routes"
 readme = "README.md"
 authors = [{ name = "Guillaume Onfroy", email = "guillaume@digitlcloud.com" }]

{interloper_api-0.30.1 → interloper_api-0.32.0}/src/interloper_api/app.py

@@ -9,23 +9,19 @@ from fastapi import APIRouter, FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from interloper.catalog.base import Catalog
-from interloper.errors import ComponentDriftError
+from interloper.errors import ComponentDriftError, NotFoundError
 from interloper_db import Store
 
 from interloper_api.dependencies import set_auth_config, set_catalog, set_features, set_smtp_config, set_store
 from interloper_api.routes import (
     admin,
-    assets,
     auth,
     backfills,
-    destinations,
+    components,
     external,
-    jobs,
     oauth,
     organisations,
-    resources,
     runs,
-    sources,
     ws,
 )
 from interloper_api.routes import catalog as catalog_routes
@@ -60,6 +56,11 @@ def create_app(
     """
     app = FastAPI(title="Interloper API", lifespan=ws.realtime_lifespan, **kwargs)
 
+    @app.exception_handler(NotFoundError)
+    async def _not_found_handler(_request: Request, exc: NotFoundError) -> JSONResponse:
+        """Store mutations raise NotFoundError on missing targets — a plain 404."""
+        return JSONResponse(status_code=404, content={"detail": str(exc)})
+
     @app.exception_handler(ComponentDriftError)
     async def _component_drift_handler(_request: Request, exc: ComponentDriftError) -> JSONResponse:
         """A stored component whose catalog key has drifted is a conflict, not a 500.
@@ -92,13 +93,9 @@ def create_app(
     api.include_router(organisations.router, tags=["organisations"])
     api.include_router(admin.router, tags=["admin"])
     api.include_router(catalog_routes.router, prefix="/catalog", tags=["catalog"])
-    api.include_router(resources.router, prefix="/resources", tags=["resources"])
-    api.include_router(sources.router, prefix="/sources", tags=["sources"])
-    api.include_router(destinations.router, prefix="/destinations", tags=["destinations"])
-    api.include_router(jobs.router, prefix="/jobs", tags=["jobs"])
+    api.include_router(components.router, prefix="/components", tags=["components"])
     api.include_router(runs.router, prefix="/runs", tags=["runs"])
     api.include_router(backfills.router, prefix="/backfills", tags=["backfills"])
-    api.include_router(assets.router, prefix="/assets", tags=["assets"])
     api.include_router(oauth.router, tags=["oauth"])
     api.include_router(external.router, prefix="/external", tags=["external"])
     api.include_router(ws.router, tags=["ws"])

interloper_api-0.32.0/src/interloper_api/components.py

@@ -0,0 +1,64 @@
+"""Shared helpers for reading component rows into API responses.
+
+Store methods return ``Component`` rows with children and relations eager-loaded;
+these helpers extract the shapes the response models need without touching
+the database again.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+from uuid import UUID
+
+from interloper_db import Component
+from pydantic import BaseModel
+
+
+class DestinationResponse(BaseModel):
+    """Response body for a destination, standalone or nested."""
+
+    id: UUID
+    key: str
+    name: str | None = None
+    config: dict[str, Any] | None = None
+    resources: dict[str, str] = {}
+    created_at: str | None = None
+
+
+def destination_response(dest: Component) -> DestinationResponse:
+    """Convert a destination component row to its response model."""
+    return DestinationResponse(
+        id=dest.id,
+        key=dest.key,
+        name=dest.name,
+        config=dest.config,
+        resources=resource_map(dest),
+        created_at=timestamp(dest.created_at),
+    )
+
+
+def timestamp(value: datetime | None) -> str | None:
+    """Render an optional timestamp the way every response does."""
+    return str(value) if value else None
+
+
+def resource_map(component: Component) -> dict[str, str]:
+    """Build a ``{slot: resource_id}`` map from the component's resource relations."""
+    return {rel.slot: str(rel.dst_id) for rel in component.out_relations if rel.type == "resource"}
+
+
+def destination_rows(component: Component) -> list[Component]:
+    """The destination components bound to this component, eager-loaded."""
+    return [rel.dst for rel in component.out_relations if rel.type == "destination"]
+
+
+def materializable(component: Component) -> bool:
+    """An asset's materializable toggle (defaults to true when unset)."""
+    return bool((component.config or {}).get("materializable", True))
+
+
+def user_config(component: Component) -> dict[str, Any] | None:
+    """The user-facing config, without the materializable toggle."""
+    config = {key: value for key, value in (component.config or {}).items() if key != "materializable"}
+    return config or None

{interloper_api-0.30.1 → interloper_api-0.32.0}/src/interloper_api/dependencies.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import Any
 from uuid import UUID
 
 from fastapi import Cookie, Depends, HTTPException
 from interloper.catalog.base import Catalog
+from interloper.errors import NotFoundError
 from interloper_db import Organisation, Profile, Store
-from interloper_db.models import Session as SessionModel
+from interloper_db.models import AuthSession
 
 _store: Store | None = None
 _catalog: Catalog | None = None
@@ -165,7 +167,7 @@ def get_current_user(
 def get_session_context(
     store: Store = Depends(get_store),
     session_token: str | None = Cookie(default=None),
-) -> tuple[Profile, SessionModel]:
+) -> tuple[Profile, AuthSession]:
     """Resolve user and session from the cookie.
 
     Args:
@@ -273,6 +275,45 @@ def authorize_org_member(
         raise HTTPException(status_code=403, detail=f"Requires {minimum} role or higher")
 
 
+def load_authorized(
+    fetch: Callable[[UUID], Any],
+    entity_id: UUID,
+    user: Profile,
+    store: Store,
+    *,
+    label: str,
+    minimum: str = "viewer",
+) -> Any:
+    """Fetch an org-owned entity and authorize the user by membership in its org.
+
+    The one ID-addressed authorization pattern shared by every entity route:
+    a missing entity and a non-member get the same 404 (IDs don't act as an
+    existence oracle); a member with an insufficient role gets a 403.
+
+    Args:
+        fetch: Store getter taking the entity id (e.g. ``store.get_asset``).
+        entity_id: The entity UUID.
+        user: The authenticated user.
+        store: The Store instance.
+        label: Entity label for the 404 detail (e.g. ``"Asset"``).
+        minimum: Minimum role required in the owning organisation.
+
+    Returns:
+        Whatever *fetch* returned.
+
+    Raises:
+        HTTPException: 404 if missing or the user is not a member of the
+            owning org, 403 if the role is insufficient.
+    """
+    detail = f"{label} {entity_id} not found"
+    try:
+        entity = fetch(entity_id)
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=detail)
+    authorize_org_member(user, entity.org_id, store, minimum=minimum, detail=detail)
+    return entity
+
+
 def _check_role(
     minimum: str,
     user: Profile,

{interloper_api-0.30.1 → interloper_api-0.32.0}/src/interloper_api/routes/admin.py

@@ -67,6 +67,12 @@ class UpdateRoleRequest(BaseModel):
     role: str
 
 
+class JoinOrganisationRequest(BaseModel):
+    """Request body for a super-admin joining an organisation."""
+
+    role: str = "admin"
+
+
 class InviteRequest(BaseModel):
     """Request body for inviting a user."""
 
@@ -113,6 +119,7 @@ def _send_invitation_email(
 
     smtp_config = get_smtp_config()
     if not smtp_config or not smtp_config.enabled:
+        logger.warning("SMTP not configured; invitation email to %s not sent", invitation.email)
         return
 
     token = invitation.token
@@ -177,8 +184,6 @@ def update_organisation(
 ) -> AdminOrganisationResponse:
     """Rename an organisation."""
     org = store.update_organisation(org_id, body.name)
-    if not org:
-        raise HTTPException(status_code=404, detail="Organisation not found")
     members = store.list_org_members(org_id)
     return AdminOrganisationResponse(
         id=org.id,
@@ -212,6 +217,27 @@ def list_members(
     ]
 
 
+@router.post("/organisations/{org_id}/members", status_code=201)
+def join_organisation(
+    org_id: UUID,
+    body: JoinOrganisationRequest,
+    user: Profile = Depends(require_super_admin),
+    store: Store = Depends(get_store),
+) -> MemberResponse:
+    """Add the calling super-admin to any organisation — no invitation needed."""
+    _require_org(store, org_id)
+    _validate_role(body.role)
+    if not store.add_org_member(org_id, user.id, body.role):
+        raise HTTPException(status_code=409, detail="Already a member of this organisation")
+    return MemberResponse(
+        id=user.id,
+        email=user.email,
+        name=user.name,
+        avatar_url=user.avatar_url,
+        role=body.role,
+    )
+
+
 @router.patch("/organisations/{org_id}/members/{user_id}")
 def update_member_role(
     org_id: UUID,
@@ -222,8 +248,7 @@ def update_member_role(
 ) -> dict[str, str]:
     """Change a member's role in any organisation."""
     _validate_role(body.role)
-    if not store.update_member_role(org_id, user_id, body.role):
-        raise HTTPException(status_code=404, detail="Member not found")
+    store.update_member_role(org_id, user_id, body.role)
     return {"status": "ok"}
 
 
@@ -235,8 +260,7 @@ def remove_member(
     store: Store = Depends(get_store),
 ) -> dict[str, str]:
     """Remove a member from any organisation."""
-    if not store.remove_org_member(org_id, user_id):
-        raise HTTPException(status_code=404, detail="Member not found")
+    store.remove_org_member(org_id, user_id)
     return {"status": "ok"}
 
 
@@ -301,6 +325,5 @@ def cancel_invitation(
     store: Store = Depends(get_store),
 ) -> dict[str, str]:
     """Cancel a pending invitation in any organisation."""
-    if not store.delete_invitation(invitation_id):
-        raise HTTPException(status_code=404, detail="Invitation not found")
+    store.delete_invitation(invitation_id)
     return {"status": "ok"}

{interloper_api-0.30.1 → interloper_api-0.32.0}/src/interloper_api/routes/agent.py

@@ -33,9 +33,7 @@ router = APIRouter()
 
 APP_NAME = "interloper_agent"
 
-# ---------------------------------------------------------------------------
-# Lazy runner singleton
-# ---------------------------------------------------------------------------
+# -- Lazy runner singleton -----------------------------------------------------
 
 _runner: Runner | None = None
 _session_service: InMemorySessionService | None = None
@@ -79,9 +77,7 @@ def _get_runner(store: Store, catalog: Catalog) -> Runner:
     return _runner
 
 
-# ---------------------------------------------------------------------------
-# Request / response models
-# ---------------------------------------------------------------------------
+# -- Request / response models -------------------------------------------------
 
 
 class ChatRequest(BaseModel):
@@ -113,9 +109,7 @@ def _session_to_response(session: Any) -> SessionResponse:
     )
 
 
-# ---------------------------------------------------------------------------
-# Endpoints
-# ---------------------------------------------------------------------------
+# -- Endpoints -----------------------------------------------------------------
 
 
 @router.post("/sessions")

{interloper_api-0.30.1 → interloper_api-0.32.0}/src/interloper_api/routes/auth.py

@@ -131,6 +131,11 @@ def google_callback(
         avatar_url=avatar_url,
     )
 
+    # Bootstrap super-admins from settings. Promote-only: removing an email from
+    # the list never demotes an existing super-admin.
+    if not profile.is_super_admin and email.lower() in auth_config.super_admin_emails:
+        profile = store.set_super_admin(profile.id)
+
     # Create session (no org context — frontend resolves org after login)
     token = store.create_session(user_id=profile.id)
 

{interloper_api-0.30.1 → interloper_api-0.32.0}/src/interloper_api/routes/backfills.py

@@ -11,17 +11,34 @@ from interloper_db import Profile, Store
 from interloper_db.models import Backfill
 from pydantic import BaseModel
 
-from interloper_api.dependencies import authorize_org_member, get_current_user, get_org_id, get_store, require_viewer
+from interloper_api.dependencies import (
+    authorize_org_member,
+    get_current_user,
+    get_org_id,
+    get_store,
+    load_authorized,
+    require_viewer,
+)
 
 router = APIRouter()
 
 
+class BackfillCreateRequest(BaseModel):
+    """Request body for queuing a backfill."""
+
+    component_id: UUID
+    start_date: dt.date
+    end_date: dt.date
+    concurrency: int = 1
+    fail_fast: bool = False
+
+
 class BackfillResponse(BaseModel):
     """Response body for a backfill."""
 
     id: UUID
     org_id: UUID
-    job_id: UUID | None
+    component_id: UUID | None
     status: str
     start_date: dt.date
     end_date: dt.date
@@ -45,7 +62,7 @@ def _backfill_to_response(backfill: Backfill) -> BackfillResponse:
     return BackfillResponse(
         id=backfill.id,
         org_id=backfill.org_id,
-        job_id=backfill.job_id,
+        component_id=backfill.component_id,
         status=backfill.status,
         start_date=backfill.start_date,
         end_date=backfill.end_date,
@@ -73,6 +90,27 @@ def list_backfills(
     return [_backfill_to_response(b) for b in backfills]
 
 
+@router.post("/", status_code=201)
+def create_backfill(
+    body: BackfillCreateRequest,
+    user: Profile = Depends(get_current_user),
+    store: Store = Depends(get_store),
+) -> BackfillResponse:
+    """Queue a backfill for a job over a date range."""
+    job = load_authorized(
+        lambda i: store.get_component(i, kind="job"), body.component_id, user, store, label="Job", minimum="editor"
+    )
+    backfill = store.create_backfill(
+        job.org_id,
+        component_id=body.component_id,
+        start_date=body.start_date,
+        end_date=body.end_date,
+        concurrency=body.concurrency,
+        fail_fast=body.fail_fast,
+    )
+    return _backfill_to_response(backfill)
+
+
 @router.get("/{backfill_id}")
 def get_backfill(
     backfill_id: UUID,

{interloper_api-0.30.1 → interloper_api-0.32.0}/src/interloper_api/routes/catalog.py

@@ -18,6 +18,25 @@ def list_catalog(catalog: Catalog = Depends(get_catalog)) -> dict[str, Any]:
     return catalog.dump()
 
 
+@router.get("/resource-kinds")
+def list_resource_kinds(catalog: Catalog = Depends(get_catalog)) -> list[str]:
+    """Return distinct resource kinds from the catalog.
+
+    A resource kind is any registered kind anchored under ``Resource``
+    (currently ``connection`` and ``config``) — the kinds usable as
+    slot bindings on other components.
+    """
+    import interloper as il
+
+    return sorted(
+        {
+            defn.kind
+            for defn in catalog.components.values()
+            if (anchor := il.KINDS.get(defn.kind)) is not None and issubclass(anchor, il.Resource)
+        }
+    )
+
+
 @router.get("/{key}")
 def get_definition(key: str, catalog: Catalog = Depends(get_catalog)) -> dict[str, Any]:
     """Return a single component definition by key.