@servicetitan/startup 33.1.1 → 34.0.0

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

@@ -0,0 +1,196 @@
+import { log, readJson } from '../../../utils';
+import { npmTagVersion, npmView } from '../../utils';
+import { MFEPackageRollback } from '../mfe-package-rollback';
+
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: {
+        error: jest.fn(),
+        info: jest.fn(),
+        warning: jest.fn(),
+    },
+    readJson: jest.fn(),
+}));
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    npmTagVersion: jest.fn(),
+    npmView: jest.fn(),
+}));
+
+describe(`[startup] ${MFEPackageRollback.name}`, () => {
+    const registry = 'https://verdaccio.servicetitan.com';
+    const packageName = '@servicetitan/foo';
+    const tag = 'bar';
+    const rollbackTag = 'bar-rollback-1';
+    const currentVersion = '1.2.3';
+    const rollbackVersion = '1.2.2';
+
+    let args: ConstructorParameters<typeof MFEPackageRollback>[0];
+    let packageInfo: any;
+
+    beforeEach(() => {
+        args = { tag };
+        packageInfo = {
+            'dist-tags': {
+                [tag]: currentVersion,
+                [rollbackTag]: rollbackVersion,
+            },
+        };
+
+        jest.resetAllMocks();
+        jest.mocked(readJson).mockReturnValue({ name: packageName });
+        jest.mocked(npmView).mockReturnValue(packageInfo);
+        jest.mocked(npmTagVersion).mockResolvedValue(undefined);
+    });
+
+    const subject = async () => new MFEPackageRollback(args).execute();
+
+    function itReportsError(message: string | RegExp) {
+        test(`reports error: ${message}`, async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+            expect.assertions(1);
+            try {
+                await subject();
+            } catch (error: any) {
+                expect(error.message).toMatch(message);
+            }
+        });
+    }
+
+    test('reads package name from package.json', async () => {
+        await subject();
+
+        expect(readJson).toHaveBeenCalledWith('package.json');
+    });
+
+    test('fetches package info from registry', async () => {
+        await subject();
+
+        expect(npmView).toHaveBeenCalledWith({
+            packageName,
+            registry,
+        });
+    });
+
+    test('logs rollback operations', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(`Rolling back ${packageName} for tag "${tag}"`);
+        expect(log.info).toHaveBeenCalledWith(
+            `Found rollback version ${rollbackVersion} for tag "${rollbackTag}"`
+        );
+        expect(log.info).toHaveBeenCalledWith(
+            `Current tag "${tag}" points to version ${currentVersion}`
+        );
+        expect(log.info).toHaveBeenCalledWith(
+            `Rolling back ${packageName} tag "${tag}" to version ${rollbackVersion}`
+        );
+    });
+
+    test('tags rollback version with original tag', async () => {
+        await subject();
+
+        expect(npmTagVersion).toHaveBeenCalledWith({
+            packageName,
+            packageVersion: rollbackVersion,
+            registry,
+            tag,
+        });
+    });
+
+    describe('when package is not found in registry', () => {
+        beforeEach(() => {
+            jest.mocked(npmView).mockReturnValue(undefined);
+        });
+
+        itReportsError(`Package ${packageName} not found in registry`);
+    });
+
+    describe('when rollback version is not found', () => {
+        beforeEach(() => {
+            packageInfo['dist-tags'] = { [tag]: currentVersion };
+        });
+
+        itReportsError(`No rollback version found for tag "${tag}" (looking for "${rollbackTag}")`);
+    });
+
+    describe('when tag and rollback tag both point to the same version', () => {
+        beforeEach(() => {
+            packageInfo['dist-tags'] = {
+                [tag]: rollbackVersion,
+                [rollbackTag]: rollbackVersion,
+            };
+        });
+
+        test('does nothing and logs message', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(
+                `Tags "${tag}" and "${rollbackTag}" both point to version ${rollbackVersion}, skipping rollback`
+            );
+            expect(npmTagVersion).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when tag does not exist', () => {
+        beforeEach(() => {
+            packageInfo['dist-tags'] = { [rollbackTag]: rollbackVersion };
+        });
+
+        test('does not log current tag points to version', async () => {
+            await subject();
+
+            expect(log.info).not.toHaveBeenCalledWith(
+                expect.stringContaining(`Current tag "${tag}" points to version`)
+            );
+        });
+    });
+
+    describe('with registry argument', () => {
+        const customRegistry = 'https://foo';
+
+        beforeEach(() => {
+            args.registry = customRegistry;
+        });
+
+        test('uses custom registry', async () => {
+            await subject();
+
+            expect(npmView).toHaveBeenCalledWith({
+                packageName,
+                registry: customRegistry,
+            });
+            expect(npmTagVersion).toHaveBeenCalledWith({
+                packageName,
+                packageVersion: rollbackVersion,
+                registry: customRegistry,
+                tag,
+                dry: undefined,
+            });
+        });
+    });
+
+    describe('with dry argument', () => {
+        beforeEach(() => {
+            args.dry = true;
+        });
+
+        test('does not call npmTagVersion', async () => {
+            await subject();
+
+            expect(npmTagVersion).not.toHaveBeenCalled();
+        });
+
+        test('logs message', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    `(dry-run) Rolling back ${packageName} tag "${tag}" to version ${rollbackVersion}`
+                )
+            );
+        });
+    });
+});

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

@@ -1,13 +1,16 @@
 import { fs, vol } from 'memfs';
-import { lernaExec } from '../../utils';
-import { Package, PackageType, getPackages } from '../../../utils';
 import { createPackage } from '../../../__mocks__';
-
+import { Package, PackageType, getPackages } from '../../../utils';
+import { lernaExec } from '../../utils';
 import { MFEPackageClean } from '../mfe-package-clean';
 import { MFEPackagePublish } from '../mfe-package-publish';
+import { MFEPackageRollback } from '../mfe-package-rollback';
 import { MFEPublish } from '../mfe-publish';
 
 jest.mock('fs', () => fs);
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../utils');
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
@@ -143,6 +146,8 @@ describe(`[startup] ${MFEPublish.name}`, () => {
             { name: 'dry', value: true, expected: '--dry' },
             { name: 'force', value: true, expected: '--force' },
             { name: 'registry', value: 'https://foo' },
+            { name: 'trackHistory', value: true, expected: '--track-history' },
+            { name: 'trackHistory', value: false, expected: '--no-track-history' },
             { name: 'uploadSourcemaps', value: true, expected: '--upload-sourcemaps' },
             { name: 'uploadSourcemaps', value: false, expected: '--no-upload-sourcemaps' },
         ];
@@ -173,6 +178,48 @@ describe(`[startup] ${MFEPublish.name}`, () => {
             });
         });
 
+        describe('with "{rollback: true}"', () => {
+            beforeEach(() => {
+                args.rollback = true;
+                args.scope = packages.map(({ name }) => name);
+            });
+
+            test('runs rollback command', async () => {
+                await subject();
+
+                expect(lernaExec).toHaveBeenCalledWith(
+                    expect.objectContaining({
+                        cmd: 'startup mfe-package-rollback',
+                        scope: [packages[0].name],
+                    })
+                );
+            });
+
+            type ArgumentName = keyof typeof args;
+            const testArgs: { name: ArgumentName; value: any; expected?: string | string[] }[] = [
+                { name: 'dry', value: true, expected: '--dry' },
+                { name: 'registry', value: 'https://foo' },
+                { name: 'tag', value: 'my-tag' },
+                { name: 'tag', value: true, expected: [] }, // check ignores obsolete --tag with no name
+            ];
+
+            describe.each(testArgs)('with "{$name: $value}"', ({ name, value, expected }) => {
+                beforeEach(() => (args[name] = value));
+
+                test(`runs rollback with "${expected ?? `--${name} ${value}`}"`, async () => {
+                    await subject();
+
+                    expect(lernaExec).toHaveBeenCalledWith(
+                        expect.objectContaining({
+                            '--': Array.isArray(expected)
+                                ? expected
+                                : [expected ?? `--${name} ${value}`],
+                        })
+                    );
+                });
+            });
+        });
+
         describe('with multiple packages', () => {
             beforeEach(() => {
                 packages.push(
@@ -215,7 +262,7 @@ describe(`[startup] ${MFEPublish.name}`, () => {
     describe('options', () => {
         const subject = () => MFEPublish.options;
 
-        test('groups publish and clean options', () => {
+        test('groups publish, clean, and rollback options', () => {
             expect(subject()).toEqual(
                 expect.objectContaining({
                     ...Object.fromEntries(
@@ -226,10 +273,23 @@ describe(`[startup] ${MFEPublish.name}`, () => {
                     ),
                     ...Object.fromEntries(
                         Object.entries(MFEPackageClean.options).map(([key, value]) => [
-                            Object.hasOwn(MFEPackagePublish.options, key) ? `${key}\u00A0` : key,
+                            `${key}\u00A0`,
                             { group: 'Clean Options:', ...value },
                         ])
                     ),
+                    ...Object.fromEntries(
+                        Object.entries(MFEPackageRollback.options)
+                            .filter(([key]) => key !== 'scope')
+                            .map(([key, value]) => {
+                                const optionProps = Object.fromEntries(
+                                    Object.entries(value).filter(([k]) => k !== 'required')
+                                );
+                                return [
+                                    `${key}\u00A0\u00A0`,
+                                    { group: 'Rollback Options:', ...optionProps },
+                                ];
+                            })
+                    ),
                 })
             );
         });

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

@@ -1,6 +1,9 @@
 import { copyFiles } from '../../utils';
 import { PreparePackage } from '../prepare-package';
 
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     copyFiles: jest.fn(),

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

@@ -1,9 +1,11 @@
-import { Package, PackageType, getPackages, log } from '../../../utils';
 import { createPackage } from '../../../__mocks__';
-import { lernaExec, compile, typeCheck, watchStdout } from '../../utils';
-
+import { Package, PackageType, getPackages, log } from '../../../utils';
+import { compile, lernaExec, typeCheck, watchStdout } from '../../utils';
 import { Start } from '../start';
 
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     getPackages: jest.fn(),
@@ -82,6 +84,25 @@ describe(`[startup] ${Start.name}`, () => {
         });
     }
 
+    function itRunsPrebuildScript() {
+        describe('when package has "precompile" script', () => {
+            beforeEach(() => {
+                packages[0].scripts = { precompile: 'foo' };
+            });
+
+            test('runs precompile script', async () => {
+                await subject();
+
+                expect(lernaExec).toHaveBeenCalledWith({
+                    cmd: 'npm run precompile',
+                    scope: [packages[0].name],
+                    parallel: true,
+                    stream: true,
+                });
+            });
+        });
+    }
+
     test('command is greedy', () => {
         expect(Start.greedy).toBe(true);
     });
@@ -91,9 +112,10 @@ describe(`[startup] ${Start.name}`, () => {
 
         itPreparesThePackages();
         itRunsCompileAndTypeCheck();
+        itRunsPrebuildScript();
 
         describe('with --use-tsc flag', () => {
-            beforeEach(() => (args['use-tsc'] = true));
+            beforeEach(() => (args.useTsc = true));
 
             itPreparesThePackages();
             itRunsCompileAndTypeCheck({ useTsc: true });
@@ -105,6 +127,7 @@ describe(`[startup] ${Start.name}`, () => {
 
         itPreparesThePackages();
         itRunsCompileAndTypeCheck();
+        itRunsPrebuildScript();
 
         test('bundles exposed dependencies', async () => {
             await subject();
@@ -131,7 +154,7 @@ describe(`[startup] ${Start.name}`, () => {
         });
 
         describe('with "code-coverage"', () => {
-            beforeEach(() => (args['code-coverage'] = true));
+            beforeEach(() => (args.codeCoverage = true));
 
             test('enables code-coverage', async () => {
                 await subject();
@@ -162,7 +185,7 @@ describe(`[startup] ${Start.name}`, () => {
     });
 
     describe('with "scope"', () => {
-        beforeEach(() => (args.scope = 'foo'));
+        beforeEach(() => (args.scope = ['foo']));
 
         test('selects scoped packages', async () => {
             await subject();
@@ -174,7 +197,7 @@ describe(`[startup] ${Start.name}`, () => {
     });
 
     describe('with "ignore"', () => {
-        beforeEach(() => (args.ignore = 'foo'));
+        beforeEach(() => (args.ignore = ['foo']));
 
         test('selectively ignores packages', async () => {
             await subject();

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

@@ -25,7 +25,7 @@ describe(`[startup] ${Stylelint.name}`, () => {
 
             expect(stylelint).toHaveBeenCalledWith({
                 fix: args.fix,
-                paths: [...args._, ...args.paths!],
+                paths: [...(args._ ?? []), ...args.paths!],
             });
         });
     });

package/src/cli/commands/__tests__/styles-check.test.ts

@@ -1,7 +1,6 @@
 import { fs, vol } from 'memfs';
 import path from 'path';
 import { getFolders, isBundle, isLegacy, isStyleCheckDisabled, log } from '../../../utils';
-
 import { StylesCheck } from '../styles-check';
 
 jest.mock('fs', () => fs);
@@ -25,7 +24,7 @@ describe(`[startup] ${StylesCheck.name}`, () => {
 
     afterEach(() => vol.reset());
 
-    const subject = async () => new StylesCheck().execute();
+    const subject = async () => new StylesCheck({}).execute();
 
     function itExitsSilently() {
         test('exits silently', async () => {

package/src/cli/commands/__tests__/upload-sourcemaps.test.ts

@@ -9,6 +9,9 @@ import { UploadSourcemaps } from '../upload-sourcemaps';
 jest.mock('@servicetitan/install');
 jest.mock('fs', () => require('memfs').fs);
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     log: { info: jest.fn(), warning: jest.fn() },
@@ -106,12 +109,6 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
         });
     });
 
-    describe('when --releaseVersion is omitted', () => {
-        beforeEach(() => delete (args as any).releaseVersion);
-
-        itThrowsError('--release-version is required');
-    });
-
     describe('when package is not a web-component', () => {
         beforeEach(() => {
             volumeFromJSON({ 'package.json': { name: packageJSON.name } });

package/src/cli/commands/build.ts

@@ -1,19 +1,20 @@
 import { getPackages, logErrors, PackageType } from '../../utils';
-import { checkArgs, compile, lernaExec, typeCheck, ProcessTree } from '../utils';
+import { checkArgs, compile, lernaExec, ProcessTree, typeCheck } from '../utils';
 import { kendoUILicense } from './kendo-ui-license';
-import { Command, CommandArgs } from './types';
+import { Command, CommandOptions } from './types';
 
-interface Args extends CommandArgs {
-    'cdn-path'?: string;
-    'code-coverage'?: boolean;
-    'config'?: string;
-    'ignore'?: string | string[];
-    'scope'?: string | string[];
-    'stat'?: boolean;
-    'use-tsc'?: boolean;
-}
+const options = {
+    cdnPath: { string: true, description: 'Base url for application assets' },
+    codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
+    config: { string: true, hidden: true, description: 'Use specified configuration' },
+    ignore: { array: true, string: true, description: 'Packages to skip' },
+    scope: { array: true, string: true, description: 'Packages to build' },
+    stat: { boolean: true, description: 'Generate bundle report?' },
+    useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
+} satisfies CommandOptions;
 
 enum BuildProcesses {
+    Precompile,
     Compile,
     KendoUILicense,
     PreparePackage,
@@ -22,24 +23,16 @@ enum BuildProcesses {
     BundlePackage,
 }
 
-export class Build extends Command<Args> {
+export class Build extends Command<typeof options> {
     static readonly description = 'Build project for production';
     static readonly greedy = true;
-    static readonly options = {
-        'cdn-path': { string: true, description: 'Base url for application assets' },
-        'code-coverage': { boolean: true, description: 'Instrument code for coverage analysis?' },
-        'config': { string: true, hidden: true, description: 'Use specified configuration' },
-        'ignore': { array: true, description: 'Packages to skip' },
-        'scope': { array: true, description: 'Packages to build' },
-        'stat': { boolean: true, description: 'Generate bundle report?' },
-        'use-tsc': { boolean: true, description: 'Use tsc to compile packages?' },
-    };
+    static readonly options = options;
 
     @logErrors
     async execute() {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });
 
-        const useTsc = this.args['use-tsc'];
+        const useTsc = this.args.useTsc;
 
         const packages = getPackages({
             scope: this.args.scope,
@@ -50,18 +43,34 @@ export class Build extends Command<Args> {
             return;
         }
 
-        if (this.args['cdn-path']) {
-            process.env.CLIENT_CDN_PATH = this.args['cdn-path'];
+        if (this.args.cdnPath) {
+            process.env.CLIENT_CDN_PATH = this.args.cdnPath;
         }
 
         const scope = packages.map(({ name }) => name);
         const webpackScope = packages
             .filter(({ type }) => type === PackageType.Webpack)
             .map(({ name }) => name);
+        const precompileScope = packages
+            .filter(({ scripts }) => !!scripts?.precompile)
+            .map(({ name }) => name);
 
         const processTree = new ProcessTree<typeof BuildProcesses>();
 
-        processTree.add(BuildProcesses.Compile, () => compile({ packages: scope, useTsc }));
+        processTree.add(BuildProcesses.Precompile, () => {
+            if (precompileScope.length === 0) {
+                return Promise.resolve();
+            }
+            return lernaExec({
+                cmd: 'npm run precompile',
+                scope: precompileScope,
+                parallel: true,
+                stream: true,
+            });
+        });
+        processTree.add(BuildProcesses.Compile, () => compile({ packages: scope, useTsc }), {
+            dependsOn: [BuildProcesses.Precompile],
+        });
         processTree.add(BuildProcesses.KendoUILicense, () => kendoUILicense());
         processTree.add(BuildProcesses.PreparePackage, () =>
             lernaExec({
@@ -108,7 +117,7 @@ export class Build extends Command<Args> {
                     'stream': true,
                     '--': [
                         ...[this.args.config ? `--config "${this.args.config}"` : undefined],
-                        ...[this.args['code-coverage'] ? '--code-coverage' : undefined],
+                        ...[this.args.codeCoverage ? '--code-coverage' : undefined],
                         ...[this.args.stat ? '--stat' : undefined],
                     ].filter(item => !!item) as string[],
                 });

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

@@ -1,17 +1,18 @@
 import { getTsConfig, log, logErrors } from '../../utils';
 import { bundle, getModuleType } from '../utils';
-import { Command, CommandArgs } from './types';
+import { Command, CommandOptions } from './types';
 
-interface Args extends CommandArgs {
-    codeCoverage?: boolean;
-    config?: string;
-    exposedDependencies?: boolean;
-    stat?: boolean;
-    useWatchConfig?: boolean;
-    watch?: boolean;
-}
+const options = {
+    codeCoverage: { boolean: true, hidden: true },
+    config: { string: true, hidden: true },
+    exposedDependencies: { boolean: true, hidden: true },
+    stat: { boolean: true, hidden: true },
+    useWatchConfig: { boolean: true, hidden: true },
+    watch: { boolean: true, hidden: true },
+} satisfies CommandOptions;
 
-export class BundlePackage extends Command<Args> {
+export class BundlePackage extends Command<typeof options> {
+    static readonly options = options;
     @logErrors
     async execute() {
         const {

package/src/cli/commands/clean.ts

@@ -1,22 +1,68 @@
-import { exec, execSync } from 'child_process';
+import { exec as execAsync, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
 import { log, logErrors } from '../../utils';
+import { ProcessTree } from '../utils/process-tree';
 import { Command } from './types';
 
+const exec = promisify(execAsync);
+
+enum CleanProcesses {
+    ResetNx,
+    ClearJestCache,
+    ClearNpmCache,
+    ClearNpxCache,
+    CleanGitWorkingTree,
+}
+
 export class Clean extends Command {
+    static readonly allowRunFromGlobal = true;
     static readonly description = 'Reset project to fresh state';
 
     @logErrors
     async execute() {
-        ['npx nx reset', 'npx jest --clearCache', 'npm cache clear --force'].forEach(command => {
+        const processTree = new ProcessTree<typeof CleanProcesses>();
+
+        processTree.add(CleanProcesses.ResetNx, () => this.runCommand('npx nx reset'));
+        processTree.add(CleanProcesses.ClearJestCache, () =>
+            this.runCommand('npx jest --clearCache')
+        );
+        processTree.add(CleanProcesses.ClearNpmCache, () =>
+            this.runCommand('npm cache clear --force')
+        );
+        processTree.add(CleanProcesses.ClearNpxCache, () => this.clearNpxCache());
+
+        await processTree.run();
+
+        this.cleanGitWorkingTree();
+    }
+
+    private async runCommand(command: string) {
+        try {
             log.info(`Running: ${command}`);
-            execSync(command, { stdio: ['ignore', 'ignore', 'inherit'] });
-        });
+            await exec(command);
+        } catch (error) {
+            log.error(`Error running ${command}: ${error}`);
+        }
+    }
 
+    private cleanGitWorkingTree() {
         // Use exec() to avoid error when startup dependencies are deleted while startup is running
         const command = 'git clean -fdX';
         log.info(`Running: ${command}`);
         exec(command);
+    }
+
+    private async clearNpxCache() {
+        try {
+            const npmCacheDir = execSync('npm config get cache').toString().trim();
+            const npxCachePath = path.join(npmCacheDir, '_npx');
 
-        return Promise.resolve();
+            log.info('Clearing npx cache');
+            await fs.promises.rm(npxCachePath, { recursive: true, force: true });
+        } catch (error) {
+            log.error(`Error clearing npx cache: ${error}`);
+        }
     }
 }