Dhall Documentation

Description

Monorepo Module

This module provides functionality to filter out jobs based on `scope` and `filter`.
It is designed to work with a monorepo setup where jobs are defined with specific tags and scopes.

Features

- Filters jobs based on tags and scope.
- Supports custom filtering logic by overriding `filter` and `tags` modules.
- Generates a pipeline configuration for Buildkite with the filtered jobs.
- Allows prefix commands to be added before the filtered job commands.

Usage

To use this module in your client code:
1. Override the `filter` and `tags` modules as needed.
2. Provide the required inputs: `filterName`, `tags`, `scope`, `jobs`, and `prefixCommands`.
3. The module will return a pipeline configuration that can be used in Buildkite.

Source

let Tag = ./Tag.dhall

let Scope = ./Scope.dhall

let JobSpec = ./JobSpec.dhall

let Cmd = ../../Lib/Cmds.dhall

let Pipeline = ../../Pipeline/Annotated/Type.dhall

let Prelude = ../../External/Prelude.dhall

let SelectFiles = ../../Lib/SelectFiles.dhall

let Filter = ./Filter.dhall

let Command = ../../Command/Base.dhall

let Size = ../../Command/Size.dhall

let triggerCommand = ./TriggerCommand.dhall

let List/map = Prelude.List.map

let commands
    : List Tag.Type -> Text -> Scope.Type -> List JobSpec.Type -> List Cmd.Type
    =     \(tags : List Tag.Type)
      ->  \(filterName : Text)
      ->  \(scope : Scope.Type)
      ->  \(jobs : List JobSpec.Type)
      ->  List/map
            JobSpec.Type
            Cmd.Type
            (     \(job : JobSpec.Type)
              ->  let dirtyWhen = SelectFiles.compile job.dirtyWhen

                  let trigger =
                        triggerCommand "src/Jobs/${job.path}/${job.name}.dhall"

                  in        if Filter.contains job.tags tags

                      then  let cmd =
                                        if Scope.hasAny scope job.scope

                                  then  ''
                                          echo "Triggering ${job.name} because this is a release buildkite run"
                                          ${Cmd.format trigger}
                                        ''

                                  else  if Scope.hasAny scope job.scope

                                  then  ''
                                          echo "Triggering ${job.name} because this is a nightly buildkite run"
                                          ${Cmd.format trigger}
                                        ''

                                  else  if Scope.hasAny scope job.scope

                                  then  ''
                                          if (cat _computed_diff.txt | egrep -q '${dirtyWhen}'); then
                                                echo "Triggering ${job.name} for reason:"
                                                cat _computed_diff.txt | egrep '${dirtyWhen}'
                                                ${Cmd.format trigger}
                                          fi
                                        ''

                                  else  ''
                                          echo "Skipping ${job.name} because it does not run at any scope"
                                        ''

                            in  Cmd.quietly cmd

                      else  Cmd.quietly
                              ''
                                echo "Skipping ${job.name} because this is a ${filterName} stage"
                              ''
            )
            jobs

in      \(filterName : Text)
    ->  \(tags : List Tag.Type)
    ->  \(scope : Scope.Type)
    ->  \(jobs : List JobSpec.Type)
    ->  \(prefixCommands : List Cmd.Type)
    ->  let pipelineType =
              Pipeline.build
                Pipeline.Config::{
                , spec = JobSpec::{
                  , name = "monorepo-triage-${filterName}"
                  , dirtyWhen = [ SelectFiles.everything ]
                  }
                , steps =
                  [ Command.build
                      Command.Config::{
                      , commands =
                          prefixCommands # commands tags filterName scope jobs
                      , label = "Monorepo triage ${filterName}"
                      , key = "cmds-${filterName}"
                      , target = Size.Type.Multi
                      }
                  ]
                }

        in  pipelineType.pipeline