@servicetitan/startup 37.0.2 → 38.1.0

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

package/src/cli/utils/compile.ts

@@ -1,5 +1,6 @@
 import { log } from '../../utils';
 import { lernaExec } from './lerna-exec';
+import { resolveBundler } from './resolve-bundler';
 
 export function compile({
     packages,
@@ -11,12 +12,18 @@ export function compile({
     useTsc?: boolean;
 }) {
     log.info('Compiling TypeScript files...');
+
+    const options = [
+        watch && '--watch',
+        watch && !useTsc && resolveBundler({}) === 'vite' && '--react-refresh',
+    ].filter(option => typeof option === 'string');
+
     return lernaExec({
         cmd: useTsc ? 'startup task tsc-compile-package' : 'startup task swc-compile-package',
         parallel: true,
         scope: packages,
         stream: true,
         stdio: watch ? ['inherit', 'pipe', 'inherit'] : 'inherit',
-        ...(watch ? { '--': ['--watch'] } : {}),
+        ...(options.length ? { '--': options } : {}),
     });
 }

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

@@ -7,7 +7,7 @@ import { compileLess } from './compile-less';
 import { compileSass } from './compile-sass';
 
 const assetExtensions = ['eot', 'gif', 'jpg', 'otf', 'png', 'svg', 'ttf', 'woff', 'woff2'];
-const resourceExtensions = ['html', 'json'];
+const resourceExtensions = ['html', 'js', 'json'];
 export const styleExtensions = ['css', 'less', 'scss'];
 const styleTypeDefinitionExtensions = styleExtensions.map(ext => `${ext}.d.ts`);
 

package/src/cli/utils/index.ts

@@ -16,7 +16,6 @@ export * from './compile';
  */
 export * from './constants';
 export * from './eslint';
-export * from './get-bundle-command';
 export * from './get-exit-code';
 export * from './get-module-type';
 export * from './is-module-installed';
@@ -32,3 +31,4 @@ export * from './set-node-options';
 export * from './ts-config';
 export * from './type-check';
 export * from './watch-stdout';
+export * from './with-exponential-backoff';

package/src/cli/utils/resolve-bundler.ts

@@ -1,3 +1,4 @@
+import { bundleConstants } from '../../core';
 import { type Bundler, getConfiguration, log } from '../../utils';
 
 interface BundlerArgs {
@@ -19,5 +20,5 @@ export function resolveBundler(args: BundlerArgs): Bundler {
         return 'vite';
     }
 
-    return getConfiguration().bundler ?? 'webpack';
+    return getConfiguration().bundler ?? bundleConstants.defaultBundler;
 }

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

@@ -5,7 +5,7 @@ import { readJson } from '../../utils';
 export class TSConfig {
     private readonly json: Map<string, any>;
 
-    constructor(private readonly configPath: string) {
+    constructor(readonly configPath: string) {
         this.json = new Map();
     }
 

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

@@ -0,0 +1,28 @@
+export interface WithExponentialBackoffConfig {
+    initialDelay?: number;
+    maxRetries?: number;
+    onRetry?: (delay: number, error: unknown) => void;
+}
+
+export async function withExponentialBackoff<T>(
+    callback: () => Promise<T>,
+    config: WithExponentialBackoffConfig = {}
+): Promise<T> {
+    const { initialDelay = 500, maxRetries = 5, onRetry } = config;
+
+    const attempt = async (attemptNumber: number, delay: number): Promise<T> => {
+        try {
+            return await callback();
+        } catch (error) {
+            if (attemptNumber >= maxRetries) {
+                throw error;
+            }
+
+            onRetry?.(delay, error);
+            await new Promise(resolve => setTimeout(resolve, delay));
+            return attempt(attemptNumber + 1, delay * 2);
+        }
+    };
+
+    return attempt(1, initialDelay);
+}

package/src/core/constants.ts

@@ -13,4 +13,6 @@ export const bundleConstants = {
         production: 'production',
         development: 'development',
     },
+    bundlers: ['vite', 'webpack'],
+    defaultBundler: 'webpack',
 } as const;

package/src/cypress/config/__tests__/vite-config.test.ts

@@ -1,6 +1,6 @@
 import type { InlineConfig } from 'vite';
 import { createCssConfig } from '../../../vite/config/create-css-config';
-import { istanbulPlugin, svgrPlugin } from '../../../vite/plugins';
+import { ignoreModulesPlugin, istanbulPlugin, svgrPlugin } from '../../../vite/plugins';
 import { viteConfig } from '../vite-config';
 
 jest.mock('vite', () => ({
@@ -11,8 +11,9 @@ jest.mock('../../../vite/plugins');
 
 describe(`[startup/cypress-config] ${viteConfig.name}`, () => {
     const cssConfig: any = { modules: { localsConvention: 'camelCaseOnly' } };
-    const svgr: any = { name: 'svgr' };
-    const istanbul: any = { name: 'istanbul' };
+    const mockSvgrPlugin: any = { name: 'vite-plugin-svgr' };
+    const mockIstanbulPlugin: any = { name: 'istanbul' };
+    const mockIgnoreModulesPlugin: any = { name: 'ignore-modules' };
 
     let overrides: InlineConfig | undefined;
 
@@ -21,8 +22,9 @@ describe(`[startup/cypress-config] ${viteConfig.name}`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
         jest.mocked(createCssConfig).mockReturnValue(cssConfig);
-        jest.mocked(svgrPlugin).mockReturnValue(svgr);
-        jest.mocked(istanbulPlugin).mockReturnValue(istanbul);
+        jest.mocked(svgrPlugin).mockReturnValue(mockSvgrPlugin);
+        jest.mocked(istanbulPlugin).mockReturnValue(mockIstanbulPlugin);
+        jest.mocked(ignoreModulesPlugin).mockReturnValue(mockIgnoreModulesPlugin);
         overrides = undefined;
     });
 
@@ -36,8 +38,20 @@ describe(`[startup/cypress-config] ${viteConfig.name}`, () => {
         expect(subject().css).toBe(cssConfig);
     });
 
-    test('includes the SVG plugin', () => {
-        expect(subject().plugins).toContain(svgr);
+    test('adds the svgr plugin', () => {
+        expect(subject().plugins).toContain(mockSvgrPlugin);
+    });
+
+    test('adds the istanbul plugin', () => {
+        expect(subject().plugins).toContain(mockIstanbulPlugin);
+    });
+
+    test('adds the ignore-modules plugin', () => {
+        expect(subject().plugins).toContain(mockIgnoreModulesPlugin);
+    });
+
+    test('registers the ignore modules plugin for the dependency pre-bundler', () => {
+        expect(subject().optimizeDeps?.rolldownOptions?.plugins).toEqual([mockIgnoreModulesPlugin]);
     });
 
     test('enables code coverage', () => {
@@ -48,10 +62,6 @@ describe(`[startup/cypress-config] ${viteConfig.name}`, () => {
         );
     });
 
-    test('includes the coverage plugin', () => {
-        expect(subject().plugins).toContain(istanbul);
-    });
-
     test('dedupes React', () => {
         expect(subject().resolve?.dedupe).toEqual(['react', 'react-dom']);
     });

package/src/cypress/config/__tests__/webpack-config.test.ts

@@ -3,12 +3,17 @@ import { getSwcOptions } from '../../../cli/tasks';
 import { TSConfig } from '../../../cli/utils';
 import { getBaseTsConfig } from '../../../utils';
 import { JS_RULE_EXCLUDE, rulesConfig } from '../../../webpack/configs';
+import { filterWarningsPlugin, ignorePlugin } from '../../../webpack/configs/plugins';
 import { Overrides } from '../../../webpack/types';
 import { webpackConfig } from '../webpack-config';
 
 jest.mock('@servicetitan/install');
 jest.mock('fs', () => fs);
 jest.mock('../../../webpack/configs');
+jest.mock('../../../webpack/configs/plugins', () => ({
+    filterWarningsPlugin: jest.fn(),
+    ignorePlugin: jest.fn(),
+}));
 jest.mock('../../../cli/tasks');
 
 describe(`[startup/cypress-config] ${webpackConfig.name}`, () => {
@@ -19,12 +24,16 @@ describe(`[startup/cypress-config] ${webpackConfig.name}`, () => {
     const mockSwcOptions: any = { jsc: 'foobar' };
     const mockTsConfig = { compilerOptions: { target: 'es2020' } };
     const mockFallbackTsConfig = { compilerOptions: { target: 'es2018' } };
+    const mockIgnorePlugin: any = { name: 'IgnorePlugin' };
+    const mockFilterWarningsPlugin = { name: 'FilterWarningsPlugin' };
     const fallbackConfig = getBaseTsConfig();
 
     let overrides: Overrides | undefined;
 
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.mocked(ignorePlugin).mockReturnValue(mockIgnorePlugin);
+        jest.mocked(filterWarningsPlugin).mockReturnValue(mockFilterWarningsPlugin);
         jest.mocked(rulesConfig).mockReturnValue({ rules: mockRules });
         jest.mocked(getSwcOptions).mockReturnValue(mockSwcOptions);
         vol.fromJSON({
@@ -56,6 +65,14 @@ describe(`[startup/cypress-config] ${webpackConfig.name}`, () => {
         );
     });
 
+    test('adds the ignore plugin', () => {
+        expect(subject().plugins).toContain(mockIgnorePlugin);
+    });
+
+    test('adds the filter warnings plugin', () => {
+        expect(subject().plugins).toContain(mockFilterWarningsPlugin);
+    });
+
     test('includes all rules from rulesConfig', () => {
         const result = subject();
 

package/src/cypress/config/vite-config.ts

@@ -1,6 +1,6 @@
 import { type InlineConfig, mergeConfig } from 'vite';
 import { createCssConfig } from '../../vite/config/create-css-config';
-import { istanbulPlugin, svgrPlugin } from '../../vite/plugins';
+import { ignoreModulesPlugin, istanbulPlugin, svgrPlugin } from '../../vite/plugins';
 import type { ViteBuildContext } from '../../vite/types';
 
 /*
@@ -17,8 +17,22 @@ export function viteConfig(overrides?: InlineConfig): InlineConfig {
     const config: InlineConfig = {
         css: createCssConfig(false),
         resolve: { dedupe: REACT_DEDUPE },
-        optimizeDeps: { include: REACT_OPTIMIZE },
-        plugins: [svgrPlugin(context), istanbulPlugin(context)],
+        optimizeDeps: {
+            include: REACT_OPTIMIZE /*
+             * Top-level plugins don't run during dependency pre-bundling, so
+             * register ignoreModulesPlugin again here. Without this, missing
+             * optional peer dependencies inside pre-bundled packages throw at
+             * runtime instead of resolving to an empty module.
+             */,
+            rolldownOptions: {
+                plugins: [ignoreModulesPlugin({ package: { dependencies: {} } })],
+            },
+        },
+        plugins: [
+            svgrPlugin(context),
+            istanbulPlugin(context),
+            ignoreModulesPlugin({ package: { dependencies: {} } }),
+        ],
     };
 
     return mergeConfig(config, overrides ?? {});
@@ -33,5 +47,6 @@ function getContext(): ViteBuildContext {
     return {
         options: { codeCoverage: true },
         bundlerConfig: { pluginOverrides: {} },
+        package: {},
     } as ViteBuildContext;
 }

package/src/cypress/config/webpack-config.ts

@@ -6,6 +6,7 @@ import { getSwcOptions } from '../../cli/tasks';
 import { TSConfig } from '../../cli/utils';
 import { getTsConfigWithFallback, log } from '../../utils';
 import { JS_RULE_EXCLUDE, rulesConfig } from '../../webpack/configs';
+import { filterWarningsPlugin, ignorePlugin } from '../../webpack/configs/plugins';
 import { Overrides, WebpackBuildContext } from '../../webpack/types';
 
 export function webpackConfig(overrides?: Overrides): Configuration {
@@ -19,6 +20,7 @@ export function webpackConfig(overrides?: Overrides): Configuration {
         module: {
             rules,
         },
+        plugins: [ignorePlugin(context, {}), filterWarningsPlugin(context, {})],
         resolve: {
             extensions: ['.ts', '.tsx', '.js', '.jsx'],
         },