@servicetitan/startup 32.2.0 → 32.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/startup",
-    "version": "32.2.0",
+    "version": "32.3.0",
     "description": "",
     "homepage": "https://docs.st.dev/docs/frontend/startup",
     "repository": {
@@ -25,6 +25,7 @@
     "bin": "./bin/index.js",
     "devDependencies": {
         "@types/cpx": "~1.5.5",
+        "@types/debug": "^4.1.12",
         "@types/eslint": "~9.6.1",
         "@types/less": "~3.0.8",
         "@types/lodash.memoize": "^4.1.9",
@@ -33,26 +34,26 @@
         "@types/yargs": "~17.0.24"
     },
     "dependencies": {
-        "@babel/preset-env": "~7.28.3",
+        "@babel/preset-env": "~7.28.5",
         "@jest/core": "~29.7.0",
         "@jest/types": "~29.6.3",
         "@jsdevtools/coverage-istanbul-loader": "^3.0.5",
-        "@servicetitan/eslint-config": "32.2.0",
-        "@servicetitan/stylelint-config": "32.2.0",
+        "@servicetitan/eslint-config": "32.3.0",
+        "@servicetitan/stylelint-config": "32.3.0",
         "@svgr/webpack": "^8.1.0",
         "@swc/cli": "^0.5.0",
         "@swc/core": "1.13.5",
-        "@types/debug": "^4.1.12",
         "@types/jest": "~29.5.12",
         "@vitest/coverage-v8": "^3.2.4",
         "chalk": "~4.1.2",
+        "cli-table3": "^0.6.5",
         "cpx2": "8.0.0",
         "css-loader": "~7.1.2",
         "css-minimizer-webpack-plugin": "^7.0.2",
         "debounce": "^2.2.0",
         "debug": "^4.4.3",
         "deepmerge": "~4.3.1",
-        "eslint": "~9.37.0",
+        "eslint": "~9.38.0",
         "execa": "~5.1.1",
         "glob": "~11.0.3",
         "html-webpack-plugin": "~5.6.4",
@@ -77,7 +78,7 @@
         "postcss": "~8.5.6",
         "prettier": "~3.6.2",
         "sass": "~1.93.2",
-        "sass-loader": "~16.0.5",
+        "sass-loader": "~16.0.6",
         "semver": "~7.7.3",
         "source-map-loader": "~5.0.0",
         "style-loader": "~4.0.0",
@@ -125,5 +126,5 @@
     "cli": {
         "webpack": false
     },
-    "gitHead": "76a83fea33e04809b97c72720751878b1e3002d7"
+    "gitHead": "201392862b3cb12500b3c8c4f6310b101b87201b"
 }

package/src/cli/commands/__tests__/build.test.ts

@@ -61,7 +61,7 @@ describe(`[startup] ${Build.name}`, () => {
     }
 
     test('command is greedy', () => {
-        expect(new Build(args).greedy).toBe(true);
+        expect(Build.greedy).toBe(true);
     });
 
     test('selects TSC and Webpack packages', async () => {

package/src/cli/commands/__tests__/bundle-package.test.ts

@@ -46,6 +46,16 @@ describe(`[startup] ${BundlePackage.name}`, () => {
         });
     });
 
+    describe('with "code-coverage"', () => {
+        beforeEach(() => (args.codeCoverage = true));
+
+        test('bundles with code coverage', async () => {
+            await subject();
+
+            expect(bundle).toHaveBeenCalledWith(expect.objectContaining({ codeCoverage: true }));
+        });
+    });
+
     describe('with "config"', () => {
         beforeEach(() => (args.config = 'foo.config.js'));
 
@@ -56,7 +66,7 @@ describe(`[startup] ${BundlePackage.name}`, () => {
         });
 
         describe('with "exposed-dependencies"', () => {
-            beforeEach(() => (args['exposed-dependencies'] = true));
+            beforeEach(() => (args.exposedDependencies = true));
 
             test('ignores config file', async () => {
                 await subject();
@@ -69,7 +79,7 @@ describe(`[startup] ${BundlePackage.name}`, () => {
     });
 
     describe('with "exposed-dependencies"', () => {
-        beforeEach(() => (args['exposed-dependencies'] = true));
+        beforeEach(() => (args.exposedDependencies = true));
 
         test('bundles exposed dependencies', async () => {
             await subject();
@@ -102,6 +112,16 @@ describe(`[startup] ${BundlePackage.name}`, () => {
         });
     });
 
+    describe('with "use-watch-config"', () => {
+        beforeEach(() => (args.useWatchConfig = true));
+
+        test('bundles package with useWatchConfig', async () => {
+            await subject();
+
+            expect(bundle).toHaveBeenCalledWith(expect.objectContaining({ useWatchConfig: true }));
+        });
+    });
+
     describe('when tsconfig\'s compilerOptions.module is not "esnext"', () => {
         beforeEach(() => {
             vol.fromJSON({

package/src/cli/commands/__tests__/install.test.ts

@@ -1,7 +1,7 @@
 import { vol, fs } from 'memfs';
 import { execSync } from 'child_process';
 import { getStartupVersion, log } from '../../../utils';
-import { gitCloneRepo, isCI } from '../../utils';
+import { gitCloneRepo, isCI, npmWhoAmI } from '../../utils';
 
 import { Install } from '../install';
 
@@ -11,6 +11,7 @@ jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     gitCloneRepo: jest.fn(),
     isCI: jest.fn(),
+    npmWhoAmI: jest.fn(),
 }));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
@@ -37,11 +38,12 @@ describe(`${Install.name}`, () => {
     }
 
     beforeEach(() => {
-        args = undefined;
+        args = {};
         jest.clearAllMocks();
         jest.mocked(gitCloneRepo).mockResolvedValue(true);
         jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
         jest.mocked(isCI).mockReturnValue(false);
+        jest.mocked(npmWhoAmI).mockReturnValue(undefined);
         jest.spyOn(fs, 'mkdtempSync').mockImplementation(() => tempDirPath);
         volFromJSON();
     });
@@ -105,7 +107,11 @@ describe(`${Install.name}`, () => {
         test('does not configure NPM token', async () => {
             await subject();
 
-            expect(execSync).not.toHaveBeenCalledWith(expect.stringMatching(/npm config/));
+            expect(gitCloneRepo).not.toHaveBeenCalled();
+            expect(execSync).not.toHaveBeenCalledWith(
+                expect.stringMatching(/npm config/),
+                expect.anything()
+            );
         });
     }
 
@@ -113,10 +119,29 @@ describe(`${Install.name}`, () => {
         test('does not delete project token', async () => {
             await subject();
 
-            expect(execSync).not.toHaveBeenCalledWith(expect.stringMatching(/npm config delete/));
+            expect(execSync).not.toHaveBeenCalledWith(
+                expect.stringMatching(/npm config delete/),
+                expect.anything()
+            );
         });
     }
 
+    describe('when "st-team" is already logged in', () => {
+        beforeEach(() => jest.mocked(npmWhoAmI).mockReturnValue('st-team'));
+
+        itDoesNotConfigureNpmToken();
+
+        describe('with --token', () => {
+            beforeEach(() => (args = { token: true }));
+
+            test('configures NPM token', async () => {
+                await subject();
+
+                expect(execSync).toHaveBeenCalledWith(expect.stringMatching(/npm config set/));
+            });
+        });
+    });
+
     describe('when .npmrc uses an environment variable', () => {
         beforeEach(() => {
             volFromJSON({
@@ -195,6 +220,19 @@ describe(`${Install.name}`, () => {
         itDoesNotConfigureNpmToken();
     });
 
+    describe('with --token', () => {
+        beforeEach(() => (args = { token: true }));
+
+        test('does not run "npm i"', async () => {
+            await subject();
+
+            expect(execSync).not.toHaveBeenCalledWith(
+                expect.stringMatching(/npm i/),
+                expect.anything()
+            );
+        });
+    });
+
     function itLogsError(message: string | RegExp) {
         test('logs error', async () => {
             await subject();

package/src/cli/commands/__tests__/lint.test.ts

@@ -39,7 +39,7 @@ describe(`[startup] ${Lint.name}`, () => {
     });
 
     test('command is greedy', () => {
-        expect(new Lint(args).greedy).toBe(true);
+        expect(Lint.greedy).toBe(true);
     });
 
     test('runs eslint directly', async () => {

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

@@ -0,0 +1,394 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { fs, vol } from 'memfs';
+import { createInterface } from 'readline/promises';
+import { formatRelativeDate, toArray } from '../../../utils';
+import { isTTY, npmView, npmWhoAmI, runCommand } from '../../utils';
+import { MFEList } from '../mfe-list';
+
+jest.mock('cli-table3');
+jest.mock('fs', () => fs);
+jest.mock('readline/promises', () => ({
+    createInterface: jest.fn(),
+}));
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    isTTY: jest.fn(),
+    npmView: jest.fn(),
+    npmWhoAmI: jest.fn(),
+    runCommand: jest.fn(),
+}));
+
+describe(`[startup] ${MFEList.name}`, () => {
+    const DEFAULT_LIMIT = 20;
+    const TOTAL_VERSIONS = DEFAULT_LIMIT + 1;
+    const mfeName = 'foo';
+    let distTags: Record<string, string>;
+    let time: Record<string, string>;
+    let args: ConstructorParameters<typeof MFEList>[0];
+
+    function volFromJSON(overrides: Record<string, any> = {}) {
+        vol.fromJSON({
+            'package.json': JSON.stringify({ workspaces: ['packages/*'] }),
+            'packages/lib/package.json': JSON.stringify({ name: 'lib' }),
+            'packages/mfe/package.json': JSON.stringify({
+                name: mfeName,
+                cli: { 'web-component': true },
+            }),
+            ...overrides,
+        });
+    }
+
+    beforeEach(() => {
+        const versions = Array.from(new Array(TOTAL_VERSIONS), makeVersion);
+        time = versions.reduce<Record<string, string>>((result, version, index) => {
+            result[version] = hourAgo(index + 1).toISOString();
+            return result;
+        }, {});
+        distTags = {
+            dev: versions[0],
+            other: versions[0], // version with multiple tags
+            qa: versions[5],
+            stage: versions[10],
+            prod: versions[15],
+            latest: versions[DEFAULT_LIMIT],
+        };
+        args = { _: [] }; // eslint-disable-line @typescript-eslint/naming-convention
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress output
+        jest.mocked(npmWhoAmI).mockReturnValue('Foo');
+        jest.mocked(npmView).mockImplementation(({ packageName }) => ({
+            'name': packageName,
+            'version': distTags?.latest,
+            'dist-tags': distTags,
+            'time': {
+                created: hourAgo(24).toDateString(),
+                modified: new Date().toISOString(),
+                ...time,
+            },
+        }));
+        volFromJSON();
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = () => new MFEList(args).execute();
+
+    function hourAgo(count: number) {
+        const date = new Date();
+        date.setHours(date.getHours() - count);
+        return date;
+    }
+
+    function makeVersion() {
+        const hash = Math.floor(Math.random() * 1e8).toString(16);
+        return `0.0.0-master.${hash}`;
+    }
+
+    interface ExpectTableInfo {
+        name: string;
+        tags: Record<string, string>;
+        versions: [string, string][];
+    }
+
+    function expectCaption({
+        name,
+        version,
+        total,
+    }: {
+        name: string;
+        version?: string;
+        total: number;
+    }) {
+        const caption = [
+            chalk.bold.cyan(name),
+            version && `version: ${version}`,
+            `versions: ${total}`,
+        ]
+            .filter(el => !!el)
+            .join(' | ');
+
+        expect(jest.mocked(process.stdout.write)).toHaveBeenCalledWith(caption + '\n');
+    }
+
+    function expectTable(info: ExpectTableInfo | ExpectTableInfo[]) {
+        if (Array.isArray(info) && info.length === 0) {
+            expect(jest.mocked(Table).mock.instances).toHaveLength(0);
+            return;
+        }
+
+        toArray(info).forEach(({ name, tags, versions }, index) => {
+            const table = jest.mocked(Table).mock.instances[index];
+            const pushes = jest.mocked(table.push).mock.calls.map((...args) => args[0][0]);
+
+            const versionTags = Object.entries(tags).reduce<Record<string, string[]>>(
+                (result, [tag, version]) => {
+                    result[version] = [...(result[version] ?? []), tag];
+                    return result;
+                },
+                {}
+            );
+
+            expectCaption({ name, version: tags.latest, total: TOTAL_VERSIONS });
+
+            expect(pushes).toEqual([
+                ...versions.map(([version, when]) => [
+                    version,
+                    versionTags[version] ? chalk.bold.cyan(versionTags[version].join(', ')) : '',
+                    formatRelativeDate(when),
+                ]),
+            ]);
+        });
+    }
+
+    function itOmitsTable() {
+        test('omits table', async () => {
+            await subject();
+
+            expectTable([]);
+        });
+    }
+
+    test(`outputs table with last ${DEFAULT_LIMIT} published versions`, async () => {
+        await subject();
+
+        expect(Table).toHaveBeenCalledWith({
+            head: ['Version', 'Tag', 'When'].map(title => chalk.bold.cyan(title)),
+            style: { head: [] },
+        });
+
+        expectTable({
+            name: mfeName,
+            tags: distTags,
+            versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+        });
+    });
+
+    describe('when MFE has no versions', () => {
+        beforeEach(() => {
+            jest.mocked(npmView).mockImplementation(
+                ({ packageName }) => ({ name: packageName }) as any
+            );
+        });
+
+        itOmitsTable();
+    });
+
+    describe('when MFE has no "latest" tag', () => {
+        beforeEach(() => delete distTags.latest);
+
+        test('outputs table', async () => {
+            await subject();
+
+            expectTable({
+                name: mfeName,
+                tags: distTags,
+                versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+            });
+        });
+    });
+
+    describe('with --tagged', () => {
+        beforeEach(() => (args.tagged = true));
+
+        test('outputs only tagged versions', async () => {
+            await subject();
+
+            expectTable({
+                name: mfeName,
+                tags: distTags,
+                versions: [...new Set(Object.values(distTags))].map(version => [
+                    version,
+                    time[version],
+                ]),
+            });
+        });
+
+        describe('when MFE has no tags', () => {
+            beforeEach(() => ((distTags as any) = undefined));
+
+            itOmitsTable();
+        });
+    });
+
+    describe('with --registry', () => {
+        beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
+
+        test('passes registry to npmView', async () => {
+            await subject();
+
+            expect(npmView).toHaveBeenCalledWith({
+                packageName: mfeName,
+                registry: args.registry,
+            });
+        });
+    });
+
+    describe('with --all', () => {
+        beforeEach(() => (args.all = true));
+
+        test('outputs all published versions', async () => {
+            await subject();
+
+            expectTable([
+                {
+                    name: mfeName,
+                    tags: distTags,
+                    versions: Object.entries(time),
+                },
+            ]);
+        });
+    });
+
+    describe('with --limit', () => {
+        beforeEach(() => (args.limit = 5));
+
+        test('outputs specified number of versions', async () => {
+            await subject();
+
+            expectTable([
+                {
+                    name: mfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, args.limit),
+                },
+            ]);
+        });
+    });
+
+    describe('when workspace has no MFEs', () => {
+        beforeEach(() => vol.reset());
+
+        itOmitsTable();
+    });
+
+    describe('when workspace has multiple MFEs', () => {
+        const otherMfeName = `${mfeName}2`; // ensure sorts after first name
+
+        beforeEach(() => {
+            volFromJSON({
+                'packages/mfe2/package.json': JSON.stringify({
+                    name: otherMfeName,
+                    cli: { 'web-component': true },
+                }),
+            });
+        });
+
+        test('outputs published versions for all MFEs', async () => {
+            await subject();
+
+            expectTable([
+                {
+                    name: mfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                },
+                {
+                    name: otherMfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                },
+            ]);
+        });
+
+        describe('with MFE name', () => {
+            beforeEach(() => (args._ = [otherMfeName]));
+
+            test('outputs only specified MFE', async () => {
+                await subject();
+
+                expectTable({
+                    name: otherMfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                });
+            });
+        });
+
+        describe('with --ignore', () => {
+            beforeEach(() => (args.ignore = mfeName));
+
+            test('omits specified MFE', async () => {
+                await subject();
+
+                expectTable({
+                    name: otherMfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                });
+            });
+        });
+
+        describe('with non-existent MFE name', () => {
+            beforeEach(() => {
+                jest.mocked(npmView).mockReturnValue(undefined);
+            });
+
+            itOmitsTable();
+        });
+    });
+
+    describe('when machine is not authorized', () => {
+        const readline = { question: jest.fn(), close: jest.fn() };
+        let answer: string;
+
+        beforeEach(() => {
+            answer = 'Y';
+            jest.mocked(readline.question).mockImplementation(() => Promise.resolve(answer));
+            jest.mocked(createInterface).mockReturnValue(readline as any);
+            jest.mocked(npmWhoAmI).mockReturnValue(undefined);
+            jest.mocked(isTTY).mockReturnValue(true);
+        });
+
+        test('prompts and authorizes machine', async () => {
+            await subject();
+
+            expect(readline.question).toHaveBeenCalledWith(
+                expect.stringMatching(/machine is not authorized.*Authorize\? \[Y\/n\]/)
+            );
+            expect(readline.close).toHaveBeenCalled();
+            expect(runCommand).toHaveBeenCalledWith(
+                'npx --yes verdaccio-okta-oauth@latest --registry=https://verdaccio.servicetitan.com',
+                { quiet: true }
+            );
+        });
+
+        describe('when user does not answer', () => {
+            beforeEach(() => (answer = ''));
+
+            test('authorizes machine', async () => {
+                await subject();
+
+                expect(runCommand).toHaveBeenCalled();
+            });
+        });
+
+        describe('when user declines', () => {
+            beforeEach(() => (answer = 'n'));
+
+            test('throws error', async () => {
+                await expect(subject()).rejects.toThrow(/Not authorized/);
+            });
+        });
+
+        describe('when terminal is not interactive', () => {
+            beforeEach(() => jest.mocked(isTTY).mockReturnValue(false));
+
+            test('skips prompt and throws error', async () => {
+                await expect(subject()).rejects.toThrow(/machine is not authorized/);
+
+                expect(readline.question).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('with --registry', () => {
+            beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
+
+            test('skips check whether machine is authorized', async () => {
+                await subject();
+
+                expect(npmWhoAmI).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

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

@@ -3,6 +3,8 @@ import { lernaExec } from '../../utils';
 import { Package, PackageType, getPackages } from '../../../utils';
 import { createPackage } from '../../../__mocks__';
 
+import { MFEPackageClean } from '../mfe-package-clean';
+import { MFEPackagePublish } from '../mfe-package-publish';
 import { MFEPublish } from '../mfe-publish';
 
 jest.mock('fs', () => fs);
@@ -209,4 +211,27 @@ describe(`[startup] ${MFEPublish.name}`, () => {
             });
         });
     });
+
+    describe('options', () => {
+        const subject = () => MFEPublish.options;
+
+        test('groups publish and clean options', () => {
+            expect(subject()).toEqual(
+                expect.objectContaining({
+                    ...Object.fromEntries(
+                        Object.entries(MFEPackagePublish.options).map(([key, value]) => [
+                            key,
+                            { group: 'Publish Options:', ...value },
+                        ])
+                    ),
+                    ...Object.fromEntries(
+                        Object.entries(MFEPackageClean.options).map(([key, value]) => [
+                            Object.hasOwn(MFEPackagePublish.options, key) ? `${key}\u00A0` : key,
+                            { group: 'Clean Options:', ...value },
+                        ])
+                    ),
+                })
+            );
+        });
+    });
 });

package/src/cli/commands/__tests__/start.test.ts

@@ -83,7 +83,7 @@ describe(`[startup] ${Start.name}`, () => {
     }
 
     test('command is greedy', () => {
-        expect(new Start(args).greedy).toBe(true);
+        expect(Start.greedy).toBe(true);
     });
 
     describe('with TSC package', () => {