@servicetitan/startup 28.5.0 → 29.0.0

package/src/cli/commands/__tests__/mfe-package-clean.test.ts

@@ -1,7 +1,7 @@
 import { fs, vol } from 'memfs';
 import { isWebComponent, log } from '../../../utils';
 import { gitGetBranch } from '../../utils/cli-git';
-import { npmGetPackageVersionDates, npmUnpublish } from '../../utils/cli-npm';
+import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../../utils/cli-npm';
 
 import { MFEPackageClean } from '../mfe-package-clean';
 
@@ -12,7 +12,7 @@ jest.mock('../../../utils', () => ({
     log: { error: jest.fn(), info: jest.fn() },
 }));
 jest.mock('../../utils/cli-npm', () => ({
-    npmGetPackageVersionDates: jest.fn(),
+    npmGetPackageVersionsDetails: jest.fn(),
     npmUnpublish: jest.fn(),
 }));
 jest.mock('../../utils/cli-git', () => ({
@@ -24,26 +24,26 @@ const DEFAULT_VERSIONS_TO_KEEP = 5;
 describe(`[startup] ${MFEPackageClean.name}`, () => {
     const registry = 'https://verdaccio.servicetitan.com';
     const packageName = '@servicetitan/foo';
+    let gitBranch: string;
     let args: ConstructorParameters<typeof MFEPackageClean>[0];
-    let versions: Record<string, Date>;
+    let versions: Version[];
 
     function getBranchVersions(branchName: string, length: number) {
-        return Object.fromEntries(
-            Array.from({ length }).map((_, index) => [
-                `0.0.0-${branchName}.${(0xff000000 + index).toString(16)}`,
-                dayAgo(index + 1), // tests assume versions are in reverse chronological order
-            ])
-        );
+        return Array.from({ length }).map((_, index) => ({
+            name: `0.0.0-${branchName}.${(0xff000000 + index).toString(16)}`,
+            date: dayAgo(index + 1), // tests assume versions are in reverse chronological order
+        }));
     }
 
     beforeEach(() => {
         args = {};
-        versions = getBranchVersions('master', 10);
+        gitBranch = 'master';
+        versions = getBranchVersions(gitBranch, 10);
 
         jest.resetAllMocks();
         jest.mocked(isWebComponent).mockReturnValue(true);
-        jest.mocked(npmGetPackageVersionDates).mockImplementation(() => Object.entries(versions));
-        jest.mocked(gitGetBranch).mockImplementation(() => 'current');
+        jest.mocked(npmGetPackageVersionsDetails).mockImplementation(() => versions);
+        jest.mocked(gitGetBranch).mockImplementation(() => gitBranch);
         vol.fromJSON({ 'package.json': JSON.stringify({ name: packageName }) });
     });
 
@@ -54,69 +54,91 @@ describe(`[startup] ${MFEPackageClean.name}`, () => {
     test('fetches package info from registry', async () => {
         await subject();
 
-        expect(npmGetPackageVersionDates).toHaveBeenCalledWith(registry, packageName);
+        expect(npmGetPackageVersionsDetails).toHaveBeenCalledWith(registry, packageName);
     });
 
-    function itLogsAndUnpublishedOldestPackages({ branch = 'master' }: { branch?: string } = {}) {
-        test('logs and unpublishes oldest packages', async () => {
-            const oldest = Object.entries(versions).slice(DEFAULT_VERSIONS_TO_KEEP);
+    function itLogsAndUnpublishedOldestPackages({
+        oldest,
+        title,
+    }: { branch?: string; oldest?: () => Record<string, Version[]>; title?: string } = {}) {
+        test(title ?? `logs and unpublishes oldest packages`, async () => {
+            const expected = oldest?.() ?? {
+                [gitBranch]: versions.slice(DEFAULT_VERSIONS_TO_KEEP),
+            };
 
             await subject();
 
             expect(log.info).toHaveBeenCalledWith(
                 'found versions for unpublish:',
-                JSON.stringify({ [branch]: oldest }, null, 4)
+                JSON.stringify(expected, null, 2)
             );
-            oldest.forEach(([version]) => {
-                expect(npmUnpublish).toHaveBeenCalledWith(registry, packageName, version);
-            });
+
+            Object.values(expected)
+                .flat()
+                .forEach(({ name }) => {
+                    expect(npmUnpublish).toHaveBeenCalledWith(registry, packageName, name);
+                });
         });
     }
 
-    itLogsAndUnpublishedOldestPackages();
-
-    describe.each(['dev', 'develop', 'next'])('when branch is %s', branch => {
+    describe.each(['dev', 'develop', 'master', 'next'])('when branch is %s', branch => {
         beforeEach(() => {
-            versions = transform(versions, (v: string) => v.replace('master', branch));
+            versions = transform(versions, name => name.replace(gitBranch, branch));
+            gitBranch = branch;
         });
 
-        itLogsAndUnpublishedOldestPackages({ branch });
+        itLogsAndUnpublishedOldestPackages();
     });
 
-    describe.each(['qa', true])('when selected branch is %s', (branch: string | true) => {
-        let branchedVersions: typeof versions = {};
-        const branchName = branch === true ? 'current' : branch;
+    describe('with versions from multiple branches', () => {
+        const otherBranch = 'next';
 
-        beforeEach(() => {
-            args.branch = branch;
+        beforeEach(() => (versions = [...versions, ...getBranchVersions(otherBranch, 7)]));
 
-            branchedVersions = getBranchVersions(branchName, 7);
-
-            versions = {
-                ...versions,
-                ...branchedVersions,
-            };
+        itLogsAndUnpublishedOldestPackages({
+            oldest: () => ({
+                [gitBranch]: versions
+                    .filter(({ name }) => name.includes(gitBranch))
+                    .slice(DEFAULT_VERSIONS_TO_KEEP),
+            }),
+            title: 'log and unpublishes oldest versions from the current branch',
         });
 
-        test(`logs and unpublishes oldest packages for ${branchName} branch`, async () => {
-            const oldest = Object.entries(branchedVersions).slice(DEFAULT_VERSIONS_TO_KEEP);
-
-            await subject();
+        describe('with --branch argument', () => {
+            beforeEach(() => (args.branch = otherBranch));
+
+            itLogsAndUnpublishedOldestPackages({
+                branch: otherBranch,
+                oldest: () => ({
+                    [otherBranch]: versions
+                        .filter(({ name }) => name.includes(otherBranch))
+                        .slice(DEFAULT_VERSIONS_TO_KEEP),
+                }),
+                title: 'logs and unpublishes oldest versions from the specified branch',
+            });
+        });
 
-            expect(log.info).toHaveBeenCalledWith(
-                'found versions for unpublish:',
-                JSON.stringify({ [branchName]: oldest }, null, 4)
-            );
-            oldest.forEach(([version]) => {
-                expect(npmUnpublish).toHaveBeenCalledWith(registry, packageName, version);
+        describe('with --all argument', () => {
+            beforeEach(() => (args.all = true));
+
+            itLogsAndUnpublishedOldestPackages({
+                oldest: () => ({
+                    [gitBranch]: versions
+                        .filter(({ name }) => name.includes(gitBranch))
+                        .slice(DEFAULT_VERSIONS_TO_KEEP),
+                    [otherBranch]: versions
+                        .filter(({ name }) => name.includes(otherBranch))
+                        .slice(DEFAULT_VERSIONS_TO_KEEP),
+                }),
+                title: 'logs and unpublishes oldest versions from all branches',
             });
         });
     });
 
     describe('with master versions generated by nerdbank versioning', () => {
         beforeEach(() => {
-            versions = transform(versions, (v: string, index: number) =>
-                v.replace(/master.*/, `${index}.0.0`)
+            versions = transform(versions, (name, index) =>
+                name.replace(/master.*/, `${index}.0.0`)
             );
         });
 
@@ -125,26 +147,78 @@ describe(`[startup] ${MFEPackageClean.name}`, () => {
 
     describe('with branch versions generated by nerdbank versioning', () => {
         beforeEach(() => {
-            versions = transform(versions, (v: string, index: number) =>
-                v.replace(/master.*/, `${index}.0.0-next-${index}`)
+            gitBranch = 'next';
+            versions = transform(versions, (name, index) =>
+                name.replace(/master.*/, `${index}.0.0-next-${index}`)
             );
         });
 
-        itLogsAndUnpublishedOldestPackages({ branch: 'next' });
+        itLogsAndUnpublishedOldestPackages();
     });
 
-    describe('with "count" argument', () => {
-        beforeEach(() => (args.count = Object.keys(versions).length - 1));
+    describe('with --count argument', () => {
+        beforeEach(() => (args.count = versions.length - 1));
 
         test('keeps the specified number of versions', async () => {
             await subject();
 
+            const oldest = versions.slice(args.count);
+
             expect(log.info).toHaveBeenCalledWith(
                 'found versions for unpublish:',
-                JSON.stringify({ master: Object.entries(versions).slice(-1) }, null, 4)
+                JSON.stringify({ master: oldest }, null, 2)
+            );
+
+            expect(npmUnpublish).toHaveBeenCalledTimes(oldest.length);
+        });
+    });
+
+    describe('with --registry argument', () => {
+        beforeEach(() => (args.registry = 'https://foo.com'));
+
+        test('fetches package info from specified registry', async () => {
+            await subject();
+
+            expect(npmGetPackageVersionsDetails).toHaveBeenCalledWith(args.registry, packageName);
+        });
+
+        test('unpublishes from the specified registry', async () => {
+            await subject();
+
+            expect(npmUnpublish).toHaveBeenCalledWith(
+                args.registry,
+                packageName,
+                expect.any(String)
             );
+        });
+    });
+
+    describe('with --dry argument', () => {
+        beforeEach(() => (args.dry = true));
+
+        test('does not unpublish packages', async () => {
+            await subject();
+
+            expect(npmUnpublish).not.toHaveBeenCalled();
+        });
+    });
 
-            expect(npmUnpublish).toHaveBeenCalledTimes(1);
+    describe('when version has a tag', () => {
+        const tag = 'prod';
+        let tagged: Version;
+
+        beforeEach(() => {
+            tagged = versions[DEFAULT_VERSIONS_TO_KEEP];
+            tagged.tag = tag;
+        });
+
+        test('does not unpublish tagged version', async () => {
+            await subject();
+
+            expect(npmUnpublish).toHaveBeenCalledTimes(DEFAULT_VERSIONS_TO_KEEP - 1);
+            expect(log.info).toHaveBeenCalledWith(
+                `ignoring version ${tagged.name} tagged "${tag}"`
+            );
         });
     });
 
@@ -158,9 +232,9 @@ describe(`[startup] ${MFEPackageClean.name}`, () => {
         test('logs error', async () => {
             await subject();
 
-            const firstUnpublishVersion = Object.entries(versions)[DEFAULT_VERSIONS_TO_KEEP][0];
+            const firstUnpublishVersion = versions[DEFAULT_VERSIONS_TO_KEEP];
             expect(log.error).toHaveBeenCalledWith(
-                `error while removing ${packageName} version ${firstUnpublishVersion}`
+                `error while removing ${packageName} version ${firstUnpublishVersion.name}`
             );
         });
     });
@@ -175,30 +249,31 @@ describe(`[startup] ${MFEPackageClean.name}`, () => {
     }
 
     describe('when version does not start with "0.0.0-"', () => {
-        beforeEach(() => {
-            versions = transform(versions, (v: string) => v.replace('0.0.0-', ''));
-        });
+        beforeEach(() => (versions = transform(versions, name => name.replace('0.0.0-', ''))));
 
         itDoesNotUnpublish();
     });
 
     describe('when branch is not recognized', () => {
-        beforeEach(() => {
-            versions = transform(versions, (v: string) => v.replace('master', 'foo'));
-        });
+        beforeEach(() => (versions = transform(versions, name => name.replace(gitBranch, 'foo'))));
 
         itDoesNotUnpublish();
     });
 
     describe('when version is not recognized', () => {
-        const unknownVersions = ['0.0.0-master-1^', '0.0.0-master-2^'];
+        const unknownVersions = [
+            { name: '0.0.0-master-1^', date: new Date() },
+            { name: '0.0.0-master-2^', date: new Date() },
+        ];
 
-        beforeEach(() => unknownVersions.forEach(version => (versions[version] = new Date())));
+        beforeEach(() => (versions = [...versions, ...unknownVersions]));
 
         test('logs unrecognized versions', async () => {
             await subject();
 
-            expect(log.info).toHaveBeenCalledWith('unknown versions:', unknownVersions.join());
+            unknownVersions.forEach(({ name }) => {
+                expect(log.info).toHaveBeenCalledWith(`skipping unrecognized version: ${name}`);
+            });
         });
     });
 
@@ -223,11 +298,6 @@ function dayAgo(count: number) {
     return date;
 }
 
-function transform(
-    versions: Record<string, Date>,
-    callback: (version: string, index: number) => string
-) {
-    return Object.fromEntries(
-        Object.entries(versions).map(([version, date], index) => [callback(version, index), date])
-    );
+function transform(versions: Version[], callback: (name: string, index: number) => string) {
+    return versions.map((v, index) => ({ ...v, name: callback(v.name, index) }));
 }

package/src/cli/commands/__tests__/mfe-package-publish.test.ts

@@ -6,7 +6,6 @@ import {
     npmGetPackageVersions,
     npmPackageSet,
     npmPublish,
-    npmPublishDry,
     npmTagVersion,
 } from '../../utils/cli-npm';
 import { MFEPackagePublish } from '../mfe-package-publish';
@@ -25,7 +24,6 @@ jest.mock('../../utils/cli-npm', () => ({
     npmGetPackageVersions: jest.fn(),
     npmPackageSet: jest.fn(),
     npmPublish: jest.fn(),
-    npmPublishDry: jest.fn(),
     npmTagVersion: jest.fn(),
 }));
 
@@ -108,7 +106,7 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
     test('publishes package and logs message', async () => {
         await subject();
 
-        expect(npmPublish).toHaveBeenCalledWith('prod');
+        expect(npmPublish).toHaveBeenCalled();
         expect(log.info).toHaveBeenCalledWith(
             expect.stringContaining(`published ${packageName} version ${defaultPackageVersion()}`)
         );
@@ -119,10 +117,20 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
             describe.each(branches)('when branch is %s', branch => {
                 beforeEach(() => (args.branch = branch));
 
-                test(`uses tag ${tag}`, async () => {
+                test(`uses tag "${tag}"`, async () => {
                     await subject();
 
-                    expect(npmPublish).toHaveBeenCalledWith(tag);
+                    expect(npmPublish).toHaveBeenCalledWith({ dry: false, tag });
+                });
+
+                describe('with "dry" argument', () => {
+                    beforeEach(() => (args.dry = true));
+
+                    test(`does dry run with tag "${tag}"`, async () => {
+                        await subject();
+
+                        expect(npmPublish).toHaveBeenCalledWith({ dry: true, tag });
+                    });
                 });
             });
         }
@@ -134,17 +142,7 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         test('uses specified tag', async () => {
             await subject();
 
-            expect(npmPublish).toHaveBeenCalledWith(args.tag);
-        });
-    });
-
-    describe('when "tag" is false', () => {
-        beforeEach(() => (args.tag = false));
-
-        test('omits the tag', async () => {
-            await subject();
-
-            expect(npmPublish).toHaveBeenCalledWith('');
+            expect(npmPublish).toHaveBeenCalledWith({ dry: false, tag: args.tag });
         });
     });
 
@@ -161,10 +159,9 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
     describe('with "dry" argument', () => {
         beforeEach(() => (args.dry = true));
 
-        test('does dry run and logs message', async () => {
+        test('logs message', async () => {
             await subject();
 
-            expect(npmPublishDry).toHaveBeenCalled();
             expect(log.info).toHaveBeenCalledWith(
                 expect.stringContaining(
                     `(dry-run) published ${packageName} version ${defaultPackageVersion()}`
@@ -263,10 +260,20 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         describe('with "force" argument"', () => {
             beforeEach(() => (args.force = true));
 
-            test('publishes the package', async () => {
+            test('publishes the package with tag "latest"', async () => {
                 await subject();
 
-                expect(npmPublish).toHaveBeenCalledWith('');
+                expect(npmPublish).toHaveBeenCalledWith({ dry: false, tag: 'latest' });
+            });
+
+            describe('with "dry" argument', () => {
+                beforeEach(() => (args.dry = true));
+
+                test(`does dry run with tag "latest"`, async () => {
+                    await subject();
+
+                    expect(npmPublish).toHaveBeenCalledWith({ dry: true, tag: 'latest' });
+                });
             });
         });
     });

package/src/cli/commands/__tests__/mfe-publish.test.ts

@@ -96,10 +96,13 @@ describe(`[startup] ${MFEPublish.name}`, () => {
             });
 
             type ArgumentName = keyof typeof args;
-            const testArgs: { name: ArgumentName; value: any; expected?: string }[] = [
-                { name: 'count', value: 10 },
+            const testArgs: { name: ArgumentName; value: any; expected?: string | string[] }[] = [
+                { name: 'all', value: true, expected: '--all' },
                 { name: 'branch', value: 'foo-123' },
-                { name: 'branch', value: true, expected: '--branch' },
+                { name: 'branch', value: true, expected: [] }, // check ignores obsolete --branch with no name
+                { name: 'count', value: 10 },
+                { name: 'dry', value: true, expected: '--dry' },
+                { name: 'registry', value: 'https://foo' },
             ];
 
             describe.each(testArgs)('with "{$name: $value}"', ({ name, value, expected }) => {
@@ -109,18 +112,22 @@ describe(`[startup] ${MFEPublish.name}`, () => {
                     await subject();
 
                     expect(lernaExec).toHaveBeenCalledWith(
-                        expect.objectContaining({ '--': [expected ?? `--${name} ${value}`] })
+                        expect.objectContaining({
+                            '--': Array.isArray(expected)
+                                ? expected
+                                : [expected ?? `--${name} ${value}`],
+                        })
                     );
                 });
             });
         });
 
         type ArgumentName = keyof typeof args;
-        const testArgs: { name: ArgumentName; value: any; expected?: string }[] = [
+        const testArgs: { name: ArgumentName; value: any; expected?: string | string[] }[] = [
             { name: 'build', value: true },
             { name: 'branch', value: 'foo-123' },
             { name: 'tag', value: 'foo' },
-            { name: 'tag', value: false, expected: '--no-tag' },
+            { name: 'tag', value: true, expected: [] }, // check ignores obsolete --tag with no name
             { name: 'dry', value: true, expected: '--dry' },
             { name: 'force', value: true, expected: '--force' },
             { name: 'registry', value: 'https://foo' },
@@ -133,7 +140,11 @@ describe(`[startup] ${MFEPublish.name}`, () => {
                 await subject();
 
                 expect(lernaExec).toHaveBeenCalledWith(
-                    expect.objectContaining({ '--': [expected ?? `--${name} ${value}`] })
+                    expect.objectContaining({
+                        '--': Array.isArray(expected)
+                            ? expected
+                            : [expected ?? `--${name} ${value}`],
+                    })
                 );
             });
         });

package/src/cli/commands/mfe-package-clean.ts

@@ -1,12 +1,15 @@
 import { isWebComponent, log, logErrors, readJson } from '../../utils';
-import { gitGetBranch } from '../utils/cli-git';
-import { npmGetPackageVersionDates, npmUnpublish } from '../utils/cli-npm';
 import { getBranchesConfigs } from '../../utils/get-branch-configs';
+import { gitGetBranch } from '../utils/cli-git';
+import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../utils/cli-npm';
 import { Command } from './types';
 
 export interface ArgsPackageClean {
-    branch?: string | true;
+    all?: true;
+    branch?: string;
     count?: number;
+    dry?: boolean;
+    registry?: string;
 }
 
 export class MFEPackageClean implements Command {
@@ -23,37 +26,34 @@ export class MFEPackageClean implements Command {
         }
 
         const data = this.getCleanData();
-        const packageJson = readJson('package.json');
-        const packageName = packageJson.name;
+        const packageName = readJson('package.json').name;
         const branchedVersions = this.getBranchedVersions(packageName, data.registry);
 
-        log.info(
-            `branched versions (${data.count}):`,
-            JSON.stringify(branchedVersions, undefined, 4)
-        );
-
-        const branchedVersionsToClean: Record<string, [string, Date][]> = {};
+        log.info(`branched versions (${data.count}):`, JSON.stringify(branchedVersions, null, 2));
 
-        for (const branch of Object.keys(branchedVersions)) {
-            // limit branches for now
-            if (!branchedVersions[branch] || !data.branches.includes(branch)) {
+        const branchedVersionsToClean: Record<string, Version[]> = {};
+        for (const [branch, versions] of Object.entries(branchedVersions)) {
+            // Limit branches for now
+            if (!data.branches.includes(branch)) {
+                log.info(`ignoring unrecognized branch "${branch}"`);
                 continue;
             }
 
-            branchedVersions[branch].sort(([, adt], [, bdt]) => (adt > bdt ? -1 : 1));
-            branchedVersionsToClean[branch] = branchedVersions[branch].slice(data.count);
+            branchedVersionsToClean[branch] = this.excludeTagged(versions)
+                .sort(({ date: adt }, { date: bdt }) => (adt > bdt ? -1 : 1))
+                .slice(data.count);
         }
 
-        log.info(
-            'found versions for unpublish:',
-            JSON.stringify(branchedVersionsToClean, undefined, 4)
-        );
-
+        log.info('found versions for unpublish:', JSON.stringify(branchedVersionsToClean, null, 2));
         const unVersions = Object.keys(branchedVersionsToClean).reduce(
-            (out, br) => [...out, ...branchedVersionsToClean[br].map(([v]) => v)],
+            (out, br) => [...out, ...branchedVersionsToClean[br].map(({ name }) => name)],
             []
         );
 
+        if (this.args.dry) {
+            return;
+        }
+
         for (const version of unVersions) {
             try {
                 // eslint-disable-next-line no-await-in-loop
@@ -64,6 +64,16 @@ export class MFEPackageClean implements Command {
         }
     }
 
+    private excludeTagged(versions: Version[]) {
+        return versions.filter(({ name, tag }) => {
+            if (tag) {
+                log.info(`ignoring version ${name} tagged "${tag}"`);
+                return false;
+            }
+            return true;
+        });
+    }
+
     private getCleanData(): {
         count: number;
         registry: string;
@@ -76,66 +86,57 @@ export class MFEPackageClean implements Command {
 
         let branches: string[];
 
-        if (this.args.branch === true) {
-            branches = [gitGetBranch()];
+        if (this.args.all === true) {
+            branches = Object.keys(getBranchesConfigs());
         } else if (typeof this.args.branch === 'string') {
             branches = [this.args.branch];
         } else {
-            branches = Object.keys(getBranchesConfigs());
+            branches = [gitGetBranch()];
         }
 
-        const registry = 'https://verdaccio.servicetitan.com';
+        const registry = this.args.registry ?? 'https://verdaccio.servicetitan.com';
 
         return { count, registry, branches };
     }
 
     private getBranchedVersions(packageName: string, registry: string) {
-        const versions = npmGetPackageVersionDates(registry, packageName);
-        const branchedVersions: Record<string, [string, Date][]> = {};
-        const unknownVersions: string[] = [];
-
-        const addVersion = (branch: string, version: string, dt: Date) => {
-            if (!branchedVersions[branch]) {
-                branchedVersions[branch] = [];
-            }
+        const versions = npmGetPackageVersionsDetails(registry, packageName);
+        const branchedVersions: Record<string, Version[]> = {};
 
-            branchedVersions[branch].push([version, dt]);
-        };
+        function addVersion(branch: string, version: Version) {
+            branchedVersions[branch] ??= [];
+            branchedVersions[branch].push(version);
+        }
 
-        for (const [version, dt] of versions) {
-            if (!version.startsWith('0.0.0-')) {
+        for (const version of versions) {
+            const { name } = version;
+            if (!name.startsWith('0.0.0-')) {
                 continue;
             }
 
-            const buildVersion = version.replace('0.0.0-', '');
+            const buildVersion = name.replace('0.0.0-', '');
 
+            // master version generated by nerdbank versioning
             if (/^(\d+)\.(\d+)\.(\d+)$/.test(buildVersion)) {
-                // master version generated by nerdbank versioning
-                addVersion('master', version, dt);
+                addVersion('master', version);
                 continue;
             }
 
+            // branch version generated by nerdbank versioning
             const match1 = buildVersion.match(/^(\d+)\.(\d+)\.(\d+)-([\dA-Za-z-]+).([\dA-Za-z]+)$/);
-
             if (match1?.length) {
-                // branch version generated by nerdbank versioning
-                addVersion(match1[4], version, dt);
+                addVersion(match1[4], version);
                 continue;
             }
 
+            // branch version generated by mfe-publisher versioning
             const match2 = buildVersion.match(/^([\dA-Za-z-]+).([\dA-Za-z]+)$/);
-
             if (match2?.length) {
-                // branch version generated by mfe-publisher versioning
-                addVersion(match2[1], version, dt);
+                addVersion(match2[1], version);
                 continue;
             }
 
-            unknownVersions.push(version);
-        }
-
-        if (unknownVersions.length) {
-            log.info('unknown versions:', unknownVersions.join());
+            log.info(`skipping unrecognized version: ${name}`);
         }
 
         return branchedVersions;