docker-compose.dev.yml

version: "3"

services:
  frontend:
    build:
      context: ./peerprep_fe
      dockerfile: Dockerfile.dev
    volumes:
      - ./peerprep_fe:/app
      - /app/node_modules
    environment:
      - CHOKIDAR_USEPOLLING=true
      - NEXT_POLLING_INTERVAL=1000
      - FRONTEND_PORT=${FRONTEND_PORT}
      - API_GATEWAY_PORT=${API_GATEWAY_PORT}
      - GATEWAY_SERVICE_ROUTE=gateway-service
    ports:
      - ${FRONTEND_PORT}:3000
    depends_on:
      - gateway-service

  gateway-service:
    build:
      context: ./gateway_service
      dockerfile: Dockerfile.dev
    volumes:
      - ./gateway_service:/app
      - /app/node_modules
    environment:
      - MONGODB_URI=${MONGODB_URI}
      - KAFKA_BROKER_PORT=${KAFKA_BROKER_PORT}
      - JWT_SECRET=${JWT_SECRET}
      - GATEWAY_SERVICE_ROUTE=gateway-service
      - API_GATEWAY_PORT=${API_GATEWAY_PORT}
      - KAFKA_BROKER_ROUTE=kafka-service
      - KAFKA_KEY=${KAFKA_KEY}
      - KAFKA_PASSWORD=${KAFKA_PASSWORD}
      - MATCHING_SERVICE_ROUTE=matching-service
      - MATCHING_SERVICE_PORT=${MATCHING_SERVICE_PORT}
      - COLLAB_SERVICE_ROUTE=collab-service
      - COLLAB_SERVICE_PORT=${COLLAB_SERVICE_PORT}
      - USER_SERVICE_ROUTE=user-service
      - USER_SERVICE_PORT=${USER_SERVICE_PORT}
      - QUESTION_SERVICE_ROUTE=question-service
      - QUESTION_SERVICE_PORT=${QUESTION_SERVICE_PORT}
      - REDIS_ROUTE=redis://redis
      - REDIS_PORT=${REDIS_PORT}
      - PISTON_SERVICE_ROUTE=piston
      - PISTON_PORT=2000
    ports:
      - ${API_GATEWAY_PORT}:5003
    depends_on:
      kafka-init:
        condition: service_completed_successfully
      kafka-service:
        condition: service_healthy

  user-service:
    build:
      context: ./users_service
      dockerfile: Dockerfile.dev
    volumes:
      - ./users_service:/app
      - /app/node_modules
    environment:
      - MONGODB_URI=${MONGODB_URI}
      - USER_SERVICE_PORT=${USER_SERVICE_PORT}
      - JWT_SECRET=${JWT_SECRET}
    ports:
      - ${USER_SERVICE_PORT}:5001
    depends_on:
      - matching-service

  question-service:
    build:
      context: ./question_service
      dockerfile: Dockerfile.dev
    volumes:
      - ./question_service:/app
      - /app/node_modules
    environment:
      - MONGODB_URI=${MONGODB_URI}
      - QUESTION_SERVICE_PORT=${QUESTION_SERVICE_PORT}
    ports:
      - ${QUESTION_SERVICE_PORT}:5002

  collab-service:
    build:
      context: ./collab_service
      dockerfile: Dockerfile.dev
    volumes:
      - ./collab_service:/app
      - /app/node_modules
    environment:
      - COLLAB_SERVICE_PORT=${COLLAB_SERVICE_PORT}
      - MONGODB_URI=${MONGODB_URI}
      - MATCHING_SERVICE_PORT=${MATCHING_SERVICE_PORT}
      - API_GATEWAY_PORT=${API_GATEWAY_PORT}
      - USER_SERVICE_PORT=${USER_SERVICE_PORT}
      - QUESTION_SERVICE_PORT=${QUESTION_SERVICE_PORT}
      - KAFKA_BROKER_PORT=${KAFKA_BROKER_PORT}
      - JWT_SECRET=${JWT_SECRET}
      - GATEWAY_SERVICE_ROUTE=gateway-service
      - USER_SERVICE_ROUTE=user-service
      - QUESTION_SERVICE_ROUTE=question-service
      - KAFKA_BROKER_ROUTE=kafka-service
      - KAFKA_KEY=${KAFKA_KEY}
      - KAFKA_PASSWORD=${KAFKA_PASSWORD}
    ports:
      - ${COLLAB_SERVICE_PORT}:5005
    depends_on:
      kafka-init:
        condition: service_completed_successfully
      kafka-service:
        condition: service_healthy

  matching-service:
    build:
      context: ./matching_service
      dockerfile: Dockerfile.dev
    volumes:
      - ./matching_service:/app
      - /app/node_modules
    environment:
      - MONGODB_URI=${MONGODB_URI}
      - MATCHING_SERVICE_PORT=${MATCHING_SERVICE_PORT}
      - API_GATEWAY_PORT=${API_GATEWAY_PORT}
      - USER_SERVICE_PORT=${USER_SERVICE_PORT}
      - QUESTION_SERVICE_PORT=${QUESTION_SERVICE_PORT}
      - KAFKA_BROKER_PORT=${KAFKA_BROKER_PORT}
      - JWT_SECRET=${JWT_SECRET}
      - GATEWAY_SERVICE_ROUTE=gateway-service
      - USER_SERVICE_ROUTE=user-service
      - QUESTION_SERVICE_ROUTE=question-service
      - KAFKA_BROKER_ROUTE=kafka-service
      - REDIS_ROUTE=redis://redis
      - REDIS_PORT=${REDIS_PORT}
      - KAFKA_KEY=${KAFKA_KEY}
      - KAFKA_PASSWORD=${KAFKA_PASSWORD}
    ports:
      - ${MATCHING_SERVICE_PORT}:5004
    depends_on:
      kafka-init:
        condition: service_completed_successfully
      kafka-service:
        condition: service_healthy

  kafka-service:
    image: apache/kafka:latest
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker, controller
      KAFKA_LISTENERS: PLAINTEXT://:${KAFKA_BROKER_PORT},CONTROLLER://:${KAFKA_CONTROLLER_PORT}
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka-service:${KAFKA_BROKER_PORT}
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka-service:${KAFKA_CONTROLLER_PORT}
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_NUM_PARTITIONS: ${KAFKA_NUM_PARTITIONS}
    ports:
      - "${KAFKA_BROKER_PORT}:9092"
    healthcheck:
      test: ["CMD", "nc", "-z", "${KAFKA_BROKER_ROUTE}", "${KAFKA_BROKER_PORT}"]
      interval: 30s
      timeout: 20s
      retries: 3
      start_period: 30s

  kafka-init:
    image: apache/kafka:latest
    depends_on:
      kafka-service:
        condition: service_healthy
    command: >
      bash -c '
        echo "Waiting for Kafka to be ready..." &&
        sleep 10 &&
        /opt/kafka/bin/kafka-topics.sh \
          --create \
          --if-not-exists \
          --bootstrap-server kafka-service:${KAFKA_BROKER_PORT} \
          --topic collaboration-events \
          --partitions ${KAFKA_NUM_PARTITIONS:-1} \
          --replication-factor 1 &&
        /opt/kafka/bin/kafka-topics.sh \
          --create \
          --if-not-exists \
          --bootstrap-server kafka-service:${KAFKA_BROKER_PORT} \
          --topic gateway-events \
          --partitions ${KAFKA_NUM_PARTITIONS:-1} \
          --replication-factor 1 &&
        /opt/kafka/bin/kafka-topics.sh \
          --create \
          --if-not-exists \
          --bootstrap-server kafka-service:${KAFKA_BROKER_PORT} \
          --topic matching-events \
          --partitions ${KAFKA_NUM_PARTITIONS:-1} \
          --replication-factor 1
      '
    environment:
      KAFKA_BROKER_PORT: ${KAFKA_BROKER_PORT}
      KAFKA_NUM_PARTITIONS: ${KAFKA_NUM_PARTITIONS:-1}

  redis:
    image: redis:latest
    ports:
      - ${REDIS_PORT}:6379
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3