release-it 20.1.0 → 20.2.0

package/lib/plugin/npm/npm.js

@@ -215,6 +215,16 @@ class npm extends Plugin {
     return urlJoin(baseUrl, publicPath, this.getName());
   }
 
+  getStagedPackagesUrl() {
+    const name = this.getName();
+    const entity = name.startsWith('@') ? name.slice(1).split('/')[0] : this.getContext('username');
+    return entity ? `https://www.npmjs.com/settings/${entity}/staged-packages` : 'https://www.npmjs.com';
+  }
+
+  logWouldStage() {
+    this.log.log(`📦 Would stage (dry-run). Approve at ${this.getStagedPackagesUrl()} after a real run.`);
+  }
+
   getRegistry() {
     const { publishConfig } = this.getContext();
     const registries = publishConfig
@@ -278,13 +288,19 @@ class npm extends Plugin {
       ...fixArgs(publishArgs)
     ].filter(Boolean);
     const publishCommand = stage ? ['stage', 'publish'] : ['publish'];
-    const isInteractive = !this.config.isCI || Boolean(this.config.isPromptOnlyVersion);
+    const isInteractive = !stage && (!this.config.isCI || Boolean(this.config.isPromptOnlyVersion));
     return this.exec([publishPackageManager, ...publishCommand, ...args], {
       options: { ...getOptions(), interactive: isInteractive }
     })
-      .then(() => {
+      .then(output => {
         if (stage) {
-          this.setContext({ isStaged: true });
+          if (this.config.isDryRun) {
+            this.logWouldStage();
+          } else {
+            const id = output?.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)?.[0];
+            const approve = `${publishPackageManager} stage approve${id ? ` ${id}` : ''}`;
+            this.log.log(`📦 Staged, not yet published. Approve at ${this.getStagedPackagesUrl()} (or \`${approve}\`).`);
+          }
         } else {
           this.setContext({ isReleased: true });
           this.config.setContext({ isReleased: true });
@@ -293,6 +309,7 @@ class npm extends Plugin {
       .catch(err => {
         this.debug(err);
         if (this.config.isDryRun && /publish over the previously published version/.test(err)) {
+          if (stage) this.logWouldStage();
           return Promise.resolve();
         }
 
@@ -309,14 +326,9 @@ class npm extends Plugin {
   }
 
   afterRelease() {
-    const { isReleased, isStaged } = this.getContext();
+    const { isReleased } = this.getContext();
     if (isReleased) {
       this.log.log(`🔗 ${this.getPackageUrl()}`);
-    } else if (isStaged) {
-      const pm = this.options.publishPackageManager || 'npm';
-      this.log.log(
-        `📦 Staged for publishing. Approve with \`${pm} stage approve\` (see \`${pm} stage list\`) or on npmjs.com. Requires 2FA.`
-      );
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-it",
-  "version": "20.1.0",
+  "version": "20.2.0",
   "description": "Generic CLI tool to automate versioning and package publishing-related tasks.",
   "keywords": [
     "build",

package/test/npm.js

@@ -377,6 +377,47 @@ describe('npm', async () => {
     assert.deepEqual(exec.mock.calls.at(-1).arguments[0], ['pnpm', 'stage', 'publish', '.', '--tag', 'latest']);
   });
 
+  test('should print the staged-packages approval URL after stage publish', async t => {
+    const unscoped = await factory(npm, { options: { npm: { stage: true } } });
+    unscoped.setContext({ name: 'pkg', username: 'webpro' });
+    t.mock.method(unscoped.shell, 'exec', () => Promise.resolve());
+    await unscoped.publish();
+    assert.match(unscoped.log.log.mock.calls.map(c => c.arguments[0]).join('\n'), /settings\/webpro\/staged-packages/);
+
+    const scoped = await factory(npm, { options: { npm: { stage: true } } });
+    scoped.setContext({ name: '@release-it/x', username: 'webpro' });
+    t.mock.method(scoped.shell, 'exec', () => Promise.resolve());
+    await scoped.publish();
+    assert.match(scoped.log.log.mock.calls.map(c => c.arguments[0]).join('\n'), /settings\/release-it\/staged-packages/);
+  });
+
+  test('should surface the stage id from publish output in the approval message', async t => {
+    const npmClient = await factory(npm, { options: { npm: { stage: true } } });
+    npmClient.setContext({ name: 'pkg', username: 'webpro' });
+    const id = '71289309-c232-432b-a2d4-32a14fa08177';
+    t.mock.method(npmClient.shell, 'exec', () => Promise.resolve(`+ pkg@1.0.0 (staged with id ${id})`));
+    await npmClient.publish();
+    const logged = npmClient.log.log.mock.calls.map(c => c.arguments[0]).join('\n');
+    assert.match(logged, new RegExp(`npm stage approve ${id}`));
+  });
+
+  test('should describe a staged dry-run, whether npm resolves or rejects the un-bumped version', async t => {
+    const execs = [
+      () => Promise.resolve('staged with id 71289309-c232-432b-a2d4-32a14fa08177'),
+      () => Promise.reject(new Error('npm error You cannot publish over the previously published versions: 1.0.0.'))
+    ];
+    for (const exec of execs) {
+      const npmClient = await factory(npm, { options: { 'dry-run': true, npm: { stage: true } } });
+      npmClient.setContext({ name: 'pkg', username: 'webpro' });
+      t.mock.method(npmClient.shell, 'exec', exec);
+      await npmClient.publish();
+      const logged = npmClient.log.log.mock.calls.map(c => c.arguments[0]).join('\n');
+      assert.match(logged, /Would stage \(dry-run\)/);
+      assert.match(logged, /settings\/webpro\/staged-packages/);
+      assert.doesNotMatch(logged, /stage approve 71289309/);
+    }
+  });
+
   test('should skip checks', async () => {
     const options = { npm: { skipChecks: true } };
     const npmClient = await factory(npm, { options });