@servicetitan/startup 30.3.1 → 31.1.0

package/src/cli/utils/__tests__/get-module-type.test.ts

@@ -47,5 +47,24 @@ describe('[startup] Cli Utils', () => {
                 expect(subject()).toBe(module);
             });
         });
+
+        describe('when config extends relative path', () => {
+            const module = 'baz';
+
+            beforeEach(() => {
+                vol.fromJSON({
+                    'base.json': JSON.stringify({
+                        compilerOptions: { module },
+                    }),
+                    'foo/tsconfig.json': JSON.stringify({
+                        extends: '../base.json',
+                    }),
+                });
+            });
+
+            test("returns extended config's module", () => {
+                expect(subject('foo/tsconfig.json')).toBe(module);
+            });
+        });
     });
 });

package/src/cli/utils/__tests__/lerna-exec.test.ts

@@ -5,6 +5,13 @@ import { lernaExec } from '../lerna-exec';
 
 jest.mock('execa');
 
+const AVAILABLE_PARALLELISM = 2;
+
+jest.mock('node:os', () => ({
+    ...jest.requireActual('node:os'),
+    availableParallelism: () => AVAILABLE_PARALLELISM,
+}));
+
 describe(`${lernaExec.name}`, () => {
     let args: Parameters<typeof lernaExec>[0];
 
@@ -12,34 +19,60 @@ describe(`${lernaExec.name}`, () => {
         jest.clearAllMocks();
         jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress log output
         args = { cmd: 'foo' };
+        delete process.env.CI;
     });
 
     const subject = () => lernaExec(args);
 
     function expectExecaCalledWith(commandLine: string) {
         const [cmd, ...args] = commandLine.split(' ');
-        expect(execa).toHaveBeenCalledWith(cmd, args, { stdio: 'inherit' });
+        expect(execa).toHaveBeenCalledWith(cmd, args, {
+            stdio: 'inherit',
+            env: {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                FORCE_COLOR: 'true',
+            },
+        });
     }
 
-    test('runs "lerna exec -- {cmd}" command', () => {
-        subject();
+    function itRunsLernaExec(option?: string) {
+        const optionString = option ? ` ${option}` : '';
+        test(`runs "lerna exec${optionString} -- {cmd}"`, () => {
+            subject();
 
-        expectExecaCalledWith(`lerna exec -- ${args.cmd}`);
-    });
+            expectExecaCalledWith(`lerna exec${optionString} -- ${args.cmd}`);
+        });
+    }
+
+    itRunsLernaExec();
 
     describe.each([
         { arg: { parallel: true }, option: '--parallel' },
         { arg: { stream: true }, option: '--stream' },
         { arg: { bail: false }, option: '--no-bail' },
-        { arg: { concurrency: 1 }, option: '--concurrency=1' },
-        { arg: { concurrency: 0 }, option: '--concurrency=0' },
+        { arg: { parallel: 1 }, option: '--concurrency=1' },
+        { arg: { parallel: 0 }, option: '--concurrency=0' },
     ] as { arg: Partial<typeof args>; option: string }[])('with $arg', ({ arg, option }) => {
-        beforeEach(() => Object.assign(args, arg));
+        beforeEach(() => {
+            Object.assign(args, arg);
+        });
 
-        test(`runs "lerna exec ${option} -- {cmd}"`, () => {
-            subject();
+        itRunsLernaExec(option);
+    });
 
-            expectExecaCalledWith(`lerna exec ${option} -- ${args.cmd}`);
+    describe('when process.env.CI=true', () => {
+        beforeEach(() => {
+            process.env.CI = 'true';
+        });
+        describe.each([
+            { arg: { parallel: true }, option: `--concurrency=${AVAILABLE_PARALLELISM}` },
+            { arg: { parallel: 10 }, option: '--concurrency=10' },
+        ] as { arg: Partial<typeof args>; option: string }[])('with $arg', ({ arg, option }) => {
+            beforeEach(() => {
+                Object.assign(args, arg);
+            });
+
+            itRunsLernaExec(option);
         });
     });
 
@@ -63,4 +96,18 @@ describe(`${lernaExec.name}`, () => {
             expectExecaCalledWith(`lerna exec -- ${args.cmd} ${args['--']!.join(' ')}`);
         });
     });
+
+    describe('with "stdio"', () => {
+        beforeEach(() => (args.stdio = 'ignore'));
+
+        test('runs execa with stdio option', () => {
+            subject();
+
+            expect(execa).toHaveBeenCalledWith(
+                'lerna',
+                expect.any(Array),
+                expect.objectContaining({ stdio: args.stdio })
+            );
+        });
+    });
 });

package/src/cli/utils/__tests__/pipe-stdout.test.ts

@@ -0,0 +1,39 @@
+import execa from 'execa';
+import { pipeStdout } from '../pipe-stdout';
+
+describe(`${pipeStdout.name}`, () => {
+    const proc = {
+        stdout: { on: jest.fn(), off: jest.fn() },
+    } as unknown as execa.ExecaChildProcess;
+
+    const subject = () => pipeStdout(proc);
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+    });
+
+    test('subscribes to stdout', () => {
+        subject();
+
+        expect(proc.stdout!.on).toHaveBeenCalledWith('data', expect.any(Function));
+    });
+
+    test('unsubscribes from stdout', () => {
+        const unsubscribe = subject();
+        const handler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+        unsubscribe();
+
+        expect(proc.stdout!.off).toHaveBeenCalledWith('data', handler);
+    });
+
+    test('handler writes output to stdout', () => {
+        subject();
+
+        const handler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+        handler('output');
+
+        expect(globalThis.process.stdout.write).toHaveBeenCalledWith('output');
+    });
+});

package/src/cli/utils/__tests__/process-tree.test.ts

@@ -0,0 +1,175 @@
+import { HandlerResult, ProcessTree } from '../process-tree';
+
+enum TestProcesses {
+    A,
+    B,
+    C,
+}
+
+describe(`[startup] ${ProcessTree.name}`, () => {
+    const createProcess = (
+        name: number,
+        timeout: number,
+        { watchMode = false, returnObject }: { watchMode?: boolean; returnObject?: boolean } = {}
+    ) => {
+        output.push(`started:${name}`);
+        if (watchMode) {
+            return {
+                process: new Promise(() => {}),
+                onComplete: new Promise<void>(resolve =>
+                    setTimeout(() => {
+                        output.push(`completed:${name}`);
+                        resolve();
+                    }, timeout)
+                ),
+            };
+        }
+        const promise = new Promise<void>(resolve =>
+            setTimeout(() => {
+                output.push(`finished:${name}`);
+                resolve();
+            }, timeout)
+        );
+        return returnObject ? promise : { process: promise };
+    };
+
+    const subject = async () => {
+        const processTree = new ProcessTree<typeof TestProcesses>();
+
+        [TestProcesses.A, TestProcesses.B, TestProcesses.C].forEach(id => {
+            processTree.add(id, handlers[id], {
+                ...(dependsOn[id] ? { dependsOn: dependsOn[id] } : {}),
+            });
+        });
+
+        processTree.run();
+
+        await jest.runAllTimersAsync();
+
+        return processTree;
+    };
+
+    let handlers: Record<TestProcesses, () => HandlerResult>;
+    let dependsOn: { [key in TestProcesses]?: TestProcesses[] };
+    let output: string[] = [];
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        jest.clearAllMocks();
+        output = [];
+        handlers = {
+            [TestProcesses.A]: () => {
+                return createProcess(TestProcesses.A, 3000);
+            },
+            [TestProcesses.B]: () => {
+                return createProcess(TestProcesses.B, 2000);
+            },
+            [TestProcesses.C]: () => {
+                return createProcess(TestProcesses.C, 1000);
+            },
+        };
+        dependsOn = {};
+    });
+
+    function itRunsProcessesInParallel() {
+        test('runs processes in parallel', async () => {
+            await subject();
+            expect(output).toEqual([
+                `started:${TestProcesses.A}`,
+                `started:${TestProcesses.B}`,
+                `started:${TestProcesses.C}`,
+                `finished:${TestProcesses.C}`,
+                `finished:${TestProcesses.B}`,
+                `finished:${TestProcesses.A}`,
+            ]);
+        });
+    }
+
+    itRunsProcessesInParallel();
+
+    describe('when handler returns an object', () => {
+        beforeEach(() => {
+            handlers[TestProcesses.A] = () =>
+                createProcess(TestProcesses.A, 3000, { returnObject: true });
+        });
+
+        itRunsProcessesInParallel();
+    });
+
+    describe('when processes have dependencies', () => {
+        beforeEach(() => (dependsOn[TestProcesses.B] = [TestProcesses.A]));
+
+        test('waits for dependency to finish', async () => {
+            await subject();
+            expect(output).toEqual([
+                `started:${TestProcesses.A}`,
+                `started:${TestProcesses.C}`,
+                `finished:${TestProcesses.C}`,
+                `finished:${TestProcesses.A}`,
+                `started:${TestProcesses.B}`,
+                `finished:${TestProcesses.B}`,
+            ]);
+        });
+
+        describe('when dependency is in watch mode', () => {
+            beforeEach(() => {
+                handlers[TestProcesses.A] = () =>
+                    createProcess(TestProcesses.A, 3000, { watchMode: true });
+            });
+
+            test('waits for dependency to complete initialization', async () => {
+                await subject();
+                expect(output).toEqual([
+                    `started:${TestProcesses.A}`,
+                    `started:${TestProcesses.C}`,
+                    `finished:${TestProcesses.C}`,
+                    `completed:${TestProcesses.A}`,
+                    `started:${TestProcesses.B}`,
+                    `finished:${TestProcesses.B}`,
+                ]);
+            });
+        });
+
+        describe('when more than one process depends on another', () => {
+            beforeEach(() => (dependsOn[TestProcesses.C] = [TestProcesses.A]));
+
+            test('processes wait for dependencies to finish', async () => {
+                await subject();
+                expect(output).toEqual([
+                    `started:${TestProcesses.A}`,
+                    `finished:${TestProcesses.A}`,
+                    `started:${TestProcesses.B}`,
+                    `started:${TestProcesses.C}`,
+                    `finished:${TestProcesses.C}`,
+                    `finished:${TestProcesses.B}`,
+                ]);
+            });
+        });
+
+        describe('when process depends on multiple processes', () => {
+            beforeEach(() => {
+                dependsOn[TestProcesses.C] = [TestProcesses.A, TestProcesses.B];
+            });
+            test('waits for all dependencies to finish', async () => {
+                await subject();
+                expect(output).toEqual([
+                    `started:${TestProcesses.A}`,
+                    `finished:${TestProcesses.A}`,
+                    `started:${TestProcesses.B}`,
+                    `finished:${TestProcesses.B}`,
+                    `started:${TestProcesses.C}`,
+                    `finished:${TestProcesses.C}`,
+                ]);
+            });
+        });
+    });
+
+    test("throws when dependency doesn't exist", () => {
+        const processTree = new ProcessTree<typeof TestProcesses>();
+        expect(() =>
+            processTree.add(TestProcesses.A, handlers[TestProcesses.A], {
+                dependsOn: [TestProcesses.B],
+            })
+        ).toThrow(/Unknown process dependency/);
+    });
+});

package/src/cli/utils/__tests__/set-node-options.test.ts

@@ -1,6 +1,6 @@
 import os from 'os';
 import { getConfigurationSafe } from '../../../utils';
-import { CommandName } from '../../../utils/get-configuration';
+import { Command } from '../../commands';
 
 import { setNodeOptions } from '../set-node-options';
 
@@ -13,21 +13,37 @@ jest.mock('../../../utils', () => ({
     getConfigurationSafe: jest.fn(() => ({})),
 }));
 
+class MockCommand implements Command {
+    get greedy() {
+        return true;
+    }
+
+    description() {
+        return 'mock command';
+    }
+
+    async execute() {
+        return Promise.resolve();
+    }
+}
+
 describe(`[startup] utils:${setNodeOptions.name}`, () => {
     const MB = 1024 * 1024;
     const DEFAULT_SIZE = 8192;
     const originalNodeOptions = process.env.NODE_OPTIONS;
     const maxOldSpaceSize = `--max_old_space_size=${DEFAULT_SIZE}`;
-    const command = CommandName.build;
+    const commandName: any = 'mock';
+    const command = new MockCommand();
 
     beforeEach(() => {
         delete process.env.NODE_OPTIONS;
         (os.totalmem as jest.Mock).mockReturnValue(16384 * MB);
+        jest.spyOn(command, 'greedy', 'get').mockReturnValue(true);
     });
 
     afterAll(() => (process.env.NODE_OPTIONS = originalNodeOptions));
 
-    const subject = () => setNodeOptions(command);
+    const subject = () => setNodeOptions(commandName, command);
 
     test(`returns true and adds ${maxOldSpaceSize} to process.env.NODE_OPTIONS`, () => {
         expect(subject()).toBe(true);
@@ -35,6 +51,16 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
         expect(process.env.NODE_OPTIONS).toEqual(maxOldSpaceSize);
     });
 
+    describe('when the command is not greedy', () => {
+        beforeEach(() => jest.spyOn(command, 'greedy', 'get').mockReturnValue(false));
+
+        test('returns false and does not set NODE_OPTIONS', () => {
+            expect(subject()).toBe(false);
+
+            expect(process.env.NODE_OPTIONS).toBeUndefined();
+        });
+    });
+
     describe('when system has insufficient memory', () => {
         const totalMem = 4096 * MB;
 
@@ -104,11 +130,11 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
 
             beforeEach(() => (process.env.NODE_OPTIONS = envOptions));
 
-            test("prepends cli's NODE_OPTIONS to existing NODE_OPTIONS", () => {
+            test("appends cli's NODE_OPTIONS to existing NODE_OPTIONS", () => {
                 expect(subject()).toBe(true);
 
                 expect(process.env.NODE_OPTIONS).toEqual(
-                    [maxOldSpaceSize, ...options, envOptions].join(' ')
+                    [maxOldSpaceSize, envOptions, ...options].join(' ')
                 );
             });
         });
@@ -120,7 +146,7 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
         beforeEach(() =>
             (getConfigurationSafe as jest.Mock).mockReturnValue({
                 // eslint-disable-next-line @typescript-eslint/naming-convention
-                [command]: { NODE_OPTIONS: options },
+                [commandName]: { NODE_OPTIONS: options },
             })
         );
 
@@ -130,4 +156,23 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
             expect(process.env.NODE_OPTIONS).toBe(`${maxOldSpaceSize} ${options.join(' ')}`);
         });
     });
+
+    describe("when cli's and command's config have duplicate NODE_OPTIONS", () => {
+        const options = ['--no-warning', '--test'];
+
+        beforeEach(() => {
+            (getConfigurationSafe as jest.Mock).mockReturnValue({
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                NODE_OPTIONS: options,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                [commandName]: { NODE_OPTIONS: options },
+            });
+        });
+
+        test('drops duplicate NODE_OPTIONS', () => {
+            subject();
+
+            expect(process.env.NODE_OPTIONS).toBe(`${maxOldSpaceSize} ${options.join(' ')}`);
+        });
+    });
 });

package/src/cli/utils/__tests__/type-check.test.ts

@@ -0,0 +1,47 @@
+import execa from 'execa';
+import { typeCheck } from '../type-check';
+
+jest.mock('execa', () => jest.fn());
+
+describe('[startup] Cli Utils', () => {
+    describe(`${typeCheck.name}`, () => {
+        const packages = ['foo', 'bar'];
+        let args: Parameters<typeof typeCheck>[0];
+
+        beforeEach(() => {
+            jest.clearAllMocks();
+            args = { packages };
+        });
+
+        function itRunsTscCompile({ watch }: { watch?: boolean } = {}) {
+            expect(execa).toHaveBeenCalledWith(
+                'startup',
+                [
+                    'task',
+                    'tsc-compile',
+                    ...packages.map(name => `--scope=${name}`),
+                    watch ? '--watch' : undefined,
+                ].filter(i => i !== undefined),
+                { stdio: 'inherit' }
+            );
+        }
+
+        const subject = async () => typeCheck(args);
+
+        test('type checks packages', async () => {
+            await subject();
+
+            itRunsTscCompile();
+        });
+
+        describe('with "watch"', () => {
+            beforeEach(() => (args.watch = true));
+
+            test('type checks packages in watch mode', async () => {
+                await subject();
+
+                itRunsTscCompile({ watch: true });
+            });
+        });
+    });
+});

package/src/cli/utils/__tests__/watch-stdout.test.ts

@@ -0,0 +1,68 @@
+import execa from 'execa';
+import { watchStdout } from '../watch-stdout';
+
+describe(`${watchStdout.name}`, () => {
+    const proc = {
+        stdout: { on: jest.fn(), off: jest.fn() },
+    } as unknown as execa.ExecaChildProcess;
+    let indicator = 'indicator';
+    const handler = jest.fn();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+        indicator = 'indicator';
+    });
+
+    const subject = () => watchStdout(proc, indicator, handler);
+
+    test('subscribes to stdout', () => {
+        subject();
+
+        expect(proc.stdout!.on).toHaveBeenCalledWith('data', expect.any(Function));
+    });
+
+    test('unsubscribes from stdout', () => {
+        const unsubscribe = subject();
+
+        const stdoutHandler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+        unsubscribe();
+
+        expect(proc.stdout!.off).toHaveBeenCalledWith('data', stdoutHandler);
+    });
+
+    describe('when indicator is empty string', () => {
+        beforeEach(() => {
+            indicator = '';
+        });
+
+        test("doesn't subscribe to stdout", () => {
+            subject();
+
+            expect(proc.stdout!.on).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('stdout handler', () => {
+        beforeEach(() => {
+            subject();
+        });
+
+        test('calls the handler when there is match', () => {
+            const stdoutHandler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+            stdoutHandler(indicator);
+
+            expect(handler).toHaveBeenCalledWith(1);
+        });
+
+        test("doesn't call the handler when there is no match", () => {
+            const stdoutHandler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+            stdoutHandler('abc');
+
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+});

package/src/cli/utils/bundle.ts

@@ -6,15 +6,19 @@ import { getPortPromise } from 'portfinder';
 import webpack, { Configuration } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
 
-import { getPackageName, isDevServerDisabled, isWebComponent, log } from '../../utils';
+import {
+    getPackageName,
+    hasHeadlessBundle,
+    isDevServerDisabled,
+    isWebComponent,
+    log,
+} from '../../utils';
 import { Overrides, createWebpackConfig } from '../../webpack';
 
 interface Options {
     buildStat?: boolean;
     codeCoverage?: boolean;
     config?: string;
-    esbuild?: boolean;
-    experimentalBundlers?: boolean;
 }
 
 function getName() {
@@ -36,9 +40,8 @@ export async function bundle(options: Options = {}) {
     const mode = 'production';
     const fallback = `./${webpackProdConfigFileName}`;
     const config = readWebpackConfig({ ...options, fallback });
-    const { buildStat, codeCoverage, esbuild, experimentalBundlers } = options;
-
-    const webpackOptions = { name, buildStat, codeCoverage, esbuild, experimentalBundlers };
+    const { buildStat, codeCoverage } = options;
+    const webpackOptions = { name, buildStat, codeCoverage };
 
     if (isWebComponent()) {
         const webpackConfig: Overrides = {
@@ -46,10 +49,18 @@ export async function bundle(options: Options = {}) {
             plugins: config?.plugins,
         };
 
-        return Promise.all([
+        const bundles = [
             run(createWebpackConfig(webpackConfig, { embed: true, ...webpackOptions })),
             run(createWebpackConfig(webpackConfig, webpackOptions)),
-        ]);
+        ];
+
+        if (hasHeadlessBundle()) {
+            bundles.push(
+                run(createWebpackConfig(webpackConfig, { ...webpackOptions, headless: true }))
+            );
+        }
+
+        return Promise.all(bundles);
     }
 
     return run(config ?? createWebpackConfig({ configuration: { mode } }, webpackOptions));
@@ -61,8 +72,7 @@ export async function bundleWatch(options: Options = {}) {
     const name = getName();
     const mode = 'development';
     const config = readWebpackConfig({ ...options, fallback: `./${webpackDevConfigFileName}` });
-    const { codeCoverage, esbuild, experimentalBundlers } = options;
-    const configOverrides = { codeCoverage, esbuild, experimentalBundlers, name };
+    const configOverrides = { codeCoverage: options.codeCoverage, name };
 
     if (isWebComponent()) {
         const webpackConfig: Overrides = {
@@ -70,27 +80,26 @@ export async function bundleWatch(options: Options = {}) {
             plugins: config?.plugins,
         };
 
-        return Promise.all([
-            runWatch(
-                createWebpackConfig(webpackConfig, {
-                    embed: true,
-                    ...configOverrides,
-                })
-            ),
+        const bundles = [
+            runWatch(createWebpackConfig(webpackConfig, { embed: true, ...configOverrides })),
             isDevServerDisabled()
                 ? runWatch(createWebpackConfig(webpackConfig, configOverrides))
                 : runServe(createWebpackConfig(webpackConfig, configOverrides)),
-        ]);
+        ];
+
+        if (hasHeadlessBundle()) {
+            bundles.push(
+                runWatch(createWebpackConfig(webpackConfig, { ...configOverrides, headless: true }))
+            );
+        }
+
+        return Promise.all(bundles);
     }
 
     const webpackConfig =
         config ?? createWebpackConfig({ configuration: { mode } }, configOverrides);
 
-    if (isDevServerDisabled()) {
-        return runWatch(webpackConfig);
-    }
-
-    return runServe(webpackConfig);
+    return isDevServerDisabled() ? runWatch(webpackConfig) : runServe(webpackConfig);
 }
 
 function readWebpackConfig({ config, fallback }: Options & { fallback: string }) {

package/src/cli/utils/check-args.ts

@@ -0,0 +1,13 @@
+import { log } from '../../utils';
+
+interface Options {
+    obsolete?: string[];
+}
+
+export function checkArgs(args: Record<string, any>, { obsolete }: Options) {
+    obsolete?.forEach(arg => {
+        if (args[arg.replace(/^--/, '')]) {
+            log.warning(`WARNING: ${arg} option is obsolete and is ignored`);
+        }
+    });
+}