docker-compose.yml

volumes:
  node-data: {}
  postgres_db: {}
  redis_db: {}
  caddy_config: {}
  caddy_data: {}

services:
  # Caddy Reverse Proxy with CORS enabled
  caddy:
    ulimits:
      nofile:
        soft: 65536 # Soft limit for open files (WebSocket connections count)
        hard: 65536 # Hard limit for open files
    image: caddy:latest
    ports:
      - "127.0.0.1:8000:8000"
    volumes:
      - ./indexers/Caddyfile:/etc/caddy/Caddyfile # Mount the Caddyfile
      - caddy_data:/data # Volume for Let's Encrypt certificates
      - caddy_config:/config
    depends_on:
      - node
    restart: unless-stopped

  # Subspace Node
  node:
    image: ghcr.io/autonomys/node:${NODE_DOCKER_TAG}
    volumes:
      - node-data:/var/subspace:rw
    ports:
      - "30333:30333/tcp"
      - "30433:30433/tcp"
      - "127.0.0.1:9944:9944/tcp"
    restart: unless-stopped
    command:
      [
        "run",
        "--chain",
        "${NETWORK_ID}",
        "--base-path",
        "/var/subspace",
        "--state-pruning",
        "archive",
        "--blocks-pruning",
        "archive",
        "--listen-on",
        "/ip4/0.0.0.0/tcp/30333",
        "--dsn-listen-on",
        "/ip4/0.0.0.0/tcp/30433",
        "--rpc-cors",
        "all",
        "--rpc-methods",
        "unsafe",
        "--rpc-listen-on",
        "0.0.0.0:9944",
        "--rpc-max-subscriptions-per-connection",
        "1000",
        "--rpc-max-connections",
        "20000",
        "--name",
        "astral",
        "--sync",
        "full",
      ]
    healthcheck:
      timeout: 5s
      interval: 30s
      retries: 60

  # Postgres Database
  postgres:
    image: postgres:16-alpine
    volumes:
      - postgres_db:/var/lib/postgresql/data
      - ./indexers/db/docker-entrypoint-initdb.d/init-db.sql:/docker-entrypoint-initdb.d/init-db.sql
      - ./indexers/db/postgresql.conf:/etc/postgresql/postgresql.conf
    restart: unless-stopped
    hostname: postgres
    shm_size: 8g
    environment:
      POSTGRES_DB: ${DB_DATABASE}
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_MAX_CONNECTIONS: 500
      POSTGRES_HOST_AUTH_METHOD: md5
      POSTGRES_INITDB_ARGS: --auth=md5
    ports:
      - "${DB_PORT}:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    command: ["postgres", "-c", "config_file=/etc/postgresql/postgresql.conf"]

  # PGCat Proxy
  pgcat:
    image: ghcr.io/postgresml/pgcat:4a7a6a8e7a78354b889002a4db118a8e2f2d6d79
    command:
      - "pgcat"
      - "/etc/pgcat/pgcat.toml"
    volumes:
      - "./indexers/db/pgcat.toml:/etc/pgcat/pgcat.toml"
    ports:
      - "6432:6432"
    healthcheck:
      test: ["CMD", "pgcat", "--version"]
      interval: 10s
      timeout: 5s
      retries: 3
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

  # Hasura GraphQL Engine
  hasura:
    image: hasura/graphql-engine:v2.40.0
    depends_on:
      postgres:
        condition: service_healthy
    volumes:
      - ./indexers/db/migrations:/hasura-migrations
      - ./indexers/db/metadata:/hasura-metadata
    restart: unless-stopped
    environment:
      # Essential Environment Variables
      HASURA_GRAPHQL_METADATA_DATABASE_URL: postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE}
      HASURA_GRAPHQL_DATABASE_URL: postgres://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_DATABASE} # Main database connection
      HASURA_GRAPHQL_ADMIN_SECRET: ${HASURA_GRAPHQL_ADMIN_SECRET} # Admin access secret
      HASURA_GRAPHQL_JWT_SECRET: ${HASURA_GRAPHQL_JWT_SECRET} # JWT authentication secret

      # Console and Development Mode
      HASURA_GRAPHQL_ENABLE_CONSOLE: ${HASURA_GRAPHQL_ENABLE_CONSOLE} # Disable console in production
      HASURA_GRAPHQL_DEV_MODE: "true" # Disable development mode features

      # Role and CORS Settings
      HASURA_GRAPHQL_UNAUTHORIZED_ROLE: user # Default role for unauthenticated users
      HASURA_GRAPHQL_CORS_DOMAIN: ${HASURA_GRAPHQL_CORS_DOMAIN} # Allowed domains for CORS
      HASURA_GRAPHQL_STRINGIFY_NUMERIC_TYPES: "true"

      # Performance and Connection Settings
      HASURA_GRAPHQL_MAX_CONNECTIONS: 100 # Maximum number of database connections
      HASURA_GRAPHQL_STRIPES: 2 # Number of connection pool stripes
      HASURA_GRAPHQL_CONNECTIONS_PER_STRIPE: 50 # Connections per stripe
      HASURA_GRAPHQL_IDLE_TIMEOUT: 180 # Idle connection timeout in seconds
      HASURA_GRAPHQL_TIMEOUT: 60 # Request timeout in seconds
      HASURA_GRAPHQL_ENABLE_QUERY_CACHE: true # Enable query caching

      # Subscriptions
      HASURA_GRAPHQL_ENABLE_SUBSCRIPTIONS: true # Enable subscriptions
      HASURA_GRAPHQL_ENABLE_WEBSOCKETS: true # Enable WebSockets
      HASURA_GRAPHQL_SUBSCRIPTIONS_PER_STRIPE: 10 # Subscriptions per stripe
      HASURA_GRAPHQL_SUBSCRIPTIONS_TIMEOUT: 180 # Subscription timeout in seconds
      # HASURA_GRAPHQL_WS_READ_COOKIE: true # Read cookies over WebSockets

      # Logging Settings
      HASURA_GRAPHQL_LOG_LEVEL: "warn" # Log verbosity level
      HASURA_GRAPHQL_ENABLED_LOG_TYPES: "startup,http-log,webhook-log,websocket-log,query-log" # Enabled log types

      # Security and Authorization
      HASURA_GRAPHQL_ENABLE_ALLOWLIST: "false" # Disable query allowlisting

      # Hasura Migrations and Metadata
      HASURA_GRAPHQL_MIGRATIONS_DIR: /hasura-migrations
      HASURA_GRAPHQL_METADATA_DIR: /hasura-metadata

      # Task Board Action Endpoint
      HASURA_GRAPHQL_ACTION_TASK_BOARD: http://taskboard:${BULL_PORT}
      HASURA_GRAPHQL_ACTION_TASK_BOARD_SESSION_SECRET: ${BULL_SESSION_SECRET}
    ports:
      - "${HASURA_GRAPHQL_PORT}:8080"
    command:
      - graphql-engine
      - serve

  dictionary_subquery_node:
    profiles: [dictionary, indexers]
    build:
      context: ./indexers/dictionary/${DICTIONARY_DIRECTORY}
    depends_on:
      pgcat:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    environment:
      DB_USER: ${DB_USER}
      DB_PASS: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
    volumes:
      - ./indexers/dictionary/${DICTIONARY_DIRECTORY}:/dictionary
    healthcheck:
      test: ["CMD", "curl", "-f", "http://dictionary_subquery_node:3000/ready"]
      interval: 3s
      timeout: 5s
      retries: 10
    command:
      - -f=/dictionary
      - --disable-historical=true

  dictionary_graphql_engine:
    profiles: [dictionary, indexers]
    image: onfinality/subql-query:latest
    ports:
      - "127.0.0.1:${DICTIONARY_SUBQUERY_NODE_PORT}:3000"
    depends_on:
      pgcat:
        condition: service_healthy
      postgres:
        condition: service_healthy
      dictionary_subquery_node:
        condition: service_healthy
    restart: unless-stopped
    environment:
      DB_USER: ${DB_USER}
      DB_PASS: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
    command:
      - --name=dictionary
      - --playground

  # Indexers Subquery Nodes
  consensus_subquery_node:
    profiles: [indexers]
    image: subquerynetwork/subql-node-substrate:latest
    ports:
      - "127.0.0.1:3001:3000"
    depends_on:
      pgcat:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    environment:
      ENDPOINT: ${RPC_URLS}
      CHAIN_ID: ${CHAIN_ID}
      DB_USER: ${DB_USER}
      DB_PASS: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
    volumes:
      - ./indexers/consensus:/consensus
    command:
      - ${SUB_COMMAND:-} # set SUB_COMMAND env variable to "test" to run tests
      - -f=/consensus
      - --db-schema=consensus
      - --workers=1
      - --unsafe
      - --batch-size=120
      - --scale-batch-size
      - --unfinalized-blocks=true
      - --disable-historical=false
      #  - --profiler
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/ready"]
      interval: 3s
      timeout: 5s
      retries: 10

  leaderboard_subquery_node:
    profiles: [indexers]
    image: subquerynetwork/subql-node-substrate:latest
    ports:
      - "127.0.0.1:3002:3000"
    depends_on:
      pgcat:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    environment:
      ENDPOINT: ${RPC_URLS}
      CHAIN_ID: ${CHAIN_ID}
      DB_USER: ${DB_USER}
      DB_PASS: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
    volumes:
      - ./indexers/leaderboard:/leaderboard
    command:
      - ${SUB_COMMAND:-} # set SUB_COMMAND env variable to "test" to run tests
      - -f=/leaderboard
      - --db-schema=leaderboard
      - --workers=1
      - --batch-size=100
      - --scale-batch-size
      - --unfinalized-blocks=true
      - --disable-historical=false
      #  - --profiler
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/ready"]
      interval: 3s
      timeout: 5s
      retries: 10

  staking_subquery_node:
    profiles: [indexers]
    image: subquerynetwork/subql-node-substrate:latest
    ports:
      - "127.0.0.1:3003:3000"
    depends_on:
      pgcat:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    environment:
      ENDPOINT: ${RPC_URLS}
      CHAIN_ID: ${CHAIN_ID}
      DICTIONARY: ${DICTIONARY_URL}
      DB_USER: ${DB_USER}
      DB_PASS: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
    volumes:
      - ./indexers/staking:/staking
    command:
      - ${SUB_COMMAND:-} # set SUB_COMMAND env variable to "test" to run tests
      - -f=/staking
      - --db-schema=staking
      - --workers=1
      - --unsafe
      - --batch-size=125
      - --scale-batch-size
      - --unfinalized-blocks=true
      - --disable-historical=false
      #  - --profiler
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/ready"]
      interval: 3s
      timeout: 5s
      retries: 10

  files_subquery_node:
    profiles: [indexers]
    image: subquerynetwork/subql-node-substrate:latest
    ports:
      - "127.0.0.1:3004:3000"
    depends_on:
      pgcat:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    environment:
      ENDPOINT: ${RPC_URLS}
      CHAIN_ID: ${CHAIN_ID}
      DB_USER: ${DB_USER}
      DB_PASS: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
    volumes:
      - ./indexers/files:/files
    command:
      - ${SUB_COMMAND:-} # set SUB_COMMAND env variable to "test" to run tests
      - -f=/files
      - --db-schema=files
      - --workers=1
      - --unsafe
      - --batch-size=50
      - --scale-batch-size
      - --unfinalized-blocks=true
      - --disable-historical=false
      #  - --profiler
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/ready"]
      interval: 3s
      timeout: 5s
      retries: 10

  # Redis
  redis:
    profiles: [task]
    image: redis:latest
    restart: unless-stopped
    ports:
      - "${REDIS_PORT}:6379"
    volumes:
      - redis_db:/data
    hostname: redis
    command: ["redis-server", "--bind", "0.0.0.0", "--port", "6379"]
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "redis-cli -h localhost -p 6379 ping | grep PONG || exit 1",
        ]
      interval: 5s
      timeout: 5s
      retries: 10

  # Express + BullMQ
  taskboard:
    profiles: [task]
    build:
      context: ./indexers/taskboard
    depends_on:
      pgcat:
        condition: service_healthy
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    volumes:
      - ./indexers/taskboard:/app
    hostname: taskboard
    restart: unless-stopped
    ports:
      - "${BULL_PORT}:${BULL_PORT}"
    environment:
      BULL_USERNAME: ${BULL_USERNAME}
      BULL_PASSWORD: ${BULL_PASSWORD}
      BULL_PORT: ${BULL_PORT}
      BULL_SESSION_SECRET: ${BULL_SESSION_SECRET}

      REDIS_HOST: redis
      REDIS_PORT: ${REDIS_PORT}

      DB_USER: ${DB_USER}
      DB_PASSWORD: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}

      NETWORK_ID: ${NETWORK_ID}
      LOG_LEVEL: ${LOG_LEVEL}

      SLACK_TOKEN: ${SLACK_TOKEN}
      SLACK_CONVERSATION_ID: ${SLACK_CONVERSATION_ID}

  # NestJS API Service
  api:
    build:
      context: ./indexers/api
      dockerfile: Dockerfile
    depends_on:
      postgres:
        condition: service_healthy
      hasura:
        condition: service_started
    restart: unless-stopped
    ports:
      - "${API_PORT}:3000"
    environment:
      NODE_ENV: ${NODE_ENV}
      DB_HOST: ${DB_HOST}
      DB_PORT: ${DB_PORT}
      DB_USER: ${DB_USER}
      DB_PASSWORD: ${DB_PASSWORD}
      DB_DATABASE: ${DB_DATABASE}
    hostname: api
    volumes:
      - ./indexers/api:/app
      - /app/node_modules