Keep the engine's state in SQLite, not Postgres

One process owns this database — the image has run a single uvicorn
worker for that reason since the four-engines bug — so a file beside the
flows is the honest shape for it, and it is what lets `fluksio serve`
need no infrastructure at all. Live values, node execution and the work
queue never came here anyway; what does is a rollup a minute at a time,
a row per cascade and the run history, and WAL keeps the readers going
while that one writer works.

DATA_DIR is now the one setting that moves everything an installation
keeps; the rest derive from it and the images still spell theirs out.
The schema is prepared in-process at startup, so the prestart service is
gone, and the ten Postgres-only revisions collapse into one portable
baseline.

Three things only worked because psycopg was casting for us: a token's
subject arriving as a string where the column is a UUID, `greatest`, and
`date_bin`. The timestamps needed a column type of their own — SQLite
stores no offset, and a naive datetime read back either raises against an
aware `now` or serialises as local time.

Postgres stays in the stack only for Umami, behind the analytics profile.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

backend/tests/conftest.py

@@ -1,18 +1,18 @@
 import uuid
 from collections.abc import Generator
 from datetime import UTC, datetime
+from pathlib import Path
 from typing import Any
 
 import pytest
 from cryptography.hazmat.primitives.asymmetric import rsa
 from fastapi.testclient import TestClient
-from sqlalchemy import create_engine, text
 from sqlalchemy.engine import make_url
-from sqlmodel import Session, SQLModel, select
+from sqlmodel import Session, select
 
 from fluksio.cloud import config as cloud_config
 from fluksio.core.config import settings
-from fluksio.core.db import engine, init_db
+from fluksio.core.db import engine, prepare
 from fluksio.main import app
 from fluksio.models import User
 from tests.utils.portal import INSTALLATION_ID, ISSUER, jwks
@@ -33,28 +33,25 @@ def flow_data(tmp_path_factory: pytest.TempPathFactory) -> Generator[None, None,
 @pytest.fixture(scope="session", autouse=True)
 def db() -> Generator[Session, None, None]:
     """Create the throwaway database `tests/__init__.py` points at, drop it after."""
-    url = make_url(str(settings.SQLALCHEMY_DATABASE_URI))
-    # The teardown drops this database, so refuse to run against anything but
+    url = make_url(settings.SQLALCHEMY_DATABASE_URI)
+    # The teardown deletes this database, so refuse to run against anything but
     # the dedicated test one.
-    assert url.database and url.database.endswith("_test"), url.database
+    assert url.get_backend_name() == "sqlite", url.get_backend_name()
+    assert url.database and url.database.endswith("_test.db"), url.database
 
-    maintenance = create_engine(
-        url.set(database="postgres"), isolation_level="AUTOCOMMIT"
-    )
-    drop = text(f'DROP DATABASE IF EXISTS "{url.database}" WITH (FORCE)')
-    with maintenance.connect() as connection:
-        connection.execute(drop)
-        connection.execute(text(f'CREATE DATABASE "{url.database}"'))
-
-    SQLModel.metadata.create_all(engine)
+    path = Path(url.database)
+    path.unlink(missing_ok=True)
+    # The real path, so the suite runs against a database built the way a
+    # deployment's is — including the alembic stamp the app's own startup
+    # would otherwise trip over.
+    prepare(engine)
     with Session(engine) as session:
-        init_db(session)
         yield session
 
     engine.dispose()
-    with maintenance.connect() as connection:
-        connection.execute(drop)
-    maintenance.dispose()
+    # The write-ahead log and its index are part of the database.
+    for suffix in ("", "-wal", "-shm"):
+        path.with_name(path.name + suffix).unlink(missing_ok=True)
 
 
 @pytest.fixture(scope="module")