Keep users in the flow
with less typing.

import asyncio
import hashlib
import os
import time

import httpx
from fastapi import Request
from fastapi.responses import JSONResponse

# Add to your existing FastAPI app. Load these on the server only.
api_key = os.environ.get("AUTOCOMPLETE_API_KEY")
website_origin = os.environ.get("AUTOCOMPLETE_WEBSITE_ORIGIN")
if not api_key or not website_origin:
    raise RuntimeError("Set AUTOCOMPLETE_API_KEY and AUTOCOMPLETE_WEBSITE_ORIGIN")


def session_response(body, status=200):
    return JSONResponse(body, status_code=status, headers={"Cache-Control": "no-store"})


# Keep your existing login, CSRF and rate-limit middleware on this route.
@app.post("/api/autocomplete-session")
async def autocomplete_session(request: Request):
    # CONNECT YOUR AUTH: this value must come from your verified login.
    # Adapt this line to your auth library's stable internal user ID.
    user_id = getattr(request.state, "user_id", None)
    if user_id is None or user_id == "":
        return session_response({"error": "sign_in_required"}, 401)
    # Apply any plan or experiment eligibility checks here as well.
    if request.headers.get("origin") != website_origin:
        return session_response({"error": "origin_not_allowed"}, 403)

    # Map your internal ID (not an email) to an API-compatible opaque ID.
    opaque_user_id = hashlib.sha256(str(user_id).encode("utf-8")).hexdigest()
    try:
        started_at = time.monotonic()
        async with asyncio.timeout(5), httpx.AsyncClient(timeout=5, follow_redirects=False) as client:
            response = await client.post(
                "https://autocomplete.dev/v1/browser-sessions",
                headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
                json={"user_id": opaque_user_id, "origin": website_origin},
            )
            if not response.is_success:
                return session_response({
                    "error": "autocomplete_unavailable", "upstream_status": response.status_code,
                }, 429 if response.status_code == 429 else 502)
            session = response.json()
            token, expires_at = session.get("token"), session.get("expires_at")
            if (not isinstance(token, str) or not token or type(expires_at) is not int
                    or not 0 < expires_at <= 9_007_199_254_740_991):
                return session_response({"error": "invalid_session_response"}, 502)
            if "expires_in" in session:
                expires_in = session["expires_in"]
                if type(expires_in) not in (int, float) or not 0 <= expires_in <= 900:
                    return session_response({"error": "invalid_session_response"}, 502)
                expires_in -= max(0, time.monotonic() - started_at)
            else:  # Compatibility with older APIs; uses only the server's clock.
                expires_in = min(900, expires_at - time.time())
            if expires_in <= 0:
                return session_response({"error": "invalid_session_response"}, 502)
            return session_response({"token": token, "expires_at": expires_at, "expires_in": expires_in})
    except (httpx.HTTPError, TimeoutError, ValueError, AttributeError):
        return session_response({"error": "autocomplete_unavailable"}, 503)

import { createHash } from 'node:crypto';

// Add to your existing Express app. Load these on the server only.
const apiKey = process.env.AUTOCOMPLETE_API_KEY;
const websiteOrigin = process.env.AUTOCOMPLETE_WEBSITE_ORIGIN;
if (!apiKey || !websiteOrigin) {
  throw new Error('Set AUTOCOMPLETE_API_KEY and AUTOCOMPLETE_WEBSITE_ORIGIN');
}

// Register after your existing login, CSRF and rate-limit middleware.
app.post('/api/autocomplete-session', async (req, res) => {
  res.set('Cache-Control', 'no-store');

  // CONNECT YOUR AUTH: req.user must come from your verified login.
  // Adapt this line to your auth library's stable internal user ID.
  const userId = req.user?.id;
  if (userId == null || userId === '') {
    return res.status(401).json({ error: 'sign_in_required' });
  }
  // Apply any plan or experiment eligibility checks here as well.
  if (req.get('Origin') !== websiteOrigin) {
    return res.status(403).json({ error: 'origin_not_allowed' });
  }

  // Map your internal ID (not an email) to an API-compatible opaque ID.
  const opaqueUserId = createHash('sha256').update(String(userId)).digest('hex');
  try {
    const startedAt = performance.now();
    const response = await fetch('https://autocomplete.dev/v1/browser-sessions', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ user_id: opaqueUserId, origin: websiteOrigin }),
      signal: AbortSignal.timeout(5000),
      redirect: 'error',
    });
    if (!response.ok) {
      return res.status(response.status === 429 ? 429 : 502).json({
        error: 'autocomplete_unavailable', upstream_status: response.status,
      });
    }
    const session = await response.json();
    const { token, expires_at } = session;
    if (typeof token !== 'string' || !token ||
        !Number.isSafeInteger(expires_at) || expires_at <= 0) {
      return res.status(502).json({ error: 'invalid_session_response' });
    }
    let expires_in;
    if (Object.hasOwn(session, 'expires_in')) {
      expires_in = session.expires_in;
      if (!Number.isFinite(expires_in) || expires_in < 0 || expires_in > 900) {
        return res.status(502).json({ error: 'invalid_session_response' });
      }
      expires_in -= Math.max(0, performance.now() - startedAt) / 1000;
    } else { // Compatibility with older APIs; uses only the server's clock.
      expires_in = Math.min(900, expires_at - Date.now() / 1000);
    }
    if (expires_in <= 0) return res.status(502).json({ error: 'invalid_session_response' });
    return res.json({ token, expires_at, expires_in });
  } catch {
    return res.status(503).json({ error: 'autocomplete_unavailable' });
  }
});