@jsenv/monorepo 0.3.17 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/monorepo",
-  "version": "0.3.17",
+  "version": "0.4.0",
   "type": "module",
   "description": "Helpers to manage packages in a monorepo",
   "repository": {

package/src/publish_packages.js

@@ -6,8 +6,17 @@ import {
   VERSION_COMPARE_RESULTS,
 } from "./internal/compare_two_package_versions.js";
 import { fetchWorkspaceLatests } from "./internal/fetch_workspace_latests.js";
+import { syncPackagesVersions } from "./sync_packages_versions.js";
+
+export const publishPackages = async ({ directoryUrl, packagesRelations }) => {
+  const versionsInSync = await ensureVersionsAreInSync({
+    directoryUrl,
+    packagesRelations,
+  });
+  if (!versionsInSync) {
+    return;
+  }
 
-export const publishPackages = async ({ directoryUrl }) => {
   const workspacePackages = await collectWorkspacePackages({ directoryUrl });
   const registryLatestVersions = await fetchWorkspaceLatests(workspacePackages);
   const toPublishPackageNames = Object.keys(workspacePackages).filter(
@@ -58,3 +67,69 @@ export const publishPackages = async ({ directoryUrl }) => {
     Promise.resolve(),
   );
 };
+
+/*
+ * Publishing while package.json files are not in sync would put on the registry
+ * packages depending on versions that do not exist (or are outdated).
+ * When versions are not in sync we ask permission to sync them before publishing.
+ */
+const ensureVersionsAreInSync = async ({ directoryUrl, packagesRelations }) => {
+  const { outdatedPackageNames, versionUpdates, dependencyUpdates } =
+    await syncPackagesVersions({
+      logs: false,
+      dryRun: true,
+      directoryUrl,
+      packagesRelations,
+    });
+  if (outdatedPackageNames.length) {
+    console.warn(
+      `${UNICODE.FAILURE} ${outdatedPackageNames.length} packages have a version older than the one published on registry
+  - ${outdatedPackageNames.join(`
+  - `)}
+Run "npm run monorepo:sync_versions" and review the changes before publishing`,
+    );
+    return false;
+  }
+  const outOfSyncCount = versionUpdates.length + dependencyUpdates.length;
+  if (outOfSyncCount === 0) {
+    return true;
+  }
+  console.warn(`${UNICODE.WARNING} versions are not in sync, ${outOfSyncCount} things must be updated in package.json files
+  - ${[
+    ...versionUpdates.map(
+      ({ packageName, from, to }) => `${packageName}: ${from} -> ${to}`,
+    ),
+    ...dependencyUpdates.map(
+      ({ packageName, dependencyName, from, to }) =>
+        `${packageName} -> ${dependencyName}: ${from} -> ${to}`,
+    ),
+  ].join(`
+  - `)}`);
+  const confirmed = await confirm(`Sync versions and publish?`);
+  if (!confirmed) {
+    console.log(`${UNICODE.INFO} publish aborted, versions are not in sync`);
+    return false;
+  }
+  await syncPackagesVersions({ directoryUrl, packagesRelations });
+  return true;
+};
+
+const confirm = async (question) => {
+  if (!process.stdin.isTTY) {
+    console.warn(
+      `${UNICODE.FAILURE} cannot ask confirmation (stdin is not a TTY)`,
+    );
+    return false;
+  }
+  const { createInterface } = await import("node:readline/promises");
+  const readlineInterface = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    const answer = await readlineInterface.question(`${question} (y/N) `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    readlineInterface.close();
+  }
+};

package/src/sync_packages_versions.js

@@ -14,6 +14,7 @@ import { shouldUpdateVersion } from "./internal/should_update_version.js";
 
 export const syncPackagesVersions = async ({
   logs = true,
+  dryRun = false,
   directoryUrl,
   packagesRelations = {},
 }) => {
@@ -50,35 +51,28 @@ export const syncPackagesVersions = async ({
   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.
+    if (!dryRun) {
+      outdatedPackageNames.forEach((outdatedPackageName) => {
+        const workspacePackage = workspacePackages[outdatedPackageName];
+        workspacePackage.packageObject.version =
+          registryLatestVersions[outdatedPackageName];
+        workspacePackage.updateFile(workspacePackage.packageObject);
+      });
+    }
+    if (logs) {
+      console.warn(
+        `${UNICODE.WARNING} ${outdatedPackageNames.length} packages ${
+          dryRun ? "are outdated" : "modified because they where outdated"
+        }.
 Use a tool like "git diff" to see the new versions and ensure this is what you want`,
-    );
+      );
+    }
     return {
+      outdatedPackageNames,
       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,
@@ -204,13 +198,33 @@ Use a tool like "git diff" to see the new versions and ensure this is what you w
             packageInfo.packageUrl,
           ),
         });
+        if (!toPublishPackageNames.includes(packageName)) {
+          toPublishPackageNames.push(packageName);
+        }
       }
     });
   }
-  Object.keys(packageFilesToUpdate).forEach((packageName) => {
-    const workspacePackage = workspacePackages[packageName];
-    workspacePackage.updateFile(workspacePackage.packageObject);
-  });
+  if (logs) {
+    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(`
+  - `)}`,
+      );
+    }
+  }
+  if (!dryRun) {
+    Object.keys(packageFilesToUpdate).forEach((packageName) => {
+      const workspacePackage = workspacePackages[packageName];
+      workspacePackage.updateFile(workspacePackage.packageObject);
+    });
+  }
   const updateCount = versionUpdates.length + dependencyUpdates.length;
   if (logs) {
     if (updateCount === 0) {
@@ -226,6 +240,7 @@ Use a tool like "git diff" to see the new versions and ensure this is what you w
   }
 
   return {
+    outdatedPackageNames,
     versionUpdates,
     dependencyUpdates,
   };