add setting release publisher to the publish step

Author: gagik

.github/workflows/prepare-release-mongosh.yml

@@ -26,19 +26,21 @@ jobs:
   prepare-release:
     runs-on: ubuntu-latest
     steps:
-      - name: Create Github App Token
-        uses: mongodb-js/devtools-shared/actions/setup-bot-token@main
+      - uses: mongodb-js/devtools-shared/actions/setup-bot-token@main
         id: app-token
         with:
           app-id: ${{ vars.DEVTOOLS_BOT_APP_ID }}
           private-key: ${{ secrets.DEVTOOLS_BOT_PRIVATE_KEY }}
 
-      - name: Checkout
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          # NOTE: this is necessary to get the full history
-          # and check if tags are already present
-          fetch-depth: 0
+          # don't checkout a detatched HEAD
+          ref: ${{ github.head_ref }}
+
+          # this is important so git log can pick up on
+          # the whole history to generate the list of AUTHORS
+          fetch-depth: "0"
+          token: ${{ steps.app-token.outputs.token }}
 
       - name: Setup Node.js Environment
         uses: actions/setup-node@v4
@@ -87,15 +89,15 @@ jobs:
       - name: Bump mongosh and package versions
         shell: bash
         env:
-          LAST_BUMP_COMMIT_MESSAGE: "chore(release): prepare for mongosh v${NEXT_VERSION} ${{ github.event.inputs.jiraTicket }}"
+          MONGOSH_RELEASE_VERSION: ${{ env.NEXT_VERSION }}
         run: |
           set -e
           echo Bumping mongosh versions to ${NEXT_VERSION} and packages
 
-          MONGOSH_RELEASE_VERSION=${NEXT_VERSION} npm run bump
+          npm run bump
             
           git add .
-          git commit --no-allow-empty -m "$LAST_BUMP_COMMIT_MESSAGE" || true
+          git commit --no-allow-empty -m "chore(release): prepare for mongosh v${NEXT_VERSION} ${{ github.event.inputs.jiraTicket }}" || true
 
       - name: Create Pull Request
         uses: peter-evans/create-pull-request@5e914681df9dc83aa4e4905692ca88beb2f9e91f # 7.0.5

.github/workflows/release-mongosh.yml

@@ -13,18 +13,22 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - name: Create Github App Token
-      uses: mongodb-js/devtools-shared/actions/setup-bot-token@main
+    - uses: mongodb-js/devtools-shared/actions/setup-bot-token@main
       id: app-token
       with:
         app-id: ${{ vars.DEVTOOLS_BOT_APP_ID }}
         private-key: ${{ secrets.DEVTOOLS_BOT_PRIVATE_KEY }}
-
+    
     - uses: actions/checkout@v4
       with:
         # don't checkout a detatched HEAD
         ref: ${{ github.head_ref }}
 
+        # this is important so git log can pick up on
+        # the whole history to generate the list of AUTHORS
+        fetch-depth: "0"
+        token: ${{ steps.app-token.outputs.token }}
+
     - name: Extract version from the branch
       run: |
         set -e
@@ -51,6 +55,7 @@ jobs:
     - name: "Publish what is not already in NPM"
       env:
         NPM_TOKEN: ${{ secrets.DEVTOOLSBOT_NPM_TOKEN }}
+        MONGOSH_RELEASE_PUBLISHER: ${{ github.triggering_actor }}
       run: |
         echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" >> ~/.npmrc
         npm config list

packages/build/src/npm-packages/bump.ts

@@ -8,6 +8,7 @@ import {
 import { promises as fs } from 'fs';
 import path from 'path';
 import { getPackagesInTopologicalOrder } from '@mongodb-js/monorepo-tools';
+import { getPackageConfigurations } from './helpers';
 
 /** Bumps only the main mongosh release packages to the set version. */
 export async function bumpMongoshReleasePackages(): Promise<void> {
@@ -17,21 +18,21 @@ export async function bumpMongoshReleasePackages(): Promise<void> {
       'MONGOSH_RELEASE_VERSION version not specified during mongosh bump'
     );
   }
-  console.info(`mongosh: Bumping package versions to ${version}`);
-  const monorepoRootPath = path.resolve(__dirname, '..', '..', '..', '..');
-  const packages = await getPackagesInTopologicalOrder(monorepoRootPath);
-
-  const workspaceNames = packages
-    .map((p) => p.name)
-    .filter((name) => MONGOSH_RELEASE_PACKAGES.includes(name));
 
-  const locations = [monorepoRootPath, ...packages.map((p) => p.location)];
+  console.info(`mongosh: Bumping package versions to ${version}`);
+  const packages = await getPackagesInTopologicalOrder(PROJECT_ROOT);
+  const packageConfigurations = await getPackageConfigurations(packages);
 
-  for (const location of locations) {
-    const packageJsonPath = path.join(location, 'package.json');
-    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+  const mongoshReleasePackages = packages.filter((packageInfo) =>
+    MONGOSH_RELEASE_PACKAGES.includes(packageInfo.name)
+  );
+  const workspaceNames = mongoshReleasePackages.map(
+    (packageInfo) => packageInfo.name
+  );
 
+  for (const [packageJsonPath, packageJson] of packageConfigurations) {
     packageJson.version = version;
+
     for (const grouping of [
       'dependencies',
       'devDependencies',

packages/build/src/npm-packages/helpers.spec.ts

@@ -0,0 +1,130 @@
+import { expect } from 'chai';
+import path from 'path';
+import type { SinonStub } from 'sinon';
+import sinon from 'sinon';
+import type { PackageInfo } from '@mongodb-js/monorepo-tools';
+import { getPackagesInTopologicalOrder } from '@mongodb-js/monorepo-tools';
+import { PROJECT_ROOT } from './constants';
+import { promises as fs } from 'fs';
+import {
+  getPackageConfigurations,
+  markBumpedFilesAsAssumeUnchanged,
+} from './helpers';
+
+describe('npm-packages helpers', function () {
+  before(function () {
+    if (process.version.startsWith('v16.')) return this.skip();
+  });
+
+  describe('markBumpedFilesAsAssumeUnchanged', function () {
+    let packages: PackageInfo[];
+    let expectedFiles: string[];
+    let spawnSync: SinonStub;
+
+    beforeEach(async function () {
+      expectedFiles = [
+        path.resolve(__dirname, '..', '..', '..', '..', 'lerna.json'),
+        path.resolve(__dirname, '..', '..', '..', '..', 'package.json'),
+        path.resolve(__dirname, '..', '..', '..', '..', 'package-lock.json'),
+      ];
+      packages = await getPackagesInTopologicalOrder(PROJECT_ROOT);
+      for (const { location } of packages) {
+        expectedFiles.push(path.resolve(location, 'package.json'));
+      }
+
+      spawnSync = sinon.stub();
+    });
+
+    it('marks files with --assume-unchanged', function () {
+      markBumpedFilesAsAssumeUnchanged(packages, true, spawnSync);
+      expectedFiles.forEach((f) => {
+        expect(spawnSync).to.have.been.calledWith(
+          'git',
+          ['update-index', '--assume-unchanged', f],
+          sinon.match.any
+        );
+      });
+    });
+
+    it('marks files with --no-assume-unchanged', function () {
+      markBumpedFilesAsAssumeUnchanged(packages, false, spawnSync);
+      expectedFiles.forEach((f) => {
+        expect(spawnSync).to.have.been.calledWith(
+          'git',
+          ['update-index', '--no-assume-unchanged', f],
+          sinon.match.any
+        );
+      });
+    });
+  });
+
+  describe('getPackageConfigurations', function () {
+    const packages: PackageInfo[] = [
+      {
+        name: 'package1',
+        version: '1.0.0',
+        location: '/packages/package1',
+        private: false,
+      },
+      {
+        name: 'package2',
+        version: '1.0.0',
+        location: '/packages/package2',
+        private: false,
+      },
+    ];
+    let readFileStub: sinon.SinonStub;
+
+    beforeEach(function () {
+      readFileStub = sinon.stub(fs, 'readFile').throws('Unexpected path');
+      readFileStub
+        .withArgs(path.join(packages[0].location, 'package.json'))
+        .resolves(
+          JSON.stringify({
+            name: packages[0].name,
+            version: packages[0].version,
+          })
+        )
+        .withArgs(path.join(packages[1].location, 'package.json'))
+        .resolves(
+          JSON.stringify({
+            name: packages[1].name,
+            version: packages[1].version,
+          })
+        );
+    });
+
+    afterEach(function () {
+      sinon.restore();
+    });
+
+    it('should return package configurations', async function () {
+      const result = await getPackageConfigurations(packages);
+
+      expect(result).to.deep.equal([
+        [
+          path.join(packages[0].location, 'package.json'),
+          {
+            name: packages[0].name,
+            version: packages[0].version,
+          },
+        ],
+        [
+          path.join(packages[1].location, 'package.json'),
+          {
+            name: packages[1].name,
+            version: packages[1].version,
+          },
+        ],
+      ]);
+
+      expect(readFileStub).has.callCount(2);
+      expect(readFileStub.firstCall.args[0]).to.equal(
+        path.join(packages[0].location, 'package.json')
+      );
+      expect(readFileStub.secondCall.args[0]).to.equal(
+        path.join(packages[1].location, 'package.json')
+      );
+    });
+  });
+});

packages/build/src/npm-packages/helpers.ts

@@ -0,0 +1,56 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import type { PackageInfo } from '@mongodb-js/monorepo-tools';
+import { PROJECT_ROOT } from './constants';
+import { spawnSync as spawnSyncFn } from '../helpers/spawn-sync';
+
+export async function getPackageConfigurations(
+  packages: PackageInfo[]
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<[path: string, contents: Record<string, any>][]> {
+  return Promise.all(
+    packages.map(async (packageInfo) => {
+      const packageJsonPath = path.join(packageInfo.location, 'package.json');
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const packageJsonContents: Record<string, any> = JSON.parse(
+        await fs.readFile(packageJsonPath, 'utf8')
+      );
+      return [packageJsonPath, packageJsonContents];
+    })
+  );
+}
+
+export function markBumpedFilesAsAssumeUnchanged(
+  packages: PackageInfo[],
+  assumeUnchanged: boolean,
+  spawnSync: typeof spawnSyncFn = spawnSyncFn
+): void {
+  const filesToAssume = [
+    path.resolve(PROJECT_ROOT, 'lerna.json'),
+    path.resolve(PROJECT_ROOT, 'package.json'),
+    path.resolve(PROJECT_ROOT, 'package-lock.json'),
+  ];
+  for (const { location } of packages) {
+    filesToAssume.push(path.resolve(location, 'package.json'));
+  }
+
+  for (const f of filesToAssume) {
+    spawnSync(
+      'git',
+      [
+        'update-index',
+        assumeUnchanged ? '--assume-unchanged' : '--no-assume-unchanged',
+        f,
+      ],
+      {
+        stdio: 'inherit',
+        cwd: PROJECT_ROOT,
+        encoding: 'utf8',
+      },
+      true
+    );
+    console.info(
+      `File ${f} is now ${assumeUnchanged ? '' : 'NOT '}assumed to be unchanged`
+    );
+  }
+}