@jsenv/monorepo 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/monorepo",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Helpers to manage packages in a monorepo",
   "license": "MIT",
   "author": {

package/src/main.js

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

package/src/sync_packages_versions.js

@@ -21,7 +21,7 @@ export const syncPackagesVersions = async ({
 
   const outdatedPackageNames = [];
   const toPublishPackageNames = [];
-  Object.keys(workspacePackages).forEach((packageName) => {
+  for (const packageName of Object.keys(workspacePackages)) {
     const workspacePackage = workspacePackages[packageName];
     const workspacePackageVersion = workspacePackage.packageObject.version;
     const registryLatestVersion = registryLatestVersions[packageName];
@@ -34,7 +34,7 @@ export const syncPackagesVersions = async ({
           );
     if (result === VERSION_COMPARE_RESULTS.SMALLER) {
       outdatedPackageNames.push(packageName);
-      return;
+      continue;
     }
     if (!workspacePackage.packageObject.private) {
       if (
@@ -44,7 +44,7 @@ export const syncPackagesVersions = async ({
         toPublishPackageNames.push(packageName);
       }
     }
-  });
+  }
 
   const versionUpdates = [];
   const dependencyUpdates = [];
@@ -116,95 +116,99 @@ Use a tool like "git diff" to see the new versions and ensure this is what you w
     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({
+  dependencies: {
+    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,
-          from: workspacePackage.packageObject.version,
-          to: increaseVersion(workspacePackage.packageObject.version),
+          dependencyType: "dependencies",
+          dependencyName,
+          from: versionInDependencies,
+          to: version,
         });
-        if (!workspacePackage.packageObject.private) {
-          toPublishPackageNames.push(packageName);
+        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),
+  }
+  dev_dependencies: {
+    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,
+        });
       });
-    }
-  });
-
+    });
+  }
+  package_relations: {
+    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`);

package/src/upgrade_external_versions.js

@@ -0,0 +1,162 @@
+import { UNICODE, createTaskLog } from "@jsenv/log";
+import { fetchLatestInRegistry } from "@jsenv/package-publish/src/internal/fetchLatestInRegistry.js";
+
+import { collectWorkspacePackages } from "./internal/collect_workspace_packages.js";
+
+import {
+  compareTwoPackageVersions,
+  VERSION_COMPARE_RESULTS,
+} from "./internal/compare_two_package_versions.js";
+
+export const upgradeExternalVersions = async ({ directoryUrl }) => {
+  const internalPackages = await collectWorkspacePackages({ directoryUrl });
+  let externalPackages = {};
+  collect_external_packages: {
+    const addExternalPackage = ({
+      internalPackageName,
+      name,
+      type,
+      version,
+    }) => {
+      // ignore local deps
+      if (
+        version.startsWith("./") ||
+        version.startsWith("../") ||
+        version.startsWith("file:")
+      ) {
+        return;
+      }
+      const existing = externalPackages[name];
+      if (existing) {
+        externalPackages[name].push({
+          internalPackageName,
+          type,
+          version,
+        });
+        return;
+      }
+      externalPackages[name] = [];
+      externalPackages[name].push({
+        internalPackageName,
+        type,
+        version,
+      });
+    };
+    for (const internalPackageName of Object.keys(internalPackages)) {
+      const internalPackage = internalPackages[internalPackageName];
+      const internalPackageObject = internalPackage.packageObject;
+      const {
+        dependencies = {},
+        devDependencies = {},
+        peerDependencies = {},
+      } = internalPackageObject;
+      const dependencyNames = Object.keys(dependencies);
+      dependencyNames.forEach((dependencyName) => {
+        addExternalPackage({
+          internalPackageName,
+          type: "dependencies",
+          name: dependencyName,
+          version: dependencies[dependencyName],
+        });
+      });
+      const devDependencyNames = Object.keys(devDependencies);
+      devDependencyNames.forEach((devDependencyName) => {
+        addExternalPackage({
+          internalPackageName,
+          type: "devDependencies",
+          name: devDependencyName,
+          version: dependencies[devDependencyName],
+        });
+      });
+      const peerDependencyNames = Object.keys(peerDependencies);
+      peerDependencyNames.forEach((peerDependencyName) => {
+        addExternalPackage({
+          internalPackageName,
+          type: "peerDependencies",
+          name: peerDependencyName,
+          version: dependencies[peerDependencyName],
+        });
+      });
+    }
+  }
+  const externalPackageNames = Object.keys(externalPackages);
+  console.log(
+    `${UNICODE.INFO} ${externalPackageNames.length} external packages found`,
+  );
+
+  const latestVersions = {};
+  fetch_latest_versions: {
+    let done = 0;
+    const total = externalPackageNames.length;
+    const fetchTask = createTaskLog(`fetch latest versions`);
+    try {
+      await Promise.all(
+        externalPackageNames.map(async (externalPackageName) => {
+          const latestPackageInRegistry = await fetchLatestInRegistry({
+            registryUrl: "https://registry.npmjs.org",
+            packageName: externalPackageName,
+          });
+          if (latestPackageInRegistry === null) {
+            throw new Error(`${externalPackageName} not found on NPM registry`);
+          }
+          const registryLatestVersion = latestPackageInRegistry.version;
+          latestVersions[externalPackageName] = registryLatestVersion;
+          done++;
+          fetchTask.setRightText(`${done}/${total}`);
+        }),
+      );
+      fetchTask.done();
+    } catch (e) {
+      fetchTask.fail();
+      throw e;
+    }
+  }
+
+  const packageFilesToUpdate = {};
+  const updates = [];
+  for (const externalPackageName of externalPackageNames) {
+    const externalPackageRefs = externalPackageNames[externalPackageName];
+    for (const externalPackageRef of externalPackageRefs) {
+      const internalPackageName = externalPackageRef.internalPackageName;
+      const internalPackageDeps =
+        internalPackages[internalPackageName].packageObject[
+          externalPackageRef.type
+        ];
+      const versionDeclared = internalPackageDeps[externalPackageName];
+      const registryLatestVersion = latestVersions[externalPackageName];
+      const comparisonResult = compareTwoPackageVersions(
+        versionDeclared,
+        registryLatestVersion,
+      );
+      if (comparisonResult === VERSION_COMPARE_RESULTS.GREATER) {
+        console.warn(
+          `${UNICODE.WARNING} ${externalPackageName} version declared in ${internalPackageName} "${externalPackageRef.type}" (${versionDeclared}) is greater than latest version in registry (${registryLatestVersion})`,
+        );
+        continue;
+      }
+      if (comparisonResult === VERSION_COMPARE_RESULTS.SMALLER) {
+        updates.push({
+          packageName: internalPackageName,
+          dependencyName: externalPackageName,
+          from: versionDeclared,
+          to: registryLatestVersion,
+        });
+        internalPackageDeps[externalPackageName] = registryLatestVersion;
+        packageFilesToUpdate[internalPackageName] = true;
+      }
+    }
+  }
+  Object.keys(packageFilesToUpdate).forEach((packageName) => {
+    const internalPackage = internalPackages[packageName];
+    internalPackage.updateFile(internalPackage.packageObject);
+  });
+  if (updates.length === 0) {
+    console.log(`${UNICODE.OK} all versions in package.json files are in sync`);
+  } else {
+    console.log(
+      `${UNICODE.INFO} ${updates.length} versions modified in package.json files
+  Use a tool like "git diff" to review these changes then run "npm install"`,
+    );
+  }
+  return updates;
+};

package/src/upgrade_packages_versions.js

@@ -1,57 +0,0 @@
-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;
-};