@servicetitan/startup 37.0.2 → 38.1.0

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 });
+        });
+    });
 });

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

@@ -1,14 +1,23 @@
 import type { SwcOptions } from '@swc/cli';
+import path from 'path';
 import { TSConfig } from '../../utils';
 
 type JscConfig = NonNullable<SwcOptions['jsc']>;
 
-export function getSwcOptions(tsConfig: TSConfig) {
+export function getSwcOptions(tsConfig: TSConfig, { reactRefresh = false } = {}) {
     const target = tsConfig.getValue<JscConfig['target']>('compilerOptions.target');
     const legacyDecorator = tsConfig.getValue<boolean>('compilerOptions.experimentalDecorators');
     const decoratorMetadata = tsConfig.getValue<boolean>('compilerOptions.emitDecoratorMetadata');
     const sourceMaps = tsConfig.getValue<SwcOptions['sourceMaps']>('compilerOptions.sourceMap');
     const module = tsConfig.getValue<string>('compilerOptions.module')?.toLowerCase();
+    const paths = tsConfig.getValue<JscConfig['paths']>('compilerOptions.paths');
+    /*
+     * `compilerOptions.baseUrl` is deprecated in TypeScript, so it's not read here.
+     * TS resolves `paths` relative to the tsconfig directory; SWC requires an
+     * absolute `jsc.baseUrl` whenever `jsc.paths` is set.
+     */
+    const baseUrl =
+        paths !== undefined ? path.resolve(path.dirname(tsConfig.configPath)) : undefined;
 
     return {
         jsc: {
@@ -18,11 +27,15 @@ export function getSwcOptions(tsConfig: TSConfig) {
                 decorators: true,
             },
             target,
+            baseUrl,
+            paths,
             transform: {
                 legacyDecorator,
                 decoratorMetadata,
                 react: {
                     runtime: 'automatic',
+                    refresh: reactRefresh,
+                    development: reactRefresh,
                 },
             },
         },

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

@@ -7,6 +7,7 @@ import { Task } from '../task';
 import { getSwcOptions } from './get-swc-options';
 
 interface Args {
+    reactRefresh?: boolean;
     watch?: boolean;
 }
 
@@ -15,8 +16,11 @@ function overwriteMerge(_destinationArray: unknown[], sourceArray: unknown[]) {
 }
 
 export class SwcCompilePackage extends Task {
-    constructor({ watch }: Args) {
+    private readonly reactRefresh: boolean | undefined;
+
+    constructor({ reactRefresh, watch }: Args) {
         super({ name: 'swc-compile-package', global: false, watch });
+        this.reactRefresh = reactRefresh;
     }
 
     async execute(): Promise<void> {
@@ -60,7 +64,7 @@ export class SwcCompilePackage extends Task {
         return deepmerge(
             {
                 cliOptions: getCliOptions(tsConfig, { watch: this.watch }),
-                swcOptions: getSwcOptions(tsConfig),
+                swcOptions: getSwcOptions(tsConfig, { reactRefresh: this.reactRefresh }),
             },
             packageConfig,
             { arrayMerge: overwriteMerge, clone: false }

package/src/cli/tasks/task.ts

@@ -1,4 +1,4 @@
-import { formatDuration, log, readJsonSafe } from '../../utils';
+import { exitWhenParentExits, formatDuration, log, readJsonSafe } from '../../utils';
 
 class TaskTimer {
     private counter = 0;
@@ -65,7 +65,7 @@ export interface TaskParameters {
 export abstract class Task {
     protected readonly watch: boolean;
     protected readonly taskTimer: TaskTimer;
-    private readonly name: string;
+    protected readonly name: string;
     private readonly global: boolean;
 
     constructor({ name, watch, global }: TaskParameters) {
@@ -76,6 +76,12 @@ export abstract class Task {
         this.checkRunLocation();
     }
 
+    watchForParentExit(): void {
+        if (this.watch) {
+            exitWhenParentExits(this.name);
+        }
+    }
+
     protected logCompletionResults({
         measure,
         counter,

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

@@ -1,22 +1,13 @@
-import execa from 'execa';
 import { fs, vol } from 'memfs';
 import path from 'path';
-import { log } from '../../../../utils';
+import { CliTask } from '../../cli-task';
 import { TscCompile } from '../tsc-compile';
 
 jest.mock('fs', () => fs);
-jest.mock('execa', () =>
-    jest.fn().mockReturnValue(
-        Object.assign(Promise.resolve(), {
-            stdout: {
-                on: jest.fn(),
-            },
-        })
-    )
-);
 
 describe(`[startup] ${TscCompile.name} task`, () => {
     let options: ConstructorParameters<typeof TscCompile>[0];
+    let runChildProcessSpy: jest.SpyInstance;
 
     beforeEach(() => {
         vol.fromJSON({
@@ -46,8 +37,9 @@ describe(`[startup] ${TscCompile.name} task`, () => {
             }),
             'package.json': JSON.stringify({ workspaces: ['packages/*'] }),
         });
-        jest.clearAllMocks();
-        jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress log output
+        runChildProcessSpy = jest
+            .spyOn(CliTask.prototype as any, 'runChildProcess')
+            .mockResolvedValue(undefined);
         options = {};
     });
 
@@ -55,20 +47,12 @@ describe(`[startup] ${TscCompile.name} task`, () => {
 
     function itRunsTsc(
         caption: string,
-        {
-            watch = false,
-            tsConfigs,
-            stdio,
-        }: {
-            watch?: boolean;
-            tsConfigs: string[];
-            stdio: string | string[];
-        }
+        { watch = false, tsConfigs }: { watch?: boolean; tsConfigs: string[] }
     ) {
         test(`runs tsc ${caption}`, () => {
             subject();
 
-            expect(execa).toHaveBeenCalledWith(
+            expect(runChildProcessSpy).toHaveBeenCalledWith(
                 'tsc',
                 expect.arrayContaining(
                     [
@@ -79,10 +63,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
                         '--emitDeclarationOnly',
                         ...tsConfigs.map(config => expect.stringContaining(path.normalize(config))),
                     ].filter(item => item !== undefined)
-                ),
-                {
-                    stdio,
-                }
+                )
             );
         });
     }
@@ -91,7 +72,6 @@ describe(`[startup] ${TscCompile.name} task`, () => {
 
     itRunsTsc('', {
         tsConfigs: ['foo/tsconfig.json', 'bar/tsconfig.json'],
-        stdio: 'inherit',
     });
 
     describe('in watch mode', () => {
@@ -100,7 +80,6 @@ describe(`[startup] ${TscCompile.name} task`, () => {
         itRunsTsc('in watch mode', {
             watch: true,
             tsConfigs: ['foo/tsconfig.json', 'bar/tsconfig.json'],
-            stdio: ['inherit', 'pipe', 'inherit'],
         });
     });
 
@@ -109,7 +88,6 @@ describe(`[startup] ${TscCompile.name} task`, () => {
 
         itRunsTsc('with only specified package', {
             tsConfigs: ['foo/tsconfig.json'],
-            stdio: 'inherit',
         });
     });
 
@@ -118,7 +96,6 @@ describe(`[startup] ${TscCompile.name} task`, () => {
 
         itRunsTsc('without specified package', {
             tsConfigs: ['baz/tsconfig.json', 'bar/tsconfig.json'],
-            stdio: 'inherit',
         });
     });
 
@@ -127,7 +104,6 @@ describe(`[startup] ${TscCompile.name} task`, () => {
 
         itRunsTsc('with combined filters', {
             tsConfigs: ['baz/tsconfig.json'],
-            stdio: 'inherit',
         });
     });
 });

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

@@ -1,16 +1,6 @@
-import execa from 'execa';
+import { CliTask } from '../../cli-task';
 import { TscCompilePackage } from '../tsc-compile-package';
 
-jest.mock('execa', () =>
-    jest.fn().mockReturnValue(
-        Object.assign(Promise.resolve(), {
-            stdout: {
-                on: jest.fn(),
-            },
-        })
-    )
-);
-
 const tsConfig = 'tsconfig.build.json';
 
 const tscOptions = [
@@ -41,33 +31,34 @@ jest.mock('../../../../utils', () => ({
 }));
 
 describe(`[startup] ${TscCompilePackage.name} task`, () => {
+    let runChildProcessSpy: jest.SpyInstance;
+
     beforeEach(() => {
         globalThis.performance.clearMarks();
         globalThis.performance.clearMeasures();
         jest.clearAllMocks();
+        runChildProcessSpy = jest
+            .spyOn(CliTask.prototype as any, 'runChildProcess')
+            .mockResolvedValue(undefined);
     });
 
     let watch = false;
 
     const subject = () => new TscCompilePackage({ watch }).execute();
 
-    test('calls execa', () => {
+    test('calls runChildProcess', () => {
         subject();
 
-        expect(execa).toHaveBeenCalledWith('tsc', tscOptions, {
-            stdio: 'inherit',
-        });
+        expect(runChildProcessSpy).toHaveBeenCalledWith('tsc', tscOptions);
     });
 
     describe('in watch mode', () => {
         beforeEach(() => (watch = true));
 
-        test('calls execa', () => {
+        test('calls runChildProcess', () => {
             subject();
 
-            expect(execa).toHaveBeenCalledWith('tsc', ['-w', ...tscOptions], {
-                stdio: ['inherit', 'pipe', 'inherit'],
-            });
+            expect(runChildProcessSpy).toHaveBeenCalledWith('tsc', ['-w', ...tscOptions]);
         });
     });
 });

package/src/cli/utils/__tests__/cli-npm.test.ts

@@ -1,3 +1,4 @@
+import { log } from '../../../utils';
 import {
     npmGetPackageVersions,
     npmGetPackageVersionsDetails,
@@ -20,6 +21,7 @@ jest.mock('../../../utils', () => ({
     log: {
         info: jest.fn(),
         error: jest.fn(),
+        warning: jest.fn(),
     },
 }));
 
@@ -230,6 +232,37 @@ describe('[startup] Cli Utils (Npm)', () => {
                 'npm dist-tag --registry={registry} add {packageName}@{packageVersion} {tag}'
             );
         });
+
+        describe('when the command fails once then succeeds', () => {
+            beforeEach(() => {
+                jest.useFakeTimers();
+                jest.mocked(runCommand)
+                    .mockRejectedValueOnce(new Error('{error}'))
+                    .mockResolvedValue(undefined);
+            });
+
+            afterEach(() => jest.useRealTimers());
+
+            const subjectAfterRetry = async () => {
+                const promise = subject();
+                await jest.advanceTimersByTimeAsync(100000);
+                return promise;
+            };
+
+            test('retries the command', async () => {
+                await subjectAfterRetry();
+
+                expect(runCommand).toHaveBeenCalledTimes(2);
+            });
+
+            test('logs a warning', async () => {
+                await subjectAfterRetry();
+
+                expect(log.warning).toHaveBeenCalledWith(
+                    'Failed to tag {packageName}@{packageVersion} with "{tag}", retrying in 500ms...'
+                );
+            });
+        });
     });
 
     describe(npmRemoveTag.name, () => {