Update Node Dependencies Automatically, Selectively, or Incrementally

Managing Node Dependencies Can Be Tricky

As you are probably well aware, node dependencies can and do change very quickly. Updating these dependencies can become tricky and cumbersome.

Thankfully there is a node package called npm-check-updates that can help the update process become slightly less painful. With the program you can do the following.

1. Automatically update all the dependencies
2. Selectively update the dependencies that you choose
3. Incrementally update dependencies that don't break your tests

NOTE: There is a native command with npm to show outdated node modules (npm outdated), but its output is static. If you use yarn there is also a native command called yarn upgrade-interactive, but npm-check-updates has those features and many more.

Globally Install

One way to execute npm-check-updates is to install it globally, then you can execute with the ncu command.

npm install -g npm-check-updates

ncu

Running with NPX

Another way to run npm-check-updates is to temporarily install and execute it with npx. The benefit of this approach is that you don't have to have it installed globally. However, the downside is a slower runtime since it always downloads the application before running it.

npx npm-check-updates

NOTE: If you want to learn more about npx there is a free 17 minute Execute npm Package Binaries with the npx Package Runner course on Egghead.

Automatically update all the dependencies

If you run ncu with no parameters (or npx npm-check-updates) the program will scan your project and assess your dependencies and compare those with the latest version of the dependencies. The result is a list of modules and its findings.

No changes are made to your package.json by running ncu. There is a message at the end suggesting running ncu -u to upgrade the recommended versions.

NOTE: If you are interested in how ncu determines which node modules need to be updated, you can reference their detailed documentation from their repository.

Running ncu -u to Update Dependencies

After running the previous ncu command, you can follow up (or skip the previous step) by running ncu -u (shorthand for ncu --upgrade) to automatically update your package.json with the latest versions. However, this stop only updates your package.json, it does not actually install those modules, you'll need to follow up with npm install if you want to do that. There will be a message at the end of the command to remind you of this step.

NOTE: This will update ALL of your node dependencies to the latest version. If you don't want this behavior, then you might prefer the Selectively update the dependencies that you choose section.

Installing the Dependencies that were Updated

As the previous step mentioned, you'll need to manually npm install after running ncu -u to actually install the node modules that were updated.

Selectively update the dependencies that you choose

Instead of installing the latest version of ALL of your dependencies, you may instead, wish to selectively pick which node modules you'd like to upgrade. For example, maybe you'd first like to target those modules with only patch upgrades, or only handpick a few modules to start.

Thankfully, you can selectively pick which modules to upgrade by running ncu -i (which is shorthand for ncu --interactive). This mode will prompt you for each node module asking if you would like to upgrade. At the end of the command, it will output which modules were updated in your package.json, but as with the ncu -u command, it is up to you to run npm install to actually install the modules.

Incrementally update dependencies that don't break your tests

Having the ability to automatically and interactively upgrade modules is great, but it doesn't help you to understand which modules might break your tests or build. Thankfully there is a special --doctor flag that will incrementally update modules while running tests along the way.

The general flow of --doctor mode is the following:

1. Runs npm install and npm test to make sure everything is passing before upgrading anything
2. Runs ncu -u to upgrade ALL of the dependencies and installs those upgrades
3. Runs npm test again to see if they pass. If the tests pass, then exit
4. If the tests fail, then restore the package.json file
5. Then start again, but for each dependency, install an upgrade and re-run the tests
6. If a breaking upgrade is found, save the partially upgraded package.json to the version that worked

Using Another npm script instead of Tests

It's possible that you don't have unit tests in your package, but you'd still like the benefit of the --doctor command. Thankfully, there is a --doctorTest flag that you can pass to define your own script that will be executed after the upgrade of each dependency. For example, if you'd like to test the status of your build you could pass --doctorTest="npm run build".

Explore the Documentation for More Features

There are many more features and options of npm-check-updates that you might like to explore. If this blog post was interesting to you, then it might be worth your time to explore the documentation and explore all that the module provides.