@jsenv/monorepo 0.4.12 → 0.4.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/monorepo",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "type": "module",
   "description": "Helpers to manage packages in a monorepo",
   "repository": {
@@ -23,10 +23,10 @@
     "/src/"
   ],
   "dependencies": {
-    "@jsenv/filesystem": "4.15.27",
-    "@jsenv/humanize": "1.8.5",
-    "@jsenv/package-publish": "1.11.58",
-    "@jsenv/urls": "2.9.16",
+    "@jsenv/filesystem": "4.15.28",
+    "@jsenv/humanize": "1.8.6",
+    "@jsenv/package-publish": "1.11.59",
+    "@jsenv/urls": "2.9.17",
     "semver": "7.8.5"
   },
   "publishConfig": {

package/src/internal/collect_unpublished_packages.js

@@ -0,0 +1,73 @@
+import { createTaskLog } from "@jsenv/humanize";
+import {
+  checkVersionStatusInRegistry,
+  VERSION_STATUS,
+} from "@jsenv/package-publish/src/internal/staged_version.js";
+import {
+  compareTwoPackageVersions,
+  VERSION_COMPARE_RESULTS,
+} from "./compare_two_package_versions.js";
+
+/*
+ * The workspace packages whose version is not published on the registry, each
+ * with its status there: absent, or staged (the registry has it but does not
+ * expose it yet)
+ */
+export const collectUnpublishedPackages = async ({
+  workspacePackages,
+  registryLatestVersions,
+  registryUrl,
+  token,
+}) => {
+  const aheadPackageNames = 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 (aheadPackageNames.length === 0) {
+    return [];
+  }
+
+  const statusTask = createTaskLog(`check versions on registry`);
+  let packageInfos;
+  try {
+    packageInfos = await Promise.all(
+      aheadPackageNames.map(async (packageName) => {
+        const workspacePackage = workspacePackages[packageName];
+        const packageVersion = workspacePackage.packageObject.version;
+        const versionStatus = await checkVersionStatusInRegistry({
+          registryUrl,
+          packageName,
+          packageVersion,
+          token,
+        });
+        return {
+          packageName,
+          packageVersion,
+          packageSlug: `${packageName}@${packageVersion}`,
+          rootDirectoryUrl: new URL("./", workspacePackage.packageUrl),
+          versionStatus,
+        };
+      }),
+    );
+    statusTask.done();
+  } catch (e) {
+    statusTask.fail();
+    throw e;
+  }
+  return packageInfos.filter(
+    ({ versionStatus }) => versionStatus !== VERSION_STATUS.PUBLISHED,
+  );
+};

package/src/main.js

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

package/src/publish_packages.js

@@ -1,14 +1,10 @@
-import { createLogger, createTaskLog, UNICODE } from "@jsenv/humanize";
+import { createLogger, UNICODE } from "@jsenv/humanize";
 import { publish } from "@jsenv/package-publish/src/internal/publish.js";
 import {
-  checkVersionStatusInRegistry,
   VERSION_STATUS,
   waitForStagedVersionToLand,
 } from "@jsenv/package-publish/src/internal/staged_version.js";
-import {
-  compareTwoPackageVersions,
-  VERSION_COMPARE_RESULTS,
-} from "./internal/compare_two_package_versions.js";
+import { collectUnpublishedPackages } from "./internal/collect_unpublished_packages.js";
 import { syncPackagesVersions } from "./sync_packages_versions.js";
 
 const REGISTRY_URL = "https://registry.npmjs.org";
@@ -16,71 +12,24 @@ const REGISTRY_URL = "https://registry.npmjs.org";
 export const publishPackages = async ({ directoryUrl, packagesRelations }) => {
   // the sync check already read the package.json files and the registry;
   // it hands both back so that publishing does not do it a second time
-  const syncResult = await ensureVersionsAreInSync({
-    directoryUrl,
-    packagesRelations,
-  });
-  if (!syncResult) {
-    return;
-  }
-  const { workspacePackages, registryLatestVersions } = syncResult;
-  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 { workspacePackages, registryLatestVersions } =
+    await ensureVersionsAreInSync({
+      directoryUrl,
+      packagesRelations,
+    });
   const token = process.env.NPM_TOKEN;
-  const statusTask = createTaskLog(`check versions on registry`);
-  let packageInfos;
-  try {
-    packageInfos = await Promise.all(
-      toPublishPackageNames.map(async (packageName) => {
-        const workspacePackage = workspacePackages[packageName];
-        const packageVersion = workspacePackage.packageObject.version;
-        const versionStatus = await checkVersionStatusInRegistry({
-          registryUrl: REGISTRY_URL,
-          packageName,
-          packageVersion,
-          token,
-        });
-        return {
-          packageName,
-          packageVersion,
-          packageSlug: `${packageName}@${packageVersion}`,
-          rootDirectoryUrl: new URL("./", workspacePackage.packageUrl),
-          versionStatus,
-        };
-      }),
-    );
-    statusTask.done();
-  } catch (e) {
-    statusTask.fail();
-    throw e;
-  }
-  const packagesToPublish = packageInfos.filter(
+  const unpublishedPackages = await collectUnpublishedPackages({
+    workspacePackages,
+    registryLatestVersions,
+    registryUrl: REGISTRY_URL,
+    token,
+  });
+  const packagesToPublish = unpublishedPackages.filter(
     ({ versionStatus }) => versionStatus === VERSION_STATUS.ABSENT,
   );
-  const stagedPackages = packageInfos.filter(
+  const stagedPackages = unpublishedPackages.filter(
     ({ versionStatus }) => versionStatus === VERSION_STATUS.STAGED,
   );
-
   if (packagesToPublish.length === 0 && stagedPackages.length === 0) {
     console.log(`${UNICODE.OK} packages are published on registry`);
     return;
@@ -107,20 +56,24 @@ export const publishPackages = async ({ directoryUrl, packagesRelations }) => {
     });
   }
   for (const { packageSlug, rootDirectoryUrl } of packagesToPublish) {
-    await publish({
+    const { success } = await publish({
       logger: createLogger({ logLevel: "info" }),
       packageSlug,
       rootDirectoryUrl,
       registryUrl: REGISTRY_URL,
       token,
     });
+    if (!success) {
+      throw new Error(`failed to publish ${packageSlug}`);
+    }
   }
 };
 
 /*
  * 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.
+ * Syncing modifies package.json files, a change to review and commit, so it is
+ * never done here: the publish fails instead.
  */
 const ensureVersionsAreInSync = async ({ directoryUrl, packagesRelations }) => {
   const {
@@ -136,19 +89,16 @@ const ensureVersionsAreInSync = async ({ directoryUrl, packagesRelations }) => {
     packagesRelations,
   });
   if (outdatedPackageNames.length) {
-    console.warn(
-      `${UNICODE.FAILURE} ${outdatedPackageNames.length} packages have a version older than the one published on registry
+    throw new Error(
+      `${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 null;
   }
   const outOfSyncCount = versionUpdates.length + dependencyUpdates.length;
-  if (outOfSyncCount === 0) {
-    return { workspacePackages, registryLatestVersions };
-  }
-  console.warn(`${UNICODE.WARNING} versions are not in sync, ${outOfSyncCount} things must be updated in package.json files
+  if (outOfSyncCount) {
+    throw new Error(`versions are not in sync, ${outOfSyncCount} things must be updated in package.json files
   - ${[
     ...versionUpdates.map(
       ({ packageName, from, to }) => `${packageName}: ${from} -> ${to}`,
@@ -158,42 +108,8 @@ Run "npm run monorepo:sync_versions" and review the changes before publishing`,
         `${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 null;
-  }
-  // the dry run has mutated its own copy of the package objects; sync again on
-  // freshly read files (but with what the registry already told us) so that the
-  // updates are actually written and the package objects match the files
-  const syncResult = await syncPackagesVersions({
-    directoryUrl,
-    packagesRelations,
-    registryLatestVersions,
-  });
-  return {
-    workspacePackages: syncResult.workspacePackages,
-    registryLatestVersions,
-  };
-};
-
-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();
+  - `)}
+Run "npm run monorepo:sync_versions" and review the changes before publishing`);
   }
+  return { workspacePackages, registryLatestVersions };
 };

package/src/sync_packages_versions.js

@@ -74,6 +74,7 @@ Use a tool like "git diff" to see the new versions and ensure this is what you w
       workspacePackages,
       registryLatestVersions,
       outdatedPackageNames,
+      toPublishPackageNames,
       versionUpdates,
       dependencyUpdates,
     };
@@ -248,6 +249,7 @@ Use a tool like "git diff" to see the new versions and ensure this is what you w
     workspacePackages,
     registryLatestVersions,
     outdatedPackageNames,
+    toPublishPackageNames,
     versionUpdates,
     dependencyUpdates,
   };

package/src/wait_for_packages_publication.js

@@ -0,0 +1,43 @@
+/*
+ * Waits until every workspace package version is published on the registry.
+ * Meant for when publishing happens elsewhere (a CI workflow for instance):
+ * it tells when the versions found in package.json files can be installed.
+ */
+
+import { humanizeDuration, UNICODE } from "@jsenv/humanize";
+import { waitForVersionInRegistry } from "@jsenv/package-publish/src/internal/staged_version.js";
+import { collectUnpublishedPackages } from "./internal/collect_unpublished_packages.js";
+import { collectWorkspacePackages } from "./internal/collect_workspace_packages.js";
+import { fetchWorkspaceLatests } from "./internal/fetch_workspace_latests.js";
+
+const REGISTRY_URL = "https://registry.npmjs.org";
+
+export const waitForPackagesPublication = async ({
+  directoryUrl,
+  timeout = 15 * 60_000,
+}) => {
+  const workspacePackages = await collectWorkspacePackages({ directoryUrl });
+  const registryLatestVersions = await fetchWorkspaceLatests(workspacePackages);
+  const unpublishedPackages = await collectUnpublishedPackages({
+    workspacePackages,
+    registryLatestVersions,
+    registryUrl: REGISTRY_URL,
+  });
+  if (unpublishedPackages.length === 0) {
+    console.log(`${UNICODE.OK} packages are published on registry`);
+    return;
+  }
+  console.log(`${UNICODE.INFO} ${unpublishedPackages.length} packages not published on registry yet
+  - ${unpublishedPackages.map(({ packageSlug }) => packageSlug).join(`
+  - `)}`);
+  for (const { packageName, packageVersion } of unpublishedPackages) {
+    await waitForVersionInRegistry({
+      registryUrl: REGISTRY_URL,
+      packageName,
+      packageVersion,
+      timeout,
+      timeoutErrorMessage: `${packageName}@${packageVersion} is still not published on ${REGISTRY_URL} after ${humanizeDuration(timeout)}. Check whatever publishes it.`,
+    });
+  }
+  console.log(`${UNICODE.OK} packages are published on registry`);
+};