PostgreSQL API
in Milliseconds

query {
  users(filter: {status: {eq: "active"}}, limit: 10) {
    id
    name
    email
    orders {
      id
      total
      items {
        product { name price }
      }
    }
  }
}

mutation {
  insertUsers(objects: [
    {name: "Charlie", email: "charlie@example.com"}
  ]) {
    id
    name
    createdAt
  }
}

# Insert a new product
curl -X POST "localhost:3000/products" \
  -H "Content-Type: application/json" \
  -d '{"name": "Widget", "price": 29.99, "stock": 100}'

# Update with filters (PATCH)
curl -X PATCH "localhost:3000/products?id=eq.1" \
  -H "Content-Type: application/json" \
  -d '{"price": 24.99}'

# Upsert (insert or update on conflict)
curl -X POST "localhost:3000/products" \
  -H "Prefer: resolution=merge-duplicates" \
  -d '{"sku": "WDG-001", "name": "Widget Pro", "price": 39.99}'

# Delete with filters
curl -X DELETE "localhost:3000/products?status=eq.discontinued"

# Include JWT in Authorization header
curl -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIs..." \
  "localhost:3000/users"

# JWT payload for PostgreSQL RLS
{
  "role": "authenticated",
  "sub": "user_123",
  "email": "alice@example.com"
}

-- PostgreSQL RLS Policy
CREATE POLICY user_isolation ON orders
  FOR ALL
  USING (user_id = current_setting('request.jwt.claims')::json->>'sub');

-- Users can only see their own orders
-- Postrust enforces this automatically

# Count orders by status
curl "localhost:3000/orders?select=status,count()&group=status"

# Sum and average
curl "localhost:3000/order_items?select=product_id,sum(quantity),avg(price)"

# Response
[
  {"status": "pending", "count": 42},
  {"status": "shipped", "count": 156}
]

# Call a PostgreSQL function
curl -X POST "localhost:3000/rpc/calculate_shipping" \
  -H "Content-Type: application/json" \
  -d '{"order_id": 123, "destination": "US"}'

# Response
{"shipping_cost": 12.99, "estimated_days": 3}

subscription {
  orders(filter: {status: {eq: "pending"}}) {
    id
    total
    status
    customer { name email }
  }
}

# Receive live updates when orders change
{"data": {"orders": {"id": 42, "status": "shipped", ...}}}

# Subscribe to a PostgreSQL view for live dashboards
subscription {
  salesDashboard {
    totalRevenue
    orderCount
    topProducts { name salesCount }
  }
}

# Updates stream in real-time as underlying data changes

# Find similar documents using embeddings
curl "localhost:3000/documents?select=id,title,content&embedding=lt.0.5&order=embedding.asc"

# Or via GraphQL with vector distance
query {
  documents(
    filter: {embedding: {near: {vector: [0.1, 0.2, ...], distance: 0.5}}}
    order: {embedding: ASC}
    limit: 10
  ) {
    id title content similarity
  }
}

-- PostgreSQL: Create embeddings table
CREATE TABLE documents (
  id SERIAL PRIMARY KEY,
  content TEXT,
  embedding vector(1536)  -- OpenAI ada-002 dimensions
);
CREATE INDEX ON documents USING ivfflat (embedding vector_cosine_ops);

# Query similar content for LLM context
curl "localhost:3000/rpc/search_similar" \
  -d '{"query_embedding": [0.1, 0.2, ...], "limit": 5}'

// crates/postrust-server/src/custom.rs
use axum::{extract::State, Json, routing::post};

pub fn custom_router() -> Router<Arc<AppState>> {
    Router::new()
        .route("/webhooks/stripe", post(handle_stripe))
        .route("/ai/embed", post(generate_embedding))
}

async fn handle_stripe(
    State(state): State<Arc<AppState>>,
    body: String,
) -> impl IntoResponse {
    // Full access to database pool, config, JWT
    let result = sqlx::query("UPDATE subscriptions...")
        .execute(&state.pool).await;
    Json(json!({ "received": true }))
}

// Add rate limiting, logging, or custom auth
use axum::middleware;

pub fn custom_router() -> Router<Arc<AppState>> {
    Router::new()
        .route("/api/expensive", post(expensive_operation))
        .layer(middleware::from_fn(rate_limit))
        .layer(middleware::from_fn(custom_auth))
}

async fn rate_limit<B>(req: Request<B>, next: Next<B>) -> Response {
    // Check rate limits, return 429 if exceeded
    next.run(req).await
}