@servicetitan/startup 30.3.0 → 31.0.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,116 @@ 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',
+                parallel: true,
+                scope,
+                stream: true,
+                ...(useTsc ? { '--': ['--copy-files'] } : {}),
+            })
+        );
+        processTree.add(
+            StartProcesses.PreparePackageWatch,
+            () =>
+                lernaExec({
+                    'cmd': 'startup prepare-package',
+                    scope,
+                    'parallel': true,
+                    'stream': true,
+                    '--': ['--watch', ...(useTsc ? ['--copy-files'] : [])],
+                }),
+            { 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.test.ts → swc-compile-package.test.ts}

@@ -1,13 +1,15 @@
 import { swcDir } from '@swc/cli';
-import { log, readJson } from '../../../utils';
+import { getSwcCompilePackageConfiguration, log, readJson } from '../../../utils';
 import { SwcCompilePackage } from '../swc-compile-package';
 import { compilerOptions } from '../../../../tsconfig/base.json';
+import deepmerge from 'deepmerge';
 
 jest.mock('@swc/cli', () => ({
     swcDir: jest.fn(),
 }));
 
 jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     getFolders: jest.fn().mockReturnValue({
         source: 'src',
         destination: 'dist',
@@ -15,14 +17,18 @@ jest.mock('../../../utils', () => ({
     log: { info: jest.fn(), text: jest.fn() },
     readJsonSafe: jest.fn().mockReturnValue({}),
     readJson: jest.fn().mockReturnValue({}),
+    getSwcCompilePackageConfiguration: jest.fn().mockReturnValue({}),
 }));
 
+function overwriteMerge(_destinationArray: unknown[], sourceArray: unknown[]) {
+    return sourceArray;
+}
+
 describe(`[startup] ${SwcCompilePackage.name} task`, () => {
     beforeEach(() => {
         globalThis.performance.clearMarks();
         globalThis.performance.clearMeasures();
         jest.clearAllMocks();
-        jest.restoreAllMocks();
     });
 
     let watch = false;
@@ -33,7 +39,7 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
         duration: 10,
     };
     const callOnSuccessHandler = (parameters: { duration: number }) => {
-        jest.mocked(swcDir).mock.calls[0][0].callbacks.onSuccess(parameters);
+        jest.mocked(swcDir).mock.calls[0][0].callbacks!.onSuccess(parameters);
     };
 
     const onFailHandlerParams = {
@@ -41,43 +47,76 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
         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);
+        jest.mocked(swcDir).mock.calls[0][0].callbacks!.onFail(parameters);
     };
 
-    test('calls swcDir', () => {
-        subject();
-
-        expect(swcDir).toHaveBeenCalledWith({
-            cliOptions: {
-                watch: false,
-                outDir: 'dist',
-                stripLeadingPaths: true,
-                extensions: ['.ts', '.tsx'],
-                filenames: ['src'],
-            },
-            swcOptions: {
-                jsc: {
-                    parser: {
-                        syntax: 'typescript',
-                        tsx: true,
-                        decorators: true,
-                    },
-                    target: compilerOptions.target,
-                    transform: {
-                        legacyDecorator: compilerOptions.experimentalDecorators,
-                        decoratorMetadata: compilerOptions.emitDecoratorMetadata,
+    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__/*',
+                            ],
+                            copyFiles: true,
+                        },
+                        swcOptions: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    tsx: true,
+                                    decorators: true,
+                                },
+                                target: compilerOptions.target,
+                                transform: {
+                                    legacyDecorator: compilerOptions.experimentalDecorators,
+                                    decoratorMetadata: compilerOptions.emitDecoratorMetadata,
+                                    react: {
+                                        runtime: 'automatic',
+                                    },
+                                },
+                            },
+                            sourceMaps: compilerOptions.sourceMap,
+                            module: {
+                                type: 'es6',
+                            },
+                        },
+                        callbacks: {
+                            onSuccess: expect.any(Function),
+                            onFail: expect.any(Function),
+                        },
                     },
-                },
-                sourceMaps: compilerOptions.sourceMap,
-                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 package is commonjs', () => {

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'],

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

@@ -1,5 +1,6 @@
 import execa from 'execa';
 import { Task, TaskParameters } from './task';
+import { pipeStdout, watchStdout } from '../utils';
 
 export interface Indicators {
     end: string;
@@ -41,24 +42,17 @@ export abstract class CliTask extends Task {
             return;
         }
 
-        childProcess.stdout!.on('data', this.stdoutDataHandler);
-        await childProcess;
-    }
-
-    private readonly stdoutDataHandler = (data: Uint8Array | string) => {
-        process.stdout.write(data);
-
-        const dataStr = data.toString();
-
-        if (dataStr.includes(this.indicators.watchStart)) {
+        pipeStdout(childProcess);
+        watchStdout(childProcess, this.indicators.watchStart, () => {
             this.taskTimer.start();
-        }
-
-        if (
-            dataStr.includes(this.indicators.end) ||
-            (this.indicators.watchEnd && dataStr.includes(this.indicators.watchEnd))
-        ) {
+        });
+        watchStdout(childProcess, this.indicators.end, () => {
             this.logCompletionResults(this.taskTimer.end());
-        }
-    };
+        });
+        watchStdout(childProcess, this.indicators.watchEnd, () => {
+            this.logCompletionResults(this.taskTimer.end());
+        });
+
+        await childProcess;
+    }
 }

package/src/cli/tasks/swc-cli.d.ts

@@ -1,3 +1,14 @@
 declare module '@swc/cli' {
-    function swcDir(options: any): void;
+    interface Options {
+        cliOptions?: {
+            [key: string]: unknown;
+        };
+        swcOptions?: {
+            [key: string]: unknown;
+        };
+        callbacks?: {
+            [key: string]: Function;
+        };
+    }
+    function swcDir(options: Options): void;
 }