action.yml

name: Setup Elixir Project
description: Configures Elixir, fetches dependencies, and manages build caching.

branding:
  icon: "droplet"
  color: "purple"

inputs:
  otp-version:
    type: string
    description: OTP version to set up
  elixir-version:
    type: string
    description: Elixir version to set up
  version-file:
    type: string
    description: a versions file (e.g. as used by `asdf`), which defines inputs
  version-type:
    type: string
    description: strict means the versions are take as-are; loose means we try
      to guess versions based on semver rules

  # Optional inputs
  build-deps:
    required: false
    type: boolean
    default: true
    description: True if we should compile dependencies
  build-app:
    required: false
    type: boolean
    default: true
    description: True if we should compile the application itself
  build-flags:
    required: false
    type: string
    default: "--all-warnings --warnings-as-errors"
    description: Flags to pass to mix compile
  cache-plts:
    required: false
    type: boolean
    default: false
    description: By default, we will not cache dialyzer PLTs files
  install-rebar:
    required: false
    type: boolean
    default: true
    description: By default, we will install Rebar (mix local.rebar --force).
  install-hex:
    required: false
    type: boolean
    default: true
    description: By default, we will install Hex (mix local.hex --force).
  cache-key:
    required: false
    type: string
    default: "v1"
    description: If you need to reset the cache for some reason, you can change this key.

outputs:
  otp-version:
    description: "Exact OTP version selected by the BEAM setup step"
    value: ${{ steps.beam.outputs.otp-version }}
  elixir-version:
    description: "Exact Elixir version selected by the BEAM setup step"
    value: ${{ steps.beam.outputs.elixir-version }}

runs:
  using: "composite"
  steps:
    - name: Setup Elixir
      uses: erlef/setup-beam@v1
      id: beam
      with:
        version-type: ${{ inputs.version-type }}
        version-file: ${{ inputs.version-file }}
        elixir-version: ${{ inputs.elixir-version }}
        otp-version: ${{ inputs.otp-version }}

    - name: Get deps cache
      uses: actions/cache@v4
      with:
        path: deps/
        key: deps-${{ inputs.cache-key }}-${{ runner.os }}-${{ hashFiles('**/mix.lock') }}
        restore-keys: |
          deps-${{ inputs.cache-key }}-${{ runner.os }}-

    - name: Get build cache
      uses: actions/cache@v4
      id: build-cache
      with:
        path: _build/${{env.MIX_ENV}}/
        key: build-${{ inputs.cache-key }}-${{ runner.os }}-${{ inputs.otp-version }}-${{ inputs.elixir-version }}-${{ env.MIX_ENV }}-${{ hashFiles('**/mix.lock') }}
        restore-keys: |
          build-${{ inputs.cache-key }}-${{ runner.os }}-${{ inputs.otp-version }}-${{ inputs.elixir-version }}-${{ env.MIX_ENV }}-

    - name: Get Hex cache
      uses: actions/cache@v4
      id: hex-cache
      with:
        path: ~/.hex
        key: build-${{ runner.os }}-${{ inputs.otp-version }}-${{ inputs.elixir-version }}-${{ hashFiles('**/mix.lock') }}
        restore-keys: |
          build-${{ runner.os }}-${{ inputs.otp-version }}-${{ inputs.elixir-version }}-

    # In my experience, I have issues with incremental builds maybe 1 in 100
    # times that are fixed by doing a full recompile.
    # In order to not waste dev time on such trivial issues (while also reaping
    # the time savings of incremental builds for *most* day-to-day development),
    # I force a full recompile only on builds that we retry.
    - name: Clean to rule out incremental build as a source of flakiness
      if: github.run_attempt != '1'
      run: |
        mix deps.clean --all
        mix clean
      shell: sh

    - name: Install Rebar
      run: mix local.rebar --force
      shell: sh
      if: inputs.install-rebar == 'true'

    - name: Install Hex
      run: mix local.hex --force
      shell: sh
      if: inputs.install-hex == 'true'

    - name: Install Dependencies
      run: mix deps.get
      shell: sh

    # Normally we'd use `mix deps.compile` here, however that incurs a large
    # performance penalty when the dependencies are already fully compiled:
    # https://elixirforum.com/t/github-action-cache-elixir-always-recompiles-dependencies-elixir-1-13-3/45994/12
    #
    # Accoring to Jose Valim at the above link `mix loadpaths` will check and
    # compile missing dependencies
    - name: Compile Dependencies
      run: mix loadpaths
      shell: sh
      if: inputs.build-deps == 'true'

    - name: Compile Application
      run: mix compile ${{ inputs.build-flags }}
      shell: sh
      if: inputs.build-app == 'true'

    # Don't cache PLTs based on mix.lock hash, as Dialyzer can incrementally update even old ones
    # Cache key based on Elixir & Erlang version (also useful when running in matrix)
    - name: Restore PLT cache
      uses: actions/cache@v4
      id: plt-cache
      with:
        key: plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-${{ hashFiles('**/mix.lock') }}-${{ hashFiles('**/*.ex') }}
        restore-keys: |
          plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-${{ hashFiles('**/mix.lock') }}-${{ hashFiles('**/*.ex') }}
          plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-${{ hashFiles('**/mix.lock') }}-
          plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-
          plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-
        path: priv/plts
      if: inputs.cache-plts == 'true'

    # Create PLTs if no cache was found.
    # Always rebuild PLT when a job is retried
    # (If they were cached at all, they'll be updated when we run mix dialyzer with no flags.)
    - name: Create PLTs
      if: (steps.plt-cache.outputs.cache-hit != 'true' || github.run_attempt != '1') && inputs.cache-plts == 'true'
      shell: sh
      run: mix dialyzer --plt