schema.json

{
    "$schema": "http://json-schema.org/draft-07/schema",
    "$comment": "https://docs.reviewpad.com/docs",
    "definitions": {
        "import": {
            "type": "object",
            "properties": {
                "url": {
                    "description": "Url to another reviewpad.yml configuration file.",
                    "type": "string",
                    "pattern": "\\.(yml|yaml)$",
                    "examples": [
                        "./path/to/reviewpad.yml",
                        "https://path.com/to/reviewpad.yml"
                    ]
                }
            }
        },
        "extendedFile": {
            "type": "string",
            "description": "Url of a GitHub blob that represents another reviewpad.yml configuration file.",
            "pattern": "((https|http):\\/\\/)?github\\.com\\/[^ \"]+\\/[^ \"]+\\/blob\\/[^ \"]+(\\/[^ \"]+)?\\/[^ \"]+.(yml|yaml)$",
            "examples": [
                "https://github.com/reviewpad/.github/blob/main/reviewpad-models/common.yml",
                "https://github.com/reviewpad/reviewpad/blob/main/reviewpad.yml"
            ]
        },
        "action": {
            "description": "Action to run. This action needs to be an aladino built-in function.",
            "type": "string",
            "pattern": "^\\$[a-zA-Z_][a-zA-Z0-9_-]*\\((.|\\s)*(,(.|\\s)*)*\\)$",
            "examples": [
                "$addLabel(\"large\")",
                "$addToProject(\"reviewpad\", \"in progress\")",
                "$assignAssignees([\"john\", \"marie\", \"peter\"])",
                "$assignRandomReviewer()",
                "$assignReviewer([\"john\"])",
                "$assignReviewer($team(\"devops\"), 3)",
                "$assignTeamReviewer([\"core\", \"support\"])",
                "$close()",
                "$comment(\"This pull request has git conflicts. Please resolve them.\")",
                "$commentOnce(\"This is your first contribution! Thank you!\")",
                "$commitLint()",
                "$deleteHeadBranch()",
                "$disableActions([\"assignReviewer\"])",
                "$error(\"Please do not touch these files.\")",
                "$fail(\"Missing specs\")",
                "$info(\"Please do not forget to add the tests.\")",
                "$merge(\"rebase\")",
                "$removeLabel(\"medium\")",
                "$removeLabels([\"bug\", \"p1\"])",
                "$review(\"REQUEST_CHANGES\", \"Please include the tests for your change\")",
                "$setProjectField(\"jupiter\", \"notes\", \"missing issue\")",
                "$triggerWorkflow(\"main.yml\")",
                "$warn(\"Please do not forget to add the tests.\")"
            ]
        },
        "label": {
            "description": "A label is used to sort and describe pull requests.",
            "type": "object",
            "properties": {
                "name": {
                    "description": "The name of the label.",
                    "type": "string"
                },
                "description": {
                    "description": "A short description of the label. Must be 100 characters or fewer.",
                    "type": "string"
                },
                "color": {
                    "description": "The hexadecimal color code for the label, with or without the leading #.",
                    "type": "string",
                    "examples": [
                        "#8a2151",
                        "d2697a"
                    ]
                }
            },
            "additionalProperties": false
        },
        "rule": {
            "description": "A rule specifies a filter over a pull request.",
            "type": "object",
            "properties": {
                "name": {
                    "description": "The name of the rule that is used to identify the rule.",
                    "type": "string"
                },
                "description": {
                    "description": "The description can be used to provide more details about the rule.",
                    "type": "string"
                },
                "kind": {
                    "description": "The kind of a rule. The kind is related to different properties of pull requests that will be used in the evaluation of the 'spec' field.",
                    "type": "string",
                    "enum": [
                        "patch",
                        "author"
                    ]
                },
                "spec": {
                    "description": "The spec is a boolean expression in a domain specific language called Aladino (Portuguese translation of Aladdin).",
                    "type": "string",
                    "examples": [
                        "$any($reviewers(), ($r: String => $reviewerStatus($r) == \"APPROVED\"))",
                        "$approvalsCount() > 2",
                        "$assignees() == [\"john\"]",
                        "$author() == \"john\"",
                        "$base() == \"stage\"",
                        "$changed(\"src/@1.java\", \"test/@1.java\")",
                        "$checkRunConclusion(\"build\") == \"success\"",
                        "$comment(\"Missing tests\")",
                        "$contains($title(), \"bug\")",
                        "$fileCount() > 5",
                        "$hasGitConflicts()",
                        "$hasAnnotation(\"critical\")",
                        "$hasCodePattern(\"placeBet\\(.*\\)\")",
                        "$hasFileExtensions([\".test.ts\"])",
                        "$hasFileName(\"main.js\")",
                        "$hasLinearHistory()",
                        "$hasLinkedIssues()",
                        "$hasRequiredApprovals(2, [\"john\", \"jane\", \"peter\"])",
                        "$isBinary(\"folder/filename\")",
                        "$isDraft()",
                        "$isElementOf($author(), $team(\"devops\"))",
                        "$join([\"alice\", \"bob\"], \" \") ",
                        "$labels() == [\"feat\"]",
                        "$reviewers() != []",
                        "$selectFromJSON($toJSON(\"[1, 2, 3]\"), \"$[0]\")",
                        "$selectFromContext(\"$.title\")",
                        "$size() > 100",
                        "$toBool(\"true\")"
                    ]
                }
            },
            "required": [
                "name",
                "spec"
            ],
            "additionalProperties": false
        },
        "entityType": {
            "description": "GitHub entity type that should trigger the workflow",
            "type": "string",
            "enum": [
                "pull_request",
                "issue"
            ]
        },
        "workflow": {
            "description": "A workflow specifies a set of rules that need to be met in order to run a defined set of actions.",
            "type": "object",
            "properties": {
                "name": {
                    "description": "The workflow name.",
                    "type": "string"
                },
                "description": {
                    "description": "The description can be used to provide more details about the workflow.",
                    "type": "string"
                },
                "on": {
                    "description": "List of GitHub entity types that should trigger the workflow. By default, the value is pull_request.",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/entityType"
                    }
                },
                "run": {
                    "description": "The set of actions to be executed for a workflow, can be a single action, a list of actions, a conditional or a combination of all.",
                    "type": [
                        "array"
                    ],
                    "minItems": 1,
                    "items": {
                        "$ref": "#/definitions/condition-action"
                    }
                }
            },
            "required": [
                "name",
                "run"
            ],
            "additionalProperties": false
        },
        "stage": {
            "description": "A stage is a list of actions that will execute until the `until` condition is true.",
            "type": "object",
            "properties": {
                "actions": {
                    "description": "The set of actions to be executed while the evaluation of the rule specified in the until clause is false.",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/action"
                    },
                    "minItems": 1
                },
                "until": {
                    "description": "The rule to be met in order for the execution of the set of actions to stop.",
                    "type": "string"
                }
            },
            "required": [
                "actions"
            ],
            "additionalProperties": false
        },
        "pipeline": {
            "description": "A pipeline specifies a set of stages where each contains a set of actions to execute while the until clause evaluation is false. A pipeline only runs if it is triggered.",
            "type": "object",
            "properties": {
                "name": {
                    "description": "The pipeline name.",
                    "type": "string"
                },
                "description": {
                    "description": "The description can be used to provide more details about the pipeline.",
                    "type": "string"
                },
                "trigger": {
                    "description": "A pipeline is running if and only if the trigger is empty or the rule that is specified in it is true.",
                    "type": "string"
                },
                "stages": {
                    "type": "array",
                    "description": "List of stages of the pipeline. Each stage is a list of actions to be executed while the `until` condition is evaluated to false.",
                    "items": {
                        "$ref": "#/definitions/stage"
                    },
                    "minItems": 1
                }
            },
            "required": [
                "name",
                "stages"
            ],
            "additionalProperties": false
        },
        "groupBasic": {
            "description": "A group specifies a set of users in the repository where the workflow runs.",
            "type": "object",
            "properties": {
                "name": {
                    "description": "The name of the group that is used to identify the group.",
                    "type": "string"
                },
                "description": {
                    "description": "The description can be used to provide more details about the group.",
                    "type": "string"
                },
                "kind": {
                    "description": "The kind of a group.",
                    "type": "string",
                    "enum": [
                        "developers"
                    ]
                },
                "spec": {
                    "description": "The spec is an expression in a domain specific language called Aladino (Portuguese translation of Aladdin) that is evaluated to an array of users.",
                    "type": "string",
                    "examples": [
                        "'[\"john\", \"jane\"]'"
                    ]
                }
            },
            "required": [
                "name",
                "spec"
            ],
            "additionalProperties": false
        },
        "groupWithType": {
            "description": "A group specifies a set of users in the repository where the workflow runs.",
            "type": "object",
            "properties": {
                "name": {
                    "description": "The name of the group that is used to identify the group.",
                    "type": "string"
                },
                "description": {
                    "description": "The description can be used to provide more details about the group.",
                    "type": "string"
                },
                "kind": {
                    "description": "The kind of a group.",
                    "type": "string",
                    "enum": [
                        "developers"
                    ]
                },
                "type": {
                    "description": "The type of a group. Represents the type function to the applied to the group.",
                    "type": "string",
                    "enum": [
                        "filter"
                    ]
                },
                "param": {
                    "description": "The 'param' describes the parameter name to be used on the 'spec' expression.",
                    "type": "string",
                    "examples": [
                        "$dev"
                    ]
                },
                "where": {
                    "description": "The 'where' is an expression in a domain specific language called Aladino (Portuguese translation of Aladdin) that is evaluated to an array of users.",
                    "type": "string",
                    "examples": [
                        "$pullRequestCountBy($dev,\"all\") < 10"
                    ]
                }
            },
            "required": [
                "name",
                "kind",
                "type",
                "param",
                "where"
            ],
            "additionalProperties": false
        },
        "condition-action": {
            "anyOf": [
                {
                    "type": "object",
                    "properties": {
                        "if": {
                            "type": "string",
                            "minLength": 1
                        },
                        "then": {
                            "type": [
                                "string",
                                "array"
                            ],
                            "minItems": 1,
                            "items": {
                                "$ref": "#/definitions/condition-action"
                            }
                        },
                        "else": {
                            "type": [
                                "string",
                                "array"
                            ],
                            "minItems": 1,
                            "items": {
                                "$ref": "#/definitions/condition-action"
                            }
                        }
                    },
                    "additionalProperties": false,
                    "required": [
                        "if",
                        "then"
                    ]
                },
                {
                    "type": [
                        "string",
                        "array"
                    ],
                    "minItems": 1,
                    "items": {
                        "$ref": "#/definitions/condition-action"
                    }
                }
            ]
        }
    },
    "properties": {
        "mode": {
            "description": "The mode in which Reviewpad will run. 'verbose' to add a comment on the pull request with the triggered workflows. 'silent' to run without any comment. By default, the mode is 'silent'.",
            "type": "string",
            "enum": [
                "silent",
                "verbose"
            ]
        },
        "ignore-errors": {
            "description": "Specifies if Reviewpad should ignore execution errors. By default, this flag is 'false' which means that Reviewpad will fail if an error is raised.",
            "type": "boolean"
        },
        "metrics-on-merge": {
            "description": "Specifies if Reviewpad should add a metrics report when the pull request is merged. By default, this flag is 'false' which means that Reviewpad will not add this report.",
            "type": "boolean"
        },
        "imports": {
            "description": "List of imports to be loaded. This is used in order to allow split configuration files and use them across different projects.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/import"
            },
            "minItems": 1
        },
        "extends": {
            "description": "List of other Reviewpad configuration files as GitHub blob URLs. This allows the ability to share common specifications for all the flags, labels, rules, and workflows from multiple GitHub repositories with the possibility to override the inherited configurations.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/extendedFile"
            },
            "minItems": 1
        },
        "labels": {
            "description": "List of labels to be used. Labels that do not exist in the project will be created using the provided color and description.",
            "type": "object",
            "patternProperties": {
                "^[_a-zA-Z][a-zA-Z0-9_-]*$": {
                    "$ref": "#/definitions/label"
                }
            },
            "minProperties": 1,
            "additionalProperties": false
        },
        "rules": {
            "description": "List of rules that will be used in the workflows. All rules defined here should be used, otherwise, an error will be triggered.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/rule"
            },
            "minItems": 1,
            "additionalProperties": false
        },
        "workflows": {
            "description": "List of workflows. A workflow is tested against the selected rules and if all rules evaluate to true, then all defined actions run.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/workflow"
            },
            "minItems": 1
        },
        "groups": {
            "description": "List of groups. A group corresponds to a set of users in the repo where the pull request occurs.",
            "type": "array",
            "items": {
                "oneOf": [
                    {
                        "$ref": "#/definitions/groupBasic"
                    },
                    {
                        "$ref": "#/definitions/groupWithType"
                    }
                ]
            },
            "minItems": 1,
            "additionalProperties": false
        },
        "pipelines": {
            "description": "List of pipelines. A pipeline specifies a set of stages where each contains a set of actions to execute while the until clause evaluation is false. A pipeline only runs if it is triggered.",
            "type": "array",
            "items": {
                "$ref": "#/definitions/pipeline"
            },
            "minItems": 1
        },
        "additionalProperties": false
    },
    "additionalProperties": false
}