@servicetitan/startup 38.0.0 → 38.2.0

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

@@ -1,4 +1,7 @@
-import { runCommandOutput } from './cli-os';
+import path from 'node:path';
+import { runCommandOutput, runCommandOutputAsync } from './cli-os';
+
+const GIT_TIMEOUT_MS = 2000;
 
 export function gitGetBranch(): string {
     return runCommandOutput('git rev-parse --abbrev-ref HEAD').trim();
@@ -7,3 +10,26 @@ export function gitGetBranch(): string {
 export function gitGetCommitHash(): string {
     return runCommandOutput('git rev-parse --short HEAD').trim();
 }
+
+export interface GitContext {
+    repo?: string;
+    branch?: string;
+    userEmail?: string;
+    userName?: string;
+}
+
+export async function gitGetContext(): Promise<GitContext> {
+    const options = { quiet: true, ignoreErrors: true, timeout: GIT_TIMEOUT_MS };
+    const [rev, userEmail, userName] = await Promise.all([
+        runCommandOutputAsync('git rev-parse --abbrev-ref HEAD --show-toplevel', options),
+        runCommandOutputAsync('git config user.email', options),
+        runCommandOutputAsync('git config user.name', options),
+    ]);
+    const [branch, root] = rev?.split('\n') ?? [];
+    return {
+        repo: root ? path.basename(root) : undefined,
+        branch,
+        userEmail,
+        userName,
+    };
+}

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,9 +1,13 @@
 import {
+    exec,
+    execFileSync,
+    ExecOptions,
     execSync,
     ExecSyncOptionsWithBufferEncoding,
     spawn,
     SpawnOptionsWithoutStdio,
 } from 'child_process';
+import { promisify } from 'util';
 import { log } from '../../utils';
 
 type RunCommandOptions = SpawnOptionsWithoutStdio & { quiet?: boolean };
@@ -79,3 +83,43 @@ export function runCommandOutput(
 
     return result;
 }
+
+type RunCommandOutputAsyncOptions = ExecOptions & { quiet?: boolean; ignoreErrors?: boolean };
+
+export async function runCommandOutputAsync(
+    command: string,
+    { quiet, ignoreErrors, ...execOptions }: RunCommandOutputAsyncOptions = {}
+): Promise<string | undefined> {
+    if (!quiet) {
+        log.info(`Running: ${command}`);
+    }
+
+    try {
+        const { stdout } = await promisify(exec)(command, execOptions);
+        const result = stdout.toString().trim();
+
+        if (!quiet) {
+            log.info('command finished', result);
+        }
+
+        return result || undefined;
+    } catch (error) {
+        if (ignoreErrors) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+
+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/storybook-config/__tests__/vite-final.test.ts

@@ -6,6 +6,12 @@ import { viteFinal } from '../vite-final';
 
 jest.mock('../../vite/plugins');
 jest.mock('../../vite/config/create-filtering-logger');
+jest.mock('../../vite/config/create-css-config', () => ({
+    createCssConfig: jest.fn(() => ({
+        modules: { localsConvention: 'camelCaseOnly' },
+        preprocessorOptions: { less: { math: 'always' } },
+    })),
+}));
 
 describe(`[startup/storybook-config] ${viteFinal.name}`, () => {
     const mockSvgrPlugin: any = { name: 'vite-plugin-svgr' };

package/src/storybook-config/__tests__/webpack-final.test.ts

@@ -1,6 +1,10 @@
 import type { Configuration } from 'webpack';
 import { rulesConfig } from '../../webpack/configs';
-import { ignorePlugin, miniCssExtractPlugin } from '../../webpack/configs/plugins';
+import {
+    filterWarningsPlugin,
+    ignorePlugin,
+    miniCssExtractPlugin,
+} from '../../webpack/configs/plugins';
 import { Overrides } from '../../webpack/types';
 import { webpackFinal } from '../webpack-final';
 
@@ -18,16 +22,18 @@ describe(`[startup/storybook-config] ${webpackFinal.name}`, () => {
         { test: /\.svg$/, use: ['svg-loader'] },
         { test: /\.css$/, use: ['css-loader'] },
     ];
-    const mockMiniCssExtractPlugin: any = { name: 'MiniCssExtractPlugin' };
+    const mockFilterWarningsPlugin: any = { name: 'FilterWarningsPlugin' };
     const mockIgnorePlugin: any = { name: 'IgnorePlugin' };
+    const mockMiniCssExtractPlugin: any = { name: 'MiniCssExtractPlugin' };
     let config: Configuration;
     let overrides: Overrides | undefined;
 
     beforeEach(() => {
         jest.clearAllMocks();
         jest.mocked(rulesConfig).mockReturnValue({ rules: mockRules });
-        jest.mocked(miniCssExtractPlugin).mockReturnValue(mockMiniCssExtractPlugin);
+        jest.mocked(filterWarningsPlugin).mockReturnValue(mockFilterWarningsPlugin);
         jest.mocked(ignorePlugin).mockReturnValue(mockIgnorePlugin);
+        jest.mocked(miniCssExtractPlugin).mockReturnValue(mockMiniCssExtractPlugin);
         config = {};
         overrides = undefined;
     });
@@ -53,12 +59,16 @@ describe(`[startup/storybook-config] ${webpackFinal.name}`, () => {
         );
     });
 
-    test('adds MiniCssExtractPlugin to config', () => {
-        expect(subject().plugins).toEqual(expect.arrayContaining([mockMiniCssExtractPlugin]));
+    test('adds FilterWarningPlugin to config', () => {
+        expect(subject().plugins).toContain(mockFilterWarningsPlugin);
     });
 
     test('adds IgnorePlugin to config', () => {
-        expect(subject().plugins).toEqual(expect.arrayContaining([mockIgnorePlugin]));
+        expect(subject().plugins).toContain(mockIgnorePlugin);
+    });
+
+    test('adds MiniCssExtractPlugin to config', () => {
+        expect(subject().plugins).toContain(mockMiniCssExtractPlugin);
     });
 
     describe('when config contains rules', () => {
@@ -76,22 +86,26 @@ describe(`[startup/storybook-config] ${webpackFinal.name}`, () => {
 
     describe('when config contains plugins', () => {
         const configPlugin: any = { name: 'MockPlugin' };
+        const defaultPlugIns = [
+            mockMiniCssExtractPlugin,
+            mockIgnorePlugin,
+            mockFilterWarningsPlugin,
+        ];
 
         beforeEach(() => (config.plugins = [configPlugin]));
 
         test('appends default plugins to config', () => {
-            expect(subject().plugins).toEqual([
-                configPlugin,
-                mockMiniCssExtractPlugin,
-                mockIgnorePlugin,
-            ]);
+            expect(subject().plugins).toEqual([configPlugin, ...defaultPlugIns]);
         });
 
         describe('when MiniCssExtractPlugin is disabled', () => {
             beforeEach(() => jest.mocked(miniCssExtractPlugin).mockReturnValue(undefined));
 
             test('omits plugin', () => {
-                expect(subject().plugins).toEqual([configPlugin, mockIgnorePlugin]);
+                expect(subject().plugins).toEqual([
+                    configPlugin,
+                    ...defaultPlugIns.filter(plugin => plugin !== mockMiniCssExtractPlugin),
+                ]);
             });
         });
     });

package/src/storybook-config/webpack-final.ts

@@ -3,7 +3,11 @@ import { inspect } from 'node:util';
 import type { Configuration } from 'webpack';
 import { log } from '../utils';
 import { rulesConfig } from '../webpack/configs';
-import { ignorePlugin, miniCssExtractPlugin } from '../webpack/configs/plugins';
+import {
+    filterWarningsPlugin,
+    ignorePlugin,
+    miniCssExtractPlugin,
+} from '../webpack/configs/plugins';
 import { Overrides, WebpackBuildContext } from '../webpack/types';
 
 export function webpackFinal(config: Configuration, overrides: Overrides = {}): Configuration {
@@ -48,9 +52,11 @@ function getContext(config: Configuration): WebpackBuildContext {
 }
 
 function getPlugins(context: WebpackBuildContext, overrides: Overrides) {
-    return [miniCssExtractPlugin(context, overrides), ignorePlugin(context, {})].filter(
-        plugin => !!plugin
-    );
+    return [
+        miniCssExtractPlugin(context, overrides),
+        ignorePlugin(context, {}),
+        filterWarningsPlugin(context, {}),
+    ].filter(plugin => !!plugin);
 }
 
 function getRules(context: WebpackBuildContext, overrides: Overrides) {