Add a database: SQLite first, then Postgres

I have a working FastAPI app (code below) that keeps orders in a Python dict. Replace the dict with a database using SQLAlchemy 2.0 (the Mapped and mapped_column style) so that the same code works with SQLite and Postgres.

Requirements:
- New file app/db.py: engine from the DATABASE_URL environment variable, default sqlite:///./brew.db. If the URL starts with postgres:// or postgresql://, change it to postgresql+psycopg:// so SQLAlchemy uses the psycopg driver. Add check_same_thread=False for SQLite only. A get_db() dependency that gives each request its own session and always closes it.
- New file app/models.py: tables orders and order_items with a one-to-many relationship, as described below.
- Datetimes: store UTC, and make sure datetimes read from SQLite come back timezone-aware.
- Update app/main.py: use Depends(get_db), create tables at startup with a lifespan function, commit after changes. Keep all endpoint behaviour, status codes and rules exactly the same. Keep the Pydantic schemas unchanged.
- No Alembic yet. No raw SQL strings.

Tables:
[paste the table list from this lesson]

Current code:
[paste app/main.py and app/schemas.py]

Return only the new or changed files.

import os

from sqlalchemy import create_engine
from sqlalchemy.orm import DeclarativeBase, sessionmaker

DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./brew.db")

# Hosts often give a URL that starts with postgres:// or postgresql://.
# SQLAlchemy needs to be told which Python driver to use (psycopg).
if DATABASE_URL.startswith("postgres://"):
    DATABASE_URL = DATABASE_URL.replace("postgres://", "postgresql+psycopg://", 1)
elif DATABASE_URL.startswith("postgresql://"):
    DATABASE_URL = DATABASE_URL.replace("postgresql://", "postgresql+psycopg://", 1)

# SQLite refuses to share one connection between threads unless told it is fine.
connect_args = {"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}

engine = create_engine(DATABASE_URL, connect_args=connect_args)
SessionLocal = sessionmaker(bind=engine, autoflush=False)


class Base(DeclarativeBase):
    pass


def get_db():
    """Give each request its own session and always close it."""
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

from datetime import datetime, timezone

from sqlalchemy import DateTime, ForeignKey, Integer, String
from sqlalchemy.orm import Mapped, mapped_column, relationship
from sqlalchemy.types import TypeDecorator

from app.db import Base


class UTCDateTime(TypeDecorator):
    """SQLite drops the timezone. Put it back so every datetime is UTC."""

    impl = DateTime(timezone=True)
    cache_ok = True

    def process_result_value(self, value, dialect):
        if value is not None and value.tzinfo is None:
            value = value.replace(tzinfo=timezone.utc)
        return value


class Order(Base):
    __tablename__ = "orders"

    id: Mapped[str] = mapped_column(String(32), primary_key=True)
    customer_name: Mapped[str] = mapped_column(String(60))
    phone: Mapped[str] = mapped_column(String(10))
    total: Mapped[int] = mapped_column(Integer)
    status: Mapped[str] = mapped_column(String(20), default="received")
    pickup_time: Mapped[datetime] = mapped_column(UTCDateTime)
    created_at: Mapped[datetime] = mapped_column(UTCDateTime)

    items: Mapped[list["OrderItem"]] = relationship(
        back_populates="order",
        cascade="all, delete-orphan",
        order_by="OrderItem.id",
    )


class OrderItem(Base):
    __tablename__ = "order_items"

    id: Mapped[int] = mapped_column(primary_key=True)
    order_id: Mapped[str] = mapped_column(ForeignKey("orders.id"), index=True)
    item_id: Mapped[str] = mapped_column(String(40))
    name: Mapped[str] = mapped_column(String(80))
    price: Mapped[int] = mapped_column(Integer)  # price per item at order time
    qty: Mapped[int] = mapped_column(Integer)

    order: Mapped["Order"] = relationship(back_populates="items")

import os
import secrets
from contextlib import asynccontextmanager
from datetime import datetime, timedelta, timezone

from fastapi import Depends, FastAPI, Header, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from sqlalchemy.orm import Session

from app.db import Base, engine, get_db
from app.menu import MENU, MENU_BY_ID
from app.models import Order, OrderItem
from app.schemas import MenuItem, OrderIn, OrderOut, StatusUpdate


@asynccontextmanager
async def lifespan(app: FastAPI):
    # Create the tables if they do not exist yet. Runs once at startup.
    Base.metadata.create_all(engine)
    yield


app = FastAPI(title="Brew & Bean API", lifespan=lifespan)

# Which websites may call this API from a browser. Comma-separated list.
origins = os.getenv("CORS_ORIGINS", "http://localhost:5173").split(",")
app.add_middleware(
    CORSMiddleware,
    allow_origins=[origin.strip() for origin in origins],
    allow_methods=["GET", "POST", "PATCH"],
    allow_headers=["Content-Type", "X-Admin-Key"],
)

# Minutes from "now" for each pickup choice.
PICKUP_MINUTES = {"asap": 10, "in_15": 15, "in_30": 30, "in_60": 60}

# Which status may follow which. A finished order cannot change again.
NEXT_STATUS = {
    "received": {"preparing", "cancelled"},
    "preparing": {"ready", "cancelled"},
    "ready": {"picked_up"},
    "picked_up": set(),
    "cancelled": set(),
}


def require_admin(x_admin_key: str | None) -> None:
    expected = os.getenv("ADMIN_KEY")
    if not expected:
        raise HTTPException(503, "ADMIN_KEY is not set on the server")
    if not x_admin_key or not secrets.compare_digest(x_admin_key, expected):
        raise HTTPException(401, "Missing or wrong admin key")


@app.get("/menu", response_model=list[MenuItem])
def get_menu():
    return MENU


@app.post("/orders", response_model=OrderOut, status_code=201)
def create_order(order: OrderIn, db: Session = Depends(get_db)):
    rows = []
    total = 0
    for line in order.items:
        item = MENU_BY_ID.get(line.item_id)
        if item is None:
            raise HTTPException(422, f"Unknown item: {line.item_id}")
        total += item.price * line.qty
        rows.append(
            OrderItem(item_id=item.id, name=item.name, price=item.price, qty=line.qty)
        )

    now = datetime.now(timezone.utc)
    new_order = Order(
        id=secrets.token_urlsafe(9),
        customer_name=order.customer_name,
        phone=order.phone,
        total=total,
        status="received",
        pickup_time=now + timedelta(minutes=PICKUP_MINUTES[order.pickup]),
        created_at=now,
        items=rows,
    )
    db.add(new_order)
    db.commit()
    db.refresh(new_order)
    return new_order


@app.get("/orders/{order_id}", response_model=OrderOut)
def get_order(order_id: str, db: Session = Depends(get_db)):
    order = db.get(Order, order_id)
    if order is None:
        raise HTTPException(404, "Order not found")
    return order


@app.patch("/orders/{order_id}/status", response_model=OrderOut)
def update_status(
    order_id: str,
    update: StatusUpdate,
    x_admin_key: str | None = Header(default=None),
    db: Session = Depends(get_db),
):
    require_admin(x_admin_key)
    order = db.get(Order, order_id)
    if order is None:
        raise HTTPException(404, "Order not found")
    if update.status not in NEXT_STATUS[order.status]:
        raise HTTPException(409, f"Cannot move from {order.status} to {update.status}")
    order.status = update.status
    db.commit()
    db.refresh(order)
    return order

# set the key again if this is a new terminal
export ADMIN_KEY=dev-admin-key    # PowerShell: $env:ADMIN_KEY = "dev-admin-key"
uvicorn app.main:app --reload

python -c "import sqlite3; db = sqlite3.connect('brew.db'); print(db.execute('select id, customer_name, total, status from orders').fetchall()); print(db.execute('select order_id, item_id, price, qty from order_items').fetchall())"

docker run --name brew-pg -e POSTGRES_PASSWORD=devpass -e POSTGRES_DB=brew -p 5432:5432 -d postgres:16

# macOS, Linux, Git Bash
export DATABASE_URL=postgresql://postgres:devpass@localhost:5432/brew

# Windows PowerShell
$env:DATABASE_URL = "postgresql://postgres:devpass@localhost:5432/brew"

uvicorn app.main:app --reload

docker exec brew-pg psql -U postgres -d brew -c "select id, customer_name, total, status from orders"

I am using FastAPI with SQLAlchemy 2.0 and [SQLite | Postgres]. I get this error when I [what you did]. Explain what it means in simple words, which of my files is probably wrong, and the smallest fix. Here is the full error and the relevant code.

Error:
[paste the full error]

Code:
[paste models.py or db.py]