Thanks for this library. Would you accepted a PR for adding support for the "release" event?

Example from the GitHub Actions docs:

on:
  release:
    types: [published]

If so, would you prefer:

{ types : (List Text) }

or would you prefer a union type?

There are an increasing number of record keys of the form actions/foo. This gives a quasi-namespacing effect but maybe we want to push them into a separate record, since AFAIK we can't assemble record keys from Text or anything.

Should we have actions = { setup-haskell = ..., setup-java = ... } etc instead?

I have been evaluating using dhall to generate github actions. Under what license is the code under?
As there is no license stated, I'm guessing regular copyright would be in effect, and as such any usage of the code needs to be granted in some way.

Hi @regadas! Thanks for all your work on this. I have an issue and would like your thoughts on it.

I currently have an open PR to support reusable workflows but it only adds the types needed. To call a reusable workflow, it has to be done on the job level so a uses key will be used instead of steps. My initial thought is to make jobs.steps and jobs.runs-on Optional but this will break existing workflows (including ours) since they have to be changed to Optional values. What's your take on this?

My current work around is to merge the records e.g.

GithubActions.Workflow::{
...
, jobs = [] : List { mapKey : Text, mapValue : GithubActions.Job.Type }
}
//  { jobs = toMap { job1.uses = "my-reusable-workflow@master" } }

Hi! Quite new to Dhall so sorry if this is a dumb question. I'm in the process of converting our entire GH CICD to Dhalll.

Github workflow files extend the standard YAML syntax, in that they allow you to add expressions which can be used to programmatically set variables and inputs for jobs. For example, in our use-case we generate a list of services that need to be re-deployed (call this job A), which is then used as the deployment field in the strategy.matrix key of a later job (call this job B). The strategy in GH workflow syntax looks like:

jobs:
  jobA:
    outputs:
      deployment-matrix: ...
  jobB:
    strategy:
      matrix:
        deployment: ${{ fromJson(needs.jobA.outputs.deployment-matrix) }}

However with the current definition of Strategy a value in a matrix needs to be of type List Text, which makes the above impossible.

This isn't specific to strategy.matrix: from what I gather, almost any value in a workflow file can be replaced with a github expression. This is fine when the value is of type Text or Optional Text, but for any other type (like List Text above) it's impossible to use an expression.

Generic solution idea: we could wrap problematic types in a new polymorphic type, e.g.

-- OrGHExpression.dhall
λ(a : Type) → < GHExpression : Text | Value : a >

-- Strategy.dhall
let OrGHExpression = ./OrGHExpression.dhall

in  { matrix : List { mapKey : Text, mapValue : OrGHExpression (List Text) }
    , fail-fast : Optional Bool
    , max-parallel : Optional Natural 
    }

-- Example.dhall
Some GithubActions.Strategy::{
, matrix = 
  { deployment = ListTextOrGH.GHExpression "\${{ fromJson(needs.jobA.outputs.deployment-matrix) }}"
  , something-else = ListTextOrGH.Value [ "ubuntu-latest" ] 
  } 
} 

There are instances where you'd like the continue-on-error field in a job to reference a matrix variable for example that can itself be true or false. However, with the current type being Optional Bool, there's no way to take-in a \${{matrix.blah}} Text/String.

I thought about adding a PR, but wanted to throw up an issue first and get your thoughts.

That might feel like too much, though there's an option to define:

permissions: write-all

The hashFiles function in the Github Actions expression language can support multiple patterns: https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#hashfiles

It would be nice for the cache step in this repo to support that also, by taking a List Text instead of a single Text. I started to prepare a PR for this but got lost in apparent duplication: what is the design intent between steps/cache.dhall and steps/actions/cache.dhall? dhall hash says that they're identical. Is one deprecated?

https://github.com/regadas/github-actions-dhall/blob/afa7bc5f08b5804230f0d7b5137b2060ae1b7964/types/Input.dhall does not include all fields that are mentioned in the GHA docs

https://github.com/regadas/github-actions-dhall/blob/master/examples/scala.dhall

I'm having trouble using this for my project because of this line:

https://github.com/regadas/github-actions-dhall/blob/master/examples/scala.dhall#L51

I think it should be matrix.java here instead of matrix.scala. Otherwise I'm getting errors like "jdk 2.12.11 does not exist".

GithubActions.steps.actions/cache
  { path = "my-path", key = "my-key", hashFiles = [] : List Text }

produces this job:

      - name: my-path cache
        uses: "actions/cache@v2"
        with:
          key: "${{ runner.os }}-my-key-${{ hashFiles() }}"
          path: my-path
          restore-keys: |
            ${{ runner.os }}-my-key-

but GitHub Actions fails with Too few parameters supplied: '(' due to hashFiles().

I think we can move from
https://raw.githubusercontent.com/regadas/github-actions-dhall/master/package.dhall

to smth like
https://regadas.dev/github-actions-dhall/package.dhall

It's shorter and it will be nice once we add releases.

First of all: Awesome work, many thanks!

I think the type of RunsOn is too strict as it only permits one of the github provided runners.

There is the possibility to define a matrix for the runners, e.g. like that https://github.com/sengaya/aws-micro-cli/blob/master/.github/workflows/main.yml#L18-L21 so i would need to put something like ${{ matrix.os }} for runs-on.

Also there is the possibility for custom runners. I have no experience with this but I guess that's also not possible with the current type restriction.

Hi,

I gave this a try and after running the following command:

$ curl https://raw.githubusercontent.com/regadas/github-actions-dhall/master/examples/scala.dhall | dhall-to-yaml

I got the following error:

Error: Invalid input

(stdin):27:28:
   |
27 | in  GithubActions.Workflow::{
   |                            ^^^
unexpected ":{<newline>    ,"
expecting expression or whitespace

Here's my shell.nix specifying my dependencies:

let
  pkgs = import (fetchTarball "https://github.com/NixOS/nixpkgs-channels/archive/nixos-20.03.tar.gz") {};
  stdenv = pkgs.stdenv;

in stdenv.mkDerivation rec {
  name = "neutron";
  buildInputs = [
    pkgs.dhall-json # v1.6.2
    pkgs.openjdk # v1.8.0_222
    pkgs.sbt  # v1.3.8
  ];
}

Is this behavior expected using dhall-json-v1.6.2?

Currently, Strategy::matrix is defined as a List { mapKey : Text, mapValue : List Text }:

https://github.com/regadas/github-actions-dhall/blob/master/types/Strategy.dhall

However, Github Actions supports having an exclude key that is a list of records (not Text):

https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#example-excluding-configurations-from-a-matrix

Currently it's not possible to specify an exclude field in the matrix, because it doesn't match the type.

Hi @regadas

What do you think about using git tags and GitHub releases on this repo ?