@jsenv/monorepo 0.4.5 → 0.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/monorepo",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "type": "module",
   "description": "Helpers to manage packages in a monorepo",
   "repository": {
@@ -23,10 +23,10 @@
     "/src/"
   ],
   "dependencies": {
-    "@jsenv/filesystem": "4.15.21",
-    "@jsenv/humanize": "1.8.0",
-    "@jsenv/package-publish": "1.11.52",
-    "@jsenv/urls": "2.9.11",
+    "@jsenv/filesystem": "4.15.22",
+    "@jsenv/humanize": "1.8.1",
+    "@jsenv/package-publish": "1.11.53",
+    "@jsenv/urls": "2.9.12",
     "semver": "7.8.5"
   },
   "publishConfig": {

package/src/internal/fetch_workspace_latests.js

@@ -6,7 +6,7 @@ export const fetchWorkspaceLatests = async (workspacePackages) => {
   let done = 0;
   const total = packageNames.length;
   const latestVersions = {};
-  const fetchTask = createTaskLog(`fetch latest versions`);
+  const fetchTask = createTaskLog(`fetch latest versions of workspace packages`);
   try {
     await Promise.all(
       packageNames.map(async (packageName) => {

package/src/publish_packages.js

@@ -1,24 +1,29 @@
-import { createLogger, UNICODE } from "@jsenv/humanize";
+import { createLogger, createTaskLog, UNICODE } from "@jsenv/humanize";
 import { publish } from "@jsenv/package-publish/src/internal/publish.js";
-import { collectWorkspacePackages } from "./internal/collect_workspace_packages.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 { fetchWorkspaceLatests } from "./internal/fetch_workspace_latests.js";
 import { syncPackagesVersions } from "./sync_packages_versions.js";
 
+const REGISTRY_URL = "https://registry.npmjs.org";
+
 export const publishPackages = async ({ directoryUrl, packagesRelations }) => {
-  const versionsInSync = await ensureVersionsAreInSync({
+  // 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 (!versionsInSync) {
+  if (!syncResult) {
     return;
   }
-
-  const workspacePackages = await collectWorkspacePackages({ directoryUrl });
-  const registryLatestVersions = await fetchWorkspaceLatests(workspacePackages);
+  const { workspacePackages, registryLatestVersions } = syncResult;
   const toPublishPackageNames = Object.keys(workspacePackages).filter(
     (packageName) => {
       const workspacePackage = workspacePackages[packageName];
@@ -41,31 +46,75 @@ export const publishPackages = async ({ directoryUrl, packagesRelations }) => {
     return;
   }
 
-  const packageSlugs = toPublishPackageNames.map(
-    (name) => `${name}@${workspacePackages[name].packageObject.version}`,
+  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(
+    ({ versionStatus }) => versionStatus === VERSION_STATUS.ABSENT,
+  );
+  const stagedPackages = packageInfos.filter(
+    ({ versionStatus }) => versionStatus === VERSION_STATUS.STAGED,
   );
 
-  console.log(`${UNICODE.INFO} ${
-    toPublishPackageNames.length
-  } packages to publish
-  - ${packageSlugs.join(`
+  if (packagesToPublish.length === 0 && stagedPackages.length === 0) {
+    console.log(`${UNICODE.OK} packages are published on registry`);
+    return;
+  }
+  if (packagesToPublish.length) {
+    console.log(`${UNICODE.INFO} ${packagesToPublish.length} packages to publish
+  - ${packagesToPublish.map(({ packageSlug }) => packageSlug).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(),
-  );
+  }
+  if (stagedPackages.length) {
+    console.log(`${UNICODE.INFO} ${stagedPackages.length} packages staged on registry, waiting for it to publish them
+  - ${stagedPackages.map(({ packageSlug }) => packageSlug).join(`
+  - `)}`);
+  }
+
+  // a staged version cannot be published again, the registry only needs time to
+  // expose it; the others go through "npm publish"
+  for (const { packageName, packageVersion } of stagedPackages) {
+    await waitForStagedVersionToLand({
+      registryUrl: REGISTRY_URL,
+      packageName,
+      packageVersion,
+      token,
+    });
+  }
+  for (const { packageSlug, rootDirectoryUrl } of packagesToPublish) {
+    await publish({
+      logger: createLogger({ logLevel: "info" }),
+      packageSlug,
+      rootDirectoryUrl,
+      registryUrl: REGISTRY_URL,
+      token,
+    });
+  }
 };
 
 /*
@@ -74,13 +123,18 @@ export const publishPackages = async ({ directoryUrl, packagesRelations }) => {
  * 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,
-    });
+  const {
+    outdatedPackageNames,
+    versionUpdates,
+    dependencyUpdates,
+    workspacePackages,
+    registryLatestVersions,
+  } = 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
@@ -88,11 +142,11 @@ const ensureVersionsAreInSync = async ({ directoryUrl, packagesRelations }) => {
   - `)}
 Run "npm run monorepo:sync_versions" and review the changes before publishing`,
     );
-    return false;
+    return null;
   }
   const outOfSyncCount = versionUpdates.length + dependencyUpdates.length;
   if (outOfSyncCount === 0) {
-    return true;
+    return { workspacePackages, registryLatestVersions };
   }
   console.warn(`${UNICODE.WARNING} versions are not in sync, ${outOfSyncCount} things must be updated in package.json files
   - ${[
@@ -108,10 +162,20 @@ Run "npm run monorepo:sync_versions" and review the changes before publishing`,
   const confirmed = await confirm(`Sync versions and publish?`);
   if (!confirmed) {
     console.log(`${UNICODE.INFO} publish aborted, versions are not in sync`);
-    return false;
+    return null;
   }
-  await syncPackagesVersions({ directoryUrl, packagesRelations });
-  return true;
+  // 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) => {

package/src/sync_packages_versions.js

@@ -17,9 +17,12 @@ export const syncPackagesVersions = async ({
   dryRun = false,
   directoryUrl,
   packagesRelations = {},
+  // when the caller already knows what is on the registry it can pass it here
+  // so that a single command does not fetch the same data twice
+  registryLatestVersions,
 }) => {
   const workspacePackages = await collectWorkspacePackages({ directoryUrl });
-  const registryLatestVersions = await fetchWorkspaceLatests(workspacePackages);
+  registryLatestVersions ??= await fetchWorkspaceLatests(workspacePackages);
 
   const outdatedPackageNames = [];
   const toPublishPackageNames = [];
@@ -68,6 +71,8 @@ Use a tool like "git diff" to see the new versions and ensure this is what you w
       );
     }
     return {
+      workspacePackages,
+      registryLatestVersions,
       outdatedPackageNames,
       versionUpdates,
       dependencyUpdates,
@@ -240,6 +245,8 @@ Use a tool like "git diff" to see the new versions and ensure this is what you w
   }
 
   return {
+    workspacePackages,
+    registryLatestVersions,
     outdatedPackageNames,
     versionUpdates,
     dependencyUpdates,

package/src/upgrade_external_versions.js

@@ -93,7 +93,7 @@ export const upgradeExternalVersions = async ({
   fetch_latest_versions: {
     let done = 0;
     const total = externalPackageNames.length;
-    const fetchTask = createTaskLog(`fetch latest versions`);
+    const fetchTask = createTaskLog(`fetch latest versions of external packages`);
     try {
       await Promise.all(
         externalPackageNames.map(async (externalPackageName) => {