docker-compose.yml

services:
  django:
    build:
      context: ./django
      dockerfile: Dockerfile
    user: django
    ports:
      - "127.0.0.1:8000:8000"  # Development server
    container_name: django
    volumes:
      - shared_data:/app/cache:rw
      - E:\SSL_Certificates\codedd_ssh\test_id_rsa:/home/django/.ssh/id_rsa:ro
      - ./django:/app:rw
      - type: bind
        source: ./logs
        target: /app/logs
        bind:
          create_host_path: true
    environment:
      SERVICE_TYPE: django
      ENVIRONMENT: ${ENVIRONMENT:-dev}
      DJANGO_SETTINGS_MODULE: CodeDD.settings
      SMTP2GO_API_KEY: ${SMTP2GO_API_KEY}
      JWT_SECRET_KEY: ${JWT_SECRET_KEY}
      SECRET_KEY: ${SECRET_KEY}
      STRIPE_SECRET_KEY: ${STRIPE_SECRET_KEY}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
      BASE_PROD_ID: ${BASE_PROD_ID}
      START_UP_PROD_ID: ${START_UP_PROD_ID}
      GROWTH_PROD_ID: ${GROWTH_PROD_ID}
      ENTERPRISE_PROD_ID: ${ENTERPRISE_PROD_ID}
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
      GEMINI_API_KEY: ${GEMINI_API_KEY}
      OPENAI_MODEL: ${OPENAI_MODEL}
      GIT_SSH_COMMAND: ssh -i /home/django/.ssh/id_rsa -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no
      TYPEDB_USER: ${TYPEDB_USER}
      TYPEDB_PASSWORD: ${TYPEDB_PASSWORD}
      TYPEDB_URI: typedb://typedb:1729
      REDIS_HOST: ${REDIS_HOST}
      REDIS_PORT: ${REDIS_PORT}
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      FRONTEND_URL: "http://localhost:3000"
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB:-codedd}
      POSTGRES_HOST: postgres
      CELERY_BROKER_URL: redis://default:${REDIS_PASSWORD}@redis:6379/0
      CELERY_RESULT_BACKEND: redis://default:${REDIS_PASSWORD}@redis:6379/0
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-codedd}
      CSRF_COOKIE_SECURE: false
      DJANGO_DEBUG: "true"  # Enable Django debug mode
    entrypoint: ["/bin/bash", "/app/docker-entrypoint.sh"]
    depends_on:
      redis:
        condition: service_healthy
      typedb:
        condition: service_started
      postgres:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health/"]
      interval: 300s
      timeout: 10s
      retries: 3
      start_period: 40s
    networks:
      - backend

  celery:
    build:
      context: ./django
      dockerfile: Dockerfile
    user: django
    container_name: celery
    volumes:
      - shared_data:/app/cache:rw
      - ./django:/app:rw  # Add source code volume for hot-reloading
      - type: bind
        source: ./logs
        target: /app/logs
        bind:
          create_host_path: true
    environment:
      SERVICE_TYPE: celery
      ENVIRONMENT: ${ENVIRONMENT:-dev}
      DJANGO_SETTINGS_MODULE: CodeDD.settings
      SMTP2GO_API_KEY: ${SMTP2GO_API_KEY} 
      JWT_SECRET_KEY: ${JWT_SECRET_KEY}
      SECRET_KEY: ${SECRET_KEY}
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
      GEMINI_API_KEY: ${GEMINI_API_KEY}
      OPENAI_MODEL: ${OPENAI_MODEL}
      TYPEDB_USER: ${TYPEDB_USER}
      TYPEDB_PASSWORD: ${TYPEDB_PASSWORD}
      TYPEDB_URI: typedb://typedb:1729
      REDIS_HOST: ${REDIS_HOST}
      REDIS_PORT: ${REDIS_PORT}
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      STRIPE_SECRET_KEY: ${STRIPE_SECRET_KEY}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
      FRONTEND_URL: "http://localhost:3000"
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB:-codedd}
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-codedd}
      CELERY_BROKER_URL: redis://default:${REDIS_PASSWORD}@redis:6379/0
      CELERY_RESULT_BACKEND: redis://default:${REDIS_PASSWORD}@redis:6379/0
    entrypoint: ["/bin/bash", "/app/docker-entrypoint.sh"]
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      django:
        condition: service_healthy
    networks:
      - backend
    restart: unless-stopped

  celery-beat:
    build:
      context: ./django
      dockerfile: Dockerfile
    user: django
    container_name: celery-beat
    volumes:
      - shared_data:/app/cache:rw
      - ./django:/app:rw
      - type: bind
        source: ./logs
        target: /app/logs
        bind:
          create_host_path: true
      - ./django/deployment/scripts/celery-beat-entrypoint.sh:/entrypoint.sh:ro
    environment:
      SERVICE_TYPE: celery-beat
      ENVIRONMENT: ${ENVIRONMENT:-dev}
      DJANGO_SETTINGS_MODULE: CodeDD.settings
      SMTP2GO_API_KEY: ${SMTP2GO_API_KEY}
      JWT_SECRET_KEY: ${JWT_SECRET_KEY}
      SECRET_KEY: ${SECRET_KEY}
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
      GEMINI_API_KEY: ${GEMINI_API_KEY}
      OPENAI_MODEL: ${OPENAI_MODEL}
      TYPEDB_USER: ${TYPEDB_USER}
      TYPEDB_PASSWORD: ${TYPEDB_PASSWORD}
      TYPEDB_URI: typedb://typedb:1729
      REDIS_HOST: ${REDIS_HOST}
      REDIS_PORT: ${REDIS_PORT}
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      ENCRYPTION_KEY: ${ENCRYPTION_KEY}
      FRONTEND_URL: "http://localhost:3000"
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB:-codedd}
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-codedd}
      CELERY_BROKER_URL: redis://default:${REDIS_PASSWORD}@redis:6379/0
      CELERY_RESULT_BACKEND: redis://default:${REDIS_PASSWORD}@redis:6379/0
    entrypoint: ["/bin/bash", "/entrypoint.sh"]
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      django:
        condition: service_healthy
    networks:
      - backend
    restart: unless-stopped

  # Nginx container - The main entry point for development
  nginx:
    image: nginx:stable-alpine
    container_name: nginx
    ports:
      - "3000:80" # Access frontend via http://localhost:3000
    volumes:
      # Mount the dev Nginx config as the main configuration file
      - ./src/nginx.dev.conf:/etc/nginx/nginx.conf
    depends_on:
      - react # Depends on the React dev server being ready (loosely)
      - django    # Depends on the Django backend
    networks:
      - backend
    restart: unless-stopped

  react:
    build: 
      context: ./src
      dockerfile: Dockerfile
    container_name: react
    volumes:
      - ./src:/app/src:rw  # Simplified volume mount
      - ./public:/app/public:rw
      - ./src/package.json:/app/package.json:ro # Mount package files read-only
      - ./src/package-lock.json:/app/package-lock.json:ro # Mount package files read-only
      - node_modules:/app/node_modules  # Named volume for node_modules
    environment:
      NODE_ENV: development
      # Ensure HMR works behind proxy (for Create React App)
      WDS_SOCKET_PORT: 0
      # Polling often needed in Docker for file watching
      WATCHPACK_POLLING: true
      REACT_APP_API_URL: ${REACT_APP_API_URL}
      REACT_APP_WS_URL: ${REACT_APP_WS_URL}
      FRONTEND_URL: ${FRONTEND_URL}
      REACT_APP_STRIPE_PUBLISHABLE_KEY: ${REACT_APP_STRIPE_PUBLISHABLE_KEY}
    depends_on:
      django:
        condition: service_healthy
    networks:
      - backend
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000"]
      interval: 30s
      timeout: 10s
      retries: 3

  typedb:
    image: typedb/typedb:3.2.0
    container_name: typedb
    volumes:
      - typedb_data:/opt/typedb-server-linux-x86_64/server/data
    command: [
      "/opt/typedb-server-linux-x86_64/typedb", "server", 
      "--server.address=0.0.0.0:1729",
      "--storage.data=/opt/typedb-server-linux-x86_64/server/data"
    ]
    ports:
      - "1730:1729"
    networks:
      - backend
    restart: unless-stopped
    environment:
      - TYPEDB_DIAGNOSTICS_REPORTING=false
      - TYPEDB_STORAGE_DATA=/opt/typedb-server-linux-x86_64/server/data
    healthcheck:
      test: ["CMD", "/opt/typedb-server-linux-x86_64/typedb", "server", "status"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  postgres:
    image: postgres:17.2
    container_name: postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./django/deployment/config/postgres/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
    environment:
      POSTGRES_DB: postgres
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      PGPASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_INITDB_ARGS: "--data-checksums"
      POSTGRES_LOGGING_COLLECTOR: "on"
      POSTGRES_LOG_MIN_MESSAGES: "debug5"
      POSTGRES_LOG_MIN_DURATION_STATEMENT: "1000"
      POSTGRES_LOG_CHECKPOINTS: "on"
    ports:
      - "127.0.0.1:5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d codedd"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    networks:
      - backend
    restart: unless-stopped

  redis:
    container_name: redis
    image: redis:7.2.4
    command: redis-server --requirepass ${REDIS_PASSWORD}
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    environment:
      - REDIS_PASSWORD=${REDIS_PASSWORD}
      - REDIS_HOST=${REDIS_HOST}
      - REDIS_PORT=${REDIS_PORT}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3
    networks:
      - backend

volumes:
  typedb_data: {}
  shared_data: {}
  redis_data: {}
  postgres_data: {}
  codedd_keys:
    external: true
  node_modules: {}  # Add named volume for node_modules

# Add networks configuration
networks:
  backend:
    driver: bridge