@servicetitan/startup 30.3.0 → 31.0.0

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

@@ -1,8 +1,9 @@
-import execa from 'execa';
+import { execSync } from 'child_process';
+import { log } from '../../../utils';
 
 import { Install } from '../install';
 
-jest.mock('execa', () => jest.fn());
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     log: { info: jest.fn() }, // suppress log output
@@ -10,17 +11,31 @@ jest.mock('../../../utils', () => ({
 
 describe(`${Install.name}`, () => {
     const OLD_ENV = process.env;
-    const options = ['--no-audit', '--legacy-peer-deps'];
+    const options = ['--audit=false', '--fund=false', '--legacy-peer-deps'];
+    let args: ConstructorParameters<typeof Install>[0];
+
+    beforeEach(() => {
+        process.env = {};
+        args = undefined;
+        jest.clearAllMocks();
+    });
 
-    beforeEach(() => (process.env = {}));
     afterEach(() => (process.env = OLD_ENV));
 
-    const subject = async () => new Install().execute();
+    const subject = async () => new Install(args).execute();
+
+    test(`runs npm i ${options.join(' ')}`, async () => {
+        await subject();
+
+        expect(execSync).toHaveBeenCalledWith(`npm i ${options.join(' ')}`, {
+            stdio: 'inherit',
+        });
+    });
 
-    test('runs npm i', async () => {
+    test('logs progress', async () => {
         await subject();
 
-        expect(execa).toHaveBeenCalledWith('npm', ['i', ...options], expect.anything());
+        expect(log.info).toHaveBeenCalled();
     });
 
     describe('when in CI environment', () => {
@@ -29,7 +44,34 @@ describe(`${Install.name}`, () => {
         test('runs npm ci', async () => {
             await subject();
 
-            expect(execa).toHaveBeenCalledWith('npm', ['ci', ...options], expect.anything());
+            expect(execSync).toHaveBeenCalledWith(`npm ci ${options.join(' ')}`, {
+                stdio: 'inherit',
+            });
+        });
+    });
+
+    describe('with --quite', () => {
+        beforeEach(() => (args = { quiet: true }));
+
+        test('does not log progress', async () => {
+            await subject();
+
+            expect(log.info).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('with --fix', () => {
+        const fixOptions = [...options, '--package-lock-only', '--prefer-dedupe'];
+
+        beforeEach(() => (args = { fix: true }));
+
+        test(`runs npm i ${fixOptions.join(' ')}`, async () => {
+            await subject();
+
+            expect(execSync).toHaveBeenCalledWith(
+                `npm i ${fixOptions.join(' ')}`,
+                expect.anything()
+            );
         });
     });
 });

package/src/cli/commands/__tests__/kendo-ui-license.test.ts

@@ -1,15 +1,14 @@
 import execa from 'execa';
 
-import { log } from '../../../utils/log';
+import { log } from '../../../utils';
 import { isModuleInstalled } from '../../utils';
 import { kendoUILicense } from '../kendo-ui-license';
 
 jest.mock('execa', () => jest.fn());
 
-jest.mock('../../../utils/log', () => ({
-    log: {
-        info: jest.fn(),
-    },
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: { info: jest.fn() },
 }));
 
 jest.mock('../../utils/is-module-installed', () => ({
@@ -75,6 +74,7 @@ describe(`${kendoUILicense.name}`, () => {
         beforeEach(() => (execa as any).mockRejectedValue({ exitCode }));
 
         test('throws error', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementationOnce(jest.fn()); // suppress error output
             await expect(subject()).rejects.toThrow(`command failed with exit code ${exitCode}`);
         });
     });

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

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

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

@@ -176,8 +176,27 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         test('sets package files to "package.json"', async () => {
             await subject();
 
-            expect(npmPackageSet).toHaveBeenCalledWith('files[0]', 'dist');
-            expect(npmPackageSet).toHaveBeenCalledWith('files[1]', 'package.json');
+            ['dist/bundle', 'dist/metadata.json', 'package.json'].forEach((file, index) => {
+                expect(npmPackageSet).toHaveBeenCalledWith(`files[${index}]`, file);
+            });
+        });
+    });
+
+    describe('when package files contains "dist"', () => {
+        const files = ['dist', 'package.json', 'other.json'];
+
+        beforeEach(() =>
+            vol.fromJSON({
+                'package.json': JSON.stringify({ name: packageName, files }),
+            })
+        );
+
+        test('replaces "dist" with "dist/bundle" and "dist/metadata.json"', async () => {
+            await subject();
+
+            ['dist/bundle', 'dist/metadata.json', ...files.slice(1)].forEach((file, index) => {
+                expect(npmPackageSet).toHaveBeenCalledWith(`files[${index}]`, file);
+            });
         });
     });
 

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

@@ -39,8 +39,18 @@ describe(`[startup] ${MFEPublish.name}`, () => {
         });
     }
 
-    describe('with TSC package', () => {
-        beforeEach(() => packages.push(createPackage({ type: PackageType.TSC })));
+    test('selects Webpack packages', async () => {
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+        try {
+            await subject();
+        } catch {
+            /* ignore */
+        }
+        expect(getPackages).toHaveBeenCalledWith({ type: PackageType.Webpack });
+    });
+
+    describe('with no packages', () => {
+        beforeEach(() => (packages = []));
 
         itReportsError();
     });
@@ -73,7 +83,7 @@ describe(`[startup] ${MFEPublish.name}`, () => {
                 'cmd': 'startup mfe-package-publish',
                 'scope': packages.map(({ name }) => name),
                 'stream': true,
-                'concurrency': 1,
+                'parallel': 1,
                 '--': [],
             });
         });
@@ -155,7 +165,7 @@ describe(`[startup] ${MFEPublish.name}`, () => {
             test('runs lernaExec with {concurrency: 0}', async () => {
                 await subject();
 
-                expect(lernaExec).toHaveBeenCalledWith(expect.objectContaining({ concurrency: 0 }));
+                expect(lernaExec).toHaveBeenCalledWith(expect.objectContaining({ parallel: 0 }));
             });
         });
 
@@ -184,28 +194,14 @@ describe(`[startup] ${MFEPublish.name}`, () => {
                 );
             });
 
-            describe('with "{scope: string}"', () => {
-                beforeEach(() => (args.scope = packages[0].name));
+            describe('with "{scope}"', () => {
+                beforeEach(() => (args.scope = [packages[0].name]));
 
-                test('publishes specified packages', async () => {
+                test('selects specified packages', async () => {
                     await subject();
 
-                    expect(lernaExec).toHaveBeenCalledWith(
-                        expect.objectContaining({ scope: [packages[0].name] })
-                    );
-                });
-            });
-
-            describe('with "{scope: Array<string>}"', () => {
-                beforeEach(() => (args.scope = packages.slice(1).map(({ name }) => name)));
-
-                test('publishes the specified packages', async () => {
-                    await subject();
-
-                    expect(lernaExec).toHaveBeenCalledWith(
-                        expect.objectContaining({
-                            scope: packages.slice(1).map(({ name }) => name),
-                        })
+                    expect(getPackages).toHaveBeenCalledWith(
+                        expect.objectContaining({ scope: args.scope })
                     );
                 });
             });

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

@@ -1,35 +1,16 @@
-import { isBundle } from '../../../utils';
-import {
-    assetsCopy,
-    assetsCopyWatch,
-    stylesCopy,
-    stylesCopyWatch,
-    tcm,
-    tcmWatch,
-} from '../../utils';
-
+import { tcm, copyFiles } from '../../utils';
 import { PreparePackage } from '../prepare-package';
 
-jest.mock('../../../utils', () => ({
-    ...jest.requireActual('../../../utils'),
-    isBundle: jest.fn(),
-}));
-
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
-    assetsCopy: jest.fn().mockResolvedValue(undefined),
-    assetsCopyWatch: jest.fn().mockResolvedValue(undefined),
-    stylesCopy: jest.fn().mockResolvedValue(undefined),
-    stylesCopyWatch: jest.fn().mockResolvedValue(undefined),
-    tcm: jest.fn().mockResolvedValue(undefined),
-    tcmWatch: jest.fn().mockResolvedValue(undefined),
+    tcm: jest.fn(),
+    copyFiles: jest.fn(),
 }));
 
 describe(`[startup] ${PreparePackage.name}`, () => {
     let args: ConstructorParameters<typeof PreparePackage>[0];
 
     beforeEach(() => {
-        jest.mocked(isBundle).mockReturnValue(true);
         args = {};
     });
 
@@ -41,34 +22,34 @@ describe(`[startup] ${PreparePackage.name}`, () => {
         expect(tcm).toHaveBeenCalled();
     });
 
-    describe('when package is not a bundle', () => {
-        beforeEach(() => jest.mocked(isBundle).mockReturnValue(false));
+    describe('with "watch"', () => {
+        beforeEach(() => (args.watch = true));
 
-        test('copies assets and styles', async () => {
+        test('runs tcm in watch mode', async () => {
             await subject();
 
-            expect(assetsCopy).toHaveBeenCalled();
-            expect(stylesCopy).toHaveBeenCalled();
+            expect(tcm).toHaveBeenCalledWith({ watch: true });
         });
     });
 
-    describe('with "watch"', () => {
-        beforeEach(() => (args.watch = true));
+    describe('with --copy-files flag', () => {
+        beforeEach(() => {
+            args['copy-files'] = true;
+        });
 
-        test('runs tcm in watch mode', async () => {
+        test('runs copyFiles', async () => {
             await subject();
 
-            expect(tcmWatch).toHaveBeenCalled();
+            expect(copyFiles).toHaveBeenCalled();
         });
 
-        describe('when package is not a bundle', () => {
-            beforeEach(() => jest.mocked(isBundle).mockReturnValue(false));
+        describe('with "watch"', () => {
+            beforeEach(() => (args.watch = true));
 
-            test('copies assets and styles in watch mode', async () => {
+            test('runs copyFiles in watch mode', async () => {
                 await subject();
 
-                expect(assetsCopyWatch).toHaveBeenCalled();
-                expect(stylesCopyWatch).toHaveBeenCalled();
+                expect(copyFiles).toHaveBeenCalledWith({ watch: true });
             });
         });
     });

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

@@ -1,6 +1,6 @@
-import { Package, PackageType, getPackages } from '../../../utils';
+import { Package, PackageType, getPackages, log } from '../../../utils';
 import { createPackage } from '../../../__mocks__';
-import { lernaExec, tsc, tscWatch } from '../../utils';
+import { lernaExec, compile, typeCheck, watchStdout } from '../../utils';
 
 import { Start } from '../start';
 
@@ -8,7 +8,26 @@ jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     getPackages: jest.fn(),
 }));
-jest.mock('../../utils');
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    lernaExec: jest.fn(() => Promise.resolve()),
+    compile: jest.fn(() =>
+        Object.assign(Promise.resolve(), {
+            stdout: {
+                on: jest.fn(),
+                off: jest.fn(),
+            },
+        })
+    ),
+    typeCheck: jest.fn(() =>
+        Object.assign(Promise.resolve(), {
+            stdout: {
+                on: jest.fn(),
+            },
+        })
+    ),
+    watchStdout: jest.fn(),
+}));
 
 describe(`[startup] ${Start.name}`, () => {
     let args: ConstructorParameters<typeof Start>[0];
@@ -17,20 +36,26 @@ describe(`[startup] ${Start.name}`, () => {
     beforeEach(() => {
         args = {};
         packages = [];
-        jest.resetAllMocks();
+        jest.clearAllMocks();
         jest.mocked(getPackages).mockImplementation(() => packages);
+        jest.mocked(watchStdout).mockImplementation((_process, _indicator, handler) => {
+            handler(packages.length);
+            return jest.fn();
+        });
     });
 
-    const subject = async () => new Start(args).execute();
+    const subject = () => new Start(args).execute();
 
-    function itPreparesThePackages() {
+    function itPreparesThePackages({ copyFiles = false }: { copyFiles?: boolean } = {}) {
         test('prepares the package, then again in watch mode', async () => {
             await subject();
 
             expect(lernaExec).toHaveBeenCalledWith({
                 cmd: 'startup prepare-package',
+                parallel: true,
                 scope: packages.map(({ name }) => name),
                 stream: true,
+                ...(copyFiles ? { '--': ['--copy-files'] } : {}),
             });
 
             expect(lernaExec).toHaveBeenCalledWith({
@@ -38,21 +63,42 @@ describe(`[startup] ${Start.name}`, () => {
                 'scope': packages.map(({ name }) => name),
                 'parallel': true,
                 'stream': true,
-                '--': ['--watch'],
+                '--': ['--watch', ...(copyFiles ? ['--copy-files'] : [])],
             });
         });
     }
 
+    function itRunsCompileAndTypeCheck({ useTsc = false }: { useTsc?: boolean } = {}) {
+        test('runs compile and typeCheck', async () => {
+            await subject();
+
+            expect(compile).toHaveBeenCalledWith({
+                packages: packages.map(({ name }) => name),
+                watch: true,
+                ...(useTsc ? { useTsc } : {}),
+            });
+            expect(typeCheck).toHaveBeenCalledWith({
+                packages: packages.map(({ name }) => name),
+                watch: true,
+            });
+        });
+    }
+
+    test('command is greedy', () => {
+        expect(new Start(args).greedy).toBe(true);
+    });
+
     describe('with TSC package', () => {
         beforeEach(() => packages.push(createPackage({ type: PackageType.TSC })));
 
         itPreparesThePackages();
+        itRunsCompileAndTypeCheck();
 
-        test('runs tsc, then again in watch mode', async () => {
-            await subject();
+        describe('with --use-tsc flag', () => {
+            beforeEach(() => (args['use-tsc'] = true));
 
-            expect(tsc).toHaveBeenCalledWith(packages);
-            expect(tscWatch).toHaveBeenCalledWith(packages);
+            itPreparesThePackages({ copyFiles: true });
+            itRunsCompileAndTypeCheck({ useTsc: true });
         });
     });
 
@@ -60,6 +106,7 @@ describe(`[startup] ${Start.name}`, () => {
         beforeEach(() => packages.push(createPackage({ type: PackageType.Webpack })));
 
         itPreparesThePackages();
+        itRunsCompileAndTypeCheck();
 
         test('bundles the package in watch mode', async () => {
             await subject();
@@ -69,7 +116,7 @@ describe(`[startup] ${Start.name}`, () => {
                 'scope': packages.map(({ name }) => name),
                 'parallel': true,
                 'stream': true,
-                '--': ['--color', '--watch'],
+                '--': ['--watch'],
             });
         });
 
@@ -81,35 +128,7 @@ describe(`[startup] ${Start.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        '--': ['--color', '--watch', '--code-coverage'],
-                    })
-                );
-            });
-        });
-
-        describe('with "esbuild"', () => {
-            beforeEach(() => (args.esbuild = true));
-
-            test('enables esbuild loader', async () => {
-                await subject();
-
-                expect(lernaExec).toHaveBeenCalledWith(
-                    expect.objectContaining({
-                        '--': ['--color', '--watch', '--esbuild'],
-                    })
-                );
-            });
-        });
-
-        describe('with "experimental-bundlers"', () => {
-            beforeEach(() => (args['experimental-bundlers'] = true));
-
-            test('enables swc-loader', async () => {
-                await subject();
-
-                expect(lernaExec).toHaveBeenCalledWith(
-                    expect.objectContaining({
-                        '--': ['--color', '--watch', '--experimental-bundlers'],
+                        '--': ['--watch', '--code-coverage'],
                     })
                 );
             });
@@ -123,7 +142,7 @@ describe(`[startup] ${Start.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        '--': ['--color', '--watch', `--config "${args.config}"`],
+                        '--': ['--watch', `--config "${args.config}"`],
                     })
                 );
             });
@@ -136,7 +155,9 @@ describe(`[startup] ${Start.name}`, () => {
         test('selects scoped packages', async () => {
             await subject();
 
-            expect(getPackages).toHaveBeenCalledWith({ scope: args.scope });
+            expect(getPackages).toHaveBeenCalledWith(
+                expect.objectContaining({ scope: args.scope })
+            );
         });
     });
 
@@ -146,7 +167,23 @@ describe(`[startup] ${Start.name}`, () => {
         test('selectively ignores packages', async () => {
             await subject();
 
-            expect(getPackages).toHaveBeenCalledWith({ ignore: args.ignore });
+            expect(getPackages).toHaveBeenCalledWith(
+                expect.objectContaining({ ignore: args.ignore })
+            );
+        });
+    });
+
+    describe.each(['esbuild', 'experimental-bundlers'])('with "%s"', arg => {
+        beforeEach(() => ((args as Record<string, any>)[arg] = true));
+
+        test('logs warning', async () => {
+            const logSpy = jest.spyOn(log, 'warning');
+
+            await subject();
+
+            expect(logSpy).toHaveBeenCalledWith(
+                expect.stringContaining(`--${arg} option is obsolete`)
+            );
         });
     });
 });

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

@@ -22,6 +22,10 @@ describe(`[startup] ${Tests.name}`, () => {
 
     const subject = async () => new Tests(args).execute();
 
+    test('command is greedy', () => {
+        expect(new Tests(args).greedy).toBe(true);
+    });
+
     test('runs Jest CLI', async () => {
         await subject();
 

package/src/cli/commands/build.ts

@@ -1,19 +1,29 @@
-import { getPackages, logErrors, PackageType, splitPackagesByType } from '../../utils';
-import { lernaExec, tsc } from '../utils';
-import { Command, kendoUILicense } from '.';
+import { getPackages, logErrors, PackageType } from '../../utils';
+import { checkArgs, compile, lernaExec, typeCheck, ProcessTree } from '../utils';
+import { kendoUILicense } from './kendo-ui-license';
+import { Command } from './types';
 
 interface Args {
     'cdn-path'?: string;
     'code-coverage'?: boolean;
     'config'?: string;
-    'esbuild'?: boolean;
-    'experimental-bundlers'?: boolean;
     'ignore'?: string | string[];
     'scope'?: string | string[];
     'stat'?: boolean;
+    'use-tsc'?: boolean;
+}
+
+export enum BuildProcesses {
+    'Compile',
+    'KendoUILicense',
+    'PreparePackage',
+    'TypeCheck',
+    'BundlePackage',
 }
 
 export class Build implements Command {
+    readonly greedy = true;
+
     constructor(private args: Args) {}
 
     description() {
@@ -22,44 +32,72 @@ export class Build implements Command {
 
     @logErrors
     async execute() {
-        const packages = splitPackagesByType(
-            getPackages({ scope: this.args.scope, ignore: this.args.ignore })
-        );
-        const packagesWithPreparation = [
-            ...packages[PackageType.TSC],
-            ...packages[PackageType.Webpack],
-        ];
+        checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });
+
+        const useTsc = this.args['use-tsc'];
+
+        const packages = getPackages({
+            scope: this.args.scope,
+            ignore: this.args.ignore,
+            type: [PackageType.TSC, PackageType.Webpack],
+        });
+        if (packages.length === 0) {
+            return;
+        }
 
         if (this.args['cdn-path']) {
             process.env.CLIENT_CDN_PATH = this.args['cdn-path'];
         }
 
-        if (packagesWithPreparation.length) {
-            await lernaExec({
+        const scope = packages.map(({ name }) => name);
+
+        const processTree = new ProcessTree<typeof BuildProcesses>();
+
+        processTree.add(BuildProcesses.Compile, () => compile({ packages: scope, useTsc }));
+        processTree.add(BuildProcesses.KendoUILicense, () => kendoUILicense());
+        processTree.add(BuildProcesses.PreparePackage, () =>
+            lernaExec({
                 cmd: 'startup prepare-package',
-                scope: packagesWithPreparation.map(({ name }) => name),
+                parallel: true,
+                scope,
                 stream: true,
-            });
-        }
+                ...(useTsc ? { '--': ['--copy-files'] } : {}),
+            })
+        );
+        processTree.add(BuildProcesses.TypeCheck, () => typeCheck({ packages: scope }), {
+            dependsOn: [BuildProcesses.PreparePackage],
+        });
+        processTree.add(
+            BuildProcesses.BundlePackage,
+            () => {
+                const webpackScope = packages
+                    .filter(({ type }) => type === PackageType.Webpack)
+                    .map(({ name }) => name);
 
-        if (packages[PackageType.TSC].length) {
-            await tsc(packages[PackageType.TSC]);
-        }
+                if (webpackScope.length === 0) {
+                    return Promise.resolve();
+                }
 
-        if (packages[PackageType.Webpack].length) {
-            await kendoUILicense();
-            await lernaExec({
-                'cmd': 'startup bundle-package',
-                'scope': packages[PackageType.Webpack].map(({ name }) => name),
-                'stream': true,
-                '--': [
-                    ...[this.args.config ? `--config "${this.args.config}"` : undefined],
-                    ...[this.args['code-coverage'] ? '--code-coverage' : undefined],
-                    ...[this.args.esbuild ? '--esbuild' : undefined],
-                    ...[this.args['experimental-bundlers'] ? '--experimental-bundlers' : undefined],
-                    ...[this.args.stat ? '--stat' : undefined],
-                ].filter(item => !!item) as string[],
-            });
-        }
+                return lernaExec({
+                    'cmd': 'startup bundle-package',
+                    'scope': webpackScope,
+                    'stream': true,
+                    '--': [
+                        ...[this.args.config ? `--config "${this.args.config}"` : undefined],
+                        ...[this.args['code-coverage'] ? '--code-coverage' : undefined],
+                        ...[this.args.stat ? '--stat' : undefined],
+                    ].filter(item => !!item) as string[],
+                });
+            },
+            {
+                dependsOn: [
+                    BuildProcesses.Compile,
+                    BuildProcesses.KendoUILicense,
+                    BuildProcesses.PreparePackage,
+                ],
+            }
+        );
+
+        await processTree.run();
     }
 }