@servicetitan/startup 38.0.0 → 38.2.0

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

@@ -1,30 +1,17 @@
-import { log } from '../../../utils';
-import { pipeStdout, watchStdout } from '../../utils';
+import execa from 'execa';
+import { exitWhenParentExits, getFolders, log, readJsonSafe } from '../../../utils';
+import { killProcessTree, pipeStdout, watchStdout } from '../../utils';
 import { CliTask, Indicators } from '../cli-task';
 
-jest.mock('execa', () =>
-    jest.fn().mockReturnValue(
-        Object.assign(Promise.resolve(), {
-            stdout: {
-                on: jest.fn(),
-            },
-        })
-    )
-);
-
-jest.mock('../../utils', () => ({
-    pipeStdout: jest.fn(),
-    watchStdout: jest.fn(),
-}));
+jest.mock('execa', () => jest.fn());
+jest.mock('../../utils');
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
-    getFolders: jest.fn().mockReturnValue({
-        source: 'src',
-        destination: 'dist',
-    }),
+    exitWhenParentExits: jest.fn(),
+    getFolders: jest.fn(),
     log: { info: jest.fn() },
-    readJsonSafe: jest.fn().mockReturnValue({}),
+    readJsonSafe: jest.fn(),
 }));
 
 const taskName = 'cli-task-impl';
@@ -35,7 +22,11 @@ const indicators: Required<Indicators> = {
 };
 
 class CliTaskImpl extends CliTask {
-    constructor({ watch }: { watch: boolean }) {
+    constructor(
+        private command: string,
+        private args: string[],
+        { watch }: { watch: boolean }
+    ) {
         super({ name: taskName, global: false, watch, indicators });
     }
 
@@ -44,83 +35,204 @@ class CliTaskImpl extends CliTask {
     }
 
     async execute(): Promise<void> {
-        await this.runChildProcess('', []);
+        await this.runChildProcess(this.command, this.args);
     }
 }
 
-describe(`[startup] ${CliTask.name} task`, () => {
+describe(`[startup] ${CliTask.name}`, () => {
+    const command = 'foo';
+    const args = ['bar'];
+
     beforeEach(() => {
-        globalThis.performance.clearMarks();
-        globalThis.performance.clearMeasures();
         jest.clearAllMocks();
+        jest.mocked(readJsonSafe).mockReturnValue({});
     });
 
-    let watch = false;
-
-    const subject = () => new CliTaskImpl({ watch }).execute();
+    describe('watchForParentExit', () => {
+        const subject = () => new CliTaskImpl(command, args, { watch: true }).watchForParentExit();
 
-    test('logs completion message', async () => {
-        await subject();
+        test('does not watch for the parent process to exit', () => {
+            subject();
 
-        expect(log.info).toHaveBeenCalledWith(
-            expect.stringContaining(`${taskName} task completed in`)
-        );
+            expect(exitWhenParentExits).not.toHaveBeenCalled();
+        });
     });
 
-    describe('in watch mode', () => {
-        beforeEach(() => (watch = true));
+    describe('runChildProcess', () => {
+        const childPid = 4321;
+        let watch = false;
+
+        beforeEach(() => {
+            globalThis.performance.clearMarks();
+            globalThis.performance.clearMeasures();
+            jest.mocked(getFolders).mockReturnValue({ source: 'src', destination: 'dist' });
+            jest.mocked(execa).mockReturnValue(
+                Object.assign(Promise.resolve(), {
+                    pid: childPid,
+                    stdout: { on: jest.fn() },
+                }) as any
+            );
+        });
 
-        test('it calls pipeStdout', () => {
-            subject();
-            expect(pipeStdout).toHaveBeenCalled();
+        const subject = () => new CliTaskImpl(command, args, { watch }).execute();
+
+        test('runs command', async () => {
+            await subject();
+
+            expect(execa).toHaveBeenCalledWith(command, args, { stdio: 'inherit' });
         });
 
-        describe('onData handler', () => {
-            beforeEach(() => subject());
+        test('logs completion message', async () => {
+            await subject();
 
-            const onDataHandler = (data: string) => {
-                const handler = jest
-                    .mocked(watchStdout)
-                    .mock.calls.find(([_process, indicator]) => indicator === data)![2];
-                handler(1);
-            };
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringContaining(`${taskName} task completed in`)
+            );
+        });
+
+        describe('in watch mode', () => {
+            const originalPlatform = process.platform;
+            let onceSpy: jest.SpyInstance;
+            let killSpy: jest.SpyInstance;
+
+            beforeEach(() => {
+                watch = true;
+                onceSpy = jest.spyOn(process, 'once');
+                killSpy = jest.spyOn(process, 'kill').mockImplementation(jest.fn());
+            });
 
-            function itLogsInitialBuild(event: keyof Indicators) {
-                test('logs duration of initial build', () => {
-                    onDataHandler(indicators[event]);
+            afterEach(() => {
+                process.removeAllListeners('SIGINT');
+                process.removeAllListeners('SIGTERM');
+            });
 
-                    expect(log.info).toHaveBeenCalledWith(
-                        expect.stringContaining(`Initial ${taskName} task completed in`)
-                    );
+            function mockPlatform(platform: NodeJS.Platform) {
+                Object.defineProperty(process, 'platform', {
+                    value: platform,
+                    configurable: true,
                 });
             }
 
-            function itLogsSubsequentBuild(event: keyof Indicators) {
-                test('logs duration of subsequent build', () => {
-                    onDataHandler(indicators[event]!);
+            test('pipes stdout and conditionally runs command in own process', async () => {
+                await subject();
 
-                    expect(log.info).toHaveBeenCalledWith(
-                        expect.stringContaining(`Subsequent ${taskName} task completed in`)
-                    );
+                expect(execa).toHaveBeenCalledWith(command, args, {
+                    stdio: ['inherit', 'pipe', 'inherit'],
+                    detached: process.platform !== 'win32',
                 });
-            }
+            });
+
+            test('calls pipeStdout', () => {
+                subject();
 
-            itLogsInitialBuild('end');
+                expect(pipeStdout).toHaveBeenCalled();
+            });
+
+            test('watches for the parent process to exit', () => {
+                subject();
+
+                expect(exitWhenParentExits).toHaveBeenCalledWith(taskName, expect.any(Function));
+            });
+
+            describe('on POSIX', () => {
+                beforeEach(() => mockPlatform('darwin'));
+
+                afterEach(() => mockPlatform(originalPlatform));
+
+                describe.each<NodeJS.Signals>(['SIGINT', 'SIGTERM'])(
+                    'when the process receives %s',
+                    signal => {
+                        beforeEach(() => {
+                            subject();
+                            onceSpy.mock.calls.find(([registered]) => registered === signal)![1](
+                                signal
+                            );
+                        });
+
+                        test(`forwards ${signal} to the child process tree`, () => {
+                            expect(killProcessTree).toHaveBeenCalledWith(childPid, signal);
+                        });
+
+                        test(`re-raises ${signal}`, () => {
+                            expect(killSpy).toHaveBeenCalledWith(process.pid, signal);
+                        });
+                    }
+                );
+            });
+
+            describe('on Windows', () => {
+                beforeEach(() => mockPlatform('win32'));
+
+                afterEach(() => mockPlatform(originalPlatform));
+
+                test('does not intercept signals', () => {
+                    subject();
+
+                    expect(onceSpy).not.toHaveBeenCalled();
+                });
+            });
+
+            describe('when the parent process exits', () => {
+                const triggerParentExit = () =>
+                    jest.mocked(exitWhenParentExits).mock.calls[0][1]!();
 
-            describe('when subsequent build starts after initial build ends', () => {
                 beforeEach(() => {
-                    onDataHandler(indicators.end);
-                    onDataHandler(indicators.watchStart);
+                    subject();
+                    triggerParentExit();
                 });
 
-                itLogsSubsequentBuild('end');
-                itLogsSubsequentBuild('watchEnd');
+                test('kills the child process tree', () => {
+                    expect(killProcessTree).toHaveBeenCalledWith(childPid);
+                });
             });
 
-            describe('when subsequent build starts before initial build ends', () => {
-                beforeEach(() => onDataHandler(indicators.watchStart));
+            describe('onData handler', () => {
+                beforeEach(() => subject());
+
+                const onDataHandler = (data: string) => {
+                    const handler = jest
+                        .mocked(watchStdout)
+                        .mock.calls.find(([_process, indicator]) => indicator === data)![2];
+                    handler(1);
+                };
+
+                function itLogsInitialBuild(event: keyof Indicators) {
+                    test('logs duration of initial build', () => {
+                        onDataHandler(indicators[event]);
+
+                        expect(log.info).toHaveBeenCalledWith(
+                            expect.stringContaining(`Initial ${taskName} task completed in`)
+                        );
+                    });
+                }
+
+                function itLogsSubsequentBuild(event: keyof Indicators) {
+                    test('logs duration of subsequent build', () => {
+                        onDataHandler(indicators[event]!);
+
+                        expect(log.info).toHaveBeenCalledWith(
+                            expect.stringContaining(`Subsequent ${taskName} task completed in`)
+                        );
+                    });
+                }
+
+                itLogsInitialBuild('end');
+
+                describe('when subsequent build starts after initial build ends', () => {
+                    beforeEach(() => {
+                        onDataHandler(indicators.end);
+                        onDataHandler(indicators.watchStart);
+                    });
+
+                    itLogsSubsequentBuild('end');
+                    itLogsSubsequentBuild('watchEnd');
+                });
+
+                describe('when subsequent build starts before initial build ends', () => {
+                    beforeEach(() => onDataHandler(indicators.watchStart));
 
-                itLogsSubsequentBuild('watchEnd');
+                    itLogsSubsequentBuild('watchEnd');
+                });
             });
         });
     });

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

@@ -1,88 +1,83 @@
-import { readJsonSafe } from '../../../utils';
+import { exitWhenParentExits, readJsonSafe } from '../../../utils';
 import { Task } from '../task';
 
 jest.mock('../../../utils', () => ({
     readJsonSafe: jest.fn().mockReturnValue({}),
+    exitWhenParentExits: jest.fn(),
 }));
 
-class GlobalTask extends Task {
-    constructor() {
-        super({ name: 'GlobalTask', watch: false, global: true });
-    }
-
-    description() {
-        return '';
-    }
-
-    execute() {
-        return Promise.resolve();
-    }
-}
-
-class PackageTask extends Task {
-    constructor() {
-        super({ name: 'PackageTask', watch: false, global: false });
-    }
-
-    description() {
-        return '';
-    }
-
+class MockTask extends Task {
     execute() {
         return Promise.resolve();
     }
 }
 
 describe(`[startup] ${Task.name} entity`, () => {
+    let args: ConstructorParameters<typeof MockTask>[0];
+
     beforeEach(() => {
         globalThis.performance.clearMarks();
         globalThis.performance.clearMeasures();
         jest.clearAllMocks();
+
+        args = { name: 'mock-task', watch: false, global: false };
+    });
+
+    const subject = () => new MockTask(args);
+
+    test('runs from the package directory', () => {
+        expect(subject).not.toThrow();
     });
 
-    describe('Global task', () => {
-        const subject = () => new GlobalTask();
+    test("doesn't run from the workspace root directory", () => {
+        jest.mocked(readJsonSafe).mockReturnValueOnce({ workspaces: ['packages/*'] });
+
+        expect(subject).toThrow();
+    });
+
+    test("doesn't run from an arbitrary directory", () => {
+        jest.mocked(readJsonSafe).mockReturnValueOnce(undefined);
+
+        expect(subject).toThrow();
+    });
+
+    describe('with global: true', () => {
+        beforeEach(() => (args.global = true));
 
         test('runs from the workspace root directory', () => {
-            jest.mocked(readJsonSafe).mockReturnValueOnce({
-                workspaces: ['packages/*'],
-            });
+            jest.mocked(readJsonSafe).mockReturnValueOnce({ workspaces: ['packages/*'] });
 
             expect(subject).not.toThrow();
         });
 
         test("doesn't run from the package directory", () => {
-            jest.mocked(readJsonSafe).mockReturnValueOnce({});
-
             expect(subject).toThrow();
         });
 
-        test("doesn't run from the arbitrary directory", () => {
+        test("doesn't run from an arbitrary directory", () => {
             jest.mocked(readJsonSafe).mockReturnValueOnce(undefined);
 
             expect(subject).toThrow();
         });
     });
 
-    describe('Package task', () => {
-        const subject = () => new PackageTask();
+    describe('watchForParentExit', () => {
+        const subject = () => new MockTask(args).watchForParentExit();
 
-        test('runs from the package directory', () => {
-            jest.mocked(readJsonSafe).mockReturnValueOnce({});
+        test('does not watch for the parent process to exit', () => {
+            subject();
 
-            expect(subject).not.toThrow();
+            expect(exitWhenParentExits).not.toHaveBeenCalled();
         });
 
-        test("doesn't run from the workspace root directory", () => {
-            jest.mocked(readJsonSafe).mockReturnValueOnce({ workspaces: ['packages/*'] });
-
-            expect(subject).toThrow();
-        });
+        describe('with watch: true', () => {
+            beforeEach(() => (args.watch = true));
 
-        test("doesn't run from arbitrary directory", () => {
-            jest.mocked(readJsonSafe).mockReturnValueOnce(undefined);
+            test('watches for the parent process to exit', () => {
+                subject();
 
-            expect(subject).toThrow();
+                expect(exitWhenParentExits).toHaveBeenCalledWith(args.name);
+            });
         });
     });
 });

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

@@ -1,5 +1,6 @@
-import execa from 'execa';
-import { pipeStdout, watchStdout } from '../utils';
+import execa, { ExecaChildProcess } from 'execa';
+import { exitWhenParentExits, log } from '../../utils';
+import { killProcessTree, pipeStdout, watchStdout } from '../utils';
 import { Task, TaskParameters } from './task';
 
 export interface Indicators {
@@ -20,6 +21,10 @@ export abstract class CliTask extends Task {
         this.indicators = indicators;
     }
 
+    watchForParentExit(): void {
+        // No-op: this task exits automatically when its child process ends
+    }
+
     protected async runChildProcess(command: string, args: string[]) {
         const childProcess = execa(
             command,
@@ -27,6 +32,11 @@ export abstract class CliTask extends Task {
             this.watch
                 ? {
                       stdio: ['inherit', 'pipe', 'inherit'],
+                      /*
+                       * Put the child in its own process group so we can take down bin
+                       * wrappers that fork children of their own. Not needed on Windows.
+                       */
+                      detached: process.platform !== 'win32',
                   }
                 : {
                       stdio: 'inherit',
@@ -53,6 +63,37 @@ export abstract class CliTask extends Task {
             this.logCompletionResults(this.taskTimer.end());
         });
 
+        this.killOnParentExit(childProcess);
+        // Forward CTRL-C when signalled, rather than wait for killOnParentExit's slower poll.
+        this.forwardSignalToChild(childProcess);
+
         await childProcess;
     }
+
+    private forwardSignalToChild(childProcess: ExecaChildProcess) {
+        if (process.platform === 'win32') {
+            return;
+        }
+
+        const forward = (signal: NodeJS.Signals) => {
+            if (childProcess.pid) {
+                log.info(`${this.name} forwarding signal to child process tree`);
+                killProcessTree(childProcess.pid, signal);
+            }
+            // Re-raise to get Node's default behavior
+            process.kill(process.pid, signal);
+        };
+
+        process.once('SIGINT', () => forward('SIGINT'));
+        process.once('SIGTERM', () => forward('SIGTERM'));
+    }
+
+    private killOnParentExit(childProcess: ExecaChildProcess) {
+        exitWhenParentExits(this.name, () => {
+            if (childProcess.pid) {
+                log.info(`${this.name} killing child process tree`);
+                killProcessTree(childProcess.pid);
+            }
+        });
+    }
 }

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

@@ -1,36 +1,43 @@
 import { fs, vol } from 'memfs';
+import path from 'path';
 import { TSConfig } from '../../../utils';
 import { getSwcOptions } from '../get-swc-options';
 
 jest.mock('fs', () => fs);
 
 describe(`[startup] ${getSwcOptions.name}`, () => {
+    let options: Parameters<typeof getSwcOptions>[1];
+    const tsConfigPath = 'tsconfig.json';
+
     let tsConfig: TSConfig;
 
     function setTsConfig(config: Record<string, any> = {}) {
         return vol.fromJSON({
-            'tsconfig.json': JSON.stringify(config),
+            [tsConfigPath]: JSON.stringify(config),
         });
     }
 
     beforeEach(() => {
-        tsConfig = new TSConfig('tsconfig.json');
+        options = undefined;
+        tsConfig = new TSConfig(tsConfigPath);
         setTsConfig();
     });
 
     afterEach(() => vol.reset());
 
-    const subject = () => getSwcOptions(tsConfig);
+    const subject = () => getSwcOptions(tsConfig, options);
 
     test('returns default options', () => {
         expect(subject()).toEqual({
             jsc: {
                 parser: { syntax: 'typescript', tsx: true, decorators: true },
                 target: undefined,
+                baseUrl: undefined,
+                paths: undefined,
                 transform: {
                     decoratorMetadata: undefined,
                     legacyDecorator: undefined,
-                    react: { runtime: 'automatic' },
+                    react: { runtime: 'automatic', refresh: false, development: false },
                 },
             },
             module: { type: 'es6' },
@@ -62,6 +69,41 @@ describe(`[startup] ${getSwcOptions.name}`, () => {
         });
     });
 
+    describe('when reactRefresh is true', () => {
+        beforeEach(() => (options = { reactRefresh: true }));
+
+        test('enables react refresh and development mode', () => {
+            expect(subject().jsc.transform!.react).toEqual(
+                expect.objectContaining({
+                    development: true,
+                    refresh: true,
+                })
+            );
+        });
+    });
+
+    describe('when tsconfig contains "compilerOptions.paths"', () => {
+        beforeEach(() => setTsConfig({ compilerOptions: { paths: { foo: ['./bar'] } } }));
+
+        test('forwards paths', () => {
+            expect(subject()).toEqual(
+                expect.objectContaining({
+                    jsc: expect.objectContaining({ paths: { foo: ['./bar'] } }),
+                })
+            );
+        });
+
+        test('defaults baseUrl to the tsconfig directory', () => {
+            expect(subject()).toEqual(
+                expect.objectContaining({
+                    jsc: expect.objectContaining({
+                        baseUrl: path.resolve(path.dirname(tsConfigPath)),
+                    }),
+                })
+            );
+        });
+    });
+
     describe.each(['commonjs', 'commonJS', 'nodenext', 'NodeNext'])(
         'when compilerOptions.module is "%s"',
         module => {

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

@@ -3,7 +3,7 @@ import deepmerge from 'deepmerge';
 import { fs, vol } from 'memfs';
 import { getSwcCompilePackageConfiguration, log } from '../../../../utils';
 import { TSConfig } from '../../../utils';
-import { getSwcOptions } from '../get-swc-options';
+import * as getSwcOptionsModule from '../get-swc-options';
 import { SwcCompilePackage } from '../swc-compile-package';
 
 jest.mock('fs', () => fs);
@@ -45,11 +45,15 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
         volumeFromJSON();
     });
 
-    afterEach(() => vol.reset());
+    afterEach(() => {
+        jest.restoreAllMocks();
+        vol.reset();
+    });
 
+    let reactRefresh = false;
     let watch = false;
 
-    const subject = () => new SwcCompilePackage({ watch }).execute();
+    const subject = () => new SwcCompilePackage({ reactRefresh, watch }).execute();
 
     const onSuccessHandlerParams = {
         duration: 10,
@@ -90,7 +94,12 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
                                 '**/*.stories.*',
                             ],
                         },
-                        swcOptions: getSwcOptions(new TSConfig('tsconfig.json')),
+                        swcOptions: getSwcOptionsModule.getSwcOptions(
+                            new TSConfig('tsconfig.json'),
+                            {
+                                reactRefresh,
+                            }
+                        ),
                         callbacks: {
                             onSuccess: expect.any(Function),
                             onFail: expect.any(Function),
@@ -270,4 +279,16 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
             );
         });
     });
+
+    describe('when reactRefresh is true', () => {
+        beforeEach(() => (reactRefresh = true));
+
+        test('passes react refresh to getSwcOptions', () => {
+            const getSwcOptionsSpy = jest.spyOn(getSwcOptionsModule, 'getSwcOptions');
+
+            subject();
+
+            expect(getSwcOptionsSpy).toHaveBeenCalledWith(expect.any(TSConfig), { reactRefresh });
+        });
+    });
 });