justfile

# Laxy Development Commands
# Run `just` to see available commands

# Default recipe shows help
default:
    @just --list

# Start servers (optionally specify service name)
up service='':
    #!/usr/bin/env bash
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    if [ -z "{{service}}" ]; then
        echo "🚀 Starting Laxy development environment..."
        docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" up -d
        echo "✅ Services starting... Check logs with 'just logs'"
        echo "   Frontend: http://localhost:8002"
        echo "   Backend:  http://localhost:8001"
    else
        echo "🚀 Starting service: {{service}}..."
        docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" up -d {{service}}
    fi

# Stop servers (optionally specify service name)
down service='':
    #!/usr/bin/env bash
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    if [ -z "{{service}}" ]; then
        echo "🛑 Stopping Laxy development environment..."
        docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" down
    else
        echo "🛑 Stopping service: {{service}}..."
        docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" stop {{service}}
    fi

# Show container logs. Optionally pass a service name.
logs service='':
    #!/usr/bin/env bash
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    if [ -z "{{service}}" ]; then
        docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" logs --tail 50 -f
    else
        docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" logs --tail 50 -f {{service}}
    fi

# Build Docker images
build:
    #!/usr/bin/env bash
    echo "🔨 Building Docker images..."
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" build

# Run unit tests inside docker-compose.test.yml (pytest against laxy_backend)
test-unit:
    #!/usr/bin/env bash
    # Non-default buildx builders (e.g. docker-container drivers) cannot see locally tagged
    # images; FROM laxy:dev would try docker.io/library/laxy:dev. Force the default builder.
    if ! docker image inspect laxy:dev >/dev/null 2>&1; then
        echo "🔨 laxy:dev not found locally; building base image (docker/laxy-test/Dockerfile depends on it)..."
        docker compose -f docker-compose.yml -f docker-compose.local-dev.yml build --builder default django
    fi
    echo "🧪 Running unit tests with docker-compose.test.yml (pytest, unit-tests service)..."
    docker compose -f docker-compose.test.yml build --builder default unit-tests
    docker compose -f docker-compose.test.yml up --exit-code-from unit-tests --abort-on-container-exit --no-build
    status=$?
    echo "🧹 Cleaning up test containers..."
    docker compose -f docker-compose.test.yml down -v
    exit $status

# Run integration tests via pytest against a running local-dev environment (django container)
test-integration:
    #!/usr/bin/env bash
    echo "🔗 Running integration tests against local-dev environment (django container)..."
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django pytest -vvv --showlocals --tb=auto --integration tests/integration

# Run individual integration test suites against a running local-dev environment (django container)
test-jwt:
    #!/usr/bin/env bash
    echo "🔐 Testing JWT authentication against local-dev environment (django container)..."
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django pytest -vvv --showlocals --tb=auto --integration tests/integration/test_jwt_auth.py

test-files:
    #!/usr/bin/env bash
    echo "📁 Testing file operations against local-dev environment (django container)..."
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django pytest -vvv --showlocals --tb=auto --integration tests/integration/test_file_operations.py

test-external:
    #!/usr/bin/env bash
    echo "🔗 Testing external integrations against local-dev environment (django container)..."
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django pytest -vvv --showlocals --tb=auto --integration tests/integration/test_external_integrations.py

# Run all tests (unit + integration)
test-all: test-unit test-integration

# Default test target: unit tests only
test: test-unit

# --- Synthetic annotation corpus -------------------------------------------
# Fast tiers (detect + filter + seqid). No Django, no containers. ~1s.
test-annotation-corpus:
    @echo "🧬 Running annotation corpus (detect + filter + seqid)..."
    pytest tests/data/annotation_corpus/ -m "corpus and not e2e"

# Tier 4 read-generation sanity (generates + counts reads; no nextflow).
test-annotation-corpus-reads:
    @echo "🧬 Annotation corpus: generating reads + sanity checks..."
    pytest tests/data/annotation_corpus/test_annotation_e2e.py::test_e2e_reads_sanity

# Full nf-core/rnaseq e2e (needs nextflow + fake-cluster stack up).
test-annotation-corpus-e2e:
    @echo "🧬 Annotation corpus: full nf-core/rnaseq e2e (slow)..."
    pytest tests/data/annotation_corpus/ -m e2e

# Regenerate the shared synthetic genome from its fixed seed.
annotation-genome:
    @echo "🧬 Regenerating shared/genome.fa (fixed seed)..."
    python3 tests/data/annotation_corpus/shared/generate_genome.py -o tests/data/annotation_corpus/shared/genome.fa
    gzip -kf tests/data/annotation_corpus/shared/genome.fa

# Re-seed cases/*/annotation.* from the doc catalogue (one-off bootstrap).
annotation-fixtures:
    @echo "🧬 (Re)writing case annotation fixtures..."
    python3 tests/data/annotation_corpus/shared/make_annotation_fixtures.py
    @just annotation-manifests

# Snapshot current detector/filter behaviour into cases/*/manifest.json.
annotation-manifests:
    @echo "🧬 Regenerating manifests from actual behaviour..."
    python3 tests/data/annotation_corpus/shared/make_manifests.py

# Run database migrations
migrate:
    #!/usr/bin/env bash
    echo "🗃️  Running database migrations..."
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django python manage.py migrate

# Create Django superuser
superuser:
    #!/usr/bin/env bash
    echo "👤 Creating Django superuser..."
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django python manage.py createsuperuser

# 🔍 Code Quality Commands

# Setup local virtual environment with production dependencies
setup-venv:
    #!/usr/bin/env bash
    echo "📦 Setting up local virtual environment (production dependencies)..."
    if [ ! -d ".venv" ]; then
        uv venv
    fi
    source .venv/bin/activate && uv pip install -r requirements.txt
    echo "✅ Virtual environment ready!"

# Setup local virtual environment with development dependencies
setup-venv-dev:
    #!/usr/bin/env bash
    echo "📦 Setting up local virtual environment (development dependencies)..."
    if [ ! -d ".venv" ]; then
        uv venv
    fi
    source .venv/bin/activate && uv pip install -r requirements-dev.txt
    echo "✅ Virtual environment ready!"

# Run code linting
lint: setup-venv-dev
    @echo "🔍 Running linters..."
    @.venv/bin/ruff check --select=E9,F63,F7,F82 laxy_backend/
    @.venv/bin/ruff check --select=E9,F63,F7,F82 laxy_pipeline_apps/

# Format code with ruff
format: setup-venv-dev
    @echo "🎨 Formatting code..."
    @.venv/bin/ruff format laxy_backend/
    @.venv/bin/ruff format laxy_pipeline_apps/

# Run type checking with mypy
typecheck: setup-venv-dev
    @echo "🔬 Running type checks..."
    @.venv/bin/mypy laxy_backend/ --ignore-missing-imports

# Check system requirements
check:
    #!/usr/bin/env bash
    echo "🔍 Checking system requirements..."
    
    # Check Docker
    if command -v docker >/dev/null 2>&1; then
        echo "✅ Docker: $(docker --version)"
    else
        echo "❌ Docker not found"
        exit 1
    fi
    
    # Check Docker Compose
    if docker compose version >/dev/null 2>&1; then
        echo "✅ Docker Compose: $(docker compose version)"
    else
        echo "❌ Docker Compose not found"
        exit 1
    fi
    
    # Check Python
    if command -v python3 >/dev/null 2>&1; then
        echo "✅ Python: $(python3 --version)"
    else
        echo "❌ Python 3 not found"
        exit 1
    fi
    
    # Check uv
    if command -v uv >/dev/null 2>&1; then
        echo "✅ uv: $(uv --version)"
    else
        echo "❌ uv not found (install from https://docs.astral.sh/uv/getting-started/installation/)"
        exit 1
    fi
    
    echo "🎉 All requirements satisfied!"

# Show service status
status:
    #!/usr/bin/env bash
    echo "📊 Service Status:"
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" ps

# Open useful URLs
open:
    #!/usr/bin/env bash
    echo "🌐 Opening Laxy URLs..."
    if command -v open >/dev/null 2>&1; then
        # macOS
        open http://localhost:8002  # Frontend
        open http://localhost:8001/admin  # Admin
    elif command -v xdg-open >/dev/null 2>&1; then
        # Linux
        xdg-open http://localhost:8002
        xdg-open http://localhost:8001/admin
    else
        echo "   Frontend: http://localhost:8002"
        echo "   Admin:    http://localhost:8001/admin"
        echo "   API:      http://localhost:8001/api/v1/"
        echo "   Swagger:  http://localhost:8001/api/v1/schema/swagger-ui/"
    fi

# Execute shell in Django container
django-shell:
    #!/usr/bin/env bash
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django python manage.py shell

# Execute bash in Django container
bash:
    #!/usr/bin/env bash
    export LAXY_ENV=${LAXY_ENV:-local-dev}
    COMPOSE_FILE="docker-compose.${LAXY_ENV}.yml"
    docker compose -f docker-compose.yml -f "${COMPOSE_FILE}" exec django bash

# Full setup for new developers
setup:
    @echo "🚀 Setting up Laxy development environment..."
    just check
    just setup-venv-dev
    just build
    just up
    @echo "⏳ Waiting for services to start..."
    @sleep 10
    just status
    @echo "🎉 Setup complete! Run 'just open' to access the application"
    just open

# Complete test suite for CI/CD (unit + integration)
ci: check test-all

restart: down up