@servicetitan/startup 30.3.1 → 31.1.0

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,75 +1,33 @@
-import { isBundle } from '../../../utils';
-import {
-    assetsCopy,
-    assetsCopyWatch,
-    stylesCopy,
-    stylesCopyWatch,
-    tcm,
-    tcmWatch,
-} from '../../utils';
-
+import { 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),
+    copyFiles: jest.fn(),
 }));
 
 describe(`[startup] ${PreparePackage.name}`, () => {
     let args: ConstructorParameters<typeof PreparePackage>[0];
 
     beforeEach(() => {
-        jest.mocked(isBundle).mockReturnValue(true);
         args = {};
     });
 
     const subject = async () => new PreparePackage(args).execute();
 
-    test('runs tcm', async () => {
+    test('runs copyFiles', async () => {
         await subject();
 
-        expect(tcm).toHaveBeenCalled();
-    });
-
-    describe('when package is not a bundle', () => {
-        beforeEach(() => jest.mocked(isBundle).mockReturnValue(false));
-
-        test('copies assets and styles', async () => {
-            await subject();
-
-            expect(assetsCopy).toHaveBeenCalled();
-            expect(stylesCopy).toHaveBeenCalled();
-        });
+        expect(copyFiles).toHaveBeenCalled();
     });
 
     describe('with "watch"', () => {
         beforeEach(() => (args.watch = true));
 
-        test('runs tcm in watch mode', async () => {
+        test('runs copyFiles in watch mode', async () => {
             await subject();
 
-            expect(tcmWatch).toHaveBeenCalled();
-        });
-
-        describe('when package is not a bundle', () => {
-            beforeEach(() => jest.mocked(isBundle).mockReturnValue(false));
-
-            test('copies assets and styles 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,11 +36,15 @@ 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() {
         test('prepares the package, then again in watch mode', async () => {
@@ -43,16 +66,37 @@ describe(`[startup] ${Start.name}`, () => {
         });
     }
 
+    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();
+            itRunsCompileAndTypeCheck({ useTsc: true });
         });
     });
 
@@ -60,6 +104,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 +114,7 @@ describe(`[startup] ${Start.name}`, () => {
                 'scope': packages.map(({ name }) => name),
                 'parallel': true,
                 'stream': true,
-                '--': ['--color', '--watch'],
+                '--': ['--watch'],
             });
         });
 
@@ -81,35 +126,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 +140,7 @@ describe(`[startup] ${Start.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        '--': ['--color', '--watch', `--config "${args.config}"`],
+                        '--': ['--watch', `--config "${args.config}"`],
                     })
                 );
             });
@@ -136,7 +153,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 +165,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,70 @@ 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),
+                scope,
                 stream: true,
-            });
-        }
+            })
+        );
+        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();
     }
 }

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

@@ -9,8 +9,6 @@ interface Args {
     'code-coverage'?: boolean;
     'stat'?: boolean;
     'watch'?: boolean;
-    'esbuild'?: boolean;
-    'experimental-bundlers'?: boolean;
 }
 
 export class BundlePackage implements Command {
@@ -35,8 +33,6 @@ export class BundlePackage implements Command {
         const options = {
             config,
             codeCoverage: this.args['code-coverage'],
-            esbuild: this.args.esbuild,
-            experimentalBundlers: this.args['experimental-bundlers'],
         };
 
         if (!watch) {

package/src/cli/commands/clean.ts

@@ -0,0 +1,24 @@
+import { exec, execSync } from 'child_process';
+import { log, logErrors } from '../../utils';
+import { Command } from './types';
+
+export class Clean implements Command {
+    description() {
+        return 'resets project to fresh state';
+    }
+
+    @logErrors
+    async execute() {
+        ['npx nx reset', 'npx jest --clearCache', 'npm cache clear --force'].forEach(command => {
+            log.info(`Running: ${command}`);
+            execSync(command, { stdio: ['ignore', 'ignore', 'inherit'] });
+        });
+
+        // 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);
+
+        return Promise.resolve();
+    }
+}

package/src/cli/commands/eslint.ts

@@ -16,7 +16,7 @@ export class ESLintCommand implements Command {
     }
 
     @logErrors
-    async execute(): Promise<void> {
+    async execute() {
         const { _: paths, fix } = this.args;
         await eslint({ fix, paths });
     }

package/src/cli/commands/get-command.ts

@@ -2,6 +2,7 @@ import { CommandName } from '../../utils';
 
 import { Build } from './build';
 import { BundlePackage } from './bundle-package';
+import { Clean } from './clean';
 import { ConvertEslintConfig } from './convert-eslint-config';
 import { ESLintCommand } from './eslint';
 import { Init } from './init';
@@ -12,45 +13,34 @@ import { MFEPackageClean } from './mfe-package-clean';
 import { MFEPackagePublish } from './mfe-package-publish';
 import { MFEPublish } from './mfe-publish';
 import { PreparePackage } from './prepare-package';
+import { Review } from './review';
+import { RunTask } from './run-task';
 import { Start } from './start';
 import { StylesCheck } from './styles-check';
-import { RunTask } from './run-task';
 import { Tests } from './tests';
 import { Command, Newable } from './types';
 
+const commands: Record<CommandName, Newable<Command>> = {
+    [CommandName.build]: Build,
+    [CommandName['bundle-package']]: BundlePackage,
+    [CommandName['convert-eslint-config']]: ConvertEslintConfig,
+    [CommandName.clean]: Clean,
+    [CommandName.eslint]: ESLintCommand,
+    [CommandName.init]: Init,
+    [CommandName.install]: Install,
+    [CommandName['kendo-ui-license']]: KendoUILicense,
+    [CommandName.lint]: Lint,
+    [CommandName['mfe-package-clean']]: MFEPackageClean,
+    [CommandName['mfe-package-publish']]: MFEPackagePublish,
+    [CommandName['mfe-publish']]: MFEPublish,
+    [CommandName['prepare-package']]: PreparePackage,
+    [CommandName.review]: Review,
+    [CommandName.start]: Start,
+    [CommandName['styles-check']]: StylesCheck,
+    [CommandName.test]: Tests,
+    [CommandName.task]: RunTask,
+};
+
 export function getCommand(name: CommandName): Newable<Command> | undefined {
-    switch (name) {
-        case CommandName.build:
-            return Build;
-        case CommandName['bundle-package']:
-            return BundlePackage;
-        case CommandName['convert-eslint-config']:
-            return ConvertEslintConfig;
-        case CommandName.eslint:
-            return ESLintCommand;
-        case CommandName.init:
-            return Init;
-        case CommandName.install:
-            return Install;
-        case CommandName['kendo-ui-license']:
-            return KendoUILicense;
-        case CommandName.lint:
-            return Lint;
-        case CommandName['mfe-package-clean']:
-            return MFEPackageClean;
-        case CommandName['mfe-package-publish']:
-            return MFEPackagePublish;
-        case CommandName['mfe-publish']:
-            return MFEPublish;
-        case CommandName['prepare-package']:
-            return PreparePackage;
-        case CommandName.start:
-            return Start;
-        case CommandName['styles-check']:
-            return StylesCheck;
-        case CommandName.test:
-            return Tests;
-        case CommandName.task:
-            return RunTask;
-    }
+    return commands[name];
 }

package/src/cli/commands/index.ts

@@ -12,4 +12,4 @@ export * from './start';
 export * from './tests';
 export * from './styles-check';
 export * from './mfe-publish';
-export * from './types';
+export type * from './types';