docker-compose.all.yaml

services:
  serenibase:
    build: .
    command: ["./wait-for-postgres.sh", "postgres", "./main"]
    ports:
      - "${SERVER_PORT}:${SERVER_PORT}"
    env_file:
      - .env
    environment:
      # Use internal Docker DNS for database connection (container-to-container)
      # This overrides DATABASE_HOST from .env to ensure internal connectivity
      - DATABASE_HOST=${DATABASE_INTERNAL_HOST:-postgres}
      - DATABASE_PORT=${DATABASE_INTERNAL_PORT:-5432}
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - serenibase-network
    restart: on-failure:5

  postgres:
    image: postgres:15-alpine
    env_file:
      - .env
    environment:
      - POSTGRES_USER=${DATABASE_USER}
      - POSTGRES_PASSWORD=${DATABASE_PASSWORD}
      - POSTGRES_DB=${DATABASE_NAME}
    ports:
      - "${DATABASE_PORT}:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - serenibase-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d ${DATABASE_NAME}"]
      interval: 5s
      timeout: 5s
      retries: 5
      start_period: 30s

  antivirus-service:
    build:
      context: ./services/antivirus-service
    env_file:
      - .env
    environment:
      HOST: ${ANTIVIRUS_HOST}
      PORT: ${ANTIVIRUS_PORT}
      BASE_URL: ${ANTIVIRUS_BASE_URL}
      ALLOWED_ORIGINS: ${ANTIVIRUS_ALLOWED_ORIGINS}
      ANTIVIRUS_DRIVER: ${ANTIVIRUS_DRIVER}
      CLAMAV_ADDRESS: ${ANTIVIRUS_CLAMAV_ADDRESS}
      CLAMAV_TIMEOUT_SECONDS: ${ANTIVIRUS_CLAMAV_TIMEOUT_SECONDS}
      MAX_UPLOAD_SIZE_MB: ${ANTIVIRUS_MAX_UPLOAD_SIZE_MB}
    ports:
      - "${ANTIVIRUS_PORT}:${ANTIVIRUS_PORT}"
    networks:
      - serenibase-network

  jwt-provider:
    build:
      context: ./services/auth-service
    env_file:
      - .env
    environment:
      JWT_SECRET: ${AUTH_JWT_SECRET}
      ACCESS_TOKEN_DURATION: ${ACCESS_TOKEN_DURATION:-15m}
      REFRESH_TOKEN_DURATION: ${REFRESH_TOKEN_DURATION:-168h}
      SERVER_PORT: ${AUTH_PORT}
      SERVER_HOST: ${AUTH_HOST}
      ALLOWED_ORIGINS: ${AUTH_ALLOWED_ORIGINS}
      ENV: ${AUTH_ENV}
      LOG_LEVEL: ${AUTH_LOG_LEVEL}
    ports:
      - "${AUTH_PORT}:${AUTH_PORT}"
    networks:
      - serenibase-network

  email-service:
    build:
      context: ./services/email-service
    env_file:
      - .env
    environment:
      HOST: ${EMAIL_HOST}
      PORT: ${EMAIL_PORT}
      ALLOWED_ORIGIN: ${EMAIL_ALLOWED_ORIGIN}
      SMTP_HOST: ${EMAIL_SMTP_HOST}
      SMTP_PORT: ${EMAIL_SMTP_PORT}
      SMTP_USERNAME: ${EMAIL_SMTP_USERNAME}
      SMTP_PASSWORD: ${EMAIL_SMTP_PASSWORD}
      FROM_EMAIL: ${EMAIL_FROM_EMAIL}
    ports:
      - "${EMAIL_PORT}:${EMAIL_PORT}"
    networks:
      - serenibase-network

  sereni-storage-provider:
    build:
      context: ./services/storage-service

    environment:
      SERVER_PORT: ${STORAGE_SERVER_PORT}
      SERVER_IP: ${STORAGE_SERVER_IP}
      SERVER_HOST: ${STORAGE_SERVER_HOST}
      SERVER_SCHEME: ${STORAGE_SERVER_SCHEME}
      STORAGE_DRIVER: ${STORAGE_DRIVER}
      STORAGE_DEV_PATH: ${STORAGE_DEV_PATH}
      AWS_REGION: ${STORAGE_AWS_REGION}
      AWS_BUCKET: ${STORAGE_AWS_BUCKET}
      AWS_ACCESS_KEY: ${STORAGE_AWS_ACCESS_KEY}
      AWS_SECRET_KEY: ${STORAGE_AWS_SECRET_KEY}
      MINIO_ENDPOINT: ${STORAGE_MINIO_ENDPOINT}
      MINIO_ACCESS_KEY: ${STORAGE_MINIO_ACCESS_KEY}
      MINIO_SECRET_KEY: ${STORAGE_MINIO_SECRET_KEY}
      MINIO_BUCKET: ${STORAGE_MINIO_BUCKET}
      MINIO_USE_SSL: ${STORAGE_MINIO_USE_SSL}
      ALLOWED_ORIGINS: ${STORAGE_ALLOWED_ORIGINS}
    ports:
      - "${STORAGE_SERVER_PORT}:${STORAGE_SERVER_PORT}"
    volumes:
      - ./services/storage-service/uploads:/app/uploads:cached
    depends_on:
      - minio-init
    networks:
      - serenibase-network

  minio:
    image: minio/minio:latest
    ports:
      - "${MINIO_API_PORT:-9000}:9000"
      - "${MINIO_CONSOLE_PORT:-9001}:9001"
    environment:
      MINIO_ROOT_USER: ${STORAGE_MINIO_ACCESS_KEY}
      MINIO_ROOT_PASSWORD: ${STORAGE_MINIO_SECRET_KEY}
    command: server /data --console-address ":9001"
    volumes:
      - minio_data:/data
    networks:
      - serenibase-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 40s

  minio-init:
    image: minio/mc:latest
    environment:
      MINIO_ACCESS_KEY: ${STORAGE_MINIO_ACCESS_KEY}
      MINIO_SECRET_KEY: ${STORAGE_MINIO_SECRET_KEY}
      MINIO_BUCKET: ${STORAGE_MINIO_BUCKET}
    volumes:
      - ./cors.json:/cors.json  # Mount CORS config
    entrypoint: >
      sh -c '
        /usr/bin/mc alias set myminio http://minio:9000 $$MINIO_ACCESS_KEY $$MINIO_SECRET_KEY;
        /usr/bin/mc mb -p myminio/$$MINIO_BUCKET;
        /usr/bin/mc anonymous set download myminio/$$MINIO_BUCKET;
        /usr/bin/mc cors set /cors.json myminio/$$MINIO_BUCKET;
        echo "Bucket $$MINIO_BUCKET ready with CORS";
      '
    depends_on:
      minio:
        condition: service_healthy
    networks:
      - serenibase-network

  base-ui:
    build:
      context: ./services/base-ui
      dockerfile: Dockerfile
      args:
        - VITE_API_BASE_URL=${BASEUI_VITE_API_BASE_URL}
    env_file:
      - .env
    ports:
      - "${BASE_UI_PORT:-5050}:5050"
    restart: unless-stopped
    networks:
      - serenibase-network

  clamav:
    image: clamav/clamav:1.4
    container_name: clamav
    restart: unless-stopped
    env_file:
      - .env
    ports:
      - "${ANTIVIRUS_CLAMAV_PORT:-3310}:3310"
    volumes:
      - clamav-db:/var/lib/clamav  # Persistent virus signature database (500MB+)
      - ./data:/data:cached
    environment:
      - CLAMD_STARTUP_TIMEOUT=180
      - FRESHCLAM_CHECKS=12
      - MaxScanSize=500M
      - MaxFileSize=500M
      - StreamMaxLength=500M
      - MaxRecursion=20
      - MaxFiles=10000
    healthcheck:
      test: ["CMD", "clamdscan", "--version"]
      interval: 60s
      timeout: 10s
      retries: 5
      start_period: 30s
    networks:
      - serenibase-network

volumes:
  postgres_data:
  minio_data:
  clamav-db:
    driver: local
    driver_opts:
      type: local
      o: bind
      device: ${CLAMAV_DB_PATH:-./.clamav-db}

networks:
  serenibase-network:
    driver: bridge