Integrations and API Design

// TypeScript with Zod
import { z } from "zod"

const CompanySchema = z.object({
  id: z.string(),
  name: z.string(),
  founded_date: z.string().datetime().optional(),
  funding_total: z.number().positive().optional(),
  employee_count: z.number().int().positive().optional(),
})

// When you get data from an API
const response = await fetch("https://api.vendor.com/companies/123")
const data = await response.json()

// Validate it
const company = CompanySchema.parse(data) // Throws if invalid
// or
const result = CompanySchema.safeParse(data) // Returns success/error
if (!result.success) {
  console.error("Invalid data from API:", result.error)
  // Handle the error
}

# Python with Pydantic
from pydantic import BaseModel, validator
from datetime import datetime
from typing import Optional

class Company(BaseModel):
    id: str
    name: str
    founded_date: Optional[datetime] = None
    funding_total: Optional[float] = None
    employee_count: Optional[int] = None

    @validator('funding_total')
    def funding_must_be_positive(cls, v):
        if v is not None and v < 0:
            raise ValueError('funding must be positive')
        return v

# When you get data from an API
response = requests.get('https://api.vendor.com/companies/123')
data = response.json()

# Validate it
try:
    company = Company(**data)
except ValidationError as e:
    print(f'Invalid data from API: {e}')
    # Handle the error

// Next.js API route for Attio webhooks
import { NextRequest, NextResponse } from "next/server"
import crypto from "crypto"

export async function POST(request: NextRequest) {
  const body = await request.text()
  const signature = request.headers.get("x-attio-signature")

  // Verify webhook signature
  const expectedSignature = crypto
    .createHmac("sha256", process.env.ATTIO_WEBHOOK_SECRET!)
    .update(body)
    .digest("hex")

  if (signature !== expectedSignature) {
    return NextResponse.json({ error: "Invalid signature" }, { status: 401 })
  }

  // Parse and process the event
  const event = JSON.parse(body)

  // Handle idempotency - check if we've seen this event before
  const eventId = event.id
  const alreadyProcessed = await checkIfProcessed(eventId)
  if (alreadyProcessed) {
    return NextResponse.json({ success: true }) // Already handled
  }

  // Process the event
  await handleEvent(event)

  // Mark as processed
  await markProcessed(eventId)

  return NextResponse.json({ success: true })
}

async function fetchWithRetry(url: string, maxRetries = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url)

      if (response.status === 429) {
        // Rate limited
        const retryAfter = response.headers.get("retry-after")
        const waitSeconds = retryAfter ? parseInt(retryAfter) : Math.pow(2, attempt) + Math.random() // Exponential backoff with jitter

        await sleep(waitSeconds * 1000)
        continue
      }

      if (response.ok) {
        return response
      }

      // Other errors - decide if retriable
      if (response.status >= 500) {
        // Server error, might be transient
        await sleep(Math.pow(2, attempt) * 1000)
        continue
      }

      // Client error (4xx), don't retry
      throw new Error(`API error: ${response.status}`)
    } catch (error) {
      if (attempt === maxRetries - 1) {
        throw error
      }
      await sleep(Math.pow(2, attempt) * 1000)
    }
  }
}

await db.transaction(async (tx) => {
  const company = await tx
    .insert(companies)
    .values({
      id: data.id,
      name: data.name,
    })
    .returning()

  for (const round of data.funding_rounds) {
    await tx.insert(fundingRounds).values({
      company_id: company.id,
      round_name: round.name,
      amount: round.amount,
    })
  }

  // If any insert fails, everything rolls back
})

import { openai, anthropic } from "@ai-sdk/providers"
import { generateText } from "ai"

// Vercel AI SDK handles failover automatically
const result = await generateText({
  model: openai("gpt-4"), // Primary
  fallbacks: [anthropic("claude-3-5-sonnet")], // Fallback if primary fails
  prompt: "Summarize this company...",
})