@servicetitan/startup 38.0.0 → 38.2.0

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-git.test.ts

@@ -1,7 +1,7 @@
-import { gitGetBranch, gitGetCommitHash } from '../cli-git';
-import { runCommandOutput } from '../cli-os';
+import { gitGetBranch, gitGetCommitHash, gitGetContext } from '../cli-git';
+import { runCommandOutput, runCommandOutputAsync } from '../cli-os';
 
-jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn() }));
+jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn(), runCommandOutputAsync: jest.fn() }));
 
 describe('[startup] Cli Utils (Git)', () => {
     beforeEach(() => {
@@ -26,4 +26,55 @@ describe('[startup] Cli Utils (Git)', () => {
     describe(gitGetCommitHash.name, () => {
         itRunsCommand(gitGetCommitHash, 'git rev-parse --short HEAD');
     });
+
+    describe(gitGetContext.name, () => {
+        const root = '/repos/monolith';
+        const context = {
+            repo: 'monolith',
+            branch: 'main',
+            userEmail: 'dev@st.com',
+            userName: 'dev',
+        };
+
+        let output: Record<string, string | undefined>;
+
+        beforeEach(() => {
+            output = {
+                'rev-parse': `${context.branch}\n${root}`,
+                'user.email': context.userEmail,
+                'user.name': context.userName,
+            };
+            jest.mocked(runCommandOutputAsync).mockImplementation(command => {
+                const key = Object.keys(output).find(entry => String(command).includes(entry));
+                return Promise.resolve(key ? output[key] : undefined);
+            });
+        });
+
+        const subject = () => gitGetContext();
+
+        test('collects the repo, branch, and user', async () => {
+            expect(await subject()).toEqual(context);
+        });
+
+        describe('when one command fails', () => {
+            beforeEach(() => (output['user.email'] = undefined));
+
+            test('leaves only that field undefined', async () => {
+                expect(await subject()).toEqual({ ...context, userEmail: undefined });
+            });
+        });
+
+        describe('when every command fails', () => {
+            beforeEach(() => (output = {}));
+
+            test('leaves the fields undefined', async () => {
+                expect(await subject()).toEqual({
+                    repo: undefined,
+                    branch: undefined,
+                    userEmail: undefined,
+                    userName: undefined,
+                });
+            });
+        });
+    });
 });

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, () => {

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

@@ -1,8 +1,13 @@
-import { execSync, spawn } from 'child_process';
+import { exec, execFileSync, execSync, spawn } from 'child_process';
 import { log } from '../../../utils';
-import { runCommand, runCommandOutput } from '../cli-os';
-
-jest.mock('child_process', () => ({ execSync: jest.fn(), spawn: jest.fn() }));
+import { killProcessTree, runCommand, runCommandOutput, runCommandOutputAsync } from '../cli-os';
+
+jest.mock('child_process', () => ({
+    exec: jest.fn(),
+    execFileSync: jest.fn(),
+    execSync: jest.fn(),
+    spawn: jest.fn(),
+}));
 jest.mock('../../../utils', () => ({ log: { info: jest.fn() } })); // suppress log output
 
 describe('[startup] Cli Utils (OS)', () => {
@@ -138,4 +143,178 @@ describe('[startup] Cli Utils (OS)', () => {
             expect(logInfoSpy).not.toHaveBeenCalled();
         });
     });
+
+    describe(`${runCommandOutputAsync.name}`, () => {
+        // promisify(exec) resolves with { stdout, stderr }; the mock supplies that shape.
+        const mockExec = (
+            impl: (callback: (error: Error | null, result?: { stdout: string }) => void) => void
+        ) =>
+            jest
+                .mocked(exec)
+                .mockImplementation(((
+                    _command: string,
+                    _options: unknown,
+                    callback: (error: Error | null, result?: { stdout: string }) => void
+                ) => impl(callback)) as unknown as typeof exec);
+
+        let command: string;
+        let options: NonNullable<Parameters<typeof runCommandOutputAsync>[1]>;
+
+        beforeEach(() => {
+            jest.clearAllMocks();
+            command = 'foo';
+            options = {};
+            mockExec(callback => callback(null, { stdout: 'result\n' }));
+        });
+
+        const subject = () => runCommandOutputAsync(command, options);
+
+        test('resolves with the trimmed result', async () => {
+            await expect(subject()).resolves.toBe('result');
+        });
+
+        test('runs the command', async () => {
+            await subject();
+
+            expect(exec).toHaveBeenCalledWith(command, options, expect.any(Function));
+        });
+
+        describe('when the output is empty', () => {
+            beforeEach(() => mockExec(callback => callback(null, { stdout: '   ' })));
+
+            test('resolves with undefined', async () => {
+                await expect(subject()).resolves.toBeUndefined();
+            });
+        });
+
+        describe('with options', () => {
+            beforeEach(() => (options.timeout = 10000));
+
+            test('passes them through', async () => {
+                await subject();
+
+                expect(exec).toHaveBeenCalledWith(command, options, expect.any(Function));
+            });
+        });
+
+        test('logs the command', async () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            await subject();
+
+            expect(logInfoSpy).toHaveBeenCalledWith(`Running: ${command}`);
+        });
+
+        test('logs the result', async () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            await subject();
+
+            expect(logInfoSpy).toHaveBeenCalledWith('command finished', 'result');
+        });
+
+        describe('with quiet', () => {
+            beforeEach(() => (options.quiet = true));
+
+            test('suppresses output', async () => {
+                const logInfoSpy = jest.spyOn(log, 'info');
+                await subject();
+
+                expect(logInfoSpy).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('when the command fails', () => {
+            beforeEach(() => mockExec(callback => callback(new Error('boom'))));
+
+            test('rejects', async () => {
+                await expect(subject()).rejects.toThrow('boom');
+            });
+
+            describe('with ignoreErrors', () => {
+                beforeEach(() => (options.ignoreErrors = true));
+
+                test('resolves with undefined', async () => {
+                    await expect(subject()).resolves.toBeUndefined();
+                });
+            });
+        });
+    });
+
+    describe(`${killProcessTree.name}`, () => {
+        const pid = 1234;
+        const originalPlatform = process.platform;
+        let signal: Parameters<typeof killProcessTree>[1];
+        let killSpy: jest.SpyInstance;
+
+        function mockPlatform(platform: NodeJS.Platform) {
+            Object.defineProperty(process, 'platform', { value: platform, configurable: true });
+        }
+
+        beforeEach(() => {
+            jest.clearAllMocks();
+            killSpy = jest.spyOn(process, 'kill').mockImplementation(jest.fn());
+        });
+
+        afterEach(() => mockPlatform(originalPlatform));
+
+        const subject = () => killProcessTree(pid, signal);
+
+        describe('on POSIX', () => {
+            beforeEach(() => mockPlatform('darwin'));
+
+            test('sends SIGKILL to the process tree', () => {
+                subject();
+
+                expect(killSpy).toHaveBeenCalledWith(-pid, 'SIGKILL');
+            });
+
+            describe('with a signal', () => {
+                beforeEach(() => (signal = 'SIGTERM'));
+
+                test('send the signal to the process tree', () => {
+                    subject();
+                    expect(killSpy).toHaveBeenCalledWith(-pid, signal);
+                });
+            });
+
+            describe('when the process is already gone', () => {
+                beforeEach(() => {
+                    killSpy.mockImplementation(() => {
+                        throw new Error('ESRCH');
+                    });
+                });
+
+                test('does not throw', () => {
+                    expect(() => killProcessTree(pid)).not.toThrow();
+                });
+            });
+        });
+
+        describe('on Windows', () => {
+            beforeEach(() => mockPlatform('win32'));
+
+            test('runs taskkill /F /T on the process tree', () => {
+                subject();
+
+                expect(execFileSync).toHaveBeenCalledWith('taskkill', [
+                    '/pid',
+                    String(pid),
+                    '/t',
+                    '/f',
+                ]);
+            });
+
+            describe('when the process is already gone', () => {
+                beforeEach(() => {
+                    jest.mocked(execFileSync).mockImplementation(() => {
+                        throw new Error('not found');
+                    });
+                });
+
+                test('does not throw', () => {
+                    subject();
+                    expect(() => killProcessTree(pid)).not.toThrow();
+                });
+            });
+        });
+    });
 });

package/src/cli/utils/__tests__/compile.test.ts

@@ -1,11 +1,16 @@
 import { log } from '../../../utils';
 import { compile } from '../compile';
 import { lernaExec } from '../lerna-exec';
+import { resolveBundler } from '../resolve-bundler';
 
 jest.mock('../lerna-exec', () => ({
     lernaExec: jest.fn(),
 }));
 
+jest.mock('../resolve-bundler', () => ({
+    resolveBundler: jest.fn(() => 'webpack'),
+}));
+
 describe('[startup] Cli Utils', () => {
     const packages = ['foo', 'bar'];
     let args: Parameters<typeof compile>[0];
@@ -13,17 +18,25 @@ describe('[startup] Cli Utils', () => {
     beforeEach(() => {
         jest.clearAllMocks();
         jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress output
+        jest.mocked(resolveBundler).mockReturnValue('webpack');
         args = { packages };
     });
 
-    function itRunsSwcCompilePackage({ watch }: { watch?: boolean } = {}) {
+    function itRunsSwcCompilePackage({
+        reactRefresh,
+        watch,
+    }: { reactRefresh?: boolean; watch?: boolean } = {}) {
+        const options = [watch && '--watch', watch && reactRefresh && '--react-refresh'].filter(
+            option => typeof option === 'string'
+        );
+
         expect(lernaExec).toHaveBeenCalledWith({
             cmd: 'startup task swc-compile-package',
             parallel: true,
             scope: packages,
             stream: true,
             stdio: watch ? ['inherit', 'pipe', 'inherit'] : 'inherit',
-            ...(watch ? { '--': ['--watch'] } : {}),
+            ...(options.length ? { '--': options } : {}),
         });
     }
 
@@ -44,6 +57,28 @@ describe('[startup] Cli Utils', () => {
 
                 itRunsSwcCompilePackage({ watch: true });
             });
+
+            describe('when bundler is vite', () => {
+                beforeEach(() => jest.mocked(resolveBundler).mockReturnValue('vite'));
+
+                test('enables react refresh and watch', async () => {
+                    await subject();
+
+                    itRunsSwcCompilePackage({ reactRefresh: true, watch: true });
+                });
+
+                describe('with "useTsc"', () => {
+                    beforeEach(() => (args.useTsc = true));
+
+                    test('does not enable react refresh', async () => {
+                        await subject();
+
+                        expect(lernaExec).toHaveBeenCalledWith(
+                            expect.objectContaining({ '--': ['--watch'] })
+                        );
+                    });
+                });
+            });
         });
 
         describe('with "useTsc"', () => {

package/src/cli/utils/__tests__/copy-files.test.ts

@@ -68,7 +68,7 @@ describe(`[startup] cli utils (${copyFiles.name})`, () => {
 
     const subject = async () => copyFiles(options);
 
-    test('copies assets and styles from source to destination', async () => {
+    test('copies supported files from source to destination', async () => {
         await subject();
 
         expect(cpx.copySync).toHaveBeenCalledWith(files, destination);