Docker-compose.dev.yml

version: '3'

services:
  rabbitmq3:
    container_name: peerprep-rabbitmq
    image: rabbitmq:3-management
    environment:
      - ./apps/backend/queue/.env.dev
    ports:
      - '5672:5672'
      - '15672:15672'
    healthcheck:
      test: rabbitmq-diagnostics check_port_connectivity
      interval: 10s
      timeout: 10s
      retries: 5

  postgres:
    image: postgres
    container_name: peerprep-postgres
    restart: always
    env_file:
      - ./apps/backend/user/.env.dev
    ports:
      - "5432:5432"                         # Map postgres container's port 5432 to host's port 5432
    networks:
      - peerprep-network

  peerprep-frontend:
    container_name: peerprep-frontend
    image: peerprep-frontend                    # Name of the container
    restart: always
    build:
      context: ./apps/frontend                  # Build context is the path to the frontend directory
      dockerfile: Dockerfile.frontend.dev       # Path to the Dockerfile for the frontend
    ports:
      - "3000:3000"                             # Map frontend container's port 3000 to host's port 3000
    # volumes:
    #   - ./apps/frontend/.env.local:/app/.env.local              # Mount the frontend directory as a volume
    environment:
      - ./apps/frontend/.env.local
    depends_on:
      - peerprep-user                           # Ensure that the backend service is started first
      - peerprep-question                       # Ensure that the backend service is started first
      - peerprep-queue                          # Ensure that the backend service is started first
      - peerprep-session                        # Ensure that the backend service is started first
      - peerprep-history                        # Ensure that the backend service is started first
    networks:
      - peerprep-network

  peerprep-question:
    container_name: peerprep-question           # Name of the container
    image: peerprep-question                    # Name of the image
    restart: always
    build:
      context: ./apps/backend/question          # Build context is the path to the backend directory
      dockerfile: Dockerfile.question.dev       # Path to the Dockerfile for the backend
    ports:
      - "8000:8000"                             # Map backend container's port 8000 to host's port 8000
    # volumes:
    #   - ./apps/backend/question:/app      # Mount the backend directory as a volume
    environment:
      - ./apps/backend/question/.env.dev
    networks:
      - peerprep-network

  peerprep-user:
    container_name: peerprep-user               # Name of the container
    image: peerprep-user                        # Name of the image
    restart: always
    build:
      context: ./apps/backend/user              # Build context is the path to the backend directory
      dockerfile: Dockerfile.user.dev           # Path to the Dockerfile for the backend
    ports:
      - "8001:8001"                             # Map backend container's port 8000 to host's port 8000
    # volumes:
    #   - ./apps/backend/user:/app          # Mount the backend directory as a volume
    environment:
      - ./apps/backend/user/.env.dev
    depends_on:
      postgres:                                 # Ensure that the backend service is started first
        condition: service_started
    networks:
      - peerprep-network

  peerprep-queue:
    container_name: peerprep-queue              # Name of the container
    image: peerprep-queue  
    restart: always
    build:
      context: ./apps/backend/queue             # Build context is the path to the backend directory
      dockerfile: Dockerfile.queue.dev          # Path to the Dockerfile for the backend
    ports:
      - "8080:8080"                             # Map backend container's port 8080 to host's port 8080
    environment:
      - ./apps/backend/queue/.env.dev
    networks:
      - peerprep-network
    depends_on:
      rabbitmq3:
        condition: service_healthy

  peerprep-session:
    container_name: peerprep-session        
    image: peerprep-session                
    restart: always
    build:
      context: ./apps/backend/session       
      dockerfile: Dockerfile.session.dev    
    ports:
      - "8250:8250"                                             
      - "8251:8251"                                             
    # volumes:
    #   - ./apps/backend/question:/app      
    environment:
      - ./apps/backend/session/.env.dev
    networks:
      - peerprep-network

  peerprep-history:
    container_name: peerprep-history        
    image: peerprep-history                 
    restart: always
    build:
      context: ./apps/backend/history       
      dockerfile: Dockerfile.history.dev    
    ports:
      - "8003:8003"                         
    # volumes:
    #   - ./apps/backend/question:/app 
    environment:
      - ./apps/backend/session/.env.dev
    networks:
      - peerprep-network

  peerprep-chat:
    container_name: peerprep-chat            
    image: peerprep-chat  
    restart: always
    build:
      context: ./apps/backend/chat          
      dockerfile: Dockerfile.chat.dev          
    ports:
      - "8082:8082"                            
    environment:
      - ./apps/backend/chat/.env.dev
    networks:
      - peerprep-network
  
  peerprep-codeexec:
    container_name: peerprep-codeexec           
    image: peerprep-codeexec                  
    restart: always
    build:
      context: ./apps/backend/codeExecution          
      dockerfile: Dockerfile.codeexec.dev      
    ports:
      - "8420:8420"                           
    # volumes:
    #   - ./apps/backend/question:/app      
    environment:
      - ./apps/backend/codeExecution/.env.dev
    networks:
      - peerprep-network

# Define a custom network for your services
networks:
  peerprep-network:
    driver: bridge