├── .github └── workflows │ └── main.yml ├── GitLab ├── ArtifactsSpec │ ├── Type.dhall │ ├── append.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── CachePolicy │ ├── Type.dhall │ ├── package.dhall │ └── toJSON.dhall ├── CacheSpec │ ├── Type.dhall │ ├── append.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Defaults │ ├── Type.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Duration │ ├── Type.dhall │ ├── fromDays.dhall │ ├── fromHours.dhall │ ├── fromMinutes.dhall │ ├── fromSeconds.dhall │ ├── fromWeeks.dhall │ ├── fromYears.dhall │ ├── greaterThan.dhall │ ├── package.dhall │ ├── scale.dhall │ └── toJSON.dhall ├── Environment │ ├── Type.dhall │ ├── append.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── EnvironmentAction │ ├── Type.dhall │ ├── package.dhall │ └── toJSON.dhall ├── GitSubmoduleStrategy │ ├── Type.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Image │ ├── Type.dhall │ ├── append.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Include │ ├── Type.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Job │ ├── Type.dhall │ ├── append.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Kubernetes │ ├── Type.dhall │ ├── append.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Prelude.dhall ├── Rule │ ├── Type.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Script │ ├── Type.dhall │ └── package.dhall ├── Service │ ├── Type.dhall │ ├── mkService.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Top │ ├── Type.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── Trigger │ ├── Type.dhall │ ├── append.dhall │ ├── default.dhall │ ├── package.dhall │ └── toJSON.dhall ├── TriggerStrategy │ ├── Type.dhall │ ├── package.dhall │ └── toJSON.dhall ├── When │ ├── Type.dhall │ ├── package.dhall │ └── toJSON.dhall ├── package.dhall └── utils │ ├── dropNones.dhall │ ├── mergeOptional.dhall │ ├── mergeOptionalList.dhall │ ├── mergeOptionalRight.dhall │ ├── optionalList.dhall │ └── stringsArrayJSON.dhall ├── LICENSE ├── Prelude.dhall ├── README.mkd ├── examples ├── multiple-jobs.dhall └── single-job.dhall └── package.dhall /.github/workflows/main.yml: -------------------------------------------------------------------------------- 1 | name: Smoke Test 2 | 3 | on: 4 | push: 5 | branches: [ master ] 6 | pull_request: 7 | branches: [ master ] 8 | workflow_dispatch: 9 | 10 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel 11 | jobs: 12 | build: 13 | runs-on: ubuntu-latest 14 | steps: 15 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it 16 | - uses: actions/checkout@v2 17 | - uses: dhall-lang/setup-dhall@v4 18 | - run: dhall text --file examples/single-job.dhall 19 | - run: dhall text --file examples/multiple-jobs.dhall 20 | -------------------------------------------------------------------------------- /GitLab/ArtifactsSpec/Type.dhall: -------------------------------------------------------------------------------- 1 | let When = ../When/Type.dhall 2 | 3 | let Duration = ../Duration/Type.dhall 4 | 5 | in { when : When 6 | , expire_in : Duration 7 | , reports : { junit : Optional Text } 8 | , paths : List Text 9 | } 10 | -------------------------------------------------------------------------------- /GitLab/ArtifactsSpec/append.dhall: -------------------------------------------------------------------------------- 1 | let ArtifactsSpec = ./Type.dhall 2 | 3 | let mergeOptionalRight = ../utils/mergeOptionalRight.dhall 4 | 5 | let append 6 | : ArtifactsSpec → ArtifactsSpec → ArtifactsSpec 7 | = λ(a : ArtifactsSpec) → 8 | λ(b : ArtifactsSpec) → 9 | { when = b.when 10 | , expire_in = b.expire_in 11 | , reports.junit = 12 | mergeOptionalRight Text a.reports.junit b.reports.junit 13 | , paths = a.paths # b.paths 14 | } 15 | 16 | in append 17 | -------------------------------------------------------------------------------- /GitLab/ArtifactsSpec/default.dhall: -------------------------------------------------------------------------------- 1 | let When = ../When/Type.dhall 2 | 3 | in { when = When.OnSuccess 4 | , expire_in = ../Duration/fromDays.dhall 30 5 | , reports.junit = None Text 6 | , paths = [] : List Text 7 | } 8 | : ./Type.dhall 9 | -------------------------------------------------------------------------------- /GitLab/ArtifactsSpec/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall 2 | , default = ./default.dhall 3 | , toJSON = ./toJSON.dhall 4 | , append = ./append.dhall 5 | } 6 | -------------------------------------------------------------------------------- /GitLab/ArtifactsSpec/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let ArtifactsSpec = ../ArtifactsSpec/Type.dhall 8 | 9 | let Optional/map = Prelude.Optional.map 10 | 11 | let dropNones = ../utils/dropNones.dhall 12 | 13 | let When/toJSON = ../When/toJSON.dhall 14 | 15 | let Duration/toJSON = ../Duration/toJSON.dhall 16 | 17 | let List/map = Prelude.List.map 18 | 19 | in let ArtifactsSpec/toJSON 20 | : ArtifactsSpec → JSON.Type 21 | = λ(cs : ArtifactsSpec) → 22 | let obj 23 | : Map.Type Text JSON.Type 24 | = toMap 25 | { when = When/toJSON cs.when 26 | , expire_in = Duration/toJSON cs.expire_in 27 | , paths = 28 | JSON.array 29 | (List/map Text JSON.Type JSON.string cs.paths) 30 | } 31 | 32 | in JSON.object obj 33 | 34 | in ArtifactsSpec/toJSON 35 | -------------------------------------------------------------------------------- /GitLab/CachePolicy/Type.dhall: -------------------------------------------------------------------------------- 1 | < Pull | Push | PullPush > 2 | -------------------------------------------------------------------------------- /GitLab/CachePolicy/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/CachePolicy/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let CachePolicy = ./Type.dhall 6 | 7 | let CachePolicy/toJSON 8 | : CachePolicy → JSON.Type 9 | = λ(policy : CachePolicy) → 10 | JSON.string 11 | ( merge 12 | { Pull = "pull", Push = "push", PullPush = "pull-push" } 13 | policy 14 | ) 15 | 16 | in CachePolicy/toJSON 17 | -------------------------------------------------------------------------------- /GitLab/CacheSpec/Type.dhall: -------------------------------------------------------------------------------- 1 | let When = ../When/Type.dhall 2 | 3 | let CachePolicy = ../CachePolicy/Type.dhall 4 | 5 | in { key : Text 6 | , paths : List Text 7 | , untracked : Optional Bool 8 | , when : When 9 | , policy : Optional CachePolicy 10 | } 11 | -------------------------------------------------------------------------------- /GitLab/CacheSpec/append.dhall: -------------------------------------------------------------------------------- 1 | let CacheSpec = ./Type.dhall 2 | 3 | let CachePolicy = ../CachePolicy/Type.dhall 4 | 5 | let mergeOptionalRight = ../utils/mergeOptionalRight.dhall 6 | 7 | let append 8 | : CacheSpec → CacheSpec → CacheSpec 9 | = λ(a : CacheSpec) → 10 | λ(b : CacheSpec) → 11 | { key = b.key 12 | , paths = a.paths # b.paths 13 | , untracked = mergeOptionalRight Bool a.untracked b.untracked 14 | , when = b.when 15 | , policy = mergeOptionalRight CachePolicy a.policy b.policy 16 | } 17 | 18 | in append 19 | -------------------------------------------------------------------------------- /GitLab/CacheSpec/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, toJSON = ./toJSON.dhall, append = ./append.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/CacheSpec/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let CacheSpec = ./Type.dhall 8 | 9 | let dropNones = ../utils/dropNones.dhall 10 | 11 | let Optional/map = Prelude.Optional.map 12 | 13 | let List/map = Prelude.List.map 14 | 15 | in let CacheSpec/toJSON 16 | : CacheSpec → JSON.Type 17 | = λ(cs : CacheSpec) → 18 | let obj 19 | : Map.Type Text JSON.Type 20 | = toMap 21 | { key = JSON.string cs.key 22 | , paths = 23 | JSON.array 24 | (List/map Text JSON.Type JSON.string cs.paths) 25 | } 26 | 27 | in JSON.object obj 28 | 29 | in CacheSpec/toJSON 30 | -------------------------------------------------------------------------------- /GitLab/Defaults/Type.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Service = ../Service/Type.dhall 4 | 5 | let CacheSpec = ../CacheSpec/Type.dhall 6 | 7 | in { image : Optional Text 8 | , before_script : List Text 9 | , after_script : List Text 10 | , services : List Service 11 | , cache : Optional CacheSpec 12 | } 13 | -------------------------------------------------------------------------------- /GitLab/Defaults/default.dhall: -------------------------------------------------------------------------------- 1 | let Defaults = ./Type.dhall 2 | 3 | let Service = ../Service/Type.dhall 4 | 5 | let CacheSpec = ../CacheSpec/Type.dhall 6 | 7 | in { image = None Text 8 | , before_script = [] : List Text 9 | , after_script = [] : List Text 10 | , services = [] : List Service 11 | , cache = None CacheSpec 12 | } 13 | : Defaults 14 | -------------------------------------------------------------------------------- /GitLab/Defaults/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, default = ./default.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/Defaults/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Defaults = ./Type.dhall 8 | 9 | let CacheSpec = ../CacheSpec/package.dhall 10 | 11 | let Service = ../Service/package.dhall 12 | 13 | let dropNones = ../utils/dropNones.dhall 14 | 15 | let stringsArrayJSON = ../utils/stringsArrayJSON.dhall 16 | 17 | let Optional/map = Prelude.Optional.map 18 | 19 | let Defaults/toJSON 20 | : Defaults → JSON.Type 21 | = λ(defaults : Defaults) → 22 | let everything 23 | : Map.Type Text (Optional JSON.Type) 24 | = toMap 25 | { image = Optional/map Text JSON.Type JSON.string defaults.image 26 | , before_script = 27 | if Prelude.List.null Text defaults.before_script 28 | then None JSON.Type 29 | else Some (stringsArrayJSON defaults.before_script) 30 | , after_script = 31 | if Prelude.List.null Text defaults.after_script 32 | then None JSON.Type 33 | else Some (stringsArrayJSON defaults.after_script) 34 | , services = 35 | if Prelude.List.null Service.Type defaults.services 36 | then None JSON.Type 37 | else Some 38 | ( JSON.array 39 | ( Prelude.List.map 40 | Service.Type 41 | JSON.Type 42 | Service.toJSON 43 | defaults.services 44 | ) 45 | ) 46 | , cache = 47 | Optional/map 48 | CacheSpec.Type 49 | JSON.Type 50 | CacheSpec.toJSON 51 | defaults.cache 52 | } 53 | 54 | in JSON.object (dropNones Text JSON.Type everything) 55 | 56 | in Defaults/toJSON 57 | -------------------------------------------------------------------------------- /GitLab/Duration/Type.dhall: -------------------------------------------------------------------------------- 1 | { seconds : Natural } 2 | -------------------------------------------------------------------------------- /GitLab/Duration/fromDays.dhall: -------------------------------------------------------------------------------- 1 | let fromDays 2 | : Natural → ./Type.dhall 3 | = λ(n : Natural) → ./fromHours.dhall (24 * n) 4 | 5 | in fromDays 6 | -------------------------------------------------------------------------------- /GitLab/Duration/fromHours.dhall: -------------------------------------------------------------------------------- 1 | let fromHours 2 | : Natural → ./Type.dhall 3 | = λ(n : Natural) → ./fromMinutes.dhall (60 * n) 4 | 5 | in fromHours 6 | -------------------------------------------------------------------------------- /GitLab/Duration/fromMinutes.dhall: -------------------------------------------------------------------------------- 1 | let fromMinutes 2 | : Natural → ./Type.dhall 3 | = λ(n : Natural) → ./fromSeconds.dhall (60 * n) 4 | 5 | in fromMinutes 6 | -------------------------------------------------------------------------------- /GitLab/Duration/fromSeconds.dhall: -------------------------------------------------------------------------------- 1 | let fromSeconds 2 | : Natural → ./Type.dhall 3 | = λ(n : Natural) → { seconds = n } 4 | 5 | in fromSeconds 6 | -------------------------------------------------------------------------------- /GitLab/Duration/fromWeeks.dhall: -------------------------------------------------------------------------------- 1 | let fromWeeks 2 | : Natural → ./Type.dhall 3 | = λ(n : Natural) → ./fromDays.dhall (7 * n) 4 | 5 | in fromWeeks 6 | -------------------------------------------------------------------------------- /GitLab/Duration/fromYears.dhall: -------------------------------------------------------------------------------- 1 | let fromYears 2 | : Natural → ./Type.dhall 3 | = λ(n : Natural) → ./fromDays.dhall (365 * n) 4 | 5 | in fromYears 6 | -------------------------------------------------------------------------------- /GitLab/Duration/greaterThan.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Duration = ./Type.dhall 4 | 5 | let greaterThan 6 | : Duration → Duration → Bool 7 | = λ(x : Duration) → 8 | λ(y : Duration) → 9 | Prelude.Natural.greaterThan x.seconds y.seconds 10 | 11 | in greaterThan 12 | -------------------------------------------------------------------------------- /GitLab/Duration/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall 2 | , scale = ./scale.dhall 3 | , fromSeconds = ./fromSeconds.dhall 4 | , fromMinutes = ./fromMinutes.dhall 5 | , fromHours = ./fromHours.dhall 6 | , fromDays = ./fromDays.dhall 7 | , fromWeeks = ./fromWeeks.dhall 8 | , fromYears = ./fromYears.dhall 9 | , greaterThan = ./greaterThan.dhall 10 | , toJSON = ./toJSON.dhall 11 | } 12 | -------------------------------------------------------------------------------- /GitLab/Duration/scale.dhall: -------------------------------------------------------------------------------- 1 | let Duration = ./Type.dhall 2 | 3 | let scale 4 | : Natural → Duration → Duration 5 | = λ(n : Natural) → λ(d : Duration) → { seconds = d.seconds * n } 6 | 7 | in scale 8 | -------------------------------------------------------------------------------- /GitLab/Duration/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let Duration = ./Type.dhall 6 | 7 | let scales 8 | : List { name : Text, dur : Duration } 9 | = [ { name = "week", dur = ./fromWeeks.dhall 1 } 10 | , { name = "day", dur = ./fromDays.dhall 1 } 11 | , { name = "hour", dur = ./fromHours.dhall 1 } 12 | , { name = "minutes", dur = ./fromMinutes.dhall 1 } 13 | ] 14 | 15 | let formatDur 16 | : Duration → Text 17 | = λ(dur : Duration) → "${Natural/show dur.seconds} second" 18 | 19 | let Duration/toJSON 20 | : Duration → JSON.Type 21 | = λ(dur : Duration) → JSON.string (formatDur dur) 22 | 23 | in Duration/toJSON 24 | -------------------------------------------------------------------------------- /GitLab/Environment/Type.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let EnvironmentAction = ../EnvironmentAction/Type.dhall 4 | 5 | let Kubernetes = ../Kubernetes/Type.dhall 6 | 7 | in { name : Optional Text 8 | , url : Optional Text 9 | , on_stop : Optional Text 10 | , action : Optional EnvironmentAction 11 | , kubernetes : Optional Kubernetes 12 | , auto_stop_in : Optional Text 13 | , deployment_tier : Optional Text 14 | } 15 | -------------------------------------------------------------------------------- /GitLab/Environment/append.dhall: -------------------------------------------------------------------------------- 1 | let Environment = ./Type.dhall 2 | 3 | let EnvironmentAction = ../EnvironmentAction/package.dhall 4 | 5 | let Kubernetes = ../Kubernetes/package.dhall 6 | 7 | let mergeOptional = ../utils/mergeOptional.dhall 8 | 9 | let mergeOptionalRight = ../utils/mergeOptionalRight.dhall 10 | 11 | let append 12 | : Environment → Environment → Environment 13 | = λ(a : Environment) → 14 | λ(b : Environment) → 15 | { name = mergeOptionalRight Text a.name b.name 16 | , url = mergeOptionalRight Text a.url b.url 17 | , on_stop = mergeOptionalRight Text a.on_stop b.on_stop 18 | , action = mergeOptionalRight EnvironmentAction.Type a.action b.action 19 | , kubernetes = 20 | mergeOptional 21 | Kubernetes.Type 22 | Kubernetes.append 23 | a.kubernetes 24 | b.kubernetes 25 | , auto_stop_in = mergeOptionalRight Text a.auto_stop_in b.auto_stop_in 26 | , deployment_tier = 27 | mergeOptionalRight Text a.deployment_tier b.deployment_tier 28 | } 29 | 30 | in append 31 | -------------------------------------------------------------------------------- /GitLab/Environment/default.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Environment = ./Type.dhall 4 | 5 | let EnvironmentAction = ../EnvironmentAction/Type.dhall 6 | 7 | let Kubernetes = ../Kubernetes/Type.dhall 8 | 9 | in { name = None Text 10 | , url = None Text 11 | , on_stop = None Text 12 | , action = None EnvironmentAction 13 | , kubernetes = None Kubernetes 14 | , auto_stop_in = None Text 15 | , deployment_tier = None Text 16 | } 17 | : Environment 18 | -------------------------------------------------------------------------------- /GitLab/Environment/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall 2 | , default = ./default.dhall 3 | , toJSON = ./toJSON.dhall 4 | , append = ./append.dhall 5 | } 6 | -------------------------------------------------------------------------------- /GitLab/Environment/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Environment = ./Type.dhall 8 | 9 | let EnvironmentAction = ../EnvironmentAction/package.dhall 10 | 11 | let Kubernetes = ../Kubernetes/package.dhall 12 | 13 | let dropNones = ../utils/dropNones.dhall 14 | 15 | let Optional/map = Prelude.Optional.map 16 | 17 | let Environment/toJSON 18 | : Environment → JSON.Type 19 | = λ(environment : Environment) → 20 | let everything 21 | : Map.Type Text (Optional JSON.Type) 22 | = toMap 23 | { name = 24 | Optional/map Text JSON.Type JSON.string environment.name 25 | , url = Optional/map Text JSON.Type JSON.string environment.url 26 | , on_stop = 27 | Optional/map Text JSON.Type JSON.string environment.on_stop 28 | , action = 29 | Optional/map 30 | EnvironmentAction.Type 31 | JSON.Type 32 | EnvironmentAction.toJSON 33 | environment.action 34 | , kubernetes = 35 | Optional/map 36 | Kubernetes.Type 37 | JSON.Type 38 | Kubernetes.toJSON 39 | environment.kubernetes 40 | , auto_stop_in = 41 | Optional/map 42 | Text 43 | JSON.Type 44 | JSON.string 45 | environment.auto_stop_in 46 | , deployment_tier = 47 | Optional/map 48 | Text 49 | JSON.Type 50 | JSON.string 51 | environment.deployment_tier 52 | } 53 | 54 | in JSON.object (dropNones Text JSON.Type everything) 55 | 56 | in Environment/toJSON 57 | -------------------------------------------------------------------------------- /GitLab/EnvironmentAction/Type.dhall: -------------------------------------------------------------------------------- 1 | < Start | Prepare | Stop > 2 | -------------------------------------------------------------------------------- /GitLab/EnvironmentAction/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/EnvironmentAction/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let EnvironmentAction = ./Type.dhall 6 | 7 | let EnvironmentAction/toJSON 8 | : EnvironmentAction → JSON.Type 9 | = λ(action : EnvironmentAction) → 10 | JSON.string 11 | (merge { Start = "start", Prepare = "prepare", Stop = "stop" } action) 12 | 13 | in EnvironmentAction/toJSON 14 | -------------------------------------------------------------------------------- /GitLab/GitSubmoduleStrategy/Type.dhall: -------------------------------------------------------------------------------- 1 | < Recursive | Normal > 2 | -------------------------------------------------------------------------------- /GitLab/GitSubmoduleStrategy/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/GitSubmoduleStrategy/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let GitSubmoduleStrategy = ./Type.dhall 6 | 7 | let GitSubmoduleStrategy/toJSON 8 | : GitSubmoduleStrategy → JSON.Type 9 | = λ(s : GitSubmoduleStrategy) → 10 | JSON.string (merge { Normal = "normal", Recursive = "recursive" } s) 11 | 12 | in GitSubmoduleStrategy/toJSON 13 | -------------------------------------------------------------------------------- /GitLab/Image/Type.dhall: -------------------------------------------------------------------------------- 1 | { name : Text, entrypoint : Optional (List Text) } 2 | -------------------------------------------------------------------------------- /GitLab/Image/append.dhall: -------------------------------------------------------------------------------- 1 | let Image = ./Type.dhall 2 | 3 | let mergeOptionalList = ../utils/mergeOptionalList.dhall 4 | 5 | let append 6 | : Image → Image → Image 7 | = λ(a : Image) → 8 | λ(b : Image) → 9 | { name = b.name 10 | , entrypoint = mergeOptionalList Text a.entrypoint b.entrypoint 11 | } 12 | 13 | in append 14 | -------------------------------------------------------------------------------- /GitLab/Image/default.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | in { entrypoint = None (List Text) 4 | } 5 | -------------------------------------------------------------------------------- /GitLab/Image/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall 2 | , default = ./default.dhall 3 | , toJSON = ./toJSON.dhall 4 | , append = ./append.dhall 5 | } 6 | -------------------------------------------------------------------------------- /GitLab/Image/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let dropNones = ../utils/dropNones.dhall 8 | 9 | let Optional/map = Prelude.Optional.map 10 | 11 | let Image = ./Type.dhall 12 | 13 | let stringsArray 14 | : List Text → JSON.Type 15 | = λ(xs : List Text) → 16 | JSON.array (Prelude.List.map Text JSON.Type JSON.string xs) 17 | 18 | in let Image/toJSON 19 | : Image → JSON.Type 20 | = λ(image : Image) → 21 | let everything 22 | : Map.Type Text (Optional JSON.Type) 23 | = toMap 24 | { name = Some (JSON.string image.name) 25 | , entrypoint = Optional/map (List Text) JSON.Type stringsArray image.entrypoint 26 | } 27 | in JSON.object (dropNones Text JSON.Type everything) 28 | 29 | in Image/toJSON 30 | -------------------------------------------------------------------------------- /GitLab/Include/Type.dhall: -------------------------------------------------------------------------------- 1 | let Rule = ../Rule/Type.dhall 2 | 3 | let Include = 4 | { local : Optional Text 5 | , file : Optional Text 6 | , remote : Optional Text 7 | , template : Optional Text 8 | , rules : List Rule 9 | , project : Optional Text 10 | , ref : Optional Text 11 | } 12 | 13 | in Include 14 | -------------------------------------------------------------------------------- /GitLab/Include/default.dhall: -------------------------------------------------------------------------------- 1 | let Rule = ../Rule/Type.dhall 2 | 3 | let Include = ./Type.dhall 4 | 5 | in { local = None Text 6 | , file = None Text 7 | , remote = None Text 8 | , template = None Text 9 | , rules = [] : List Rule 10 | , project = None Text 11 | , ref = None Text 12 | } 13 | : Include 14 | -------------------------------------------------------------------------------- /GitLab/Include/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, default = ./default.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/Include/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Include = ./Type.dhall 8 | 9 | let Rule = ../Rule/package.dhall 10 | 11 | let dropNones = ../utils/dropNones.dhall 12 | 13 | let Include/toJSON 14 | : Include → JSON.Type 15 | = λ(include : Include) → 16 | let everything 17 | : Map.Type Text (Optional JSON.Type) 18 | = toMap 19 | { local = 20 | Prelude.Optional.map 21 | Text 22 | JSON.Type 23 | JSON.string 24 | include.local 25 | , file = 26 | Prelude.Optional.map Text JSON.Type JSON.string include.file 27 | , remote = 28 | Prelude.Optional.map 29 | Text 30 | JSON.Type 31 | JSON.string 32 | include.remote 33 | , template = 34 | Prelude.Optional.map 35 | Text 36 | JSON.Type 37 | JSON.string 38 | include.template 39 | , rules = 40 | if Prelude.List.null Rule.Type include.rules 41 | then None JSON.Type 42 | else Some 43 | ( JSON.array 44 | ( Prelude.List.map 45 | Rule.Type 46 | JSON.Type 47 | Rule.toJSON 48 | include.rules 49 | ) 50 | ) 51 | , project = 52 | Prelude.Optional.map 53 | Text 54 | JSON.Type 55 | JSON.string 56 | include.project 57 | , ref = 58 | Prelude.Optional.map Text JSON.Type JSON.string include.ref 59 | } 60 | 61 | in JSON.object (dropNones Text JSON.Type everything) 62 | 63 | in Include/toJSON 64 | -------------------------------------------------------------------------------- /GitLab/Job/Type.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Image = ../Image/Type.dhall 4 | 5 | let Script = ../Script/Type.dhall 6 | 7 | let Service = ../Service/Type.dhall 8 | 9 | let ArtifactsSpec = ../ArtifactsSpec/Type.dhall 10 | 11 | let CacheSpec = ../CacheSpec/Type.dhall 12 | 13 | let Environment = ../Environment/Type.dhall 14 | 15 | let Rule = ../Rule/Type.dhall 16 | 17 | let Trigger = ../Trigger/Type.dhall 18 | 19 | in { stage : Optional Text 20 | , image : Optional Image 21 | , variables : Prelude.Map.Type Text Text 22 | , rules : Optional (List Rule) 23 | , dependencies : List Text 24 | , needs : List Text 25 | , allow_failure : Bool 26 | , tags : Optional (List Text) 27 | , before_script : Optional Script 28 | , script : Script 29 | , services : Optional (List Service) 30 | , after_script : Optional Script 31 | , cache : Optional CacheSpec 32 | , artifacts : Optional ArtifactsSpec 33 | , resource_group : Optional Text 34 | , environment : Optional Environment 35 | , trigger : Optional Trigger 36 | , timeout : Optional Text 37 | , extends : List Text 38 | } 39 | -------------------------------------------------------------------------------- /GitLab/Job/append.dhall: -------------------------------------------------------------------------------- 1 | {- Right biased on conflict but prefers Some to None and merges lists and maps -} 2 | let Prelude = ../../Prelude.dhall 3 | 4 | let Job = ./Type.dhall 5 | 6 | let Image = ../Image/package.dhall 7 | 8 | let Script = ../Script/package.dhall 9 | 10 | let Service = ../Service/package.dhall 11 | 12 | let ArtifactsSpec = ../ArtifactsSpec/package.dhall 13 | 14 | let CacheSpec = ../CacheSpec/package.dhall 15 | 16 | let Environment = ../Environment/package.dhall 17 | 18 | let Rule = ../Rule/package.dhall 19 | 20 | let Trigger = ../Trigger/package.dhall 21 | 22 | let mergeOptional = ../utils/mergeOptional.dhall 23 | 24 | let mergeOptionalRight = ../utils/mergeOptionalRight.dhall 25 | 26 | let mergeOptionalList = ../utils/mergeOptionalList.dhall 27 | 28 | let append 29 | : Job → Job → Job 30 | = λ(a : Job) → 31 | λ(b : Job) → 32 | { stage = mergeOptionalRight Text a.stage b.stage 33 | , image = mergeOptional Image.Type Image.append a.image b.image 34 | , variables = a.variables # b.variables 35 | , rules = mergeOptionalList Rule.Type a.rules b.rules 36 | , dependencies = a.dependencies # b.dependencies 37 | , needs = a.needs # b.needs 38 | , allow_failure = b.allow_failure 39 | , tags = mergeOptionalList Text a.tags b.tags 40 | , before_script = mergeOptionalList Text a.before_script b.before_script 41 | , script = a.script # b.script 42 | , services = mergeOptionalList Service.Type a.services b.services 43 | , after_script = mergeOptionalList Text a.after_script b.after_script 44 | , cache = mergeOptional CacheSpec.Type CacheSpec.append a.cache b.cache 45 | , artifacts = 46 | mergeOptional 47 | ArtifactsSpec.Type 48 | ArtifactsSpec.append 49 | a.artifacts 50 | b.artifacts 51 | , resource_group = 52 | mergeOptionalRight Text a.resource_group b.resource_group 53 | , environment = 54 | mergeOptional 55 | Environment.Type 56 | Environment.append 57 | a.environment 58 | b.environment 59 | , trigger = 60 | mergeOptional Trigger.Type Trigger.append a.trigger b.trigger 61 | , timeout = mergeOptionalRight Text a.timeout b.timeout 62 | , extends = a.extends # b.extends 63 | } 64 | 65 | in append 66 | -------------------------------------------------------------------------------- /GitLab/Job/default.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Image = ../Image/Type.dhall 4 | 5 | let Script = ../Script/Type.dhall 6 | 7 | let Service = ../Service/Type.dhall 8 | 9 | let ArtifactsSpec = ../ArtifactsSpec/Type.dhall 10 | 11 | let CacheSpec = ../CacheSpec/Type.dhall 12 | 13 | let Rule = ../Rule/Type.dhall 14 | 15 | let Environment = ../Environment/Type.dhall 16 | 17 | let Trigger = ../Trigger/Type.dhall 18 | 19 | in { stage = None Text 20 | , image = None Image 21 | , variables = Prelude.Map.empty Text Text 22 | , rules = None (List Rule) 23 | , dependencies = [] : List Text 24 | , needs = [] : List Text 25 | , allow_failure = False 26 | , tags = None (List Text) 27 | , before_script = None Script 28 | , script = [] : Script 29 | , services = None (List Service) 30 | , after_script = None Script 31 | , cache = None CacheSpec 32 | , artifacts = None ArtifactsSpec 33 | , resource_group = None Text 34 | , environment = None Environment 35 | , trigger = None Trigger 36 | , timeout = None Text 37 | , extends = [] : List Text 38 | } 39 | : ./Type.dhall 40 | -------------------------------------------------------------------------------- /GitLab/Job/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall 2 | , default = ./default.dhall 3 | , toJSON = ./toJSON.dhall 4 | , append = ./append.dhall 5 | } 6 | -------------------------------------------------------------------------------- /GitLab/Job/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Job = ./Type.dhall 8 | 9 | let Image = ../Image/package.dhall 10 | 11 | let ArtifactsSpec = ../ArtifactsSpec/package.dhall 12 | 13 | let CacheSpec = ../CacheSpec/package.dhall 14 | 15 | let Rule = ../Rule/package.dhall 16 | 17 | let Script = ../Script/package.dhall 18 | 19 | let Service = ../Service/package.dhall 20 | 21 | let Environment = ../Environment/package.dhall 22 | 23 | let Trigger = ../Trigger/package.dhall 24 | 25 | let dropNones = ../utils/dropNones.dhall 26 | 27 | let optionalList = ../utils/optionalList.dhall 28 | 29 | let stringsArrayJSON = ../utils/stringsArrayJSON.dhall 30 | 31 | let Optional/map = Prelude.Optional.map 32 | 33 | let Optional/toList = Prelude.Optional.toList 34 | 35 | in let Job/toJSON 36 | : Job → JSON.Type 37 | = λ(job : Job) → 38 | let everything 39 | : Map.Type Text (Optional JSON.Type) 40 | = toMap 41 | { stage = Optional/map Text JSON.Type JSON.string job.stage 42 | , image = 43 | Optional/map Image.Type JSON.Type Image.toJSON job.image 44 | , variables = Some 45 | ( JSON.object 46 | ( Map.map 47 | Text 48 | Text 49 | JSON.Type 50 | JSON.string 51 | job.variables 52 | ) 53 | ) 54 | , rules = 55 | let rulesList = optionalList Rule.Type job.rules 56 | 57 | in if Prelude.List.null Rule.Type rulesList 58 | then None JSON.Type 59 | else Some 60 | ( JSON.array 61 | ( Prelude.List.map 62 | Rule.Type 63 | JSON.Type 64 | Rule.toJSON 65 | rulesList 66 | ) 67 | ) 68 | , dependencies = 69 | if Prelude.List.null Text job.dependencies 70 | then None JSON.Type 71 | else Some (stringsArrayJSON job.dependencies) 72 | , needs = 73 | if Prelude.List.null Text job.needs 74 | then None JSON.Type 75 | else Some (stringsArrayJSON job.needs) 76 | , tags = 77 | Optional/map 78 | (List Text) 79 | JSON.Type 80 | stringsArrayJSON 81 | job.tags 82 | , allow_failure = Some (JSON.bool job.allow_failure) 83 | , before_script = 84 | Optional/map 85 | Script.Type 86 | JSON.Type 87 | stringsArrayJSON 88 | job.before_script 89 | , script = 90 | if Prelude.List.null Text job.script 91 | then None JSON.Type 92 | else Some (stringsArrayJSON job.script) 93 | , services = 94 | let servicesList = 95 | optionalList Service.Type job.services 96 | 97 | in if Prelude.List.null Service.Type servicesList 98 | then None JSON.Type 99 | else Some 100 | ( JSON.array 101 | ( Prelude.List.map 102 | Service.Type 103 | JSON.Type 104 | Service.toJSON 105 | servicesList 106 | ) 107 | ) 108 | , after_script = 109 | Optional/map 110 | Script.Type 111 | JSON.Type 112 | stringsArrayJSON 113 | job.after_script 114 | , cache = 115 | Optional/map 116 | CacheSpec.Type 117 | JSON.Type 118 | CacheSpec.toJSON 119 | job.cache 120 | , artifacts = 121 | Optional/map 122 | ArtifactsSpec.Type 123 | JSON.Type 124 | ArtifactsSpec.toJSON 125 | job.artifacts 126 | , resource_group = 127 | Optional/map 128 | Text 129 | JSON.Type 130 | JSON.string 131 | job.resource_group 132 | , environment = 133 | Optional/map 134 | Environment.Type 135 | JSON.Type 136 | Environment.toJSON 137 | job.environment 138 | , trigger = 139 | Optional/map 140 | Trigger.Type 141 | JSON.Type 142 | Trigger.toJSON 143 | job.trigger 144 | , timeout = 145 | Optional/map Text JSON.Type JSON.string job.timeout 146 | , extends = 147 | if Prelude.List.null Text job.extends 148 | then None JSON.Type 149 | else Some 150 | ( JSON.array 151 | ( Prelude.List.map 152 | Text 153 | JSON.Type 154 | JSON.string 155 | job.extends 156 | ) 157 | ) 158 | } 159 | 160 | in JSON.object (dropNones Text JSON.Type everything) 161 | 162 | in Job/toJSON 163 | -------------------------------------------------------------------------------- /GitLab/Kubernetes/Type.dhall: -------------------------------------------------------------------------------- 1 | { namespace : Optional Text } 2 | -------------------------------------------------------------------------------- /GitLab/Kubernetes/append.dhall: -------------------------------------------------------------------------------- 1 | let Kubernetes = ./Type.dhall 2 | 3 | let mergeOptionalRight = ../utils/mergeOptionalRight.dhall 4 | 5 | let append 6 | : Kubernetes → Kubernetes → Kubernetes 7 | = λ(a : Kubernetes) → 8 | λ(b : Kubernetes) → 9 | { namespace = mergeOptionalRight Text a.namespace b.namespace } 10 | 11 | in append 12 | -------------------------------------------------------------------------------- /GitLab/Kubernetes/default.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Kubernetes = ./Type.dhall 4 | 5 | in { namespace = None Text } : Kubernetes 6 | -------------------------------------------------------------------------------- /GitLab/Kubernetes/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall 2 | , default = ./default.dhall 3 | , toJSON = ./toJSON.dhall 4 | , append = ./append.dhall 5 | } 6 | -------------------------------------------------------------------------------- /GitLab/Kubernetes/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Kubernetes = ./Type.dhall 8 | 9 | let Optional/map = Prelude.Optional.map 10 | 11 | let dropNones = ../utils/dropNones.dhall 12 | 13 | let Kubernetes/toJSON 14 | : Kubernetes → JSON.Type 15 | = λ(kubernetes : Kubernetes) → 16 | let everything 17 | : Map.Type Text (Optional JSON.Type) 18 | = toMap 19 | { namespace = 20 | Optional/map Text JSON.Type JSON.string kubernetes.namespace 21 | } 22 | 23 | in JSON.object (dropNones Text JSON.Type everything) 24 | 25 | in Kubernetes/toJSON 26 | -------------------------------------------------------------------------------- /GitLab/Prelude.dhall: -------------------------------------------------------------------------------- 1 | ./../Prelude.dhall -------------------------------------------------------------------------------- /GitLab/Rule/Type.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../../Prelude.dhall 2 | 3 | let When = ../When/Type.dhall 4 | 5 | let Map = Prelude.Map.Type 6 | 7 | in { `if` : Optional Text 8 | , changes : List Text 9 | , allow_failure : Optional Bool 10 | , when : Optional When 11 | , exists : List Text 12 | , variables : Map Text Text 13 | } 14 | -------------------------------------------------------------------------------- /GitLab/Rule/default.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../../Prelude.dhall 2 | 3 | let Map = Prelude.Map.Type 4 | 5 | let When = ../When/Type.dhall 6 | 7 | in { `if` = None Text 8 | , when = None When 9 | , exists = [] : List Text 10 | , variables = toMap {=} : Map Text Text 11 | , changes = [] : List Text 12 | , allow_failure = None Bool 13 | } 14 | : ./Type.dhall 15 | -------------------------------------------------------------------------------- /GitLab/Rule/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, default = ./default.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/Rule/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Rule = ./Type.dhall 8 | 9 | let When = ../When/Type.dhall 10 | 11 | let When/toJSON = ../When/toJSON.dhall 12 | 13 | let dropNones = ../utils/dropNones.dhall 14 | 15 | let stringsArrayJSON = ../utils/stringsArrayJSON.dhall 16 | 17 | let Optional/map = Prelude.Optional.map 18 | 19 | let Rule/toJSON 20 | : Rule → JSON.Type 21 | = λ(rule : Rule) → 22 | let everything 23 | : Map.Type Text (Optional JSON.Type) 24 | = toMap 25 | { `if` = Optional/map Text JSON.Type JSON.string rule.`if` 26 | , when = Optional/map When JSON.Type When/toJSON rule.when 27 | , allow_failure = 28 | Optional/map Bool JSON.Type JSON.bool rule.allow_failure 29 | , changes = 30 | if Prelude.List.null Text rule.changes 31 | then None JSON.Type 32 | else Some (stringsArrayJSON rule.changes) 33 | , exists = 34 | if Prelude.List.null Text rule.exists 35 | then None JSON.Type 36 | else Some (stringsArrayJSON rule.exists) 37 | , variables = Some 38 | ( JSON.object 39 | (Map.map Text Text JSON.Type JSON.string rule.variables) 40 | ) 41 | } 42 | 43 | in JSON.object (dropNones Text JSON.Type everything) 44 | 45 | in Rule/toJSON 46 | -------------------------------------------------------------------------------- /GitLab/Script/Type.dhall: -------------------------------------------------------------------------------- 1 | List Text 2 | -------------------------------------------------------------------------------- /GitLab/Script/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/Service/Type.dhall: -------------------------------------------------------------------------------- 1 | { name : Text 2 | , alias : Optional Text 3 | , entrypoint : List Text 4 | , command : List Text 5 | } 6 | -------------------------------------------------------------------------------- /GitLab/Service/mkService.dhall: -------------------------------------------------------------------------------- 1 | -- We couldn't provide a default because name is required 2 | let Service = ./Type.dhall 3 | 4 | let Service/mkService 5 | : Text → Service 6 | = λ(name : Text) → 7 | { name 8 | , alias = None Text 9 | , entrypoint = [] : List Text 10 | , command = [] : List Text 11 | } 12 | 13 | in Service/mkService 14 | -------------------------------------------------------------------------------- /GitLab/Service/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, toJSON = ./toJSON.dhall, mkService = ./mkService.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/Service/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Service = ./Type.dhall 8 | 9 | let dropNones = ../utils/dropNones.dhall 10 | 11 | let stringsArrayJSON = ../utils/stringsArrayJSON.dhall 12 | 13 | let Optional/map = Prelude.Optional.map 14 | 15 | let Service/toJSON 16 | : Service → JSON.Type 17 | = λ(service : Service) → 18 | let everything 19 | : Map.Type Text (Optional JSON.Type) 20 | = toMap 21 | { name = Some (JSON.string service.name) 22 | , alias = Optional/map Text JSON.Type JSON.string service.alias 23 | , entrypoint = 24 | if Prelude.List.null Text service.entrypoint 25 | then None JSON.Type 26 | else Some (stringsArrayJSON service.entrypoint) 27 | , command = 28 | if Prelude.List.null Text service.command 29 | then None JSON.Type 30 | else Some (stringsArrayJSON service.command) 31 | } 32 | 33 | in JSON.object (dropNones Text JSON.Type everything) 34 | 35 | in Service/toJSON 36 | -------------------------------------------------------------------------------- /GitLab/Top/Type.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Job = ../Job/Type.dhall 4 | 5 | let Rule = ../Rule/Type.dhall 6 | 7 | let Include = ../Include/Type.dhall 8 | 9 | let Defaults = ../Defaults/Type.dhall 10 | 11 | let GitSubmoduleStrategy = ../GitSubmoduleStrategy/Type.dhall 12 | 13 | in { jobs : Prelude.Map.Type Text Job 14 | , stages : Optional (List Text) 15 | , gitSubmoduleStrategy : GitSubmoduleStrategy 16 | , variables : Prelude.Map.Type Text Text 17 | , workflow : List Rule 18 | , default : Optional Defaults 19 | , include : List Include 20 | } 21 | -------------------------------------------------------------------------------- /GitLab/Top/default.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Job = ../Job/Type.dhall 4 | 5 | let Rule = ../Rule/Type.dhall 6 | 7 | let Include = ../Include/Type.dhall 8 | 9 | let Defaults = ../Defaults/Type.dhall 10 | 11 | let GitSubmoduleStrategy = ../GitSubmoduleStrategy/Type.dhall 12 | 13 | in { jobs = Prelude.Map.empty Text Job 14 | , stages = None (List Text) 15 | , gitSubmoduleStrategy = GitSubmoduleStrategy.Normal 16 | , variables = Prelude.Map.empty Text Text 17 | , workflow = [] : List Rule 18 | , default = None Defaults 19 | , include = [] : List Include 20 | } 21 | : ./Type.dhall 22 | -------------------------------------------------------------------------------- /GitLab/Top/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, default = ./default.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/Top/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let Map = Prelude.Map 6 | 7 | let Top = ./Type.dhall 8 | 9 | let Job = ../Job/package.dhall 10 | 11 | let Rule = ../Rule/package.dhall 12 | 13 | let Include = ../Include/package.dhall 14 | 15 | let Defaults = ../Defaults/package.dhall 16 | 17 | let GitSubmoduleStrategy/toJSON = ../GitSubmoduleStrategy/toJSON.dhall 18 | 19 | let dropNones = ../utils/dropNones.dhall 20 | 21 | let stringsArray 22 | : List Text → JSON.Type 23 | = λ(xs : List Text) → 24 | JSON.array (Prelude.List.map Text JSON.Type JSON.string xs) 25 | 26 | let Top/toJSON 27 | : Top → JSON.Type 28 | = λ(top : Top) → 29 | let jobs 30 | : Map.Type Text JSON.Type 31 | = Prelude.Map.map Text Job.Type JSON.Type Job.toJSON top.jobs 32 | 33 | let others 34 | : Map.Type Text JSON.Type 35 | = dropNones 36 | Text 37 | JSON.Type 38 | ( toMap 39 | { stages = 40 | Prelude.Optional.map 41 | (List Text) 42 | JSON.Type 43 | stringsArray 44 | top.stages 45 | , variables = 46 | let submoduleMap 47 | : Map.Type Text JSON.Type 48 | = toMap 49 | { GIT_SUBMODULE_STRATEGY = 50 | GitSubmoduleStrategy/toJSON 51 | top.gitSubmoduleStrategy 52 | } 53 | 54 | in Some 55 | ( JSON.object 56 | ( submoduleMap 57 | # Prelude.Map.map 58 | Text 59 | Text 60 | JSON.Type 61 | JSON.string 62 | top.variables 63 | ) 64 | ) 65 | , workflow = 66 | if Prelude.List.null Rule.Type top.workflow 67 | then None JSON.Type 68 | else Some 69 | ( JSON.object 70 | ( toMap 71 | { rules = 72 | JSON.array 73 | ( Prelude.List.map 74 | Rule.Type 75 | JSON.Type 76 | Rule.toJSON 77 | top.workflow 78 | ) 79 | } 80 | ) 81 | ) 82 | , default = 83 | Prelude.Optional.map 84 | Defaults.Type 85 | JSON.Type 86 | Defaults.toJSON 87 | top.default 88 | , include = 89 | if Prelude.List.null Include.Type top.include 90 | then None JSON.Type 91 | else Some 92 | ( JSON.array 93 | ( Prelude.List.map 94 | Include.Type 95 | JSON.Type 96 | Include.toJSON 97 | top.include 98 | ) 99 | ) 100 | } 101 | ) 102 | 103 | let everything 104 | : Map.Type Text JSON.Type 105 | = jobs # others 106 | 107 | in JSON.object everything 108 | 109 | in Top/toJSON 110 | -------------------------------------------------------------------------------- /GitLab/Trigger/Type.dhall: -------------------------------------------------------------------------------- 1 | let Include = ../Include/Type.dhall 2 | 3 | let TriggerStrategy = ../TriggerStrategy/Type.dhall 4 | 5 | let Trigger = 6 | { project : Optional Text 7 | , branch : Optional Text 8 | , include : List Include 9 | , strategy : Optional TriggerStrategy 10 | } 11 | 12 | in Trigger 13 | -------------------------------------------------------------------------------- /GitLab/Trigger/append.dhall: -------------------------------------------------------------------------------- 1 | let Trigger = ./Type.dhall 2 | 3 | let mergeOptionalRight = ../utils/mergeOptionalRight.dhall 4 | 5 | let append 6 | : Trigger → Trigger → Trigger 7 | = λ(a : Trigger) → 8 | λ(b : Trigger) → 9 | { project = mergeOptionalRight Text a.project b.project 10 | , branch = mergeOptionalRight Text a.branch b.branch 11 | , include = a.include # b.include 12 | , strategy = b.strategy 13 | } 14 | 15 | in append 16 | -------------------------------------------------------------------------------- /GitLab/Trigger/default.dhall: -------------------------------------------------------------------------------- 1 | let Trigger = ./Type.dhall 2 | 3 | let Include = ../Include/Type.dhall 4 | 5 | let TriggerStrategy = ../TriggerStrategy/Type.dhall 6 | 7 | in { project = None Text 8 | , branch = None Text 9 | , include = [] : List Include 10 | , strategy = None TriggerStrategy 11 | } 12 | : Trigger 13 | -------------------------------------------------------------------------------- /GitLab/Trigger/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall 2 | , default = ./default.dhall 3 | , toJSON = ./toJSON.dhall 4 | , append = ./append.dhall 5 | } 6 | -------------------------------------------------------------------------------- /GitLab/Trigger/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let JSON = Prelude.JSON 6 | 7 | let Trigger = ./Type.dhall 8 | 9 | let TriggerStrategy = ../TriggerStrategy/package.dhall 10 | 11 | let Include = ../Include/package.dhall 12 | 13 | let dropNones = ../utils/dropNones.dhall 14 | 15 | let Trigger/toJSON 16 | : Trigger → JSON.Type 17 | = λ(trigger : Trigger) → 18 | let everything 19 | : Map.Type Text (Optional JSON.Type) 20 | = toMap 21 | { project = 22 | Prelude.Optional.map 23 | Text 24 | JSON.Type 25 | JSON.string 26 | trigger.project 27 | , branch = 28 | Prelude.Optional.map 29 | Text 30 | JSON.Type 31 | JSON.string 32 | trigger.branch 33 | , include = 34 | if Prelude.List.null Include.Type trigger.include 35 | then None JSON.Type 36 | else Some 37 | ( JSON.array 38 | ( Prelude.List.map 39 | Include.Type 40 | JSON.Type 41 | Include.toJSON 42 | trigger.include 43 | ) 44 | ) 45 | , strategy = 46 | Prelude.Optional.map 47 | TriggerStrategy.Type 48 | JSON.Type 49 | TriggerStrategy.toJSON 50 | trigger.strategy 51 | } 52 | 53 | in JSON.object (dropNones Text JSON.Type everything) 54 | 55 | in Trigger/toJSON 56 | -------------------------------------------------------------------------------- /GitLab/TriggerStrategy/Type.dhall: -------------------------------------------------------------------------------- 1 | < Depend > 2 | -------------------------------------------------------------------------------- /GitLab/TriggerStrategy/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/TriggerStrategy/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let TriggerStrategy = ./Type.dhall 6 | 7 | let TriggerStrategy/toJSON 8 | : TriggerStrategy → JSON.Type 9 | = λ(strategy : TriggerStrategy) → 10 | merge { Depend = JSON.string "depend" } strategy 11 | 12 | in TriggerStrategy/toJSON 13 | -------------------------------------------------------------------------------- /GitLab/When/Type.dhall: -------------------------------------------------------------------------------- 1 | < Always | OnSuccess | OnFailure | Manual | Delayed | Never > 2 | -------------------------------------------------------------------------------- /GitLab/When/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type.dhall, toJSON = ./toJSON.dhall } 2 | -------------------------------------------------------------------------------- /GitLab/When/toJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let When = ./Type.dhall 6 | 7 | let When/toJSON 8 | : When → JSON.Type 9 | = λ(when : When) → 10 | JSON.string 11 | ( merge 12 | { Always = "always" 13 | , OnSuccess = "on_success" 14 | , OnFailure = "on_failure" 15 | , Manual = "manual" 16 | , Delayed = "delayed" 17 | , Never = "never" 18 | } 19 | when 20 | ) 21 | 22 | in When/toJSON 23 | -------------------------------------------------------------------------------- /GitLab/package.dhall: -------------------------------------------------------------------------------- 1 | { Job = ./Job/package.dhall 2 | , Image = ./Image/package.dhall 3 | , CacheSpec = ./CacheSpec/package.dhall 4 | , ArtifactsSpec = ./ArtifactsSpec/package.dhall 5 | , Rule = ./Rule/package.dhall 6 | , Script = ./Script/package.dhall 7 | , When = ./When/package.dhall 8 | , Top = ./Top/package.dhall 9 | , GitSubmoduleStrategy = ./GitSubmoduleStrategy/package.dhall 10 | , Duration = ./Duration/package.dhall 11 | , Environment = ./Environment/package.dhall 12 | , EnvironmentAction = ./EnvironmentAction/package.dhall 13 | , Kubernetes = ./Kubernetes/package.dhall 14 | , Include = ./Include/package.dhall 15 | , Trigger = ./Trigger/package.dhall 16 | , TriggerStrategy = ./TriggerStrategy/package.dhall 17 | , Defaults = ./Defaults/package.dhall 18 | , Service = ./Service/package.dhall 19 | , CachePolicy = ./CachePolicy/package.dhall 20 | } 21 | -------------------------------------------------------------------------------- /GitLab/utils/dropNones.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let Map = Prelude.Map 4 | 5 | let dropNones 6 | : ∀(k : Type) → ∀(a : Type) → Map.Type k (Optional a) → Map.Type k a 7 | = λ(k : Type) → 8 | λ(a : Type) → 9 | let f 10 | : Map.Entry k (Optional a) → Optional (Map.Entry k a) 11 | = λ(ent : Map.Entry k (Optional a)) → 12 | merge 13 | { None = None (Map.Entry k a) 14 | , Some = λ(y : a) → Some { mapKey = ent.mapKey, mapValue = y } 15 | } 16 | ent.mapValue 17 | 18 | in Prelude.List.concatMap 19 | (Map.Entry k (Optional a)) 20 | (Map.Entry k a) 21 | ( λ(x : Map.Entry k (Optional a)) → 22 | Prelude.Optional.toList (Map.Entry k a) (f x) 23 | ) 24 | 25 | in dropNones 26 | -------------------------------------------------------------------------------- /GitLab/utils/mergeOptional.dhall: -------------------------------------------------------------------------------- 1 | let mergeOptional 2 | : ∀(a : Type) → (a → a → a) → Optional a → Optional a → Optional a 3 | = λ(ty : Type) → 4 | λ(combine : ty → ty → ty) → 5 | λ(l : Optional ty) → 6 | λ(r : Optional ty) → 7 | let onlyR = r 8 | 9 | let onlyL = l 10 | 11 | in merge 12 | { None = onlyR 13 | , Some = 14 | λ(lSome : ty) → 15 | merge 16 | { None = l 17 | , Some = λ(rSome : ty) → Some (combine lSome rSome) 18 | } 19 | r 20 | } 21 | onlyL 22 | 23 | in mergeOptional 24 | -------------------------------------------------------------------------------- /GitLab/utils/mergeOptionalList.dhall: -------------------------------------------------------------------------------- 1 | -- Merge optionals. When both are Some, merge the lists 2 | let Prelude = ../../Prelude.dhall 3 | 4 | let mergeOptional = ./mergeOptional.dhall 5 | 6 | let mergeOptionalList 7 | : ∀(a : Type) → Optional (List a) → Optional (List a) → Optional (List a) 8 | = λ(ty : Type) → 9 | λ(l : Optional (List ty)) → 10 | λ(r : Optional (List ty)) → 11 | mergeOptional (List ty) (λ(a : List ty) → λ(b : List ty) → a # b) l r 12 | 13 | in mergeOptionalList 14 | -------------------------------------------------------------------------------- /GitLab/utils/mergeOptionalRight.dhall: -------------------------------------------------------------------------------- 1 | -- Merge optionals. When both are Some, prefer the right one 2 | let mergeOptional = ./mergeOptional.dhall 3 | 4 | let mergeOptionalRight 5 | : ∀(a : Type) → Optional a → Optional a → Optional a 6 | = λ(ty : Type) → 7 | λ(l : Optional ty) → 8 | λ(r : Optional ty) → 9 | mergeOptional ty (λ(_ : ty) → λ(x : ty) → x) l r 10 | 11 | in mergeOptionalRight 12 | -------------------------------------------------------------------------------- /GitLab/utils/optionalList.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let optionalList 4 | : ∀(a : Type) → Optional (List a) → List a 5 | = λ(a : Type) → 6 | λ(l : Optional (List a)) → 7 | Prelude.List.concat a (Prelude.Optional.toList (List a) l) 8 | 9 | in optionalList 10 | -------------------------------------------------------------------------------- /GitLab/utils/stringsArrayJSON.dhall: -------------------------------------------------------------------------------- 1 | let Prelude = ../Prelude.dhall 2 | 3 | let JSON = Prelude.JSON 4 | 5 | let stringsArrayJSON 6 | : List Text → JSON.Type 7 | = λ(xs : List Text) → 8 | JSON.array (Prelude.List.map Text JSON.Type JSON.string xs) 9 | 10 | in stringsArrayJSON 11 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2020 Ben Gamari 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | 7 | 1. Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | 10 | 2. Redistributions in binary form must reproduce the above copyright notice, 11 | this list of conditions and the following disclaimer in the documentation 12 | and/or other materials provided with the distribution. 13 | 14 | 3. Neither the name of the author nor the names of its contributors may be 15 | used to endorse or promote products derived from this software without 16 | specific prior written permission. 17 | 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 21 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 22 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 24 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 25 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /Prelude.dhall: -------------------------------------------------------------------------------- 1 | {- This file provides a central `Prelude` import for the rest of the library to 2 | use so that the integrity check only needs to be updated in one place 3 | whenever upgrading the interpreter. 4 | 5 | This allows the user to provide their own Prelude import using the 6 | `DHALL_PRELUDE` environment variable, like this: 7 | 8 | ``` 9 | $ export DHALL_PRELUDE='https://prelude.dhall-lang.org/package.dhall sha256:...' 10 | ``` 11 | 12 | Note that overriding the Prelude in this way only works if this repository 13 | is imported locally. Remote imports do not have access to environment 14 | variables and any attempt to import one will fall back to the next available 15 | import. To learn more, read: 16 | 17 | * https://github.com/dhall-lang/dhall-lang/wiki/Safety-guarantees#cross-site-scripting-xss 18 | 19 | This file also provides an import without the integrity check as a slower 20 | fallback if the user is using a different version of the Dhall interpreter. 21 | -} 22 | env:DHALL_PRELUDE 23 | ? https://raw.githubusercontent.com/dhall-lang/dhall-lang/v17.0.0/Prelude/package.dhall 24 | sha256:10db3c919c25e9046833df897a8ffe2701dc390fa0893d958c3430524be5a43e 25 | ? https://raw.githubusercontent.com/dhall-lang/dhall-lang/v17.0.0/Prelude/package.dhall 26 | sha256:10db3c919c25e9046833df897a8ffe2701dc390fa0893d958c3430524be5a43e 27 | -------------------------------------------------------------------------------- /README.mkd: -------------------------------------------------------------------------------- 1 | # `dhall-gitlab-ci`: A Dhall representation of `gitlab-ci.yml` 2 | 3 | This is a Dhall encoding of the GitLab CI configuration 4 | [schema](https://docs.gitlab.com/ee/ci/yaml/README.html). 5 | 6 | See code under the [examples](./examples) folder or checkout the [dhall-gitlab-pipeline](https://gitlab.com/mx00s/dhall-gitlab-pipeline/-/tree/master) for a more complete project example. 7 | 8 | 9 | ## [Single Job Example - Source](./examples/single-job.dhall) 10 | 11 | ```dhall 12 | let GitLab = 13 | https://raw.githubusercontent.com/bgamari/dhall-gitlab-ci/master/package.dhall 14 | 15 | let Prelude = GitLab.Prelude 16 | 17 | let renderTop = GitLab.Top.toJSON 18 | 19 | let demoJob = 20 | GitLab.Job::{ 21 | , stage = Some "build" 22 | , image = Some { name = "alpine:latest", entrypoint = Some [ " " ] } 23 | , script = [ "echo 'Hello World'" ] 24 | } 25 | 26 | let top = GitLab.Top::{ jobs = toMap { generated-job = demoJob } } 27 | 28 | in Prelude.JSON.renderYAML (renderTop top) 29 | ``` 30 | 31 | ## [Multiple Jobs Example - Source](./examples/multiple-jobs.dhall) 32 | 33 | ```dhall 34 | let GitLab = ../package.dhall 35 | 36 | let Prelude = GitLab.Prelude 37 | 38 | let List/map = Prelude.List.map 39 | 40 | let Map = Prelude.Map.Type 41 | 42 | let Job = GitLab.Job.Type 43 | 44 | let renderTop = GitLab.Top.toJSON 45 | 46 | let buildDir = "build" 47 | 48 | let targets = [ "package-1", "package-2" ] 49 | 50 | let mkJob = 51 | λ(target : Text) → 52 | GitLab.Job::{ 53 | , stage = Some "build" 54 | , image = Some { name = "alpine:latest", entrypoint = Some [ " " ] } 55 | , script = [ "echo 'Building ${buildDir}/${target} World'" ] 56 | } 57 | 58 | let jobList 59 | : List { mapKey : Text, mapValue : Job } 60 | = List/map 61 | Text 62 | { mapKey : Text, mapValue : Job } 63 | (λ(target : Text) → { mapKey = target, mapValue = mkJob target }) 64 | targets 65 | 66 | let jobMap 67 | : Map Text Job 68 | = jobList 69 | 70 | let top = GitLab.Top::{ jobs = jobMap } 71 | 72 | in Prelude.JSON.renderYAML (renderTop top) 73 | ``` 74 | -------------------------------------------------------------------------------- /examples/multiple-jobs.dhall: -------------------------------------------------------------------------------- 1 | let GitLab = ../package.dhall 2 | 3 | let Prelude = GitLab.Prelude 4 | 5 | let List/map = Prelude.List.map 6 | 7 | let Map = Prelude.Map.Type 8 | 9 | let Job = GitLab.Job.Type 10 | 11 | let renderTop = GitLab.Top.toJSON 12 | 13 | let buildDir = "build" 14 | 15 | let targets = [ "package-1", "package-2" ] 16 | 17 | let mkJob = 18 | λ(target : Text) → 19 | GitLab.Job::{ 20 | , stage = Some "build" 21 | , image = Some { name = "alpine:latest", entrypoint = Some [ " " ] } 22 | , script = [ "echo 'Building ${buildDir}/${target} World'" ] 23 | } 24 | 25 | let jobList 26 | : List { mapKey : Text, mapValue : Job } 27 | = List/map 28 | Text 29 | { mapKey : Text, mapValue : Job } 30 | (λ(target : Text) → { mapKey = target, mapValue = mkJob target }) 31 | targets 32 | 33 | let jobMap 34 | : Map Text Job 35 | = jobList 36 | 37 | let top = GitLab.Top::{ jobs = jobMap } 38 | 39 | in Prelude.JSON.renderYAML (renderTop top) 40 | -------------------------------------------------------------------------------- /examples/single-job.dhall: -------------------------------------------------------------------------------- 1 | let GitLab = 2 | ../package.dhall 3 | ? https://raw.githubusercontent.com/bgamari/dhall-gitlab-ci/master/package.dhall 4 | 5 | let Prelude = GitLab.Prelude 6 | 7 | let renderTop = GitLab.Top.toJSON 8 | 9 | let demoJob = 10 | GitLab.Job::{ 11 | , stage = Some "build" 12 | , image = Some { name = "alpine:latest", entrypoint = Some [ " " ] } 13 | , script = [ "echo 'Hello World'" ] 14 | } 15 | 16 | let top = GitLab.Top::{ jobs = toMap { generated-job = demoJob } } 17 | 18 | in Prelude.JSON.renderYAML (renderTop top) 19 | -------------------------------------------------------------------------------- /package.dhall: -------------------------------------------------------------------------------- 1 | ./GitLab/package.dhall ∧ { Prelude = ./Prelude.dhall } 2 | --------------------------------------------------------------------------------