tylerlong / yarn-upgrade-all

This is a command line utility program to upgrade all the packages in your `package.json` to the latest version (potentially upgrading packages across major versions).

yarn-upgrade-all

This is a command line utility program to upgrade all the packages in your package.json to the latest version (potentially upgrading packages across major versions).

Installation

yarn add --dev yarn-upgrade-all

Usage

yarn yarn-upgrade-all

How does it work?

For every type of dependencies in package.json, run

yarn add [--dev|--peer] <package-names>`.

Additional options

You may pass additional options to the yarn add command:

yarn yarn-upgrade-all --option-1 --option-2

Which will invoke:

yarn add [--dev|--peer] <package-names> --option-1 --option-2

What if a package failed to install?

In that case, that package will be skipped and an error message will be printed.

You need to read the error message and manually install that package.

It is the recommended flow. Because if a package failed to install, most of the time, you need to manually troubleshoot the issue and fix the issue.

Ignore some packages

You can add the following to package.json file:

...
"yarn-upgrade-all": {
    "ignore": [
        "react"
    ]
}
...

With configuration above, yarn-upgrade-all won't upgrade react for you.

Local packages

Local packages are ignored if they start with file::

"dependencies": {
  "foo": "file:../foo"
}

Installation globally

yarn global add yarn-upgrade-all

Installation on Windows

npm install -g yarn-upgrade-all

❗ Don't use yarn to install it on Windows because there is a bug: yarnpkg/yarn#2224.

Upgrade global packages

yarn-upgrade-all --global or yarn-upgrade-all -g

yarn-upgrade-all's Issues

Add option to skip some package

It would be cool to have option to skip some packages that we dont want to upgrade (or they fail to install).

Why not make it WAYYY faster and simpler

#!/usr/bin/env node
const fs = require("fs");
const path = require("path");
const childProcess = require("child_process");
const chalk = require("chalk");
const logError = message => {
    console.log(chalk.red("[Error]: " + message));
};
const logInfo = message => {
    console.log(chalk.blue("[Start]: " + message));
};
const logSuccess = message => {
    console.log(chalk.green("[Done]: " + message));
};

let global = "";
let packagePath = path.resolve(process.cwd(), "package.json");

if (!fs.existsSync(packagePath)) {
    logError("Cannot find package.json file in the current directory");
    process.exit(1);
}

const packageJson = require(packagePath);
const options = {
    dependencies: "",
    devDependencies: " --dev",
    peerDependencies: " --peer"
};
let ignorePkgs = [];
if (packageJson["ignore-upgrade"]) {
    ignorePkgs = packageJson["ignore-upgrade"];
}
let upgraded = { before: {}, after: {} };
for (let element of ["dependencies", "devDependencies", "peerDependencies"]) {
    if (packageJson[element]) {
        const packages = Object.keys(packageJson[element]);
        let packagesList = packages
            .filter(pkk => !ignorePkgs.includes(pkk))
            .map(pkk => {
                upgraded["before"][pkk] = packageJson[element][pkk];
                return pkk + "@latest";
            })
            .join(" ");
        let command = `yarn${global} add --dev ${packagesList}`;
        try {
            // logInfo(command);
            childProcess.execSync(command, { stdio: [] });
            const packageJsonAfter = JSON.parse(fs.readFileSync(packagePath));
            const packagesAfter = Object.keys(packageJsonAfter[element]);
            let packagesListAfter = packagesAfter
                .filter(pkk => !ignorePkgs.includes(pkk))
                .map(pkk => {
                    upgraded["after"][pkk] = packageJsonAfter[element][pkk];
                    return upgraded["before"][pkk] !== upgraded["after"][pkk]
                        ? `Updated: ${pkk} from: ${upgraded["before"][pkk]} | to: ${
                              upgraded["after"][pkk]
                          }\n`
                        : ``;
                })
                .join("");
            logSuccess(packagesListAfter);
        } catch (e) {
            logError(`${command} - ${e}`);
        }
    }
}

Is there a way to access a private artifact repository?

so that we can use this tool to update our private dependencies in the company

'yarn-upgrade-all' is not recognized as an internal or external command

Trying to use after install:

'yarn-upgrade-all' is not recognized as an internal or external command, operable program or batch file.

feat: passing options to yarn

Hi!

Sometimes, it might be needed to pass a specific option to yarn add.

For example, I want to execute yarn add -D --ignore-workspace-root-check <package>.

In this case, currently there is no way to pass --ignore-workspace-root-check option to yarn-upgrade-all.

How about allowing it?

I think a solution like yarn-upgrade-all --foo-option --bar-option would be good.

How do you think?

Thanks!

Performance issues

It takes a really long time to upgrade each package in particular. It would be a lot faster if you use the npm-api to fetch the versions, replace these in the package.json and run yarn after it.

Duplicates arguments to update and installs "add" package incorrectly

> yarn-upgrade-all
 [Start]: yarn add @discordjs/builders @discordjs/rest @prisma/client @tsconfig/recommended @vitalets/google-translate-api common-tags discord-api-types discord-backup discord-tictactoe discord-together discord.js dotenv glob ms quick.db topgg-autoposter ts-node
 [Done]: yarn add @discordjs/builders @discordjs/rest @prisma/client @tsconfig/recommended @vitalets/google-translate-api common-tags discord-api-types discord-backup discord-tictactoe discord-together discord.js dotenv glob ms quick.db topgg-autoposter ts-node
 [Start]: yarn add @discordjs/builders @discordjs/rest @prisma/client @tsconfig/recommended @vitalets/google-translate-api common-tags discord-api-types discord-backup discord-tictactoe discord-together discord.js dotenv glob ms quick.db topgg-autoposter ts-node add @types/common-tags @types/glob @types/ms @types/node @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint prisma typescript --dev
 [Done]: yarn add @discordjs/builders @discordjs/rest @prisma/client @tsconfig/recommended @vitalets/google-translate-api common-tags discord-api-types discord-backup discord-tictactoe discord-together discord.js dotenv glob ms quick.db topgg-autoposter ts-node add @types/common-tags @types/glob @types/ms @types/node @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint prisma typescript --dev

Great package but can have destructive results on your package.json

This is a great package but can have a destructive result if you accidentally control c the running application or it errors out on a cryptic error in node itself.

The package.json will inherit its modified state, which may be incomplete or missing packages. While easy to restore from a version control system it would be beneficial to add some testing case.

One should be to store the original package.json in a .yarn-upgrade-all tmp directory in case an issue was present. If the program was cancelled early by mistake this version could be reverted too.

Either restore the original package.json OR attempt a merge operation. Obviously if you were between a remove and add section the package goes missing. If there was an original backup when rerunning yarn-upgrade-all the program could check to see if it was interrupted and attempt to merge previous tasks.'

Goal is to have a safer outcome.

Package should remove all packages and install all with 2 commands

yarn remove one two three four
yarn add one two three fours

This works much faster than remove and add every package in sequence

Should only re-add if neccessary

So that if you fail somewhere in the middle, it'll continue from there instead of starting over

Doesn't handle local dependencies

e.g.

"dependencies": {
  "foo": "../foo"
}

These should probably just be ignored.