pgrelay 0.1.0__py3-none-any.whl

alembic.ini

@@ -0,0 +1,37 @@
+[alembic]
+script_location = migrations
+version_table = pgrelay_alembic_version
+prepend_sys_path = .
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s

migrations/env.py

@@ -0,0 +1,61 @@
+"""Alembic environment for PgRelay."""
+
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+from sqlalchemy.engine import make_url
+
+from pgrelay.config.settings import load_settings
+from pgrelay.db import models
+from pgrelay.db.base import Base
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+database_url = config.get_main_option("sqlalchemy.url") or load_settings().database_url
+url = make_url(database_url).set(drivername="postgresql+psycopg")
+config.set_main_option("sqlalchemy.url", url.render_as_string(hide_password=False))
+target_metadata = Base.metadata
+loaded_models = (models.PgRelayAttempt, models.PgRelayJob, models.PgRelayQueue, models.PgRelayWorker)
+
+
+def run_migrations_offline() -> None:
+    """Run migrations without creating an engine."""
+    context.configure(
+        url=url.render_as_string(hide_password=False),
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        version_table="pgrelay_alembic_version",
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations with a sync Alembic engine."""
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            version_table="pgrelay_alembic_version",
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

migrations/versions/0001_initial_schema.py

@@ -0,0 +1,147 @@
+"""Initial PgRelay schema."""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "0001_initial_schema"
+down_revision: str | None = None
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Create PgRelay tables and indexes."""
+    op.create_table(
+        "pgrelay_queue",
+        sa.Column("name", sa.Text(), primary_key=True),
+        sa.Column("paused", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column("concurrency_limit", sa.Integer(), nullable=False, server_default=sa.text("8")),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+        sa.CheckConstraint("concurrency_limit > 0", name="ck_pgrelay_queue_concurrency_limit"),
+    )
+    op.create_table(
+        "pgrelay_job",
+        sa.Column("id", postgresql.UUID(), primary_key=True, server_default=sa.text("gen_random_uuid()")),
+        sa.Column("queue_name", sa.Text(), sa.ForeignKey("pgrelay_queue.name"), nullable=False),
+        sa.Column("kind", sa.Text(), nullable=False),
+        sa.Column("name", sa.Text(), nullable=False),
+        sa.Column("payload", postgresql.JSONB(), nullable=False, server_default=sa.text("'{}'::jsonb")),
+        sa.Column("headers", postgresql.JSONB(), nullable=False, server_default=sa.text("'{}'::jsonb")),
+        sa.Column("metadata", postgresql.JSONB(), nullable=False, server_default=sa.text("'{}'::jsonb")),
+        sa.Column("status", sa.Text(), nullable=False, server_default=sa.text("'pending'")),
+        sa.Column("priority", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("max_attempts", sa.Integer(), nullable=False, server_default=sa.text("10")),
+        sa.Column("attempt_count", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("available_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+        sa.Column("timeout_seconds", sa.Integer(), nullable=False, server_default=sa.text("30")),
+        sa.Column("idempotency_key", sa.Text(), nullable=True),
+        sa.Column("dedupe_key", sa.Text(), nullable=True),
+        sa.Column(
+            "replayed_from_job_id",
+            postgresql.UUID(),
+            sa.ForeignKey("pgrelay_job.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+        sa.Column("locked_by", sa.Text(), nullable=True),
+        sa.Column("locked_until", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("last_error_type", sa.Text(), nullable=True),
+        sa.Column("last_error_message", sa.Text(), nullable=True),
+        sa.Column("last_response_status", sa.Integer(), nullable=True),
+        sa.Column("trace_id", sa.Text(), nullable=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+        sa.Column("completed_at", sa.DateTime(timezone=True), nullable=True),
+        sa.CheckConstraint("kind IN ('http', 'handler')", name="ck_pgrelay_job_kind"),
+        sa.CheckConstraint(
+            "status IN ('pending', 'leased', 'succeeded', 'dead_letter', 'cancelled')",
+            name="ck_pgrelay_job_status",
+        ),
+        sa.CheckConstraint("max_attempts > 0", name="ck_pgrelay_job_max_attempts"),
+    )
+    op.create_table(
+        "pgrelay_attempt",
+        sa.Column("id", postgresql.UUID(), primary_key=True, server_default=sa.text("gen_random_uuid()")),
+        sa.Column(
+            "job_id",
+            postgresql.UUID(),
+            sa.ForeignKey("pgrelay_job.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("attempt_number", sa.Integer(), nullable=False),
+        sa.Column("worker_id", sa.Text(), nullable=False),
+        sa.Column("status", sa.Text(), nullable=False),
+        sa.Column("started_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("finished_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+        sa.Column("duration_ms", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("error_type", sa.Text(), nullable=True),
+        sa.Column("error_message", sa.Text(), nullable=True),
+        sa.Column("response_status", sa.Integer(), nullable=True),
+        sa.Column("response_body_preview", sa.String(length=2000), nullable=True),
+        sa.CheckConstraint("attempt_number > 0", name="ck_pgrelay_attempt_number"),
+        sa.CheckConstraint(
+            "status IN ('succeeded', 'failed', 'timeout', 'lease_expired')",
+            name="ck_pgrelay_attempt_status",
+        ),
+    )
+    op.create_table(
+        "pgrelay_worker",
+        sa.Column("worker_id", sa.Text(), primary_key=True),
+        sa.Column("queues", postgresql.ARRAY(sa.Text()), nullable=False),
+        sa.Column("hostname", sa.Text(), nullable=False),
+        sa.Column("started_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+        sa.Column("last_heartbeat_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.text("now()")),
+    )
+    op.create_index(
+        "idx_pgrelay_job_claim",
+        "pgrelay_job",
+        ["queue_name", sa.literal_column("priority DESC"), "available_at", "created_at"],
+        postgresql_where=sa.text("status = 'pending'"),
+    )
+    op.create_index(
+        "idx_pgrelay_job_locked_expired",
+        "pgrelay_job",
+        ["locked_until"],
+        postgresql_where=sa.text("status = 'leased'"),
+    )
+    op.create_index("idx_pgrelay_job_status_created", "pgrelay_job", ["status", "created_at"])
+    op.create_index(
+        "idx_pgrelay_job_dedupe_key",
+        "pgrelay_job",
+        ["dedupe_key"],
+        postgresql_where=sa.text("dedupe_key IS NOT NULL"),
+    )
+    op.create_index(
+        "uq_pgrelay_job_queue_idempotency_key",
+        "pgrelay_job",
+        ["queue_name", "idempotency_key"],
+        unique=True,
+        postgresql_where=sa.text("idempotency_key IS NOT NULL"),
+    )
+    op.create_index(
+        "idx_pgrelay_job_replayed_from",
+        "pgrelay_job",
+        ["replayed_from_job_id"],
+        postgresql_where=sa.text("replayed_from_job_id IS NOT NULL"),
+    )
+    op.create_index("idx_pgrelay_attempt_job_started", "pgrelay_attempt", ["job_id", "started_at"])
+    op.create_index("idx_pgrelay_worker_last_heartbeat", "pgrelay_worker", ["last_heartbeat_at"])
+
+
+def downgrade() -> None:
+    """Drop PgRelay tables and indexes."""
+    op.drop_index("idx_pgrelay_worker_last_heartbeat", table_name="pgrelay_worker")
+    op.drop_index("idx_pgrelay_attempt_job_started", table_name="pgrelay_attempt")
+    op.drop_index("idx_pgrelay_job_replayed_from", table_name="pgrelay_job")
+    op.drop_index("uq_pgrelay_job_queue_idempotency_key", table_name="pgrelay_job")
+    op.drop_index("idx_pgrelay_job_dedupe_key", table_name="pgrelay_job")
+    op.drop_index("idx_pgrelay_job_status_created", table_name="pgrelay_job")
+    op.drop_index("idx_pgrelay_job_locked_expired", table_name="pgrelay_job")
+    op.drop_index("idx_pgrelay_job_claim", table_name="pgrelay_job")
+    op.drop_table("pgrelay_worker")
+    op.drop_table("pgrelay_attempt")
+    op.drop_table("pgrelay_job")
+    op.drop_table("pgrelay_queue")

pgrelay/__init__.py

@@ -0,0 +1,3 @@
+"""PgRelay package."""
+
+__version__ = "0.1.0"

pgrelay/__main__.py

@@ -0,0 +1,12 @@
+"""Module entrypoint for PgRelay."""
+
+from pgrelay.cli.app import app
+
+
+def main() -> None:
+    """Run the PgRelay CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

pgrelay/api/__init__.py

@@ -0,0 +1 @@
+"""API package."""

pgrelay/api/app.py

@@ -0,0 +1,98 @@
+"""FastAPI application factory."""
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+
+from pgrelay.api.routers import health, jobs, queues, stats, workers
+from pgrelay.config.settings import Settings, load_settings
+from pgrelay.db.session import create_engine, create_session_factory
+from pgrelay.errors import ERROR_STATUS_CODES, PgRelayError
+from pgrelay.observability.logging import setup_logging
+from pgrelay.repositories.attempts import AttemptRepository
+from pgrelay.repositories.jobs import JobRepository
+from pgrelay.repositories.queues import QueueRepository
+from pgrelay.repositories.stats import StatsRepository
+from pgrelay.repositories.workers import WorkerRepository
+from pgrelay.schemas.api_errors import ApiError, ApiErrorResponse
+from pgrelay.services.enqueue import EnqueueService
+from pgrelay.services.jobs import JobService
+from pgrelay.services.queues import QueueService
+from pgrelay.services.stats import StatsService
+from pgrelay.services.workers import WorkerService
+
+
+def create_app(settings: Settings | None = None) -> FastAPI:
+    """Create a configured FastAPI app."""
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+        runtime_settings = settings or load_settings()
+        runtime_settings.validate_runtime()
+        setup_logging(runtime_settings.log_level)
+        engine = create_engine(runtime_settings)
+        session_factory = create_session_factory(engine)
+        queue_repository = QueueRepository()
+        job_repository = JobRepository(queue_repository)
+        attempt_repository = AttemptRepository()
+        worker_repository = WorkerRepository()
+        stats_repository = StatsRepository()
+        app.state.settings = runtime_settings
+        app.state.engine = engine
+        app.state.session_factory = session_factory
+        app.state.enqueue_service = EnqueueService(job_repository, runtime_settings)
+        app.state.job_service = JobService(job_repository, attempt_repository)
+        app.state.queue_service = QueueService(queue_repository)
+        app.state.worker_service = WorkerService(worker_repository)
+        app.state.stats_service = StatsService(stats_repository)
+        try:
+            yield
+        finally:
+            await engine.dispose()
+
+    app = FastAPI(title="PgRelay Admin API", version="0.1.0", lifespan=lifespan)
+    app.add_exception_handler(PgRelayError, _pgrelay_error_handler)  # type: ignore[arg-type]
+    app.add_exception_handler(RequestValidationError, _request_validation_handler)  # type: ignore[arg-type]
+    app.add_exception_handler(HTTPException, _http_exception_handler)  # type: ignore[arg-type]
+    app.add_exception_handler(Exception, _unexpected_exception_handler)
+    app.include_router(health.router)
+    app.include_router(jobs.router)
+    app.include_router(queues.router)
+    app.include_router(stats.router)
+    app.include_router(workers.router)
+    return app
+
+
+def _error_response(code: str, message: str, details: dict[str, Any] | None, status_code: int) -> JSONResponse:
+    body = ApiErrorResponse(error=ApiError(code=code, message=message, details=details))
+    return JSONResponse(status_code=status_code, content=jsonable_encoder(body))
+
+
+async def _pgrelay_error_handler(_request: Request, exc: PgRelayError) -> JSONResponse:
+    """Handle PgRelay domain errors."""
+    code = exc.error_code
+    return _error_response(code, str(exc), None, ERROR_STATUS_CODES.get(code, 500))
+
+
+async def _request_validation_handler(_request: Request, exc: RequestValidationError) -> JSONResponse:
+    """Handle FastAPI request validation errors."""
+    return _error_response(
+        "validation_error", "Request validation failed", {"errors": jsonable_encoder(exc.errors())}, 422
+    )
+
+
+async def _http_exception_handler(_request: Request, exc: HTTPException) -> JSONResponse:
+    """Handle HTTP exceptions with the common envelope."""
+    if isinstance(exc.detail, dict) and "error" in exc.detail:
+        return JSONResponse(status_code=exc.status_code, content=exc.detail)
+    return _error_response("http_error", str(exc.detail), None, exc.status_code)
+
+
+async def _unexpected_exception_handler(_request: Request, exc: Exception) -> JSONResponse:
+    """Handle unexpected errors."""
+    return _error_response("pgrelay_error", "Internal server error", {"type": type(exc).__name__}, 500)

pgrelay/api/dependencies.py

@@ -0,0 +1,62 @@
+"""FastAPI dependency helpers."""
+
+from collections.abc import AsyncGenerator
+from typing import cast
+
+from fastapi import Header, Request
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from pgrelay.config.settings import Settings
+from pgrelay.security.auth import require_api_token
+from pgrelay.services.enqueue import EnqueueService
+from pgrelay.services.jobs import JobService
+from pgrelay.services.queues import QueueService
+from pgrelay.services.stats import StatsService
+from pgrelay.services.workers import WorkerService
+
+
+def get_settings(request: Request) -> Settings:
+    """Return application settings."""
+    return cast(Settings, request.app.state.settings)
+
+
+async def get_session(request: Request) -> AsyncGenerator[AsyncSession, None]:
+    """Yield an API database session."""
+    session_factory: async_sessionmaker[AsyncSession] = request.app.state.session_factory
+    async with session_factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+
+
+def get_enqueue_service(request: Request) -> EnqueueService:
+    """Return enqueue service."""
+    return cast(EnqueueService, request.app.state.enqueue_service)
+
+
+def get_job_service(request: Request) -> JobService:
+    """Return job service."""
+    return cast(JobService, request.app.state.job_service)
+
+
+def get_queue_service(request: Request) -> QueueService:
+    """Return queue service."""
+    return cast(QueueService, request.app.state.queue_service)
+
+
+def get_stats_service(request: Request) -> StatsService:
+    """Return stats service."""
+    return cast(StatsService, request.app.state.stats_service)
+
+
+def get_worker_service(request: Request) -> WorkerService:
+    """Return worker service."""
+    return cast(WorkerService, request.app.state.worker_service)
+
+
+async def require_auth(request: Request, authorization: str | None = Header(default=None)) -> None:
+    """Require API authentication for admin endpoints."""
+    await require_api_token(get_settings(request), authorization)

pgrelay/api/routers/__init__.py

@@ -0,0 +1 @@
+"""API routers package."""

pgrelay/api/routers/health.py

@@ -0,0 +1,28 @@
+"""Health endpoints."""
+
+from fastapi import APIRouter, Request
+from sqlalchemy import text
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from pgrelay.errors import DatabaseUnavailableError
+
+router = APIRouter(tags=["health"])
+
+
+@router.get("/healthz")
+async def healthz() -> dict[str, str]:
+    """Return process liveness."""
+    return {"status": "ok"}
+
+
+@router.get("/readyz")
+async def readyz(request: Request) -> dict[str, str]:
+    """Return database readiness."""
+    session_factory: async_sessionmaker[AsyncSession] = request.app.state.session_factory
+    try:
+        async with session_factory() as session:
+            await session.execute(text("SELECT 1"))
+    except SQLAlchemyError as exc:
+        raise DatabaseUnavailableError("Database unavailable") from exc
+    return {"status": "ready", "database": "ok"}

pgrelay/api/routers/jobs.py

@@ -0,0 +1,107 @@
+"""Job admin endpoints."""
+
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, Query, Response, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pgrelay.api.dependencies import get_enqueue_service, get_job_service, get_session, require_auth
+from pgrelay.schemas.enqueue import EnqueueJobRequest
+from pgrelay.schemas.jobs import (
+    AttemptResponse,
+    CancelJobResponse,
+    JobListResponse,
+    JobResponse,
+    ReplayJobRequest,
+    ReplayJobResponse,
+)
+from pgrelay.sdk.result import EnqueueResult
+from pgrelay.services.enqueue import EnqueueService
+from pgrelay.services.jobs import JobService
+
+router = APIRouter(prefix="/v1/jobs", tags=["jobs"], dependencies=[Depends(require_auth)])
+SESSION_DEPENDENCY = Depends(get_session)
+ENQUEUE_SERVICE_DEPENDENCY = Depends(get_enqueue_service)
+JOB_SERVICE_DEPENDENCY = Depends(get_job_service)
+
+
+@router.post("", response_model=EnqueueResult, status_code=status.HTTP_201_CREATED)
+async def enqueue_job(
+    request: EnqueueJobRequest,
+    response: Response,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: EnqueueService = ENQUEUE_SERVICE_DEPENDENCY,
+) -> EnqueueResult:
+    """Enqueue a job through the admin API."""
+    result = await service.enqueue(session, request)
+    if not result.created:
+        response.status_code = status.HTTP_200_OK
+    return result
+
+
+@router.get("", response_model=JobListResponse)
+async def list_jobs(
+    status_filter: str | None = Query(default=None, alias="status"),
+    queue_name: str | None = None,
+    kind: str | None = None,
+    name: str | None = None,
+    dedupe_key: str | None = None,
+    limit: int = Query(default=50, ge=1, le=200),
+    offset: int = Query(default=0, ge=0),
+    include_total: bool = False,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: JobService = JOB_SERVICE_DEPENDENCY,
+) -> JobListResponse:
+    """List jobs without payload fields."""
+    return await service.list_jobs(
+        session,
+        status=status_filter,
+        queue_name=queue_name,
+        kind=kind,
+        name=name,
+        dedupe_key=dedupe_key,
+        limit=limit,
+        offset=offset,
+        include_total=include_total,
+    )
+
+
+@router.get("/{job_id}", response_model=JobResponse)
+async def get_job(
+    job_id: UUID,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: JobService = JOB_SERVICE_DEPENDENCY,
+) -> JobResponse:
+    """Return job detail."""
+    return await service.detail(session, job_id=job_id)
+
+
+@router.get("/{job_id}/attempts", response_model=list[AttemptResponse])
+async def get_attempts(
+    job_id: UUID,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: JobService = JOB_SERVICE_DEPENDENCY,
+) -> list[AttemptResponse]:
+    """Return attempts for a job."""
+    return await service.attempts_for_job(session, job_id=job_id)
+
+
+@router.post("/{job_id}/replay", response_model=ReplayJobResponse, status_code=status.HTTP_201_CREATED)
+async def replay_job(
+    job_id: UUID,
+    request: ReplayJobRequest,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: JobService = JOB_SERVICE_DEPENDENCY,
+) -> ReplayJobResponse:
+    """Replay a job."""
+    return await service.replay(session, job_id=job_id, force=request.force)
+
+
+@router.post("/{job_id}/cancel", response_model=CancelJobResponse)
+async def cancel_job(
+    job_id: UUID,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: JobService = JOB_SERVICE_DEPENDENCY,
+) -> CancelJobResponse:
+    """Cancel a pending job."""
+    return await service.cancel(session, job_id=job_id)

pgrelay/api/routers/queues.py

@@ -0,0 +1,52 @@
+"""Queue admin endpoints."""
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pgrelay.api.dependencies import get_queue_service, get_session, require_auth
+from pgrelay.schemas.queues import QueueResponse, QueueUpdateRequest
+from pgrelay.services.queues import QueueService
+
+router = APIRouter(prefix="/v1/queues", tags=["queues"], dependencies=[Depends(require_auth)])
+SESSION_DEPENDENCY = Depends(get_session)
+QUEUE_SERVICE_DEPENDENCY = Depends(get_queue_service)
+
+
+@router.get("", response_model=list[QueueResponse])
+async def list_queues(
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: QueueService = QUEUE_SERVICE_DEPENDENCY,
+) -> list[QueueResponse]:
+    """List queues."""
+    return await service.list_queues(session)
+
+
+@router.put("/{queue_name}", response_model=QueueResponse)
+async def update_queue(
+    queue_name: str,
+    request: QueueUpdateRequest,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: QueueService = QUEUE_SERVICE_DEPENDENCY,
+) -> QueueResponse:
+    """Create or update a queue."""
+    return await service.upsert_or_update(session, queue_name=queue_name, request=request)
+
+
+@router.post("/{queue_name}/pause", response_model=QueueResponse)
+async def pause_queue(
+    queue_name: str,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: QueueService = QUEUE_SERVICE_DEPENDENCY,
+) -> QueueResponse:
+    """Pause a queue."""
+    return await service.pause(session, queue_name=queue_name)
+
+
+@router.post("/{queue_name}/resume", response_model=QueueResponse)
+async def resume_queue(
+    queue_name: str,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: QueueService = QUEUE_SERVICE_DEPENDENCY,
+) -> QueueResponse:
+    """Resume a queue."""
+    return await service.resume(session, queue_name=queue_name)

pgrelay/api/routers/stats.py

@@ -0,0 +1,22 @@
+"""Stats endpoints."""
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pgrelay.api.dependencies import get_session, get_stats_service, require_auth
+from pgrelay.schemas.stats import StatsResponse
+from pgrelay.services.stats import StatsService
+
+router = APIRouter(prefix="/v1/stats", tags=["stats"], dependencies=[Depends(require_auth)])
+SESSION_DEPENDENCY = Depends(get_session)
+STATS_SERVICE_DEPENDENCY = Depends(get_stats_service)
+
+
+@router.get("", response_model=StatsResponse)
+async def get_stats(
+    approximate: bool = False,
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: StatsService = STATS_SERVICE_DEPENDENCY,
+) -> StatsResponse:
+    """Return PgRelay stats."""
+    return await service.get_stats(session, approximate=approximate)

pgrelay/api/routers/workers.py

@@ -0,0 +1,21 @@
+"""Worker endpoints."""
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from pgrelay.api.dependencies import get_session, get_worker_service, require_auth
+from pgrelay.schemas.workers import WorkerResponse
+from pgrelay.services.workers import WorkerService
+
+router = APIRouter(prefix="/v1/workers", tags=["workers"], dependencies=[Depends(require_auth)])
+SESSION_DEPENDENCY = Depends(get_session)
+WORKER_SERVICE_DEPENDENCY = Depends(get_worker_service)
+
+
+@router.get("", response_model=list[WorkerResponse])
+async def list_workers(
+    session: AsyncSession = SESSION_DEPENDENCY,
+    service: WorkerService = WORKER_SERVICE_DEPENDENCY,
+) -> list[WorkerResponse]:
+    """List worker heartbeats."""
+    return await service.list_workers(session)

pgrelay/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package."""