@servicetitan/startup 38.0.0 → 38.1.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-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,12 @@
-import { execSync, spawn } from 'child_process';
+import { execFileSync, execSync, spawn } from 'child_process';
 import { log } from '../../../utils';
-import { runCommand, runCommandOutput } from '../cli-os';
+import { killProcessTree, runCommand, runCommandOutput } from '../cli-os';
 
-jest.mock('child_process', () => ({ execSync: jest.fn(), spawn: jest.fn() }));
+jest.mock('child_process', () => ({
+    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 +142,83 @@ describe('[startup] Cli Utils (OS)', () => {
             expect(logInfoSpy).not.toHaveBeenCalled();
         });
     });
+
+    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);

package/src/cli/utils/__tests__/with-exponential-backoff.test.ts

@@ -0,0 +1,119 @@
+import { withExponentialBackoff, WithExponentialBackoffConfig } from '../with-exponential-backoff';
+
+describe('[startup] withExponentialBackoff', () => {
+    const result = '{result}';
+    const error = new Error('{error}');
+
+    let callback: jest.Mock;
+    let config: WithExponentialBackoffConfig;
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        callback = jest.fn();
+        config = {};
+    });
+
+    afterEach(() => jest.useRealTimers());
+
+    const subject = () => withExponentialBackoff(callback, config);
+
+    describe('when the callback succeeds on the first attempt', () => {
+        beforeEach(() => callback.mockResolvedValue(result));
+
+        test('resolves with the result', async () => {
+            await expect(subject()).resolves.toBe(result);
+        });
+
+        test('calls the callback once', async () => {
+            await subject();
+
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('when the callback fails once then succeeds', () => {
+        beforeEach(() => {
+            callback.mockRejectedValueOnce(error).mockResolvedValue(result);
+        });
+
+        const subjectAfterRetry = async () => {
+            const promise = subject();
+            await jest.advanceTimersByTimeAsync(100000);
+            return promise;
+        };
+
+        test('resolves with the result', async () => {
+            await expect(subjectAfterRetry()).resolves.toBe(result);
+        });
+
+        test('calls the callback twice', async () => {
+            await subjectAfterRetry();
+
+            expect(callback).toHaveBeenCalledTimes(2);
+        });
+
+        describe('with onRetry configured', () => {
+            beforeEach(() => (config.onRetry = jest.fn()));
+
+            test('calls onRetry with the initial delay and the error', async () => {
+                await subjectAfterRetry();
+
+                expect(config.onRetry).toHaveBeenCalledWith(500, error);
+            });
+        });
+    });
+
+    describe('when the callback keeps failing', () => {
+        beforeEach(() => callback.mockRejectedValue(error));
+
+        const subjectAfterRetries = async () => {
+            const promise = subject().catch((e: unknown) => e);
+            await jest.advanceTimersByTimeAsync(100000);
+            return promise;
+        };
+
+        test('rejects with the underlying error', async () => {
+            await expect(subjectAfterRetries()).resolves.toBe(error);
+        });
+
+        test('calls the callback maxRetries times', async () => {
+            await subjectAfterRetries();
+
+            expect(callback).toHaveBeenCalledTimes(5);
+        });
+
+        test('doubles the delay passed to onRetry on each attempt', async () => {
+            config.onRetry = jest.fn();
+
+            await subjectAfterRetries();
+
+            expect(config.onRetry).toHaveBeenNthCalledWith(1, 500, error);
+            expect(config.onRetry).toHaveBeenNthCalledWith(2, 1000, error);
+            expect(config.onRetry).toHaveBeenNthCalledWith(3, 2000, error);
+            expect(config.onRetry).toHaveBeenNthCalledWith(4, 4000, error);
+        });
+
+        describe('with a custom maxRetries', () => {
+            beforeEach(() => (config.maxRetries = 2));
+
+            test('calls the callback maxRetries times', async () => {
+                await subjectAfterRetries();
+
+                expect(callback).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe('with a custom initialDelay', () => {
+            beforeEach(() => {
+                config.initialDelay = 10;
+                config.onRetry = jest.fn();
+            });
+
+            test('uses it for the first retry delay', async () => {
+                await subjectAfterRetries();
+
+                expect(config.onRetry).toHaveBeenNthCalledWith(1, 10, error);
+            });
+        });
+    });
+});

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

@@ -1,4 +1,6 @@
+import { log } from '../../utils';
 import { runCommand, runCommandOutput } from './cli-os';
+import { withExponentialBackoff } from './with-exponential-backoff';
 
 export interface Version {
     name: string;
@@ -76,10 +78,23 @@ export async function npmTagVersion({
     registry?: string;
     tag: string;
 }) {
-    await runCommand(
-        `npm dist-tag ${
-            registry ? `--registry=${registry} ` : ''
-        }add ${packageName}@${packageVersion} ${tag}`
+    /*
+     * Retrying with backoff because verdaccio's dist-tag write can briefly 404
+     * right after the version it targets was published (metadata propagation lag).
+     */
+    await withExponentialBackoff(
+        () =>
+            runCommand(
+                `npm dist-tag ${
+                    registry ? `--registry=${registry} ` : ''
+                }add ${packageName}@${packageVersion} ${tag}`
+            ),
+        {
+            onRetry: delay =>
+                log.warning(
+                    `Failed to tag ${packageName}@${packageVersion} with "${tag}", retrying in ${delay}ms...`
+                ),
+        }
     );
 }
 

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

@@ -1,4 +1,5 @@
 import {
+    execFileSync,
     execSync,
     ExecSyncOptionsWithBufferEncoding,
     spawn,
@@ -79,3 +80,16 @@ export function runCommandOutput(
 
     return result;
 }
+
+export function killProcessTree(pid: number, signal: NodeJS.Signals = 'SIGKILL') {
+    try {
+        if (process.platform === 'win32') {
+            execFileSync('taskkill', ['/pid', String(pid), '/t', '/f']);
+        } else {
+            // negative pid targets the whole process group
+            process.kill(-pid, signal);
+        }
+    } catch {
+        // tree already gone
+    }
+}