implement pack for base publish provider and use in both providers

Author: TheLarkInn

common/reviews/api/rush-lib.api.md

@@ -832,6 +832,7 @@ export interface IPublishProjectInfo {
 // @beta
 export interface IPublishProvider {
     checkExistsAsync(options: IPublishProviderCheckExistsOptions): Promise<boolean>;
+    packAsync(options: IPublishProviderPackOptions): Promise<void>;
     readonly providerName: string;
     publishAsync(options: IPublishProviderPublishOptions): Promise<void>;
 }
@@ -843,6 +844,14 @@ export interface IPublishProviderCheckExistsOptions {
     readonly version: string;
 }
 
+// @beta
+export interface IPublishProviderPackOptions {
+    readonly dryRun: boolean;
+    readonly logger: ILogger;
+    readonly projects: ReadonlyArray<IPublishProjectInfo>;
+    readonly releaseFolder: string;
+}
+
 // @beta
 export interface IPublishProviderPublishOptions {
     readonly dryRun: boolean;

libraries/rush-lib/src/cli/actions/PublishAction.ts

@@ -16,7 +16,6 @@ import { type IChangeInfo, ChangeType } from '../../api/ChangeManagement';
 import { type IPublishJson, PUBLISH_CONFIGURATION_FILE } from '../../api/PublishConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { RushCommandLineParser } from '../RushCommandLineParser';
-import { PublishUtilities } from '../../logic/PublishUtilities';
 import { ChangelogGenerator } from '../../logic/ChangelogGenerator';
 import { PrereleaseToken } from '../../logic/PrereleaseToken';
 import { ChangeManager } from '../../logic/ChangeManager';
@@ -409,8 +408,8 @@ export class PublishAction extends BaseRushAction {
         };
 
         if (this._pack.value) {
-          // packs to tarball instead of publishing to NPM repository
-          await this._npmPackAsync(packageName, packageConfig);
+          // packs to distributable artifacts via publish providers
+          await this._packProjectViaProvidersAsync(packageConfig);
           await applyTagAsync(this._applyGitTagsOnPack.value);
         } else {
           const published: boolean = await this._publishProjectViaProvidersAsync(packageConfig);
@@ -500,45 +499,57 @@ export class PublishAction extends BaseRushAction {
     return published;
   }
 
-  private async _npmPackAsync(packageName: string, project: RushConfigurationProject): Promise<void> {
-    const args: string[] = ['pack'];
-    const env: { [key: string]: string | undefined } = PublishUtilities.getEnvArgs();
-
-    await PublishUtilities.execCommandAsync({
-      shouldExecute: this._publish.value,
-      command: this.rushConfiguration.packageManagerToolFilename,
-      args,
-      workingDirectory: project.publishFolder,
-      environment: env
+  /**
+   * Pack a project via all of its registered publish targets.
+   * Returns true if at least one target produced an artifact.
+   */
+  private async _packProjectViaProvidersAsync(project: RushConfigurationProject): Promise<boolean> {
+    let packed: boolean = false;
+    const version: string = project.packageJsonEditor.version;
+    const dryRun: boolean = !this._publish.value;
+    const logger: Logger = new Logger({
+      loggerName: 'publish',
+      terminalProvider: new ConsoleTerminalProvider({ verboseEnabled: false }),
+      getShouldPrintStacks: () => false
     });
 
-    if (this._publish.value) {
-      // Copy the tarball the release folder
-      const tarballName: string = this._calculateTarballName(project);
-      const tarballPath: string = path.join(project.publishFolder, tarballName);
-      const destFolder: string = this._releaseFolder.value
-        ? this._releaseFolder.value
-        : path.join(this.rushConfiguration.commonTempFolder, 'artifacts', 'packages');
-
-      FileSystem.move({
-        sourcePath: tarballPath,
-        destinationPath: path.join(destFolder, tarballName),
-        overwrite: true
-      });
-    }
-  }
+    // Determine the release folder
+    const releaseFolder: string = this._releaseFolder.value
+      ? this._releaseFolder.value
+      : path.join(this.rushConfiguration.commonTempFolder, 'artifacts', 'packages');
 
-  private _calculateTarballName(project: RushConfigurationProject): string {
-    // Same logic as how npm forms the tarball name
-    const packageName: string = project.packageName;
-    const name: string = packageName[0] === '@' ? packageName.substr(1).replace(/\//g, '-') : packageName;
+    // Ensure the release folder exists
+    FileSystem.ensureFolder(releaseFolder);
 
-    if (this.rushConfiguration.packageManager === 'yarn') {
-      // yarn tarballs have a "v" before the version number
-      return `${name}-v${project.packageJson.version}.tgz`;
-    } else {
-      return `${name}-${project.packageJson.version}.tgz`;
+    for (const target of project.publishTargets) {
+      if (target === 'none') {
+        continue;
+      }
+
+      const provider: IPublishProvider = await this._getProviderAsync(target, project.packageName);
+      const providerConfig: Record<string, unknown> | undefined = await this._getProviderConfigAsync(
+        project,
+        target
+      );
+
+      await provider.packAsync({
+        projects: [
+          {
+            project,
+            newVersion: version,
+            previousVersion: version,
+            changeType: ChangeType.none,
+            providerConfig
+          }
+        ],
+        releaseFolder,
+        dryRun,
+        logger
+      });
+      packed = true;
     }
+
+    return packed;
   }
 
   private _setDependenciesBeforePublish(): void {

libraries/rush-lib/src/index.ts

@@ -190,6 +190,7 @@ export type {
   IPublishProvider,
   IPublishProjectInfo,
   IPublishProviderPublishOptions,
+  IPublishProviderPackOptions,
   IPublishProviderCheckExistsOptions,
   PublishProviderFactory
 } from './pluginFramework/IPublishProvider';

libraries/rush-lib/src/pluginFramework/IPublishProvider.ts

@@ -85,6 +85,36 @@ export interface IPublishProviderCheckExistsOptions {
   readonly providerConfig: Record<string, unknown> | undefined;
 }
 
+/**
+ * Options passed to {@link IPublishProvider.packAsync}.
+ * @beta
+ */
+export interface IPublishProviderPackOptions {
+  /**
+   * The set of projects to pack.
+   */
+  readonly projects: ReadonlyArray<IPublishProjectInfo>;
+
+  /**
+   * The folder where packed artifacts should be placed.
+   * Corresponds to the `--release-folder` CLI parameter.
+   * When not specified, a default location is used
+   * (e.g., `<commonTempFolder>/artifacts/packages`).
+   */
+  readonly releaseFolder: string;
+
+  /**
+   * If true, the provider should perform all steps except the actual pack,
+   * logging what would have been done.
+   */
+  readonly dryRun: boolean;
+
+  /**
+   * A logger instance for reporting progress and errors.
+   */
+  readonly logger: ILogger;
+}
+
 /**
  * Interface for publish providers that handle publishing packages to a specific target
  * (e.g. npm registry, VS Code Marketplace).
@@ -106,6 +136,16 @@ export interface IPublishProvider {
    */
   publishAsync(options: IPublishProviderPublishOptions): Promise<void>;
 
+  /**
+   * Packs the specified projects into distributable artifacts for this provider's target.
+   * Each provider defines what "packing" means for its artifact type:
+   * - npm: runs `<packageManager> pack` to produce a `.tgz` tarball
+   * - vsix: runs `vsce package` to produce a `.vsix` file
+   *
+   * Artifacts are written to the `releaseFolder` specified in options.
+   */
+  packAsync(options: IPublishProviderPackOptions): Promise<void>;
+
   /**
    * Checks whether a specific version of a project already exists at the publish target.
    * Returns true if the version is already published.

libraries/rush-lib/src/pluginFramework/test/RushSession.test.ts

@@ -17,6 +17,7 @@ function createMockFactory(providerName: string): PublishProviderFactory {
   return async () => ({
     providerName,
     publishAsync: async () => {},
+    packAsync: async () => {},
     checkExistsAsync: async () => false
   });
 }

rush-plugins/rush-npm-publish-plugin/src/NpmPublishProvider.ts

@@ -11,6 +11,7 @@ import { FileSystem } from '@rushstack/node-core-library';
 import type {
   IPublishProvider,
   IPublishProviderPublishOptions,
+  IPublishProviderPackOptions,
   IPublishProviderCheckExistsOptions,
   IPublishProjectInfo
 } from '@rushstack/rush-sdk';
@@ -140,6 +141,58 @@ export class NpmPublishProvider implements IPublishProvider {
     return publishedVersions.indexOf(normalizedVersion) >= 0;
   }
 
+  public async packAsync(options: IPublishProviderPackOptions): Promise<void> {
+    const { projects, releaseFolder, dryRun, logger } = options;
+
+    for (const projectInfo of projects) {
+      const { project, newVersion } = projectInfo;
+      const packageName: string = project.packageName;
+      const publishFolder: string = project.publishFolder;
+
+      logger.terminal.writeLine(`Packing ${packageName}@${newVersion} as npm tarball...`);
+
+      const args: string[] = ['pack'];
+      const env: Record<string, string | undefined> = { ...process.env };
+      const packageManagerToolFilename: string = project.rushConfiguration.packageManagerToolFilename;
+
+      if (dryRun) {
+        logger.terminal.writeLine(
+          `  [DRY RUN] Would execute: ${packageManagerToolFilename} ${args.join(' ')}`
+        );
+        logger.terminal.writeLine(`  Working directory: ${publishFolder}`);
+      } else {
+        await this._executeCommandAsync(packageManagerToolFilename, args, publishFolder, env);
+
+        // Move the tarball to the release folder
+        const tarballName: string = this._calculateTarballName(project);
+        const tarballPath: string = path.join(publishFolder, tarballName);
+
+        FileSystem.move({
+          sourcePath: tarballPath,
+          destinationPath: path.join(releaseFolder, tarballName),
+          overwrite: true
+        });
+
+        logger.terminal.writeLine(`  Packed ${packageName}@${newVersion} to ${tarballName}`);
+      }
+    }
+  }
+
+  /**
+   * Calculate the tarball filename using npm's naming convention.
+   */
+  private _calculateTarballName(project: IPublishProjectInfo['project']): string {
+    const packageName: string = project.packageName;
+    const name: string =
+      packageName[0] === '@' ? packageName.substring(1).replace(/\//g, '-') : packageName;
+
+    if (project.rushConfiguration.packageManager === 'yarn') {
+      return `${name}-v${project.packageJson.version}.tgz`;
+    } else {
+      return `${name}-${project.packageJson.version}.tgz`;
+    }
+  }
+
   /**
    * Configure the HOME directory to use .npmrc-publish from the Rush config.
    */