Default Presets

Default preset configs for Renovate. Source repository

:enableRenovate

Enable renovate

{
  "enabled": true
}

:disableRenovate

Disable renovate

{
  "enabled": false
}

:includeNodeModules

Include package.json files found within node_modules folders

{
  "ignoreNodeModules": false
}

:pinVersions

Use version pinning (maintain a single version only and not semver ranges)

{
  "pinVersions": true
}

:preserveSemverRanges

Preserve (but continue to upgrade) any existing semver ranges

{
  "pinVersions": false
}

:pinOnlyDevDependencies

Pin dependency versions for devDependencies and retain semver ranges for others

{
  "dependencies": {
    "extends": ":preserveSemverRanges"
  },
  "devDependencies": {
    "extends": ":pinVersions"
  },
  "optionalDependencies": {
    "extends": ":preserveSemverRanges"
  },
  "peerDependencies": {
    "extends": ":preserveSemverRanges"
  }
}

:autodetectPinVersions

Autodetect whether to pin dependencies or maintain ranges

{
  "pinVersions": null
}

:separateMajorReleases

Separate major versions of dependencies into individual branches/PRs

{
  "separateMajorReleases": true
}

:separatePatchReleases

Separate patch and minor releases of dependencies into separate PRs

{
  "separatePatchReleases": true
}

:combinePatchMinorReleases

Combine any patch and minor upgrades together into same branch/PR

{
  "separatePatchReleases": false
}

:renovatePrefix

Use renovate/ as prefix for all branch names

{
  "branchprefix": "renovate/"
}

:semanticCommitType(<arg0>)

Use arg0 as semantic commit type for commit messages and PR titles

{
  "semanticCommitType": "arg0"
}

:semanticPrefixChore

Use chore as semantic commit type for commit messages and PR titles

{
  "extends": [
    ":semanticCommitType(chore)"
  ]
}

:semanticPrefixFix

Use fix as semantic commit type for commit messages and PR titles

{
  "extends": [
    ":semanticCommitType(fix)"
  ]
}

:disablePeerDependencies

Do not renovate peerDependencies versions/ranges

{
  "peerDependencies": {
    "enabled": false
  }
}

:semanticPrefixFixDepsChoreOthers

If semantic commits detected, use semantic commit type fix for dependencies and chore for all others

{
  "dependencies": {
    "extends": ":semanticCommitType(fix)"
  },
  "devDependencies": {
    "extends": ":semanticCommitType(chore)"
  },
  "optionalDependencies": {
    "extends": ":semanticCommitType(chore)"
  },
  "peerDependencies": {
    "extends": ":semanticCommitType(chore)"
  }
}

:semanticCommitTypeAll(<arg0>)

If semantic commits detected, use semantic commit type arg0 for all

{
  "dependencies": {
    "extends": ":semanticCommitType(arg0)"
  },
  "devDependencies": {
    "extends": ":semanticCommitType(arg0)"
  },
  "optionalDependencies": {
    "extends": ":semanticCommitType(arg0)"
  },
  "peerDependencies": {
    "extends": ":semanticCommitType(arg0)"
  },
  "pin": {
    "extends": ":semanticCommitType(arg0)"
  },
  "digest": {
    "extends": ":semanticCommitType(arg0)"
  }
}

:rebaseStalePrs

Rebase existing PRs any time the base branch has been updated

{
  "rebaseStalePrs": true
}

:unpublishSafe

Set a status check to warn when upgrades < 24 hours old might get unpublished

{
  "unpublishSafe": true
}

:unpublishSafeDisabled

Create branches/PRs for dependency upgrades as soon as they’re available

{
  "unpublishSafe": false
}

:prImmediately

Raise PRs immediately (after branch is created)

{
  "prCreation": "immediate"
}

:prNotPending

Wait until branch tests have passed or failed before creating the PR

{
  "prCreation": "not-pending"
}

:automergeDisabled

Disable automerging feature - wait for humans to merge all PRs

{
  "automerge": false
}

:automergeDigest

Automerge digest upgrades if they pass tests

{
  "digest": {
    "automerge": true
  }
}

:automergePatch

Automerge patch upgrades if they pass tests

{
  "patch": {
    "automerge": true
  }
}

:automergeMinor

Automerge patch and minor upgrades if they pass tests

{
  "minor": {
    "automerge": true
  },
  "patch": {
    "automerge": true
  }
}

:automergeMajor

Automerge all upgrades (inluding major) if they pass tests

{
  "automerge": true
}

:automergeBranchMergeCommit

If automerging, perform a merge-commit on branch (no PR)

{
  "automergeType": "branch-merge-commit"
}

:automergeBranchPush

If automerging, push the new commit directly to base branch (no PR)

{
  "automergeType": "branch-push"
}

:automergePr

Raise a PR first before any automerging

{
  "automergeType": "pr"
}

:automergeRequireAllStatusChecks

Require all status checks to pass before any automerging

{
  "requiredStatusChecks": []
}

:maintainLockFilesDisabled

Update existing lock files only when package.json is modified

{
  "lockFileMaintenance": {
    "enabled": false
  }
}

:pinDigestsDisabled

Disable pinning of docker dependency digests

{
  "pinDigests": false
}

:maintainLockFilesWeekly

Run lock file maintenance (updates) early Monday mornings

{
  "lockFileMaintenance": {
    "enabled": true,
    "extends": "schedule:weekly"
  }
}

:maintainLockFilesMonthly

Run lock file maintenance (updates) on the first day of each month

{
  "lockFileMaintenance": {
    "enabled": true,
    "extends": "schedule:monthly"
  }
}

:ignoreUnstable

Upgrade to unstable versions only if the existing version is unstable

{
  "ignoreUnstable": true
}

:respectLatest

Upgrade versions up to the “latest” tag in npm registry

{
  "respectLatest": true
}

:updateNotScheduled

Keep existing branches updated even when not scheduled

{
  "updateNotScheduled": true
}

:noUnscheduledUpdates

Make no updates to branches when not scheduled

{
  "updateNotScheduled": false
}

:automergeLinters

Update lint packages automatically if tests pass

{
  "packageRules": [
    {
      "extends": [
        "packages:linters"
      ],
      "automerge": true
    }
  ]
}

:doNotPinPackage(<arg0>)

Disable version pinning for arg0

{
  "packageRules": [
    {
      "packageNames": [
        "arg0"
      ],
      "pinVersions": false
    }
  ]
}

:npm

Keep package.json npm dependencies updated

{
  "javascript": {
    "enabled": true
  }
}

:onlyNpm

Renovate only npm dependencies

{
  "docker": {
    "enabled": false
  },
  "meteor": {
    "enabled": false
  }
}

:docker

Keep Dockerfile FROM sources updated

{
  "docker": {
    "enabled": true
  }
}

:meteor

Keep Meteor Npm.depends packages updated

{
  "meteor": {
    "enabled": true
  }
}

:group(<arg0>, <arg1>)

Group arg1 packages into same branch/PR

{
  "packageRules": [
    {
      "extends": [
        "arg0"
      ],
      "groupName": "arg1"
    }
  ]
}

:label(<arg0>)

Apply label arg0 to PRs

{
  "labels": [
    "arg0"
  ]
}

:labels(<arg0>, <arg1>)

Apply labels arg0 and arg1 to PRs

{
  "labels": [
    "arg0",
    "arg1"
  ]
}

:assignee(<arg0>)

Assign PRs to arg0

{
  "assignees": [
    "arg0"
  ]
}

:reviewer(<arg0>)

Add arg0 as reviewer for PRs

{
  "reviewers": [
    "arg0"
  ]
}

:assignAndReview(<arg0>)

Set arg0 as assignee and reviewer of PRs

{
  "extends": [
    ":assignee(arg0)",
    ":reviewer(arg0)"
  ]
}

:semanticCommits

Use semantic commits for commit messages and PR titles

{
  "semanticCommits": true
}

:semanticCommitScope(<arg0>)

Use semantic scope arg0 for all commits and PR titles

{
  "semanticCommitScope": "arg0"
}

:timezone(<arg0>)

Evaluate schedules according to timezone arg0

{
  "timezone": "arg0"
}

:base

deprecated alias for config:base

{
  "extends": [
    "config:base"
  ]
}

:app

deprecated alias for config:js-app

{
  "extends": [
    "config:js-app"
  ]
}

:library

deprecated alias for config:js-lib

{
  "extends": [
    "config:js-lib"
  ]
}