@jsenv/monorepo 0.0.1

package/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 jsenv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@jsenv/monorepo",
+  "version": "0.0.1",
+  "description": "Helpers to manage packages in a monorepo",
+  "license": "MIT",
+  "author": {
+    "name": "dmail",
+    "email": "dmaillard06@gmail.com",
+    "url": "https://twitter.com/damienmaillard"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jsenv/workflow",
+    "directory": "packages/monorepo"
+  },
+  "engines": {
+    "node": ">=16.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/main.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./src/main.js",
+  "files": [
+    "/src/"
+  ],
+  "scripts": {
+    "test": "node ./scripts/test.mjs"
+  },
+  "dependencies": {
+    "@jsenv/urls": "2.2.1",
+    "@jsenv/filesystem": "4.3.2",
+    "@jsenv/package-publish": "1.10.3",
+    "@jsenv/log": "3.4.1",
+    "semver": "7.5.4"
+  }
+}

package/readme.md

@@ -0,0 +1,88 @@
+# @jsenv/monorepo
+
+Helpers to manage multiple packages from a single repository. For example when using [NPM workspaces](https://docs.npmjs.com/cli/v8/using-npm/workspaces).
+
+## Updating a package
+
+Updating a package in a workspace by hand is time consuming and error prone. Let's see it with a basic example where a workspace contains two packages and you make a change to one of them.
+
+_packages/main/package.json:_
+
+```json
+{
+  "name": "main",
+  "version": "3.4.2",
+  "dependencies": {
+    "util": "1.0.0"
+  }
+}
+```
+
+_packages/util/package.json:_
+
+```json
+{
+  "name": "util",
+  "version": "1.0.0"
+}
+```
+
+Now you update "version" in "packages/util/package.json"
+
+```diff
+{
+  "name": "util",
+- "version": "1.0.0"
++ "version": "1.1.0"
+}
+```
+
+At this point you are supposed to update "packages/main/package.json" like this:
+
+```diff
+{
+  "name": "main",
+- "version": "3.4.2",
++ "version": "3.4.3",
+  "dependencies": {
+-   "util": "1.0.0"
++   "util": "1.1.0"
+  }
+}
+```
+
+In a workspace with many packages this is hard to do correctly and time consuming. You can automate the painful part as follows:
+
+1. Run _syncPackagesVersions_
+2. Review changes with a tool like "git diff"
+3. Run _publishPackages_
+
+### syncPackagesVersions
+
+_syncPackagesVersions_ is an async function ensuring versions in all package.json are in sync for all packages in the workspace. It update versions in "dependencies", "devDependencies" and increase "version" if needed. This ensure all versions are in sync before publishing.
+
+```js
+import { syncPackagesVersions } from "@jsenv/package-workspace";
+
+await syncPackagesVersions({
+  directoryUrl: new URL("./", import.meta.url),
+});
+```
+
+### Review changes
+
+Each package might need to increase their package.json "version" differently. When it's required _syncPackagesVersions_ increases PATCH number ("1.0.3" becomes "1.0.4"). After that it's up to you to review these changes to decide if you keep PATCH increment or want to increment MINOR or MAJOR instead.
+
+## publishPackages
+
+_publishPackages_ is an async function that will publish all packages in the workspace on NPM. But only the packages that are not already published.
+
+```js
+import { publishPackages } from "@jsenv/package-workspace";
+
+process.env.NPM_TOKEN = "token_auhtorized_to_publish_on_npm";
+
+await publishPackages({
+  directoryUrl: new URL("./", import.meta.url),
+});
+```

package/src/internal/collect_workspace_packages.js

@@ -0,0 +1,56 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { urlToRelativeUrl } from "@jsenv/urls";
+import { listFilesMatching } from "@jsenv/filesystem";
+
+export const collectWorkspacePackages = async ({ directoryUrl }) => {
+  const workspacePackages = {};
+  const rootPackageUrl = new URL("package.json", directoryUrl);
+  const rootPackageFileInfo = readPackageFile(rootPackageUrl);
+  const rootPackage = {
+    isRoot: true,
+    packageUrl: rootPackageUrl,
+    packageObject: rootPackageFileInfo.object,
+    updateFile: rootPackageFileInfo.updateFile,
+  };
+  workspacePackages[rootPackageFileInfo.object.name] = rootPackage;
+
+  const patterns = {};
+  const { workspaces = [] } = rootPackage.packageObject;
+  workspaces.forEach((workspace) => {
+    const workspaceUrl = new URL(workspace, rootPackageUrl).href;
+    const workspaceRelativeUrl = urlToRelativeUrl(workspaceUrl, rootPackageUrl);
+    const pattern = `${workspaceRelativeUrl}/package.json`;
+    patterns[pattern] = true;
+  });
+
+  const packageDirectoryUrls = await listFilesMatching({
+    directoryUrl,
+    patterns,
+  });
+  packageDirectoryUrls.forEach((packageDirectoryUrl) => {
+    const packageUrl = new URL("package.json", packageDirectoryUrl);
+    const packageFileInfo = readPackageFile(packageUrl);
+    workspacePackages[packageFileInfo.object.name] = {
+      packageUrl,
+      packageObject: packageFileInfo.object,
+      updateFile: packageFileInfo.updateFile,
+    };
+  });
+  return workspacePackages;
+};
+
+const readPackageFile = (url) => {
+  const packageFileContent = String(readFileSync(new URL(url)));
+  const hasFinalNewLine =
+    packageFileContent[packageFileContent.length - 1] === "\n";
+  return {
+    object: JSON.parse(packageFileContent),
+    updateFile: (data) => {
+      let dataAsJson = JSON.stringify(data, null, "  ");
+      if (hasFinalNewLine) {
+        dataAsJson += "\n";
+      }
+      writeFileSync(new URL(url), dataAsJson);
+    },
+  };
+};

package/src/internal/compare_two_package_versions.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+// https://github.com/npm/node-semver#readme
+const {
+  gt: versionGreaterThan,
+  prerelease: versionToPrerelease,
+} = require("semver");
+
+export const VERSION_COMPARE_RESULTS = {
+  SAME: "same",
+  GREATER: "greater",
+  SMALLER: "smaller",
+  DIFF_TAG: "diff_tag",
+};
+
+export const compareTwoPackageVersions = (firstVersion, secondVersion) => {
+  if (firstVersion === secondVersion) {
+    return VERSION_COMPARE_RESULTS.SAME;
+  }
+  if (versionGreaterThan(firstVersion, secondVersion)) {
+    return VERSION_COMPARE_RESULTS.GREATER;
+  }
+  const firstVersionPrerelase = versionToPrerelease(firstVersion);
+  const secondVersionPrerelease = versionToPrerelease(secondVersion);
+  if (firstVersionPrerelase === null && secondVersionPrerelease === null) {
+    return VERSION_COMPARE_RESULTS.SMALLER;
+  }
+  if (firstVersionPrerelase !== null && secondVersionPrerelease === null) {
+    return VERSION_COMPARE_RESULTS.SMALLER;
+  }
+  if (firstVersionPrerelase === null && secondVersionPrerelease !== null) {
+    return VERSION_COMPARE_RESULTS.SMALLER;
+  }
+  const [firstReleaseTag, firstPrereleaseVersion] = firstVersionPrerelase;
+  const [secondReleaseTag, secondPrereleaseVersion] = firstVersionPrerelase;
+  if (firstReleaseTag !== secondReleaseTag) {
+    return VERSION_COMPARE_RESULTS.DIFF_TAG;
+  }
+  if (firstPrereleaseVersion === secondPrereleaseVersion) {
+    return VERSION_COMPARE_RESULTS.SAME;
+  }
+  if (firstPrereleaseVersion > secondPrereleaseVersion) {
+    return VERSION_COMPARE_RESULTS.GREATER;
+  }
+  return VERSION_COMPARE_RESULTS.SMALLER;
+};

package/src/internal/dependency_graph.js

@@ -0,0 +1,65 @@
+export const buildDependencyGraph = (workspacePackages) => {
+  const dependencyGraph = {};
+  Object.keys(workspacePackages).forEach((packageName) => {
+    dependencyGraph[packageName] = {
+      dependencies: [],
+    };
+  });
+  const findDependency = (packageName, dependencyName) => {
+    const trace = [];
+    const visit = (name) => {
+      if (name === dependencyName) return true;
+      trace.push(name);
+      return dependencyGraph[name].dependencies.some((name) => visit(name));
+    };
+    const found = dependencyGraph[packageName].dependencies.some((name) => {
+      return visit(name);
+    });
+    return found ? trace : null;
+  };
+  const markPackageAsDependentOf = (packageName, dependencyName) => {
+    const dependencyTrace = findDependency(dependencyName, packageName);
+    if (dependencyTrace) {
+      throw new Error(
+        `Circular dependency between ${packageName} and ${dependencyName}`,
+      );
+    }
+    dependencyGraph[packageName].dependencies.push(dependencyName);
+  };
+  Object.keys(workspacePackages).forEach((packageName) => {
+    const workspacePackage = workspacePackages[packageName];
+    const { packageObject } = workspacePackage;
+    const { dependencies = {} } = packageObject;
+    Object.keys(dependencies).forEach((dependencyName) => {
+      const dependencyAsWorkspacePackage = workspacePackages[dependencyName];
+      if (dependencyAsWorkspacePackage) {
+        markPackageAsDependentOf(packageName, dependencyName);
+      }
+    });
+  });
+  return dependencyGraph;
+};
+
+export const orderByDependencies = (dependencyGraph) => {
+  const visited = [];
+  const sorted = [];
+  const visit = (packageName, importerPackageName) => {
+    const isSorted = sorted.includes(packageName);
+    if (isSorted) return;
+    const isVisited = visited.includes(packageName);
+    if (isVisited) {
+      throw new Error(
+        `Circular dependency between ${packageName} and ${importerPackageName}`,
+      );
+    }
+    visited.push(packageName);
+    dependencyGraph[packageName].dependencies.forEach((dependencyName) => {
+      visit(dependencyName, packageName);
+    });
+    sorted.push(packageName);
+  };
+  Object.keys(dependencyGraph).forEach((packageName) => {
+    visit(packageName);
+  });
+  return sorted;
+};

package/src/internal/fetch_workspace_latests.js

@@ -0,0 +1,37 @@
+import { createTaskLog } from "@jsenv/log";
+import { fetchLatestInRegistry } from "@jsenv/package-publish/src/internal/fetchLatestInRegistry.js";
+
+export const fetchWorkspaceLatests = async (workspacePackages) => {
+  const packageNames = Object.keys(workspacePackages);
+  let done = 0;
+  const total = packageNames.length;
+  const latestVersions = {};
+  const fetchTask = createTaskLog(`fetch latest versions`);
+  try {
+    await Promise.all(
+      packageNames.map(async (packageName) => {
+        const workspacePackage = workspacePackages[packageName];
+        if (workspacePackage.packageObject.private) {
+          latestVersions[packageName] = workspacePackage.packageObject.version;
+        } else {
+          const latestPackageInRegistry = await fetchLatestInRegistry({
+            registryUrl: "https://registry.npmjs.org",
+            packageName,
+          });
+          const registryLatestVersion =
+            latestPackageInRegistry === null
+              ? null
+              : latestPackageInRegistry.version;
+          latestVersions[packageName] = registryLatestVersion;
+        }
+        done++;
+        fetchTask.setRightText(`${done}/${total}`);
+      }),
+    );
+    fetchTask.done();
+    return latestVersions;
+  } catch (e) {
+    fetchTask.fail();
+    throw e;
+  }
+};

package/src/internal/increase_version.js

@@ -0,0 +1,13 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+// https://github.com/npm/node-semver#readme
+const { parse, inc } = require("semver");
+
+export const increaseVersion = (version) => {
+  const { prerelease } = parse(version);
+  if (prerelease.length === 0) {
+    return inc(version, "patch");
+  }
+  return inc(version, "prerelease", prerelease[0]);
+};

package/src/main.js

@@ -0,0 +1,3 @@
+export { upgradePackagesVersions } from "./upgrade_packages_versions.js";
+export { syncPackagesVersions } from "./sync_packages_versions.js";
+export { publishPackages } from "./publish_packages.js";

package/src/publish_packages.js

@@ -0,0 +1,61 @@
+import { createLogger, UNICODE } from "@jsenv/log";
+
+import { publish } from "@jsenv/package-publish/src/internal/publish.js";
+import { collectWorkspacePackages } from "./internal/collect_workspace_packages.js";
+import { fetchWorkspaceLatests } from "./internal/fetch_workspace_latests.js";
+import {
+  compareTwoPackageVersions,
+  VERSION_COMPARE_RESULTS,
+} from "./internal/compare_two_package_versions.js";
+
+export const publishPackages = async ({ directoryUrl }) => {
+  const workspacePackages = await collectWorkspacePackages({ directoryUrl });
+  const registryLatestVersions = await fetchWorkspaceLatests(workspacePackages);
+  const toPublishPackageNames = Object.keys(workspacePackages).filter(
+    (packageName) => {
+      const workspacePackage = workspacePackages[packageName];
+      const registryLatestVersion = registryLatestVersions[packageName];
+      if (registryLatestVersion === null) {
+        return true;
+      }
+      const result = compareTwoPackageVersions(
+        workspacePackage.packageObject.version,
+        registryLatestVersion,
+      );
+      return (
+        result === VERSION_COMPARE_RESULTS.GREATER ||
+        result === VERSION_COMPARE_RESULTS.DIFF_TAG
+      );
+    },
+  );
+  if (toPublishPackageNames.length === 0) {
+    console.log(`${UNICODE.OK} packages are published on registry`);
+    return;
+  }
+
+  const packageSlugs = toPublishPackageNames.map(
+    (name) => `${name}@${workspacePackages[name].packageObject.version}`,
+  );
+
+  console.log(`${UNICODE.INFO} ${
+    toPublishPackageNames.length
+  } packages to publish
+  - ${packageSlugs.join(`
+  - `)}`);
+  await toPublishPackageNames.reduce(
+    async (previous, toPublishPackageName, index) => {
+      await previous;
+      await publish({
+        logger: createLogger({ logLevel: "info" }),
+        packageSlug: packageSlugs[index],
+        rootDirectoryUrl: new URL(
+          "./",
+          workspacePackages[toPublishPackageName].packageUrl,
+        ),
+        registryUrl: "https://registry.npmjs.org",
+        token: process.env.NPM_TOKEN,
+      });
+    },
+    Promise.resolve(),
+  );
+};

package/src/sync_packages_versions.js

@@ -0,0 +1,222 @@
+import { UNICODE } from "@jsenv/log";
+
+import { collectWorkspacePackages } from "./internal/collect_workspace_packages.js";
+import {
+  buildDependencyGraph,
+  orderByDependencies,
+} from "./internal/dependency_graph.js";
+import { fetchWorkspaceLatests } from "./internal/fetch_workspace_latests.js";
+import {
+  compareTwoPackageVersions,
+  VERSION_COMPARE_RESULTS,
+} from "./internal/compare_two_package_versions.js";
+import { increaseVersion } from "./internal/increase_version.js";
+
+export const syncPackagesVersions = async ({
+  directoryUrl,
+  packagesRelations = {},
+}) => {
+  const workspacePackages = await collectWorkspacePackages({ directoryUrl });
+  const registryLatestVersions = await fetchWorkspaceLatests(workspacePackages);
+
+  const outdatedPackageNames = [];
+  const toPublishPackageNames = [];
+  Object.keys(workspacePackages).forEach((packageName) => {
+    const workspacePackage = workspacePackages[packageName];
+    const workspacePackageVersion = workspacePackage.packageObject.version;
+    const registryLatestVersion = registryLatestVersions[packageName];
+    const result =
+      registryLatestVersion === null
+        ? VERSION_COMPARE_RESULTS.GREATER
+        : compareTwoPackageVersions(
+            workspacePackageVersion,
+            registryLatestVersion,
+          );
+    if (result === VERSION_COMPARE_RESULTS.SMALLER) {
+      outdatedPackageNames.push(packageName);
+      return;
+    }
+    if (!workspacePackage.packageObject.private) {
+      if (
+        result === VERSION_COMPARE_RESULTS.GREATER ||
+        result === VERSION_COMPARE_RESULTS.DIFF_TAG
+      ) {
+        toPublishPackageNames.push(packageName);
+      }
+    }
+  });
+
+  const versionUpdates = [];
+  const dependencyUpdates = [];
+  if (outdatedPackageNames.length) {
+    outdatedPackageNames.forEach((outdatedPackageName) => {
+      const workspacePackage = workspacePackages[outdatedPackageName];
+      workspacePackage.packageObject.version =
+        registryLatestVersions[outdatedPackageName];
+      workspacePackage.updateFile(workspacePackage.packageObject);
+    });
+    console.warn(
+      `${UNICODE.WARNING} ${outdatedPackageNames.length} packages modified because they where outdated.
+Use a tool like "git diff" to see the new versions and ensure this is what you want`,
+    );
+    return {
+      versionUpdates,
+      dependencyUpdates,
+    };
+  }
+  if (toPublishPackageNames.length === 0) {
+    console.log(`${UNICODE.OK} packages are published on registry`);
+  } else {
+    console.log(
+      `${UNICODE.INFO} ${
+        toPublishPackageNames.length
+      } packages could be published
+  - ${toPublishPackageNames.map(
+    (name) => `${name}@${workspacePackages[name].packageObject.version}`,
+  ).join(`
+  - `)}`,
+    );
+  }
+
+  const packageFilesToUpdate = {};
+  const updateDependencyVersion = ({
+    packageName,
+    dependencyType,
+    dependencyName,
+    from,
+    to,
+  }) => {
+    const packageDeps =
+      workspacePackages[packageName].packageObject[dependencyType];
+    const version = packageDeps[dependencyName];
+    // ignore local deps
+    if (
+      version.startsWith("./") ||
+      version.startsWith("../") ||
+      version.startsWith("file:")
+    ) {
+      return;
+    }
+    dependencyUpdates.push({
+      packageName,
+      dependencyName,
+      from,
+      to,
+    });
+    packageDeps[dependencyName] = to;
+    packageFilesToUpdate[packageName] = true;
+  };
+  const updateVersion = ({ packageName, from, to }) => {
+    const workspacePackage = workspacePackages[packageName];
+    versionUpdates.push({
+      packageName,
+      from,
+      to,
+    });
+    workspacePackage.packageObject.version = to;
+    packageFilesToUpdate[packageName] = true;
+  };
+
+  const dependencyGraph = buildDependencyGraph(workspacePackages);
+  const packageNamesOrderedByDependency = orderByDependencies(dependencyGraph);
+  packageNamesOrderedByDependency.forEach((packageName) => {
+    const workspacePackage = workspacePackages[packageName];
+    const { dependencies = {} } = workspacePackage.packageObject;
+    Object.keys(dependencies).forEach((dependencyName) => {
+      const dependencyAsWorkspacePackage = workspacePackages[dependencyName];
+      if (!dependencyAsWorkspacePackage) {
+        return;
+      }
+      const versionInDependencies = dependencies[dependencyName];
+      const version = dependencyAsWorkspacePackage.packageObject.version;
+      if (versionInDependencies === version) {
+        return;
+      }
+      updateDependencyVersion({
+        packageName,
+        dependencyType: "dependencies",
+        dependencyName,
+        from: versionInDependencies,
+        to: version,
+      });
+      if (!toPublishPackageNames.includes(packageName)) {
+        updateVersion({
+          packageName,
+          from: workspacePackage.packageObject.version,
+          to: increaseVersion(workspacePackage.packageObject.version),
+        });
+        if (!workspacePackage.packageObject.private) {
+          toPublishPackageNames.push(packageName);
+        }
+      }
+    });
+  });
+  Object.keys(workspacePackages).forEach((packageName) => {
+    const workspacePackage = workspacePackages[packageName];
+    const { devDependencies = {} } = workspacePackage.packageObject;
+    Object.keys(devDependencies).forEach((devDependencyName) => {
+      const devDependencyAsWorkspacePackage =
+        workspacePackages[devDependencyName];
+      if (!devDependencyAsWorkspacePackage) {
+        return;
+      }
+      const versionInDevDependencies = devDependencies[devDependencyName];
+      const version = devDependencyAsWorkspacePackage.packageObject.version;
+      if (versionInDevDependencies === version) {
+        return;
+      }
+      updateDependencyVersion({
+        packageName,
+        dependencyType: "devDependencies",
+        dependencyName: devDependencyName,
+        from: versionInDevDependencies,
+        to: version,
+      });
+    });
+  });
+
+  Object.keys(packagesRelations).forEach((packageName) => {
+    const relatedPackageNames = packagesRelations[packageName];
+    const someRelatedPackageUpdated = relatedPackageNames.some(
+      (relatedPackageName) => {
+        return (
+          dependencyUpdates.some(
+            (dependencyUpdate) =>
+              dependencyUpdate.packageName === relatedPackageName,
+          ) ||
+          versionUpdates.some(
+            (versionUpdate) => versionUpdate.packageName === relatedPackageName,
+          )
+        );
+      },
+    );
+    if (someRelatedPackageUpdated) {
+      const packageInfo = workspacePackages[packageName];
+      updateVersion({
+        packageName,
+        from: packageInfo.packageObject.version,
+        to: increaseVersion(packageInfo.packageObject.version),
+      });
+    }
+  });
+
+  Object.keys(packageFilesToUpdate).forEach((packageName) => {
+    const workspacePackage = workspacePackages[packageName];
+    workspacePackage.updateFile(workspacePackage.packageObject);
+  });
+
+  const updateCount = versionUpdates.length + dependencyUpdates.length;
+  if (updateCount === 0) {
+    console.log(`${UNICODE.OK} all versions in package.json files are in sync`);
+  } else {
+    console.log(
+      `${UNICODE.INFO} ${updateCount} versions modified in package.json files
+  Use a tool like "git diff" to review these changes`,
+    );
+  }
+
+  return {
+    versionUpdates,
+    dependencyUpdates,
+  };
+};

package/src/upgrade_packages_versions.js

@@ -0,0 +1,57 @@
+import { UNICODE } from "@jsenv/log";
+
+import { collectWorkspacePackages } from "./internal/collect_workspace_packages.js";
+import { fetchWorkspaceLatests } from "./internal/fetch_workspace_latests.js";
+import {
+  compareTwoPackageVersions,
+  VERSION_COMPARE_RESULTS,
+} from "./internal/compare_two_package_versions.js";
+
+export const upgradePackagesVersions = async ({ directoryUrl }) => {
+  const workspacePackages = await collectWorkspacePackages({ directoryUrl });
+  const registryLatestVersions = await fetchWorkspaceLatests(workspacePackages);
+
+  const outdatedPackageNames = [];
+  const toPublishPackageNames = [];
+  Object.keys(workspacePackages).forEach((packageName) => {
+    const workspacePackage = workspacePackages[packageName];
+    const workspacePackageVersion = workspacePackage.packageObject.version;
+    const registryLatestVersion = registryLatestVersions[packageName];
+    const result =
+      registryLatestVersion === null
+        ? VERSION_COMPARE_RESULTS.GREATER
+        : compareTwoPackageVersions(
+            workspacePackageVersion,
+            registryLatestVersion,
+          );
+    if (result === VERSION_COMPARE_RESULTS.SMALLER) {
+      outdatedPackageNames.push(packageName);
+      return;
+    }
+    if (!workspacePackage.packageObject.private) {
+      if (
+        result === VERSION_COMPARE_RESULTS.GREATER ||
+        result === VERSION_COMPARE_RESULTS.DIFF_TAG
+      ) {
+        toPublishPackageNames.push(packageName);
+      }
+    }
+  });
+
+  const updates = [];
+  if (outdatedPackageNames.length === 0) {
+    console.log(`${UNICODE.OK} all versions are up-to-date`);
+    return updates;
+  }
+  for (const outdatedPackageName of outdatedPackageNames) {
+    const workspacePackage = workspacePackages[outdatedPackageName];
+    workspacePackage.packageObject.version =
+      registryLatestVersions[outdatedPackageName];
+    workspacePackage.updateFile(workspacePackage.packageObject);
+  }
+  console.log(
+    `${UNICODE.INFO} ${outdatedPackageNames.length} packages versions upgraded
+Use a tool like "git diff" to see the new versions then run "npm install"`,
+  );
+  return updates;
+};