@servicetitan/startup 31.5.1 → 32.0.0

package/src/cli/commands/prepare-package.ts

@@ -7,7 +7,7 @@ interface Args {
 }
 
 export class PreparePackage implements Command {
-    constructor(private args: Args) {}
+    constructor(private readonly args: Args) {}
 
     @logErrors
     execute() {

package/src/cli/commands/review/rules/__tests__/require-all-react-dependencies.test.ts

@@ -0,0 +1,132 @@
+import { FixCategory, Project, ReviewConfiguration } from '../../types';
+import { setVersion } from '../../utils';
+import { mockConfig, mockPackages, mockProject } from '../__mocks__';
+
+import { RequireAllReactDependencies } from '../require-all-react-dependencies';
+
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    setVersion: jest.fn(),
+}));
+
+describe(`[startup] Review ${RequireAllReactDependencies.name}`, () => {
+    const id = 'require-all-react-dependencies';
+    const rule = new RequireAllReactDependencies();
+    let config: ReviewConfiguration;
+    let dependencies: Project['dependencies'];
+
+    beforeEach(() => {
+        config = {};
+        dependencies = {};
+        jest.clearAllMocks();
+    });
+
+    const project = () =>
+        mockProject({ config, dependencies, packages: mockPackages(dependencies) });
+
+    const subject = () => rule.run(project());
+
+    const fixSubject = () => {
+        const testProject = project();
+        rule.fix(rule.run(testProject)[0], testProject);
+    };
+
+    function itReturnsError({
+        packageName,
+        present,
+        absent,
+    }: {
+        packageName: string;
+        present: string;
+        absent: string;
+    }) {
+        test('returns error', () => {
+            expect(subject()).toEqual([
+                expect.objectContaining({
+                    id,
+                    message: `package "${packageName}" depends on ${present} but not on ${absent}`,
+                    fixable: FixCategory.isolated,
+                }),
+            ]);
+        });
+    }
+
+    function itReturnsNothing() {
+        test(`returns nothing`, () => {
+            expect(subject()).toEqual([]);
+        });
+    }
+
+    itReturnsNothing();
+
+    describe('when package depends only on "react"', () => {
+        beforeEach(() => {
+            dependencies = {
+                react: { '^18': ['lib'] },
+            };
+        });
+
+        itReturnsError({ packageName: 'lib', present: 'react', absent: 'react-dom' });
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expect(setVersion).toHaveBeenCalledWith({
+                project: project(),
+                packageName: 'lib',
+                dependency: 'react-dom',
+                version: '^18',
+                key: 'dependencies',
+            });
+        });
+
+        test('ignores invalid error', () => {
+            rule.fix({} as any, project());
+
+            expect(setVersion).not.toHaveBeenCalled();
+        });
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: 'lib' })));
+
+            itReturnsNothing();
+        });
+    });
+
+    describe('when package depends only on "react-dom"', () => {
+        beforeEach(() => {
+            dependencies = {
+                'react-dom': { '^18': ['lib'] },
+            };
+        });
+
+        itReturnsError({ packageName: 'lib', present: 'react-dom', absent: 'react' });
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expect(setVersion).toHaveBeenCalledWith({
+                project: project(),
+                packageName: 'lib',
+                dependency: 'react',
+                version: '^18',
+                key: 'dependencies',
+            });
+        });
+    });
+
+    describe('when package depends on both "react" and "react-dom"', () => {
+        beforeEach(() => {
+            dependencies = {
+                'react': { '^18': ['lib'] },
+                'react-dom': { '^18': ['lib'] },
+            };
+        });
+
+        itReturnsNothing();
+    });
+
+    test('returns nothing when package has no dependencies', () => {
+        expect(rule.run(mockProject({ packages: [{ name: 'foo' } as any] }))).toEqual([]);
+    });
+});

package/src/cli/commands/review/rules/__tests__/require-one-package-version.test.ts

@@ -6,7 +6,6 @@ import { mockConfig, mockPackages, mockProject } from '../__mocks__';
 
 import { RequireOnePackageVersion } from '../require-one-package-version';
 
-jest.mock('child_process', () => ({ execSync: jest.fn() }));
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     setVersion: jest.fn(),

package/src/cli/commands/review/rules/__tests__/require-one-react-version.test.ts

@@ -0,0 +1,22 @@
+import { RequireOneCollectionVersion } from '../require-one-collection-version';
+
+import { RequireOneReactVersion } from '../require-one-react-version';
+
+jest.mock('../require-one-collection-version');
+
+describe(`[startup] Review ${RequireOneReactVersion.name}`, () => {
+    const reactPackages = ['react', 'react-dom'];
+
+    beforeEach(() => jest.clearAllMocks());
+
+    const subject = () => new RequireOneReactVersion();
+
+    test('calls RequireOneCollectionVersion with react packages', () => {
+        subject();
+
+        expect(RequireOneCollectionVersion).toHaveBeenCalledWith({
+            name: 'react',
+            packages: reactPackages,
+        });
+    });
+});

package/src/cli/commands/review/rules/__tests__/{require-one-uikit-version.ts → require-one-uikit-version.test.ts}

@@ -7,6 +7,7 @@ jest.mock('../require-one-collection-version');
 describe(`[startup] Review ${RequireOneUikitVersion.name}`, () => {
     const uikitPackages = [
         '@servicetitan/ajax-handlers',
+        '@servicetitan/datadog-rum',
         '@servicetitan/error-boundary',
         '@servicetitan/eslint-config',
         '@servicetitan/eslint-plugin',

package/src/cli/commands/review/rules/index.ts

@@ -1,17 +1,21 @@
 import { PackageRule } from '../types';
 import { NoTypescriptEntryPoint } from './no-typescript-entry-point';
+import { RequireAllReactDependencies } from './require-all-react-dependencies';
 import { RequireExplicitSideEffects } from './require-explicit-side-effects';
 import { RequireNpmrc } from './require-npmrc';
 import { RequireOneAnvilUikitContribVersion } from './require-one-anvil-uikit-contrib-version';
 import { RequireOnePackageVersion } from './require-one-package-version';
+import { RequireOneReactVersion } from './require-one-react-version';
 import { RequireOneUikitVersion } from './require-one-uikit-version';
 import { RequireProjectVersionInRootNodeModules } from './require-project-version-in-root-node-modules';
 import { RequireServiceTitanScope } from './require-servicetitan-scope';
 
 export const rules: PackageRule[] = [
     new RequireOnePackageVersion(),
+    new RequireAllReactDependencies(),
     new RequireOneUikitVersion(),
     new RequireOneAnvilUikitContribVersion(),
+    new RequireOneReactVersion(),
     new RequireProjectVersionInRootNodeModules(),
     new NoTypescriptEntryPoint(),
     new RequireServiceTitanScope(),

package/src/cli/commands/review/rules/require-all-react-dependencies.ts

@@ -0,0 +1,53 @@
+import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
+import { applyFilter, formatList, getMaxVersion, setVersion } from '../utils';
+
+const REACT_DEPENDENCIES = ['react', 'react-dom'];
+
+interface ErrorData {
+    missing: string[];
+    packageName: string;
+    version: string;
+}
+
+export class RequireAllReactDependencies implements PackageRule {
+    get id() {
+        return 'require-all-react-dependencies';
+    }
+
+    run({ config, packages }: Project) {
+        const ruleConfig = config.rules?.[this.id];
+        return applyFilter(ruleConfig, packages, ({ name }) => name)
+            .map(pkg => this.checkDependencies(pkg))
+            .filter(error => !!error);
+    }
+
+    fix({ data }: PackageError<ErrorData>, project: Project) {
+        const { missing, packageName, version } = data ?? {};
+        if (!(missing?.length && packageName && version)) {
+            return;
+        }
+
+        missing.forEach(dependency => {
+            setVersion({ project, packageName, dependency, version, key: 'dependencies' });
+        });
+    }
+
+    private checkDependencies(pkg: Package): PackageError<ErrorData> | undefined {
+        const { dependencies = {}, name } = pkg;
+        const present = REACT_DEPENDENCIES.filter(name => !!dependencies[name]);
+        if (present.length === 0 || present.length === REACT_DEPENDENCIES.length) {
+            return;
+        }
+
+        const missing = REACT_DEPENDENCIES.filter(name => !dependencies[name]);
+        const message = `package "${name}" depends on ${present[0]} but not on ${formatList(missing)}`;
+        const version = getMaxVersion(present.map(name => dependencies[name]));
+        return {
+            id: this.id,
+            message,
+            location: pkg.location,
+            fixable: FixCategory.isolated,
+            data: { missing, packageName: name, version },
+        };
+    }
+}

package/src/cli/commands/review/rules/require-one-react-version.ts

@@ -0,0 +1,9 @@
+import { RequireOneCollectionVersion } from './require-one-collection-version';
+
+const REACT_PACKAGES = ['react', 'react-dom'];
+
+export class RequireOneReactVersion extends RequireOneCollectionVersion {
+    constructor() {
+        super({ name: 'react', packages: REACT_PACKAGES });
+    }
+}

package/src/cli/commands/review/rules/require-one-uikit-version.ts

@@ -2,6 +2,7 @@ import { RequireOneCollectionVersion } from './require-one-collection-version';
 
 const UIKIT_PACKAGES = [
     '@servicetitan/ajax-handlers',
+    '@servicetitan/datadog-rum',
     '@servicetitan/error-boundary',
     '@servicetitan/eslint-config',
     '@servicetitan/eslint-plugin',

package/src/cli/commands/review/utils/__tests__/set-version.test.ts

@@ -7,25 +7,23 @@ import { setVersion } from '../set-version';
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
 
 describe(`[startup] Review ${setVersion.name}`, () => {
+    const packageName = 'lib1';
+    const dependency = 'foo';
+    const version = '2.0.0';
     let pkg: Package;
-    let packageName: string;
-    let dependency: string;
-    let version: string;
+    let params: Parameters<typeof setVersion>[0];
 
     beforeEach(() => {
-        packageName = 'lib1';
-        dependency = 'foo';
-        version = '2.0.0';
         pkg = {
             name: packageName,
             location: path.normalize(`packages/${packageName}`),
             dependencies: { [dependency]: '1.0.0' },
         };
+        params = { project: { packages: [pkg] } as any, packageName, dependency, version };
         jest.clearAllMocks();
     });
 
-    const subject = () =>
-        setVersion({ project: { packages: [pkg] } as any, packageName, dependency, version });
+    const subject = () => setVersion(params);
 
     function itDoesNothing() {
         test('does nothing', () => {
@@ -74,6 +72,18 @@ describe(`[startup] Review ${setVersion.name}`, () => {
         beforeEach(() => delete pkg.dependencies);
 
         itDoesNothing();
+
+        describe('when key is specified', () => {
+            beforeEach(() => (params.key = 'dependencies'));
+
+            test('sets dependency version', () => {
+                subject();
+
+                expect(execSync).toHaveBeenCalledWith(
+                    `npm pkg set ${params.key}["${dependency}"]="${version}" -w ${pkg.location}`
+                );
+            });
+        });
     });
 
     describe('when package is missing', () => {

package/src/cli/commands/review/utils/format-depends-on.ts

@@ -2,10 +2,13 @@ const collator = new Intl.Collator();
 
 export function formatDependsOn(dependents: string[], dependency: string) {
     const { length } = dependents;
-    if (length === 1) {
-        return `${dependents[0]} depends on ${dependency}`;
-    }
+    return length === 1
+        ? `${dependents[0]} depends on ${dependency}`
+        : `${formatList(dependents.toSorted((a, b) => collator.compare(a, b)))} depend on ${dependency}`;
+}
 
-    const sorted = dependents.toSorted((a, b) => collator.compare(a, b));
-    return `${sorted.slice(0, -1).join(', ')} and ${sorted[length - 1]} depend on ${dependency}`;
+export function formatList(items: string[]) {
+    return items.length > 1
+        ? `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`
+        : items[0];
 }

package/src/cli/commands/review/utils/set-version.ts

@@ -8,14 +8,22 @@ interface Params {
     packageName: string;
     dependency: string;
     version: string;
+    key?: string;
 }
-export function setVersion({ project: { packages }, packageName, dependency, version }: Params) {
+
+export function setVersion(params: Params) {
+    const {
+        project: { packages },
+        packageName,
+        dependency,
+        version,
+    } = params;
     const pkg = packages.find(({ name }) => name === packageName);
     if (!pkg) {
         return;
     }
 
-    const key = getKey(pkg, dependency);
+    const key = params.key ?? getKey(pkg, dependency);
     if (!key) {
         return;
     }

package/src/cli/commands/start.ts

@@ -31,7 +31,7 @@ enum StartProcesses {
 export class Start implements Command {
     readonly greedy = true;
 
-    constructor(private args: Args) {}
+    constructor(private readonly args: Args) {}
 
     description() {
         return 'run project in development mode';

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

@@ -0,0 +1,78 @@
+import { getConfiguration } from '../../../../utils';
+import { Jest, Vitest } from '../runners';
+import { Tests } from '../tests';
+
+jest.mock('../runners');
+jest.mock('../../../../utils', () => ({
+    ...jest.requireActual('../../../../utils'),
+    getConfiguration: jest.fn(),
+}));
+
+type TestArgs = ConstructorParameters<typeof Tests>[0];
+
+describe(`[startup] ${Tests.name}`, () => {
+    let args: TestArgs;
+
+    beforeEach(() => {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        args = { _: ['foo'], $0: 'bar' };
+        jest.mocked(getConfiguration).mockReturnValue({});
+        jest.clearAllMocks();
+    });
+
+    const subject = async () => new Tests(args).execute();
+
+    test('command is greedy', () => {
+        expect(new Tests(args).greedy).toBe(true);
+    });
+
+    function itRunsJest() {
+        test('runs Jest', async () => {
+            await subject();
+
+            const { runner, ...rest } = args;
+            expect(Jest).toHaveBeenCalledWith(rest);
+            expect(jest.mocked(Jest).mock.instances[0].run).toHaveBeenCalled();
+        });
+    }
+
+    function itRunsVitest() {
+        test('runs Vitest', async () => {
+            await subject();
+
+            expect(Vitest).toHaveBeenCalled();
+            expect(jest.mocked(Vitest).mock.instances[0].run).toHaveBeenCalled();
+        });
+    }
+
+    itRunsJest();
+
+    describe('with --runner=vitest', () => {
+        beforeEach(() => (args.runner = 'vitest'));
+
+        itRunsVitest();
+    });
+
+    describe('with unrecognized --runner', () => {
+        beforeEach(() => (args.runner = 'foo' as any));
+
+        test('throws error', () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+            expect(subject).rejects.toThrow('unrecognized runner "foo"');
+        });
+    });
+
+    describe('with {testRunner: "vitest"}', () => {
+        beforeEach(() => {
+            jest.mocked(getConfiguration).mockReturnValue({ testRunner: 'vitest' });
+        });
+
+        itRunsVitest();
+
+        describe('with --runner=jest', () => {
+            beforeEach(() => (args.runner = 'jest'));
+
+            itRunsJest();
+        });
+    });
+});

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

@@ -0,0 +1 @@
+export * from './tests';

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

@@ -1,30 +1,27 @@
 import { runCLI } from '@jest/core';
-import { Config } from '@jest/types';
-import { getJestConfigCLI } from '../../../utils';
 
-import { Tests } from '../tests';
+import { Jest } from '../jest';
+import { getJestConfigCLI } from '../../../../../utils';
 
 jest.mock('@jest/core', () => ({ runCLI: jest.fn() }));
-jest.mock('../../../utils', () => ({
-    ...jest.requireActual('../../../utils'),
+jest.mock('../../../../../utils', () => ({
+    ...jest.requireActual('../../../../../utils'),
     getJestConfigCLI: jest.fn(),
 }));
 
-describe(`[startup] ${Tests.name}`, () => {
+type JestArgs = ConstructorParameters<typeof Jest>[0];
+
+describe(`[startup] Test ${Jest.name}`, () => {
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    const args: Config.Argv = { _: ['foo'], $0: 'bar' };
-    const jestConfig: Config.Argv = { ...args, setupFilesAfterEnv: ['./setupTests.js'] };
+    const args: JestArgs = { _: ['foo'], $0: 'bar' };
+    const jestConfig: JestArgs = { ...args, setupFilesAfterEnv: ['./setupTests.js'] };
 
     beforeAll(() => {
         jest.mocked(getJestConfigCLI).mockReturnValue(jestConfig);
         jest.mocked(runCLI).mockResolvedValue({ results: { success: true } } as any);
     });
 
-    const subject = async () => new Tests(args).execute();
-
-    test('command is greedy', () => {
-        expect(new Tests(args).greedy).toBe(true);
-    });
+    const subject = async () => new Jest(args).run();
 
     test('runs Jest CLI', async () => {
         await subject();

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

@@ -0,0 +1,150 @@
+import deepmerge from 'deepmerge';
+import { fs, vol } from 'memfs';
+import { configDefaults, coverageConfigDefaults, mergeConfig, ViteUserConfig } from 'vitest/config';
+import { parseCLI, resolveConfig, startVitest } from 'vitest/node';
+import { Vitest } from '../vitest';
+
+/**
+ * Mocking "vitest/" includes all vite and vitest entry points because there is
+ * one identity-obj-proxy for "^(vite|vitest)/" @see cli.test.moduleNameMapper
+ * in {@link file://./../../../../../../../../package.json}
+ */
+jest.mock('vitest/', () => ({
+    configDefaults: { exclude: ['node_modules'] },
+    coverageConfigDefaults: { exclude: ['node_modules'] },
+    mergeConfig: jest.fn(),
+    parseCLI: jest.fn(),
+    resolveConfig: jest.fn(),
+    startVitest: jest.fn(),
+}));
+
+jest.mock('fs', () => fs);
+
+describe(`[startup] Test ${Vitest.name}`, () => {
+    const defaultConfig: ViteUserConfig['test'] = {
+        coverage: {
+            include: ['**/*.{ts,tsx}'],
+            exclude: [
+                ...coverageConfigDefaults.exclude,
+                '**/__mocks__/**',
+                '**/*.stories.*',
+                '\\.yalc',
+            ],
+            reporter: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
+        },
+        environment: 'jsdom',
+        exclude: [...configDefaults.exclude, '\\.yalc'],
+        restoreMocks: true,
+        server: { deps: { inline: ['@servicetitan/anvil2'] } },
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        jest.mocked(mergeConfig).mockImplementation((a, b) => deepmerge(a, b));
+        jest.mocked(parseCLI).mockReturnValue({ filter: [], options: {} });
+        jest.mocked(resolveConfig).mockResolvedValue({ viteConfig: {} } as any);
+        jest.mocked(startVitest).mockResolvedValue({ close: jest.fn() } as any);
+
+        vol.fromJSON({ 'package.json': JSON.stringify({}) });
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = async () => new Vitest().run();
+
+    test('runs startVitest with default config', async () => {
+        await subject();
+
+        expect(startVitest).toHaveBeenCalledWith('test', [], {}, { test: defaultConfig });
+    });
+
+    test('closes vitest', async () => {
+        await subject();
+
+        const vitest = await jest.mocked(startVitest).mock.results[0].value;
+        expect(vitest.close).toHaveBeenCalled();
+    });
+
+    describe('with package.json config', () => {
+        const packageJSONConfig: ViteUserConfig['test'] = { bail: 1, globals: false };
+
+        beforeEach(() => {
+            vol.fromJSON({
+                'package.json': JSON.stringify({ cli: { vitest: packageJSONConfig } }),
+            });
+        });
+
+        test('merges package.json config with default config', async () => {
+            await subject();
+
+            expect(startVitest).toHaveBeenCalledWith(
+                'test',
+                [],
+                {},
+                { test: { ...defaultConfig, ...packageJSONConfig } }
+            );
+        });
+    });
+
+    describe('with vite test config', () => {
+        const viteTestConfig: ViteUserConfig['test'] = { name: 'foo', watch: false };
+
+        beforeEach(() => {
+            jest.mocked(resolveConfig).mockResolvedValue({
+                viteConfig: { test: viteTestConfig },
+            } as any);
+        });
+
+        test('merges vite test config with default config', async () => {
+            await subject();
+
+            expect(startVitest).toHaveBeenCalledWith(
+                'test',
+                [],
+                {},
+                { test: { ...defaultConfig, ...viteTestConfig } }
+            );
+        });
+    });
+
+    describe('with command line options', () => {
+        const originalArgv = process.argv;
+        const cliOptions = ['--mode=foo', 'foo'];
+
+        beforeEach(() => {
+            process.argv = ['node', 'startup', 'test', ...cliOptions];
+        });
+
+        afterEach(() => (process.argv = originalArgv));
+
+        test('runs startVitest with parsed options', async () => {
+            const parseCliResult: ReturnType<typeof parseCLI> = {
+                filter: ['foo'],
+                options: { mode: 'foo' },
+            };
+
+            jest.mocked(parseCLI).mockReturnValue(parseCliResult);
+
+            await subject();
+
+            expect(parseCLI).toHaveBeenCalledWith(['vitest', ...cliOptions]);
+            expect(startVitest).toHaveBeenCalledWith(
+                'test',
+                parseCliResult.filter,
+                parseCliResult.options,
+                expect.anything()
+            );
+        });
+
+        describe.each(['--runner <name>', '--runner=<name>'])('with %s', args => {
+            beforeEach(() => (process.argv = [...process.argv, ...args.split(' ')]));
+
+            test('omits "runner" from parseCLI arguments', async () => {
+                await subject();
+
+                expect(parseCLI).toHaveBeenCalledWith(['vitest', ...cliOptions]);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export * from './jest';
+export * from './vitest';