@servicetitan/startup 31.5.1 → 32.0.0

package/src/cli/commands/{tests.ts → test/runners/jest.ts}

@@ -1,22 +1,11 @@
-import { Config } from '@jest/types';
 import { runCLI } from '@jest/core';
-import { getJestConfigCLI, logErrors } from '../../utils';
-import { Command } from '.';
-
-/**
- * Named as tests to exclude it from the Jest pattern
- */
-export class Tests implements Command {
-    readonly greedy = true;
-
-    constructor(private args: Config.Argv) {}
+import { Config } from '@jest/types';
+import { getJestConfigCLI } from '../../../../utils';
 
-    description() {
-        return 'run tests';
-    }
+export class Jest {
+    constructor(private readonly args: Config.Argv) {}
 
-    @logErrors
-    async execute() {
+    async run() {
         const jestConfig = getJestConfigCLI(this.args);
         const {
             results: { success },

package/src/cli/commands/test/runners/vitest.ts

@@ -0,0 +1,70 @@
+import { configDefaults, coverageConfigDefaults, mergeConfig, ViteUserConfig } from 'vitest/config';
+import { startVitest, parseCLI, resolveConfig } from 'vitest/node';
+import { getVitestConfiguration, log } from '../../../../utils';
+
+type VitestConfig = NonNullable<ViteUserConfig['test']>;
+
+export class Vitest {
+    async run() {
+        const cliOptions = getCliOptions();
+        const userConfig = await getUserConfig();
+
+        // startVitest sets process.exitCode to 1 when tests fail
+        const vitest = await startVitest('test', cliOptions.filter, cliOptions.options, userConfig);
+        await vitest.close();
+    }
+}
+
+const RUNNER_OPTION = '--runner';
+
+function excludeRunnerOption(args: string[]) {
+    return args.reduce<string[]>((result, item, index) => {
+        if (!item.startsWith(RUNNER_OPTION) && (index === 0 || args[index - 1] !== RUNNER_OPTION)) {
+            result.push(item);
+        }
+        return result;
+    }, []);
+}
+
+function getCliOptions() {
+    // parseCLI requires the first element to be "vitest"
+    const result = parseCLI(['vitest', ...excludeRunnerOption(process.argv.slice(3))]);
+
+    /* istanbul ignore next: debug only */
+    log.debug('vitest:cliOptions', () => JSON.stringify(result, null, 2));
+
+    return result;
+}
+
+function getDefaultConfig(): VitestConfig {
+    return {
+        coverage: {
+            exclude: [
+                ...coverageConfigDefaults.exclude,
+                '**/__mocks__/**',
+                '**/*.stories.*',
+                '\\.yalc',
+            ],
+            include: ['**/*.{ts,tsx}'],
+            reporter: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
+        },
+        environment: 'jsdom',
+        exclude: [...configDefaults.exclude, '\\.yalc'],
+        restoreMocks: true,
+        server: { deps: { inline: ['@servicetitan/anvil2'] } }, // fixes css parser errors
+    };
+}
+
+async function getUserConfig(): Promise<ViteUserConfig> {
+    const { viteConfig } = await resolveConfig();
+
+    const result = mergeConfig(
+        mergeConfig(getDefaultConfig(), getVitestConfiguration()),
+        viteConfig.test ?? {}
+    );
+
+    /* istanbul ignore next: debug only */
+    log.debug('vitest:userConfig', () => JSON.stringify(result, null, 2));
+
+    return { test: result };
+}

package/src/cli/commands/test/tests.ts

@@ -0,0 +1,34 @@
+import { Config } from '@jest/types';
+import { getConfiguration, logErrors } from '../../../utils';
+import { Command } from '../types';
+import { Jest, Vitest } from './runners';
+
+type Args = Config.Argv & {
+    runner?: 'jest' | 'vitest';
+};
+
+/**
+ * This class is named "Tests" instead of "Test" because the corresponding
+ * "test.ts" would be interpreted as a test file.
+ */
+export class Tests implements Command {
+    readonly greedy = true;
+
+    constructor(private readonly args: Args) {}
+
+    description() {
+        return 'run tests';
+    }
+
+    @logErrors
+    async execute() {
+        const { runner = getConfiguration().testRunner ?? 'jest', ...restArgs } = this.args;
+        if (runner === 'jest') {
+            await new Jest(restArgs).run();
+        } else if (runner === 'vitest') {
+            await new Vitest().run();
+        } else {
+            throw new Error(`unrecognized runner "${runner}"`);
+        }
+    }
+}

package/src/cli/commands/upload-sourcemaps.ts

@@ -1,8 +1,8 @@
 import path from 'path';
 import { execSync } from 'child_process';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
+import { isCI, TSConfig } from '../utils';
 import { Command } from './types';
-import { TSConfig } from '../utils';
 
 interface Args {
     dry?: boolean;
@@ -35,7 +35,7 @@ export class UploadSourcemaps implements Command {
     private checkArgs() {
         if (!process.env.DATADOG_API_KEY) {
             const message = 'DATADOG_API_KEY environment variable is not set';
-            if (!process.env.CI) {
+            if (!isCI()) {
                 throw new Error(message);
             }
             log.warning(`${message}; skipping sourcemaps`);

package/src/cli/index.ts

@@ -3,8 +3,7 @@ import path from 'path';
 import { argv, Arguments } from 'yargs';
 import { CommandName, getStartupVersion, log } from '../utils';
 import { getCommand, getUserCommands } from './commands';
-import { setNodeOptions } from './utils';
-import { maybeCreateGitFolder } from './utils/maybe-create-git-folder';
+import { maybeCreateGitFolder, setNodeOptions } from './utils';
 
 const argvSync = argv as Arguments;
 const name = argvSync._[0]?.toString() as CommandName;

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

@@ -34,7 +34,7 @@ jest.mock('../../../webpack', () => ({ createWebpackConfig: jest.fn() }));
 describe('[startup] Cli Utils', () => {
     const pkg = createPackage({});
     const createWebpackResult = { stats: { all: true } };
-    let compiler: Partial<ReturnType<typeof webpack>>;
+    let compiler: Partial<NonNullable<ReturnType<typeof webpack>>>;
 
     beforeEach(() => {
         jest.resetAllMocks();

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

@@ -1,11 +1,16 @@
-import { runCommandOutput } from '../cli-os';
+import { runCommand, runCommandOutput } from '../cli-os';
 
-import { gitGetBranch, gitGetCommitHash } from '../cli-git';
+import { gitCloneRepo, gitGetBranch, gitGetCommitHash, gitIsReachable } from '../cli-git';
+import { isCI } from '../is-ci';
 
-jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn() }));
+jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
+jest.mock('../cli-os', () => ({ runCommand: jest.fn(), runCommandOutput: jest.fn() }));
 
 describe('[startup] Cli Utils (Git)', () => {
-    beforeEach(() => jest.resetAllMocks());
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
+    });
 
     function itRunsCommand(subject: Function, command: string) {
         test(`runs "${command}"`, () => {
@@ -18,11 +23,142 @@ describe('[startup] Cli Utils (Git)', () => {
         });
     }
 
-    describe(`${gitGetBranch.name}`, () => {
+    describe(gitGetBranch.name, () => {
         itRunsCommand(gitGetBranch, 'git rev-parse --abbrev-ref HEAD');
     });
 
-    describe(`${gitGetCommitHash.name}`, () => {
+    describe(gitGetCommitHash.name, () => {
         itRunsCommand(gitGetCommitHash, 'git rev-parse --short HEAD');
     });
+
+    describe(gitCloneRepo.name, () => {
+        const destination = 'foo';
+        const name = '{name}';
+
+        const webUrl = `https://github.com/servicetitan/${name}.git`;
+        const sshUrl = `git@github.com:servicetitan/${name}.git`;
+
+        let params: Parameters<typeof gitCloneRepo>[0];
+
+        beforeEach(() => (params = { destination, name }));
+
+        const subject = () => gitCloneRepo(params);
+
+        function itReturns(value: boolean) {
+            test(`it returns ${value}`, async () => {
+                expect(await subject()).toBe(value);
+            });
+        }
+
+        test(`clones ${webUrl} to destination directory`, async () => {
+            await subject();
+
+            expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
+                quiet: true,
+            });
+        });
+
+        itReturns(true);
+
+        describe(`when cloning ${webUrl} fails`, () => {
+            beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
+
+            test(`clones ${sshUrl} to destination directory`, async () => {
+                await subject();
+
+                expect(runCommand).toHaveBeenCalledWith(
+                    `git clone -q ${sshUrl} ${destination}`,
+                    expect.anything()
+                );
+            });
+
+            itReturns(true);
+
+            describe(`when cloning ${sshUrl} also fails`, () => {
+                beforeEach(() => {
+                    jest.mocked(runCommand).mockRejectedValue('Nope!');
+                });
+
+                itReturns(false);
+            });
+        });
+
+        describe('when running in CI environment with GITHUB_TOKEN', () => {
+            const originalEnv = process.env;
+            const token = 'foo-bar';
+
+            beforeEach(() => {
+                jest.mocked(isCI).mockReturnValue(true);
+                process.env.GITHUB_TOKEN = token;
+            });
+            afterEach(() => (process.env = originalEnv));
+
+            test(`adds token to ${webUrl}`, async () => {
+                await subject();
+
+                const urlWithToken = webUrl.replace('github.com', `oauth2:${token}@github.com`);
+                expect(runCommand).toHaveBeenCalledWith(
+                    `git clone -q ${urlWithToken} ${destination}`,
+                    expect.anything()
+                );
+            });
+        });
+    });
+
+    describe(gitIsReachable.name, () => {
+        const name = '{name}';
+
+        let params: Parameters<typeof gitIsReachable>[0];
+
+        beforeEach(() => (params = { name }));
+
+        const subject = () => gitIsReachable(params);
+
+        function itReturns(value: boolean) {
+            test(`it returns ${value}`, () => {
+                expect(subject()).toBe(value);
+            });
+        }
+
+        const webUrl = `https://github.com/servicetitan/${name}.git`;
+        const sshUrl = `git@github.com:servicetitan/${name}.git`;
+
+        test(`checks if ${webUrl} is reachable`, () => {
+            subject();
+
+            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
+                quiet: true,
+            });
+        });
+
+        itReturns(true);
+
+        describe(`when ${webUrl} is not reachable`, () => {
+            beforeEach(() => {
+                jest.mocked(runCommandOutput).mockImplementationOnce(() => {
+                    throw new Error('Oops!');
+                });
+            });
+
+            test(`checks if ${sshUrl} is reachable`, () => {
+                subject();
+
+                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
+                    quiet: true,
+                });
+            });
+
+            itReturns(true);
+
+            describe(`when ${sshUrl} is also unreachable`, () => {
+                beforeEach(() =>
+                    jest.mocked(runCommandOutput).mockImplementation(() => {
+                        throw new Error('Oops');
+                    })
+                );
+
+                itReturns(false);
+            });
+        });
+    });
 });

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

@@ -1,12 +1,13 @@
 import { fs, vol } from 'memfs';
 import { ESLint } from 'eslint';
 
+import { getDestinationFolders } from '../../../utils';
 import { eslint } from '../eslint';
-import { getDestinationFolders } from '../../../utils/get-destination-folders';
 
 jest.mock('fs', () => fs);
 jest.mock('eslint');
-jest.mock('../../../utils/get-destination-folders', () => ({
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     getDestinationFolders: jest.fn(),
 }));
 

package/src/cli/utils/__tests__/is-ci.test.ts

@@ -0,0 +1,40 @@
+import { isCI } from '../is-ci';
+
+describe(`[startup] Utils ${isCI.name}`, () => {
+    const originalCI = process.env.CI;
+
+    beforeAll(() => delete process.env.CI);
+    afterAll(() => (process.env.CI = originalCI));
+
+    const subject = () => isCI();
+
+    function itReturns(value: boolean) {
+        test(`returns ${value}`, () => {
+            expect(subject()).toBe(value);
+        });
+    }
+
+    itReturns(false);
+
+    describe.each([
+        { value: '', result: false },
+        { value: '1', result: true },
+    ])('when process.env.CI is "$value"', ({ value, result }) => {
+        beforeEach(() => (process.env.CI = value));
+
+        afterEach(() => delete process.env.CI);
+
+        itReturns(result);
+    });
+
+    describe.each([
+        { value: '', result: false },
+        { value: '1', result: true },
+    ])('when process.env.TEAMCITY_VERSION is "$value"', ({ value, result }) => {
+        beforeEach(() => (process.env.TEAMCITY_VERSION = value));
+
+        afterEach(() => delete process.env.TEAMCITY_VERSION);
+
+        itReturns(result);
+    });
+});

package/src/cli/utils/__tests__/lerna-exec.test.ts

@@ -1,9 +1,11 @@
 import execa from 'execa';
 
 import { log } from '../../../utils';
+import { isCI } from '../is-ci';
 import { lernaExec } from '../lerna-exec';
 
 jest.mock('execa');
+jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
 
 const AVAILABLE_PARALLELISM = 2;
 
@@ -17,9 +19,9 @@ describe(`${lernaExec.name}`, () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
         jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress log output
         args = { cmd: 'foo' };
-        delete process.env.CI;
     });
 
     const subject = () => lernaExec(args);
@@ -60,10 +62,11 @@ describe(`${lernaExec.name}`, () => {
         itRunsLernaExec(option);
     });
 
-    describe('when process.env.CI=true', () => {
+    describe('when in CI environment', () => {
         beforeEach(() => {
-            process.env.CI = 'true';
+            jest.mocked(isCI).mockReturnValue(true);
         });
+
         describe.each([
             { arg: { parallel: true }, option: `--concurrency=${AVAILABLE_PARALLELISM}` },
             { arg: { parallel: 10 }, option: '--concurrency=10' },

package/src/cli/utils/bundle.ts

@@ -57,6 +57,7 @@ export async function bundle(options: Options = {}) {
     const customConfig = readWebpackConfig({ ...options, fallback });
     const webpackOptions = getWebpackOptions(options, customConfig);
 
+    /* istanbul ignore next: debug only */
     log.debug('custom-webpack-config', () => stringifyConfig(customConfig));
 
     if (isWebComponent()) {
@@ -135,7 +136,7 @@ function readConfig(relativePath?: string): Record<string, any> | undefined {
 }
 
 async function run(config: Configuration) {
-    const compiler = webpack(config);
+    const compiler = createWebpackCompiler(config);
 
     const stats = await new Promise<webpack.Stats>((resolve, reject) => {
         compiler.run((error, stats) => {
@@ -155,7 +156,7 @@ async function run(config: Configuration) {
 }
 
 async function runServe({ devServer = {}, ...config }: Configuration) {
-    const compiler = webpack(config);
+    const compiler = createWebpackCompiler(config);
     const host = devServer.host ?? 'localhost';
     const port = await getPortPromise({
         port: Number(devServer.port) || 8080,
@@ -175,7 +176,7 @@ async function runServe({ devServer = {}, ...config }: Configuration) {
 }
 
 async function runWatch(config: Configuration) {
-    const compiler = webpack(config);
+    const compiler = createWebpackCompiler(config);
     return new Promise<void>((_0, reject) => {
         const watching = compiler.watch({}, e => {
             if (e) {
@@ -186,3 +187,7 @@ async function runWatch(config: Configuration) {
         });
     });
 }
+
+function createWebpackCompiler(config: Configuration) {
+    return webpack(config)!; // webpack only potentially returns null when given a callback argument
+}

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

@@ -1,9 +1,59 @@
-import { runCommandOutput } from './cli-os';
+import { log } from '../../utils';
+import { runCommand, runCommandOutput } from './cli-os';
+import { isCI } from './is-ci';
 
-export const gitGetBranch = (): string => {
+export function gitGetBranch(): string {
     return runCommandOutput('git rev-parse --abbrev-ref HEAD').trim();
-};
+}
 
-export const gitGetCommitHash = (): string => {
+export function gitGetCommitHash(): string {
     return runCommandOutput('git rev-parse --short HEAD').trim();
-};
+}
+
+interface Repo {
+    owner?: string;
+    name: string;
+}
+
+export async function gitCloneRepo(params: Repo & { destination: string }) {
+    const { destination, name, owner = 'servicetitan' } = params;
+    const gitUrls = getGitUrls({ owner, name });
+
+    for (const url of gitUrls) {
+        try {
+            const command = `git clone -q ${url} ${destination}`;
+            log.debug('git:clone-repo', `running ${command}`);
+
+            // eslint-disable-next-line no-await-in-loop
+            await runCommand(command, { quiet: true });
+            return true;
+        } catch {
+            // ignore error
+        }
+    }
+
+    return false;
+}
+
+export function gitIsReachable({ owner = 'servicetitan', name }: Repo) {
+    return getGitUrls({ owner, name }).some(url => {
+        try {
+            runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
+            return true;
+        } catch {
+            return false;
+        }
+    });
+}
+
+function getGitUrls({ owner, name }: Repo) {
+    const webUrl = `https://github.com/${owner}/${name}.git`;
+    const sshUrl = `git@github.com:${owner}/${name}.git`;
+
+    const urls = [webUrl, sshUrl];
+    if (isCI() && !!process.env.GITHUB_TOKEN) {
+        urls.unshift(webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`));
+    }
+
+    return urls;
+}

package/src/cli/utils/index.ts

@@ -1,15 +1,21 @@
 export * from './bundle';
 export * from './check-args';
+export * from './cli-git';
+export * from './cli-npm';
+export * from './cli-os';
 export * from './compile';
 export * from './compile-less';
 export * from './compile-sass';
 export * from './copy-files';
 export * from './eslint';
 export * from './get-module-type';
+export * from './is-ci';
 export * from './is-module-installed';
 export * from './lerna-exec';
+export * from './maybe-create-git-folder';
 export * from './pipe-stdout';
 export * from './process-tree';
+export * from './publish';
 export * from './set-node-options';
 export * from './ts-config';
 export * from './type-check';

package/src/cli/utils/is-ci.ts

@@ -0,0 +1,3 @@
+export function isCI() {
+    return !!process.env.CI || !!process.env.TEAMCITY_VERSION;
+}

package/src/cli/utils/lerna-exec.ts

@@ -2,6 +2,7 @@ import execa, { StdioOption } from 'execa';
 import os from 'node:os';
 
 import { log } from '../../utils';
+import { isCI } from './is-ci';
 
 interface Args {
     'bail'?: boolean;
@@ -37,7 +38,7 @@ function getOptions(args: Args) {
         result.push('--no-bail');
     }
     if (args.parallel === true) {
-        result.push(process.env.CI ? `--concurrency=${os.availableParallelism()}` : '--parallel');
+        result.push(isCI() ? `--concurrency=${os.availableParallelism()}` : '--parallel');
     } else if (typeof args.parallel === 'number') {
         result.push(`--concurrency=${args.parallel}`);
     }

package/src/cli/utils/set-node-options.ts

@@ -1,5 +1,5 @@
 import os from 'os';
-import { CommandName, NodeConfiguration, getConfigurationSafe } from '../../utils';
+import { CommandName, getConfigurationSafe } from '../../utils';
 import { Command } from '../commands';
 
 const MAX_OLD_SPACE_SIZE_OPTION = 'max_old_space_size';
@@ -13,7 +13,7 @@ const MIN_REMAINING_MEMORY_MB = 512;
  */
 export function setNodeOptions(commandName: CommandName, command: Command) {
     const cliConfig = getConfigurationSafe();
-    const cmdConfig: NodeConfiguration = cliConfig[commandName];
+    const cmdConfig = cliConfig[commandName];
 
     const cliNodeOptions = cliConfig.NODE_OPTIONS ?? [];
     const cmdNodeOptions = cmdConfig?.NODE_OPTIONS ?? [];

package/src/index.ts

@@ -1,3 +1,2 @@
 export * from './webpack';
-export * from './jest';
 export * from './utils/get-packages';