@servicetitan/startup 28.4.0 → 29.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/startup",
-    "version": "28.4.0",
+    "version": "29.0.0",
     "description": "",
     "homepage": "https://docs.st.dev/docs/frontend/startup",
     "repository": {
@@ -28,35 +28,35 @@
         "@types/yargs": "~17.0.24"
     },
     "dependencies": {
-        "@babel/preset-env": "~7.26.7",
+        "@babel/preset-env": "~7.26.9",
         "@jest/core": "~29.7.0",
         "@jest/types": "~29.6.3",
         "@jsdevtools/coverage-istanbul-loader": "^3.0.5",
-        "@servicetitan/eslint-config": "28.4.0",
-        "@servicetitan/stylelint-config": "28.4.0",
+        "@servicetitan/eslint-config": "29.0.0",
+        "@servicetitan/stylelint-config": "29.0.0",
         "@svgr/webpack": "^8.1.0",
         "@swc/core": "1.10.7",
         "@types/debug": "^4.1.12",
         "@types/jest": "~29.5.12",
         "chalk": "~4.1.2",
         "chokidar": "~4.0.3",
-        "cpx2": "7.0.1",
+        "cpx2": "8.0.0",
         "css-loader": "~7.1.2",
-        "css-minimizer-webpack-plugin": "^7.0.0",
+        "css-minimizer-webpack-plugin": "^7.0.2",
         "debug": "^4.4.0",
         "deepmerge": "~4.3.1",
-        "esbuild-loader": "~4.2.2",
+        "esbuild-loader": "~4.3.0",
         "eslint": "~8.57.0",
         "execa": "~5.1.1",
         "fork-ts-checker-webpack-plugin": "~9.0.2",
-        "glob": "~10.4.2",
+        "glob": "~11.0.1",
         "html-webpack-plugin": "~5.6.3",
         "identity-obj-proxy": "~3.0.0",
         "jest": "~29.7.0",
         "jest-circus": "~29.7.0",
         "jest-environment-jsdom": "^29.7.0",
         "jest-fetch-mock": "~3.0.3",
-        "lerna": "~8.1.9",
+        "lerna": "~8.2.1",
         "less": "~4.2.2",
         "less-loader": "~12.2.0",
         "less-plugin-npm-import": "~2.1.0",
@@ -67,22 +67,22 @@
         "moment-locales-webpack-plugin": "~1.2.0",
         "multimatch": "~5.0.0",
         "portfinder": "~1.0.32",
-        "postcss": "~8.5.1",
-        "prettier": "~3.4.2",
-        "sass": "~1.83.4",
-        "sass-loader": "~16.0.4",
+        "postcss": "~8.5.3",
+        "prettier": "~3.5.3",
+        "sass": "~1.85.1",
+        "sass-loader": "~16.0.5",
         "source-map-loader": "~5.0.0",
         "style-loader": "~4.0.0",
-        "stylelint": "~16.14.1",
+        "stylelint": "~16.16.0",
         "swc-loader": "0.2.6",
-        "terser-webpack-plugin": "^5.3.11",
-        "ts-jest": "29.2.5",
+        "terser-webpack-plugin": "^5.3.14",
+        "ts-jest": "29.2.6",
         "ts-loader": "~9.5.2",
         "ts-node": "~10.9.2",
         "typed-css-modules": "~0.9.1",
-        "typescript": "5.7.3",
+        "typescript": "5.8.2",
         "username": "~5.1.0",
-        "webpack": "~5.97.1",
+        "webpack": "~5.98.0",
         "webpack-assets-manifest": "~5.2.1",
         "webpack-bundle-analyzer": "^4.10.2",
         "webpack-dev-server": "~5.2.0",
@@ -93,14 +93,12 @@
         "xhr-mock": "~2.5.1",
         "yargs": "~17.7.2"
     },
-    "DEVELOPER_NOTES": {
-        "cpx2": "Must use 7.0.1 because later versions require glob 11.x which does not support Node 18"
-    },
+    "DEVELOPER_NOTES": {},
     "publishConfig": {
         "access": "public"
     },
     "cli": {
         "webpack": false
     },
-    "gitHead": "051b5b2f70ae6be345aa08ffdd49d8c049272940"
+    "gitHead": "67b2763ad7c21532ea47c920974f87e8de433d32"
 }

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/get-command.ts

@@ -14,9 +14,7 @@ import { PreparePackage } from './prepare-package';
 import { Start } from './start';
 import { StylesCheck } from './styles-check';
 import { Tests } from './tests';
-import { Command } from './types';
-
-type Newable<T> = new (...args: any[]) => T;
+import { Command, Newable } from './types';
 
 export function getCommand(name: CommandName): Newable<Command> | undefined {
     switch (name) {