docker-compose.yml

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
    image: ewlarson/btaa-geospatial-api:0.6.0
    container_name: btaa-geospatial-api-app
    environment:
      - DATABASE_URL=postgresql+asyncpg://postgres:${POSTGRES_PASSWORD}@paradedb:5432/btaa_geospatial_api
      - DB_POOL_MIN=${DB_POOL_MIN:-1}
      - DB_POOL_MAX=${DB_POOL_MAX:-10}
      - ELASTICSEARCH_URL=http://elasticsearch:9200
      - ELASTICSEARCH_INDEX=btaa_geospatial_api
      - LOG_PATH=/app/logs
      - APPLICATION_URL=http://localhost:8000
      - CORS_ORIGINS=*
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - REDIS_PASSWORD=${REDIS_PASSWORD}
      - REDIS_TTL=604800
      - CELERY_BROKER_URL=redis://:${REDIS_PASSWORD}@redis:6379/0
      - CELERY_RESULT_BACKEND=redis://:${REDIS_PASSWORD}@redis:6379/1
      - LOG_LEVEL=DEBUG
      - KITHE_BRIDGE_URL=${KITHE_BRIDGE_URL:-}
      - KITHE_BRIDGE_TOKEN=${KITHE_BRIDGE_TOKEN:-}
      - KITHE_BRIDGE_PAGE_SIZE=${KITHE_BRIDGE_PAGE_SIZE:-500}
      - KITHE_BRIDGE_REQUEST_TIMEOUT=${KITHE_BRIDGE_REQUEST_TIMEOUT:-30}
      # Allow .env to control endpoint caching (default: true)
      - ENDPOINT_CACHE=${ENDPOINT_CACHE:-true}
      # Optional: emit X-Cache headers when caching is enabled
      - CACHE_DEBUG_HEADERS=${CACHE_DEBUG_HEADERS:-false}
      - GAZETTEER_CACHE_TTL=3600
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=changeme
      - IS_DOCKER=true
      - PYTHONPATH=/app/backend
    ports:
      - "127.0.0.1:8000:8000"
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    depends_on:
      elasticsearch:
        condition: service_healthy
      paradedb:
        condition: service_healthy
      redis:
        condition: service_healthy
    volumes:
      - ./logs:/app/logs
      - .:/app
    networks: [elastic]
    command: ["bash", "-lc", "cd /app/backend && uvicorn app.main:app --host 0.0.0.0 --port 8000 --log-level debug"]

  # Fast dev loop: no image rebuilds for code changes.
  # Use with: `docker compose up -d frontend-dev`
  frontend-dev:
    build:
      context: ./frontend
      dockerfile: Dockerfile
      # Use the deps layer: it has node_modules installed, but doesn't waste time building.
      target: deps
    container_name: btaa-geospatial-api-frontend-dev
    working_dir: /app
    environment:
      # Vite reads these at dev-server start. Prefer the local API in dev.
      - VITE_API_BASE_URL=http://localhost:8000/api/v1
      - VITE_USE_JSONP=false
      - VITE_ENFORCE_HTTPS=false
      # React Router server-side loaders in dev (runs inside this container)
      - API_BASE_URL=http://api:8000/api/v1
      - BTAA_GEOSPATIAL_API_KEY=${BTAA_GEOSPATIAL_API_KEY:-}
      - NODE_ENV=development
    command: sh -lc "rm -rf node_modules/.vite 2>/dev/null; npm run dev -- --host 0.0.0.0 --port 3000"
    volumes:
      # Mount source/config (but NOT node_modules) so we can hot-reload without rebuilds.
      - ./frontend/theme.yaml:/app/theme.yaml
      - ./frontend/app:/app/app
      - ./frontend/src:/app/src
      - ./frontend/public:/app/public
      - ./frontend/scripts:/app/scripts
      - ./frontend/server:/app/server
      - ./frontend/index.html:/app/index.html
      - ./frontend/package.json:/app/package.json
      - ./frontend/appsignal.cjs:/app/appsignal.cjs
      - ./frontend/vite.config.ts:/app/vite.config.ts
      - ./frontend/react-router.config.ts:/app/react-router.config.ts
      - ./frontend/tsconfig.json:/app/tsconfig.json
      - ./frontend/tsconfig.node.json:/app/tsconfig.node.json
      - ./frontend/tsconfig.app.json:/app/tsconfig.app.json
      - ./frontend/postcss.config.js:/app/postcss.config.js
      - ./frontend/tailwind.config.js:/app/tailwind.config.js
      - ./frontend/eslint.config.js:/app/eslint.config.js
      - ./frontend/vitest.config.ts:/app/vitest.config.ts
    ports:
      - "3000:3000"
    depends_on:
      api:
        condition: service_started
    networks: [elastic]
    restart: unless-stopped

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:9.0.0
    container_name: btaa-geospatial-api-elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - ES_JAVA_OPTS=-Xms2g -Xmx2g
      - cluster.routing.allocation.disk.threshold_enabled=true
      - cluster.routing.allocation.disk.watermark.low=85%
      - cluster.routing.allocation.disk.watermark.high=99%
      - cluster.routing.allocation.disk.watermark.flood_stage=99.5%
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    mem_limit: 4g
    ports:
      - "127.0.0.1:9200:9200"
    volumes:
      - ./data/elasticsearch:/usr/share/elasticsearch/data
    networks: [elastic]
    healthcheck:
      test: ["CMD","curl","-f","http://localhost:9200/_cluster/health"]
      interval: 30s
      timeout: 10s
      retries: 5

  paradedb:
    image: paradedb/paradedb:0.18.11
    container_name: btaa-geospatial-api-paradedb
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=btaa_geospatial_api
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    ports:
      - "127.0.0.1:2345:5432"
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    networks: [elastic]
    healthcheck:
      test: ["CMD-SHELL","pg_isready -U postgres -d btaa_geospatial_api"]
      interval: 5s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7.4.6-alpine
    container_name: btaa-geospatial-api-redis
    command: >
      redis-server
      --appendonly yes
      --protected-mode yes
      --bind 0.0.0.0
      --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis-data:/data
    networks: [elastic]
    healthcheck:
      test: ["CMD","sh","-lc","redis-cli -a \"$REDIS_PASSWORD\" ping | grep PONG"]
      interval: 5s
      timeout: 3s
      retries: 5
    restart: unless-stopped

  celery_worker:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: btaa-geospatial-api-celery
    # Concurrency is configurable; keep DB pools capped (DB_POOL_MAX) to protect Postgres.
    # -E enables task events so Flower can show task progress.
    command: bash -lc "cd /app/backend && celery -A app.tasks.worker worker -E --loglevel=INFO --concurrency=${CELERY_WORKER_CONCURRENCY:-2} --prefetch-multiplier=1"
    environment:
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - REDIS_PASSWORD=${REDIS_PASSWORD}
      - DATABASE_URL=postgresql+asyncpg://postgres:${POSTGRES_PASSWORD}@paradedb:5432/btaa_geospatial_api
      # Keep Celery DB pool small to avoid exhausting Postgres when many tasks queue up
      - DB_POOL_MIN=1
      - DB_POOL_MAX=2
      - CELERY_WORKER_CONCURRENCY=${CELERY_WORKER_CONCURRENCY:-2}
      - CELERY_BROKER_URL=redis://:${REDIS_PASSWORD}@redis:6379/0
      - CELERY_RESULT_BACKEND=redis://:${REDIS_PASSWORD}@redis:6379/1
      - REDIS_TTL=604800
      - PYTHONUNBUFFERED=1
      - PYTHONPATH=/app/backend
      - LOG_PATH=/app/logs
      - LOG_LEVEL=DEBUG
      - IS_DOCKER=true
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - OPENAI_MODEL=${OPENAI_MODEL:-gpt-3.5-turbo}
      - KITHE_BRIDGE_URL=${KITHE_BRIDGE_URL:-}
      - KITHE_BRIDGE_TOKEN=${KITHE_BRIDGE_TOKEN:-}
      - KITHE_BRIDGE_PAGE_SIZE=${KITHE_BRIDGE_PAGE_SIZE:-500}
      - KITHE_BRIDGE_REQUEST_TIMEOUT=${KITHE_BRIDGE_REQUEST_TIMEOUT:-30}
    volumes:
      - ./logs:/app/logs
      - .:/app
    depends_on:
      redis:
        condition: service_healthy
      paradedb:
        condition: service_healthy
    networks: [elastic]

  flower:
    build:
      context: .
    container_name: btaa-geospatial-api-flower
    # IMPORTANT: celery args (like --broker) must come before `flower` subcommand.
    command: bash -lc "cd /app/backend && celery -A app.tasks.worker --broker=redis://:${REDIS_PASSWORD}@redis:6379/0 flower --port=5555"
    ports:
      - "127.0.0.1:5555:5555"
    environment:
      - DATABASE_URL=postgresql+asyncpg://postgres:${POSTGRES_PASSWORD}@paradedb:5432/btaa_geospatial_api
      - DB_POOL_MIN=1
      - DB_POOL_MAX=2
      - CELERY_BROKER_URL=redis://:${REDIS_PASSWORD}@redis:6379/0
      - CELERY_RESULT_BACKEND=redis://:${REDIS_PASSWORD}@redis:6379/1
      # Allow Flower's /api/* endpoints without auth (useful for local debugging).
      - FLOWER_UNAUTHENTICATED_API=true
      - PYTHONPATH=/app/backend
      - LOG_PATH=/app/logs
      - LOG_LEVEL=DEBUG
      - IS_DOCKER=true
    volumes:
      - ./logs:/app/logs
      - .:/app
    networks: [elastic]
    depends_on:
      redis:
        condition: service_healthy
      paradedb:
        condition: service_healthy
      celery_worker:
        condition: service_started

volumes:
  elasticsearch-data:
  paradedb-data:
  redis-data:

networks:
  elastic:
    driver: bridge