@servicetitan/startup 30.3.1 → 31.1.0

package/src/cli/commands/start.ts

@@ -1,17 +1,35 @@
-import { getPackages, logErrors, PackageType, splitPackagesByType } from '../../utils';
-import { lernaExec, tsc, tscWatch } from '../utils';
-import { Command } from '.';
+import { getPackages, log, logErrors, PackageType } from '../../utils';
+import {
+    checkArgs,
+    lernaExec,
+    compile,
+    typeCheck,
+    pipeStdout,
+    watchStdout,
+    ProcessTree,
+} from '../utils';
+import { Command } from './types';
 
 interface Args {
     'config'?: string;
     'code-coverage'?: boolean;
-    'esbuild'?: boolean;
-    'experimental-bundlers'?: boolean;
     'ignore'?: string | string[];
     'scope'?: string | string[];
+    'use-tsc'?: boolean;
+}
+
+export enum StartProcesses {
+    Compile,
+    KendoUILicense,
+    PreparePackage,
+    PreparePackageWatch,
+    TypeCheck,
+    BundlePackage,
 }
 
 export class Start implements Command {
+    readonly greedy = true;
+
     constructor(private args: Args) {}
 
     description() {
@@ -20,59 +38,114 @@ export class Start 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'] });
 
-        if (packagesWithPreparation.length) {
-            await lernaExec({
-                cmd: 'startup prepare-package',
-                scope: packagesWithPreparation.map(({ name }) => name),
-                stream: true,
-            });
-        }
+        const useTsc = this.args['use-tsc'];
 
-        if (packages[PackageType.TSC].length) {
-            await tsc(packages[PackageType.TSC]);
+        const packages = getPackages({
+            scope: this.args.scope,
+            ignore: this.args.ignore,
+            type: [PackageType.TSC, PackageType.Webpack],
+        });
+        if (packages.length === 0) {
+            return;
         }
 
-        await Promise.all([
-            ...(packagesWithPreparation.length
-                ? [
-                      lernaExec({
-                          'cmd': 'startup prepare-package',
-                          'scope': packagesWithPreparation.map(({ name }) => name),
-                          'parallel': true,
-                          'stream': true,
-                          '--': ['--watch'],
-                      }),
-                  ]
-                : []),
-            ...(packages[PackageType.TSC].length ? [tscWatch(packages[PackageType.TSC])] : []),
-            ...(packages[PackageType.Webpack].length
-                ? [
-                      lernaExec({
-                          'cmd': 'startup bundle-package',
-                          'scope': packages[PackageType.Webpack].map(({ name }) => name),
-                          'parallel': true,
-                          'stream': true,
-                          '--': [
-                              '--color',
-                              '--watch',
-                              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,
-                          ].filter(item => !!item) as string[],
-                      }),
-                  ]
-                : []),
-        ]);
+        const scope = packages.map(({ name }) => name);
+
+        const processTree = new ProcessTree<typeof StartProcesses>();
+
+        processTree.add(StartProcesses.Compile, () => {
+            const process = compile({
+                packages: scope,
+                watch: true,
+                useTsc,
+            });
+
+            pipeStdout(process);
+
+            const onComplete = new Promise<void>(resolve => {
+                let counter = 0;
+                let timeout: NodeJS.Timeout;
+
+                if (!useTsc) {
+                    /*
+                     * Running the timer as a fallback
+                     * In case there are no files in the package swc will not print out completion indicator
+                     */
+                    timeout = setTimeout(() => {
+                        log.warning('Compilation timeout exceeded. Proceeding without waiting.');
+                        resolve();
+                        unwatch();
+                    }, 30000);
+                }
+
+                const unwatch = watchStdout(
+                    process,
+                    useTsc
+                        ? 'Initial tsc-compile-package task completed'
+                        : 'Initial swc-compile-package task completed',
+                    count => {
+                        counter += count;
+
+                        if (counter === scope.length) {
+                            resolve();
+                            clearTimeout(timeout);
+                        }
+                    }
+                );
+            });
+
+            return { process, onComplete };
+        });
+        processTree.add(StartProcesses.PreparePackage, () =>
+            lernaExec({
+                cmd: 'startup prepare-package',
+                scope,
+                stream: true,
+            })
+        );
+        processTree.add(
+            StartProcesses.PreparePackageWatch,
+            () =>
+                lernaExec({
+                    'cmd': 'startup prepare-package',
+                    scope,
+                    'parallel': true,
+                    'stream': true,
+                    '--': ['--watch'],
+                }),
+            { dependsOn: [StartProcesses.PreparePackage] }
+        );
+        processTree.add(
+            StartProcesses.TypeCheck,
+            () => typeCheck({ packages: scope, watch: true }),
+            { dependsOn: [StartProcesses.PreparePackage] }
+        );
+        processTree.add(
+            StartProcesses.BundlePackage,
+            () => {
+                const webpackScope = packages
+                    .filter(({ type }) => type === PackageType.Webpack)
+                    .map(({ name }) => name);
+                if (webpackScope.length === 0) {
+                    return Promise.resolve();
+                }
+                return lernaExec({
+                    'cmd': 'startup bundle-package',
+                    'scope': webpackScope,
+                    'parallel': true,
+                    'stream': true,
+                    '--': [
+                        '--watch',
+                        this.args.config ? `--config "${this.args.config}"` : undefined,
+                        this.args['code-coverage'] ? '--code-coverage' : undefined,
+                    ].filter(item => !!item) as string[],
+                });
+            },
+            { dependsOn: [StartProcesses.Compile, StartProcesses.PreparePackage] }
+        );
+
+        await processTree.run();
     }
 }

package/src/cli/commands/tests.ts

@@ -7,6 +7,8 @@ import { Command } from '.';
  * Named as tests to exclude it from the Jest pattern
  */
 export class Tests implements Command {
+    readonly greedy = true;
+
     constructor(private args: Config.Argv) {}
 
     description() {

package/src/cli/commands/types.ts

@@ -1,4 +1,5 @@
 export interface Command {
+    greedy?: boolean;
     execute(): Promise<void>;
     description(): string | undefined;
 }

package/src/cli/index.ts

@@ -24,14 +24,14 @@ if (!Command) {
 checkNodeVersion();
 maybeCreateGitFolder(Command);
 
-if (setNodeOptions(name)) {
-    // Run command in child process with amended NODE_OPTIONS
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const command = new Command({ ...argvSync, _: argvSync._.slice(1) });
+if (setNodeOptions(name, command)) {
+    log.debug('run', `Running ${name} in child process with amended NODE_OPTIONS`);
     execa(process.argv[0], process.argv.slice(1), { stdio: 'inherit' }).catch(reason => {
         process.exit(reason.exitCode);
     });
 } else {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const command = new Command({ ...argvSync, _: argvSync._.slice(1) });
     command.execute().catch(() => {
         process.exit(1);
     });

package/src/cli/tasks/__tests__/cli-task.test.ts

@@ -1,6 +1,6 @@
-import execa from 'execa';
 import { log } from '../../../utils';
 import { CliTask, Indicators } from '../cli-task';
+import { pipeStdout, watchStdout } from '../../utils';
 
 jest.mock('execa', () =>
     jest.fn().mockReturnValue(
@@ -12,7 +12,13 @@ jest.mock('execa', () =>
     )
 );
 
+jest.mock('../../utils', () => ({
+    pipeStdout: jest.fn(),
+    watchStdout: jest.fn(),
+}));
+
 jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     getFolders: jest.fn().mockReturnValue({
         source: 'src',
         destination: 'dist',
@@ -64,13 +70,19 @@ describe(`[startup] ${CliTask.name} task`, () => {
     describe('in watch mode', () => {
         beforeEach(() => (watch = true));
 
+        test('it calls pipeStdout', () => {
+            subject();
+            expect(pipeStdout).toHaveBeenCalled();
+        });
+
         describe('onData handler', () => {
             beforeEach(() => subject());
 
             const onDataHandler = (data: string) => {
-                jest.mocked(jest.mocked(execa).mock.results[0].value.stdout.on).mock.calls[0][1](
-                    data
-                );
+                const handler = jest
+                    .mocked(watchStdout)
+                    .mock.calls.find(([_process, indicator]) => indicator === data)![2];
+                handler(1);
             };
 
             function itLogsInitialBuild(event: keyof Indicators) {

package/src/cli/tasks/__tests__/swc-compile-package.test.ts

@@ -0,0 +1,290 @@
+import { fs, vol } from 'memfs';
+import { swcDir } from '@swc/cli';
+import { getSwcCompilePackageConfiguration, log } from '../../../utils';
+import { SwcCompilePackage } from '../swc-compile-package';
+import deepmerge from 'deepmerge';
+
+jest.mock('fs', () => fs);
+jest.mock('@swc/cli', () => ({
+    swcDir: jest.fn(),
+}));
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getFolders: jest.fn().mockReturnValue({
+        source: 'src',
+        destination: 'dist',
+    }),
+    log: { info: jest.fn(), text: jest.fn() },
+    getSwcCompilePackageConfiguration: jest.fn(),
+}));
+
+function overwriteMerge(_destinationArray: unknown[], sourceArray: unknown[]) {
+    return sourceArray;
+}
+
+describe(`[startup] ${SwcCompilePackage.name} task`, () => {
+    function volumeFromJSON(overrides: Record<string, any> = {}) {
+        return vol.fromJSON({
+            'package.json': JSON.stringify({}),
+            'tsconfig.json': JSON.stringify({}),
+            ...Object.fromEntries(
+                Object.entries(overrides).map(([key, value]) => [key, JSON.stringify(value)])
+            ),
+        });
+    }
+
+    beforeEach(() => {
+        globalThis.performance.clearMarks();
+        globalThis.performance.clearMeasures();
+        jest.clearAllMocks();
+
+        jest.mocked(getSwcCompilePackageConfiguration).mockReturnValue({});
+        volumeFromJSON();
+    });
+
+    afterEach(() => vol.reset());
+
+    let watch = false;
+
+    const subject = () => new SwcCompilePackage({ watch }).execute();
+
+    const onSuccessHandlerParams = {
+        duration: 10,
+    };
+    const callOnSuccessHandler = (parameters: { duration: number }) => {
+        jest.mocked(swcDir).mock.calls[0][0].callbacks!.onSuccess(parameters);
+    };
+
+    const onFailHandlerParams = {
+        duration: 10,
+        reasons: new Map([['index.js', 'Syntax error']]),
+    };
+    const callOnFailHandler = (parameters: { duration: number; reasons: Map<string, string> }) => {
+        jest.mocked(swcDir).mock.calls[0][0].callbacks!.onFail(parameters);
+    };
+
+    function itCallsSwcDir(
+        packageConfig: ReturnType<typeof getSwcCompilePackageConfiguration> = {}
+    ) {
+        test('calls swcDir', () => {
+            subject();
+
+            expect(swcDir).toHaveBeenCalledWith(
+                deepmerge(
+                    {
+                        cliOptions: {
+                            watch: false,
+                            outDir: 'dist',
+                            stripLeadingPaths: true,
+                            extensions: ['.ts', '.tsx'],
+                            filenames: ['src'],
+                            ignore: [
+                                '**/*.d.ts',
+                                '**/__tests__/*',
+                                '**/*.test.*',
+                                '**/__mocks__/*',
+                                '**/*.stories.*',
+                            ],
+                        },
+                        swcOptions: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    tsx: true,
+                                    decorators: true,
+                                },
+                                transform: {
+                                    react: {
+                                        runtime: 'automatic',
+                                    },
+                                },
+                            },
+                            module: {
+                                type: 'es6',
+                            },
+                        },
+                        callbacks: {
+                            onSuccess: expect.any(Function),
+                            onFail: expect.any(Function),
+                        },
+                    },
+                    packageConfig,
+                    { arrayMerge: overwriteMerge, clone: false }
+                )
+            );
+        });
+    }
+
+    itCallsSwcDir();
+
+    describe('when package has swc-compile-package config', () => {
+        const overrides = {
+            cliOptions: { ignore: ['**/*.d.ts', '**/__tests__/*', '**/*.test.*'] },
+        };
+        beforeEach(() => {
+            jest.mocked(getSwcCompilePackageConfiguration).mockReturnValue(overrides);
+        });
+
+        itCallsSwcDir(overrides);
+    });
+
+    describe('when tsconfig contains "exclude"', () => {
+        const exclude = ['**/stories.*'];
+
+        beforeEach(() => {
+            volumeFromJSON({
+                'base.json': { exclude },
+                'tsconfig.build.json': { extends: './base' },
+            });
+        });
+
+        test('uses exclude config', () => {
+            subject();
+
+            expect(swcDir).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    cliOptions: expect.objectContaining({ ignore: exclude }),
+                })
+            );
+        });
+    });
+
+    describe.each(
+        Object.entries({
+            target: 'jsc.target',
+            experimentalDecorators: 'jsc.transform.legacyDecorator',
+            emitDecoratorMetadata: 'jsc.transform.decoratorMetadata',
+            sourceMap: 'sourceMaps',
+        })
+    )('when tsconfig contains "compilerOptions.%s"', (compilerOption, swcOption) => {
+        beforeEach(() => {
+            volumeFromJSON({
+                'tsconfig.json': { compilerOptions: { [compilerOption]: 'foo' } },
+            });
+        });
+
+        test(`configures swcOptions.${swcOption}`, () => {
+            subject();
+
+            const keys = swcOption.split('.').toReversed();
+            const expected = keys.slice(1).reduce(
+                (result, key) => {
+                    return expect.objectContaining({ [key]: result });
+                },
+                expect.objectContaining({ [keys[0]]: 'foo' })
+            );
+            expect(swcDir).toHaveBeenCalledWith(expect.objectContaining({ swcOptions: expected }));
+        });
+    });
+
+    describe('when package is commonjs', () => {
+        beforeEach(() => {
+            volumeFromJSON({
+                'tsconfig.json': { compilerOptions: { module: 'commonjs' } },
+            });
+        });
+
+        test('swc module type is commonjs', () => {
+            subject();
+
+            expect(swcDir).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    swcOptions: expect.objectContaining({
+                        module: { type: 'commonjs' },
+                    }),
+                })
+            );
+        });
+    });
+
+    test('onSuccess handler completes task and logs completion message', async () => {
+        const task = subject();
+
+        callOnSuccessHandler(onSuccessHandlerParams);
+
+        await task;
+
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringMatching(
+                `swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
+            )
+        );
+    });
+
+    test('onFail handler fails task and logs completion message', async () => {
+        const task = subject();
+
+        callOnFailHandler(onFailHandlerParams);
+
+        await expect(task).rejects.toThrow('Compilation failed');
+
+        expect(log.text).toHaveBeenCalledWith('Syntax error');
+
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringMatching(
+                `swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
+            )
+        );
+    });
+
+    describe('in watch mode', () => {
+        beforeEach(() => (watch = true));
+
+        test('calls swcDir with watch=true', () => {
+            subject();
+
+            expect(swcDir).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    cliOptions: expect.objectContaining({
+                        watch: true,
+                    }),
+                })
+            );
+        });
+
+        test('onSuccess handler logs completion messages', () => {
+            subject();
+
+            callOnSuccessHandler(onSuccessHandlerParams);
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Initial swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
+                )
+            );
+
+            callOnSuccessHandler(onSuccessHandlerParams);
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Subsequent swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
+                )
+            );
+        });
+
+        test('onFail handler logs completion message', () => {
+            subject();
+
+            callOnFailHandler(onFailHandlerParams);
+
+            expect(log.text).toHaveBeenCalledWith('Syntax error');
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Initial swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
+                )
+            );
+
+            callOnFailHandler(onFailHandlerParams);
+
+            expect(log.text).toHaveBeenCalledWith('Syntax error');
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Subsequent swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
+                )
+            );
+        });
+    });
+});

package/src/cli/tasks/__tests__/tsc-compile-package.test.ts

@@ -30,6 +30,7 @@ const tscOptions = [
 ];
 
 jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     getFolders: jest.fn().mockReturnValue({
         source: 'src',
         destination: 'dist',

package/src/cli/tasks/__tests__/tsc-compile.test.ts

@@ -1,6 +1,7 @@
 import execa from 'execa';
 import { fs, vol } from 'memfs';
 import path from 'path';
+import { log } from '../../../utils';
 import { TscCompile } from '../tsc-compile';
 
 jest.mock('fs', () => fs);
@@ -15,10 +16,7 @@ jest.mock('execa', () =>
 );
 
 describe(`[startup] ${TscCompile.name} task`, () => {
-    let watch = false;
-    let typeCheckOnly = false;
-    let scope: string[];
-    let ignore: string[];
+    let options: ConstructorParameters<typeof TscCompile>[0];
 
     beforeEach(() => {
         vol.fromJSON({
@@ -48,19 +46,13 @@ describe(`[startup] ${TscCompile.name} task`, () => {
             }),
             'package.json': JSON.stringify({ workspaces: ['packages/*'] }),
         });
-    });
-
-    afterEach(() => {
-        vol.reset();
-        globalThis.performance.clearMarks();
-        globalThis.performance.clearMeasures();
         jest.clearAllMocks();
-        watch = false;
-        typeCheckOnly = false;
-        scope = [];
-        ignore = [];
+        jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress log output
+        options = {};
     });
 
+    afterEach(() => vol.reset());
+
     function itRunsTsc(
         caption: string,
         {
@@ -97,7 +89,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
         });
     }
 
-    const subject = () => new TscCompile({ watch, typeCheckOnly, scope, ignore }).execute();
+    const subject = () => new TscCompile(options).execute();
 
     itRunsTsc('', {
         tsConfigs: ['foo/tsconfig.json', 'bar/tsconfig.json'],
@@ -105,7 +97,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
     });
 
     describe('in watch mode', () => {
-        beforeEach(() => (watch = true));
+        beforeEach(() => (options = { watch: true }));
 
         itRunsTsc('in watch mode', {
             watch: true,
@@ -115,7 +107,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
     });
 
     describe('with "typeCheckOnly" mode', () => {
-        beforeEach(() => (typeCheckOnly = true));
+        beforeEach(() => (options = { typeCheckOnly: true }));
 
         itRunsTsc('in "typeCheckOnly" mode', {
             typeCheckOnly: true,
@@ -125,7 +117,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
     });
 
     describe('with "scope"', () => {
-        beforeEach(() => (scope = ['foo']));
+        beforeEach(() => (options = { scope: ['foo'] }));
 
         itRunsTsc('with only specified package', {
             tsConfigs: ['foo/tsconfig.json'],
@@ -134,7 +126,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
     });
 
     describe('with "ignore"', () => {
-        beforeEach(() => (ignore = ['foo']));
+        beforeEach(() => (options = { ignore: ['foo'] }));
 
         itRunsTsc('without specified package', {
             tsConfigs: ['baz/tsconfig.json', 'bar/tsconfig.json'],
@@ -143,10 +135,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
     });
 
     describe('with both "scope" and "ignore"', () => {
-        beforeEach(() => {
-            scope = ['ba*'];
-            ignore = ['bar'];
-        });
+        beforeEach(() => (options = { scope: ['ba*'], ignore: ['bar'] }));
 
         itRunsTsc('with combined filters', {
             tsConfigs: ['baz/tsconfig.json'],