interloper-api 0.2.0__py3-none-any.whl

interloper_api/routes/destinations.py

@@ -0,0 +1,118 @@
+"""Destinations API: CRUD for standalone destination instances."""
+
+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 Store
+from interloper_db.models import Destination, DestinationResource
+from pydantic import BaseModel
+
+from interloper_api.dependencies import get_org_id, get_store, require_editor, require_viewer
+
+router = APIRouter()
+
+
+class DestinationCreateRequest(BaseModel):
+    """Request body for creating/updating a destination."""
+
+    key: str
+    name: str | None = None
+    config: dict[str, Any] | None = None
+    resources: dict[str, str] | None = None
+
+
+class DestinationResponse(BaseModel):
+    """Response body for a destination."""
+
+    id: UUID
+    key: str
+    name: str | None = None
+    config: dict[str, Any] | None = None
+    resources: dict[str, str] = {}
+    created_at: str | None = None
+
+
+def _resource_map(dest: Destination) -> dict[str, str]:
+    """Build {slot_key: resource_id} from junction rows."""
+    from interloper_db.engine import get_engine
+    from sqlmodel import Session as _S
+    from sqlmodel import select as _sel
+
+    with _S(get_engine()) as s:
+        rows = s.exec(_sel(DestinationResource).where(DestinationResource.destination_id == dest.id)).all()
+    return {r.key: str(r.resource_id) for r in rows}
+
+
+def _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(dest),
+        created_at=str(dest.created_at) if dest.created_at else None,
+    )
+
+
+@router.get("/")
+def list_destinations(
+    user: object = Depends(require_viewer),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> list[DestinationResponse]:
+    """List all destinations for the current organisation."""
+    destinations = store.list_destinations(org_id)
+    return [_to_response(d) for d in destinations]
+
+
+@router.post("/")
+def create_destination(
+    body: DestinationCreateRequest,
+    user: object = Depends(require_editor),
+    org_id: UUID = Depends(get_org_id),
+    store: Store = Depends(get_store),
+) -> DestinationResponse:
+    """Create a new destination."""
+    dest = store.create_destination(
+        org_id,
+        key=body.key,
+        name=body.name,
+        config=body.config,
+        resources=body.resources,
+    )
+    return _to_response(dest)
+
+
+@router.put("/{destination_id}")
+def update_destination(
+    destination_id: UUID,
+    body: DestinationCreateRequest,
+    user: object = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> DestinationResponse:
+    """Update a destination."""
+    try:
+        dest = store.update_destination(
+            destination_id,
+            name=body.name,
+            config=body.config,
+            resources=body.resources,
+        )
+    except NotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    return _to_response(dest)
+
+
+@router.delete("/{destination_id}")
+def delete_destination(
+    destination_id: UUID,
+    user: object = Depends(require_editor),
+    store: Store = Depends(get_store),
+) -> dict[str, str]:
+    """Delete a destination."""
+    store.delete_destination(destination_id)
+    return {"status": "deleted"}

interloper_api/routes/external/__init__.py

@@ -0,0 +1,48 @@
+"""External provider API routes for FetchField resolution.
+
+Each submodule contains routes for a specific external provider.
+The combined ``router`` is re-exported here so ``app.py`` can
+import it unchanged.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+from fastapi import APIRouter, HTTPException
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def handle_error(error: Exception, context: str) -> None:
+    """Map external API errors to appropriate HTTP responses."""
+    logger.error("Error %s: %s", context, error)
+
+    if isinstance(error, httpx.HTTPStatusError):
+        status = error.response.status_code
+        if status in (401, 403):
+            raise HTTPException(status_code=status, detail=f"Authorization failed while {context}.")
+        if status == 404:
+            raise HTTPException(status_code=404, detail=f"Resource not found while {context}.")
+
+    if isinstance(error, HTTPException):
+        raise error
+
+    raise HTTPException(status_code=500, detail=f"Failed {context}.")
+
+
+# Import and register sub-routers after helpers are defined.
+from interloper_api.routes.external.amazon_ads import sub_router as amazon_ads_router  # noqa: E402
+from interloper_api.routes.external.facebook_ads import sub_router as facebook_ads_router  # noqa: E402
+from interloper_api.routes.external.google_ads import sub_router as google_ads_router  # noqa: E402
+from interloper_api.routes.external.pinterest_ads import sub_router as pinterest_ads_router  # noqa: E402
+from interloper_api.routes.external.snapchat_ads import sub_router as snapchat_ads_router  # noqa: E402
+
+router.include_router(amazon_ads_router)
+router.include_router(facebook_ads_router)
+router.include_router(google_ads_router)
+router.include_router(pinterest_ads_router)
+router.include_router(snapchat_ads_router)

interloper_api/routes/external/amazon_ads.py

@@ -0,0 +1,82 @@
+"""Amazon Ads external API routes."""
+
+from __future__ import annotations
+
+import httpx
+from fastapi import APIRouter, Depends
+from interloper_db import Profile
+from pydantic import BaseModel
+
+from interloper_api.dependencies import require_viewer
+from interloper_api.routes.external import handle_error
+
+sub_router = APIRouter()
+
+_API_URLS: dict[str, str] = {
+    "EU": "https://advertising-api-eu.amazon.com",
+    "FE": "https://advertising-api-fe.amazon.com",
+    "NA": "https://advertising-api.amazon.com",
+}
+
+_AUTH_URLS: dict[str, str] = {
+    "EU": "https://api.amazon.co.uk",
+    "FE": "https://api.amazon.co.jp",
+    "NA": "https://api.amazon.com",
+}
+
+
+class AmazonAdsConnectionRequest(BaseModel):
+    """Amazon Ads connection credentials (matches AmazonAdsConnection fields)."""
+
+    location: str = "NA"
+    client_id: str
+    client_secret: str
+    refresh_token: str
+
+
+@sub_router.post("/amazon-ads/profiles")
+async def amazon_ads_profiles(
+    body: AmazonAdsConnectionRequest,
+    _user: Profile = Depends(require_viewer),
+) -> list[dict[str, str]]:
+    """Fetch Amazon Ads advertising profiles for a connection."""
+    api_url = _API_URLS.get(body.location, _API_URLS["NA"])
+    auth_url = _AUTH_URLS.get(body.location, _AUTH_URLS["NA"])
+
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            token_resp = await client.post(
+                f"{auth_url}/auth/o2/token",
+                data={
+                    "grant_type": "refresh_token",
+                    "refresh_token": body.refresh_token,
+                    "client_id": body.client_id,
+                    "client_secret": body.client_secret,
+                },
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+            )
+            token_resp.raise_for_status()
+            access_token = token_resp.json()["access_token"]
+
+            profiles_resp = await client.get(
+                f"{api_url}/v2/profiles",
+                headers={
+                    "Authorization": f"Bearer {access_token}",
+                    "Amazon-Advertising-API-ClientId": body.client_id,
+                },
+            )
+            profiles_resp.raise_for_status()
+            profiles = profiles_resp.json()
+
+        return [
+            {
+                "profile_id": str(p["profileId"]),
+                "name": f"{p['accountInfo']['name']} ({p['countryCode']})",
+                "account_id": p["accountInfo"]["id"],
+                "country_code": p["countryCode"],
+            }
+            for p in profiles
+        ]
+    except Exception as exc:
+        handle_error(exc, "fetching Amazon Ads profiles")
+        return []  # unreachable, but satisfies type checker

interloper_api/routes/external/facebook_ads.py

@@ -0,0 +1,55 @@
+"""Facebook Ads external API routes."""
+
+from __future__ import annotations
+
+import httpx
+from fastapi import APIRouter, Depends
+from interloper_db import Profile
+from pydantic import BaseModel
+
+from interloper_api.dependencies import require_viewer
+from interloper_api.routes.external import handle_error
+
+sub_router = APIRouter()
+
+_BASE_URL = "https://graph.facebook.com/v21.0"
+
+
+class FacebookAdsConnectionRequest(BaseModel):
+    """Facebook Ads connection credentials (matches FacebookAdsConnection fields)."""
+
+    access_token: str
+    app_id: str = ""
+    app_secret: str = ""
+
+
+@sub_router.post("/facebook-ads/accounts")
+async def facebook_ads_accounts(
+    body: FacebookAdsConnectionRequest,
+    _user: Profile = Depends(require_viewer),
+) -> list[dict[str, str]]:
+    """Fetch Facebook Ads ad accounts accessible by the connection."""
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.get(
+                f"{_BASE_URL}/me/adaccounts",
+                params={
+                    "access_token": body.access_token,
+                    "fields": "account_id,name,account_status",
+                    "limit": "500",
+                },
+            )
+            resp.raise_for_status()
+            data = resp.json().get("data", [])
+
+        return [
+            {
+                "account_id": acct["account_id"],
+                "name": f"{acct.get('name', acct['account_id'])}",
+            }
+            for acct in data
+            if acct.get("account_status") == 1  # ACTIVE only
+        ]
+    except Exception as exc:
+        handle_error(exc, "fetching Facebook Ads accounts")
+        return []

interloper_api/routes/external/google_ads.py

@@ -0,0 +1,104 @@
+"""Google Ads external API routes."""
+
+from __future__ import annotations
+
+import httpx
+from fastapi import APIRouter, Depends
+from interloper_db import Profile
+from pydantic import BaseModel
+
+from interloper_api.dependencies import require_viewer
+from interloper_api.routes.external import handle_error
+
+sub_router = APIRouter()
+
+_TOKEN_URL = "https://oauth2.googleapis.com/token"
+_BASE_URL = "https://googleads.googleapis.com/v20"
+
+
+class GoogleAdsConnectionRequest(BaseModel):
+    """Google Ads connection credentials (matches GoogleAdsConnection fields)."""
+
+    client_id: str
+    client_secret: str
+    developer_token: str
+    refresh_token: str
+
+
+async def _get_access_token(client: httpx.AsyncClient, body: GoogleAdsConnectionRequest) -> str:
+    """Exchange the refresh token for an access token."""
+    resp = await client.post(
+        _TOKEN_URL,
+        data={
+            "grant_type": "refresh_token",
+            "refresh_token": body.refresh_token,
+            "client_id": body.client_id,
+            "client_secret": body.client_secret,
+        },
+    )
+    resp.raise_for_status()
+    return resp.json()["access_token"]  # type: ignore[no-any-return]
+
+
+def _auth_headers(access_token: str, developer_token: str) -> dict[str, str]:
+    return {
+        "Authorization": f"Bearer {access_token}",
+        "developer-token": developer_token,
+    }
+
+
+@sub_router.post("/google-ads/customers")
+async def google_ads_customers(
+    body: GoogleAdsConnectionRequest,
+    _user: Profile = Depends(require_viewer),
+) -> list[dict[str, str]]:
+    """Fetch Google Ads customer accounts accessible by the connection."""
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            access_token = await _get_access_token(client, body)
+            headers = _auth_headers(access_token, body.developer_token)
+
+            # Step 1: List accessible customer resource names.
+            list_resp = await client.get(
+                f"{_BASE_URL}/customers:listAccessibleCustomers",
+                headers=headers,
+            )
+            list_resp.raise_for_status()
+            resource_names: list[str] = list_resp.json().get("resourceNames", [])
+
+            # Step 2: Fetch descriptive name for each customer.
+            results: list[dict[str, str]] = []
+            for rn in resource_names:
+                # rn is like "customers/1234567890"
+                customer_id = rn.split("/")[-1]
+                query = (
+                    "SELECT customer.id, customer.descriptive_name, customer.status "
+                    "FROM customer LIMIT 1"
+                )
+                try:
+                    search_resp = await client.post(
+                        f"{_BASE_URL}/{rn}/googleAds:searchStream",
+                        headers=headers,
+                        json={"query": query},
+                    )
+                    search_resp.raise_for_status()
+                    batches = search_resp.json()
+                    for batch in batches:
+                        for row in batch.get("results", []):
+                            customer = row.get("customer", {})
+                            name = customer.get("descriptiveName", customer_id)
+                            results.append({
+                                "customer_id": customer_id,
+                                "name": f"{name} ({customer_id})",
+                            })
+                except httpx.HTTPStatusError:
+                    # Some customers may not be queryable (suspended, etc.)
+                    results.append({
+                        "customer_id": customer_id,
+                        "name": customer_id,
+                    })
+
+        return results
+    except Exception as exc:
+        handle_error(exc, "fetching Google Ads customers")
+        return []

interloper_api/routes/external/pinterest_ads.py

@@ -0,0 +1,77 @@
+"""Pinterest Ads external API routes."""
+
+from __future__ import annotations
+
+import httpx
+from fastapi import APIRouter, Depends
+from interloper_db import Profile
+from pydantic import BaseModel
+
+from interloper_api.dependencies import require_viewer
+from interloper_api.routes.external import handle_error
+
+sub_router = APIRouter()
+
+_BASE_URL = "https://api.pinterest.com/v5"
+
+
+class PinterestAdsConnectionRequest(BaseModel):
+    """Pinterest Ads connection credentials (matches PinterestAdsConnection fields)."""
+
+    client_id: str
+    client_secret: str
+    refresh_token: str
+
+
+async def _get_access_token(body: PinterestAdsConnectionRequest) -> str:
+    """Exchange refresh token for an access token using HTTP Basic auth."""
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(
+            f"{_BASE_URL}/oauth/token",
+            auth=(body.client_id, body.client_secret),
+            data={
+                "grant_type": "refresh_token",
+                "refresh_token": body.refresh_token,
+            },
+        )
+        resp.raise_for_status()
+        return resp.json()["access_token"]
+
+
+@sub_router.post("/pinterest-ads/accounts")
+async def pinterest_ads_accounts(
+    body: PinterestAdsConnectionRequest,
+    _user: Profile = Depends(require_viewer),
+) -> list[dict[str, str]]:
+    """Fetch Pinterest Ads ad accounts accessible by the connection."""
+    try:
+        token = await _get_access_token(body)
+        headers = {"Authorization": f"Bearer {token}"}
+
+        accounts: list[dict[str, str]] = []
+        bookmark: str | None = None
+
+        async with httpx.AsyncClient(timeout=30, headers=headers) as client:
+            while True:
+                params: dict[str, str] = {"page_size": "100"}
+                if bookmark:
+                    params["bookmark"] = bookmark
+
+                resp = await client.get(f"{_BASE_URL}/ad_accounts", params=params)
+                resp.raise_for_status()
+                data = resp.json()
+
+                for acct in data.get("items", []):
+                    accounts.append({
+                        "id": acct["id"],
+                        "name": acct.get("name", acct["id"]),
+                    })
+
+                bookmark = data.get("bookmark")
+                if not bookmark:
+                    break
+
+        return accounts
+    except Exception as exc:
+        handle_error(exc, "fetching Pinterest Ads accounts")
+        return []

interloper_api/routes/external/snapchat_ads.py

@@ -0,0 +1,86 @@
+"""Snapchat Ads external API routes."""
+
+from __future__ import annotations
+
+import httpx
+from fastapi import APIRouter, Depends
+from interloper_db import Profile
+from pydantic import BaseModel
+
+from interloper_api.dependencies import require_viewer
+from interloper_api.routes.external import handle_error
+
+sub_router = APIRouter()
+
+_BASE_URL = "https://adsapi.snapchat.com/v1"
+_TOKEN_URL = "https://accounts.snapchat.com/login/oauth2/access_token"
+
+
+class SnapchatAdsConnectionRequest(BaseModel):
+    """Snapchat Ads connection credentials (matches SnapchatAdsConnection fields)."""
+
+    client_id: str
+    client_secret: str
+    refresh_token: str
+
+
+async def _get_access_token(body: SnapchatAdsConnectionRequest) -> str:
+    """Exchange refresh token for an access token."""
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(
+            _TOKEN_URL,
+            data={
+                "grant_type": "refresh_token",
+                "client_id": body.client_id,
+                "client_secret": body.client_secret,
+                "refresh_token": body.refresh_token,
+            },
+        )
+        resp.raise_for_status()
+        return resp.json()["access_token"]
+
+
+@sub_router.post("/snapchat-ads/ad-accounts")
+async def snapchat_ads_accounts(
+    body: SnapchatAdsConnectionRequest,
+    _user: Profile = Depends(require_viewer),
+) -> list[dict[str, str]]:
+    """Fetch Snapchat Ads ad accounts accessible by the connection.
+
+    Flow: authenticate → list organizations → list ad accounts per org.
+    """
+    try:
+        token = await _get_access_token(body)
+        headers = {"Authorization": f"Bearer {token}"}
+
+        async with httpx.AsyncClient(timeout=30, headers=headers) as client:
+            # 1. Get organizations
+            org_resp = await client.get(f"{_BASE_URL}/me/organizations")
+            org_resp.raise_for_status()
+            orgs = org_resp.json().get("organizations", [])
+
+            # 2. Get ad accounts for each organization
+            accounts: list[dict[str, str]] = []
+            for org_wrapper in orgs:
+                org = org_wrapper.get("organization", {})
+                org_id = org.get("id")
+                if not org_id:
+                    continue
+
+                acct_resp = await client.get(f"{_BASE_URL}/organizations/{org_id}/adaccounts")
+                acct_resp.raise_for_status()
+                ad_accounts = acct_resp.json().get("adaccounts", [])
+
+                for acct_wrapper in ad_accounts:
+                    acct = acct_wrapper.get("adaccount", {})
+                    if acct.get("status") != "ACTIVE":
+                        continue
+                    accounts.append({
+                        "id": acct["id"],
+                        "name": acct.get("name", acct["id"]),
+                    })
+
+        return accounts
+    except Exception as exc:
+        handle_error(exc, "fetching Snapchat Ads ad accounts")
+        return []