@servicetitan/startup 30.3.0 → 31.0.0

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

@@ -0,0 +1,33 @@
+import { RequireOneCollectionVersion } from '../require-one-collection-version';
+
+import { RequireOneAnvilUikitContribVersion } from '../require-one-anvil-uikit-contrib-version';
+
+jest.mock('../require-one-collection-version');
+
+describe(`[startup] Review ${RequireOneAnvilUikitContribVersion.name}`, () => {
+    const anvilUikitContribPackages = [
+        '@servicetitan/confirm-navigation',
+        '@servicetitan/confirm',
+        '@servicetitan/culture',
+        '@servicetitan/data-query',
+        '@servicetitan/datetime-utils',
+        '@servicetitan/form-state',
+        '@servicetitan/form',
+        '@servicetitan/link-item',
+        '@servicetitan/notifications',
+        '@servicetitan/table',
+    ];
+
+    beforeEach(() => jest.clearAllMocks());
+
+    const subject = () => new RequireOneAnvilUikitContribVersion();
+
+    test('calls RequireOneCollectionVersion with anvil-uikit-contrib packages', () => {
+        subject();
+
+        expect(RequireOneCollectionVersion).toHaveBeenCalledWith({
+            name: 'anvil-uikit-contrib',
+            packages: anvilUikitContribPackages,
+        });
+    });
+});

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

@@ -0,0 +1,155 @@
+import chalk from 'chalk';
+import path from 'path';
+import { FixCategory, Project, ReviewConfiguration } from '../../types';
+import { setVersion } from '../../utils';
+import { mockConfig, mockPackages, mockProject } from '../__mocks__';
+
+import { RequireOneCollectionVersion } from '../require-one-collection-version';
+
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    setVersion: jest.fn(),
+}));
+
+describe(`[startup] Review ${RequireOneCollectionVersion.name}`, () => {
+    const collection = { name: 'uikit', packages: ['foo', 'bar'] };
+    const id = `require-one-${collection.name}-version`;
+    const rule = new RequireOneCollectionVersion(collection);
+    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());
+
+    function itReturnsError(...details: string[]) {
+        test('returns error', () => {
+            expect(subject()).toEqual(
+                expect.objectContaining({
+                    id,
+                    message: `project depends on multiple versions of ${collection.name} packages`,
+                    details,
+                    fixable: FixCategory.normal,
+                })
+            );
+        });
+    }
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toBeUndefined();
+        });
+    }
+
+    describe('when all packages have same version', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: { '1.0.0': ['lib'] },
+                bar: { '1.0.0': ['lib'] },
+            };
+        });
+
+        itReturnsNothing();
+    });
+
+    describe('with multiple versions of one package', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: {
+                    '1.0.0': ['lib1'],
+                    '2.0.0': ['lib2'],
+                },
+            };
+        });
+
+        itReturnsError(
+            `${path.normalize('packages/lib2/package.json')} depends on ${chalk.red('foo@2.0.0')}`,
+            `${path.normalize('packages/lib1/package.json')} depends on ${chalk.red('foo@1.0.0')}`
+        );
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: 'foo' })));
+
+            itReturnsNothing();
+        });
+
+        describe('fix', () => {
+            const subject = () => {
+                const testProject = project();
+                rule.fix(rule.run(testProject)!, testProject);
+            };
+
+            test('fixes error', () => {
+                subject();
+
+                expect(setVersion).toHaveBeenCalledWith({
+                    project: project(),
+                    packageName: 'lib1',
+                    dependency: 'foo',
+                    version: '2.0.0',
+                });
+            });
+
+            test('ignores invalid error', () => {
+                rule.fix({} as any, project());
+
+                expect(setVersion).not.toHaveBeenCalled();
+            });
+        });
+    });
+
+    describe('when single dependent uses conflicting versions', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: { '2.0.0': ['lib'] },
+                bar: { '1.0.0': ['lib'] },
+            };
+        });
+
+        itReturnsError(
+            `${path.normalize('packages/lib/package.json')} depends on ${chalk.red('bar@1.0.0')}`,
+            `${path.normalize('packages/lib/package.json')} depends on ${chalk.yellow('foo@2.0.0')}`
+        );
+    });
+
+    describe('with multiple dependents use conflicting versions of different packages', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: { '1.0.0': ['lib1'] },
+                bar: { '2.0.0': ['lib2'] },
+            };
+        });
+
+        itReturnsError(
+            `${path.normalize('packages/lib1/package.json')} depends on ${chalk.red('foo@1.0.0')}`,
+            `${path.normalize('packages/lib2/package.json')} depends on ${chalk.yellow('bar@2.0.0')}`
+        );
+    });
+
+    describe('with multiple dependents use conflicting versions of only some packages', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: {
+                    '1.0.0': ['lib1', 'lib2'],
+                    '2.0.0': ['lib3'],
+                },
+                bar: {
+                    '1.0.0': ['lib1'],
+                },
+            };
+        });
+
+        itReturnsError(
+            `${path.normalize('packages/lib1/package.json')} and ${path.normalize('packages/lib2/package.json')} depend on ${chalk.red('foo@1.0.0')}`,
+            `${path.normalize('packages/lib3/package.json')} depends on ${chalk.red('foo@2.0.0')}`,
+            `${path.normalize('packages/lib1/package.json')} depends on ${chalk.yellow('bar@1.0.0')}`
+        );
+    });
+});

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

@@ -0,0 +1,135 @@
+import chalk from 'chalk';
+import path from 'path';
+import { FixCategory, Project, ReviewConfiguration } from '../../types';
+import { setVersion } from '../../utils';
+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(),
+}));
+
+describe(`[startup] Review ${RequireOnePackageVersion.name}`, () => {
+    const id = 'require-one-package-version';
+    const rule = new RequireOnePackageVersion();
+    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 itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toEqual([]);
+        });
+    }
+
+    describe('when all packages have only one version', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: { '1.0.0': ['lib1'] },
+                bar: { '2.0.0': ['lib1'] },
+            };
+        });
+
+        itReturnsNothing();
+    });
+
+    describe('when a package has multiple versions', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: {
+                    '1.0.0': ['lib1'],
+                    '1.0.1': ['lib2'],
+                },
+            };
+        });
+
+        test('returns error', () => {
+            expect(subject()).toEqual([
+                expect.objectContaining({
+                    id,
+                    message: 'project depends on multiple versions of "foo"',
+                    details: [
+                        `${path.normalize('packages/lib1/package.json')} depends on ${chalk.yellow('1.0.0')}`,
+                        `${path.normalize('packages/lib2/package.json')} depends on ${chalk.yellow('1.0.1')}`,
+                    ],
+                    fixable: FixCategory.isolated,
+                }),
+            ]);
+        });
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: 'foo' })));
+
+            itReturnsNothing();
+        });
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expect(setVersion).toHaveBeenCalledWith({
+                project: project(),
+                packageName: 'lib1',
+                dependency: 'foo',
+                version: '1.0.1',
+            });
+        });
+
+        test('ignores invalid error', () => {
+            rule.fix({} as any, project());
+
+            expect(setVersion).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when multiple packages have multiple versions', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: {
+                    '1.0.0': ['lib1'],
+                    '1.0.1': ['lib2'],
+                },
+                bar: {
+                    '2.0.0': ['lib1'],
+                    '2.1.0': ['lib3'],
+                },
+            };
+        });
+
+        test('returns errors for each package with multiple versions', () => {
+            expect(subject()).toEqual([
+                expect.objectContaining({
+                    message: 'project depends on multiple versions of "foo"',
+                    details: [
+                        `${path.normalize('packages/lib1/package.json')} depends on ${chalk.yellow('1.0.0')}`,
+                        `${path.normalize('packages/lib2/package.json')} depends on ${chalk.yellow('1.0.1')}`,
+                    ],
+                }),
+                expect.objectContaining({
+                    message: 'project depends on multiple versions of "bar"',
+                    details: [
+                        `${path.normalize('packages/lib1/package.json')} depends on ${chalk.yellow('2.0.0')}`,
+                        `${path.normalize('packages/lib3/package.json')} depends on ${chalk.yellow('2.1.0')}`,
+                    ],
+                }),
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,40 @@
+import { RequireOneCollectionVersion } from '../require-one-collection-version';
+
+import { RequireOneUikitVersion } from '../require-one-uikit-version';
+
+jest.mock('../require-one-collection-version');
+
+describe(`[startup] Review ${RequireOneUikitVersion.name}`, () => {
+    const uikitPackages = [
+        '@servicetitan/ajax-handlers',
+        '@servicetitan/error-boundary',
+        '@servicetitan/eslint-config',
+        '@servicetitan/eslint-plugin',
+        '@servicetitan/eslint-plugin-folder-schema',
+        '@servicetitan/folder-lint',
+        '@servicetitan/hash-browser-router',
+        '@servicetitan/ko-bridge',
+        '@servicetitan/launchdarkly-service',
+        '@servicetitan/lazy-module',
+        '@servicetitan/log-service',
+        '@servicetitan/react-ioc',
+        '@servicetitan/restrict-imports',
+        '@servicetitan/startup',
+        '@servicetitan/stylelint-config',
+        '@servicetitan/suppress-warnings',
+        '@servicetitan/web-components',
+    ];
+
+    beforeEach(() => jest.clearAllMocks());
+
+    const subject = () => new RequireOneUikitVersion();
+
+    test('calls RequireOneCollectionVersion with uikit packages', () => {
+        subject();
+
+        expect(RequireOneCollectionVersion).toHaveBeenCalledWith({
+            name: 'uikit',
+            packages: uikitPackages,
+        });
+    });
+});

package/src/cli/commands/review/rules/__tests__/require-project-version-in-root-node-modules.test.ts

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { expectCalls } from '../../__mocks__';
+import { FixCategory, Package, Project, ReviewConfiguration } from '../../types';
+import { mockConfig, mockPackages, mockProject } from '../__mocks__';
+
+import { RequireProjectVersionInRootNodeModules } from '../require-project-version-in-root-node-modules';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+
+describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () => {
+    const id = 'require-project-version-in-root-node-modules';
+    const rule = new RequireProjectVersionInRootNodeModules();
+    let config: ReviewConfiguration;
+    let dependencies: Project['dependencies'];
+    let packageLock: Project['packageLock'];
+    let packages: Package[];
+
+    beforeEach(() => {
+        config = {};
+        dependencies = { foo: { '~1.0.0': ['lib'] } };
+        packages = [{ name: 'root', location: '.' }, ...mockPackages(dependencies)];
+        packageLock = { packages: {}, location: './package-lock.json' };
+        jest.clearAllMocks();
+    });
+
+    const project = () => mockProject({ config, dependencies, packageLock, packages });
+
+    const subject = () => rule.run(project());
+
+    const fixSubject = () => {
+        const testProject = project();
+        rule.fix(rule.run(testProject)!, testProject);
+    };
+
+    function itReturnsError(...details: string[]) {
+        test('returns error', () => {
+            expect(subject()).toEqual(
+                expect.objectContaining({
+                    id,
+                    message: 'project has unexpected version in root node_modules',
+                    details,
+                    location: packageLock.location,
+                    fixable: FixCategory.lockFile,
+                })
+            );
+        });
+    }
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toBeUndefined();
+        });
+    }
+
+    function fixDoesNothing() {
+        test('fix does nothing', () => {
+            fixSubject();
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+    }
+
+    describe('when root matches project version', () => {
+        beforeEach(() => {
+            packageLock.packages = { 'node_modules/foo': { version: '1.0.1' } };
+        });
+
+        itReturnsNothing();
+    });
+
+    describe('when root does not match project version', () => {
+        beforeEach(() => {
+            packageLock.packages = { 'node_modules/foo': { version: '1.1.0' } };
+        });
+
+        itReturnsError(`${chalk.yellow('foo@1.1.0')} does not match ${chalk.yellow('~1.0.0')}`);
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: 'foo' })));
+
+            itReturnsNothing();
+        });
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expectCalls(
+                ...[
+                    'npm pkg set dependencies["foo"]="~1.0.0"',
+                    'npx startup install --fix --quiet',
+                    'npm pkg delete dependencies["foo"]',
+                ].map(command => [execSync, command, { stdio: 'inherit' }])
+            );
+        });
+
+        test('fix ignores invalid error', () => {
+            rule.fix({} as any, project());
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+
+        describe('with no root package', () => {
+            beforeEach(() => packages.splice(0, 1));
+
+            fixDoesNothing();
+        });
+
+        describe('when root package already contains dependency', () => {
+            beforeEach(() => (packages[0].dependencies = { foo: '1.1.0' }));
+
+            fixDoesNothing();
+        });
+    });
+
+    describe('with no root version', () => {
+        beforeEach(() => (packageLock.packages = {}));
+
+        itReturnsNothing();
+    });
+
+    describe('when multiple versions are installed', () => {
+        beforeEach(() => (dependencies = { foo: { '~1.0.0': ['lib1'], '^2.0.0': ['lib2'] } }));
+
+        describe('when root matches version', () => {
+            beforeEach(() => {
+                packageLock.packages = { 'node_modules/foo': { version: '2.1.0' } };
+            });
+
+            itReturnsNothing();
+        });
+
+        describe('when root does not match any version', () => {
+            beforeEach(() => {
+                packageLock.packages = { 'node_modules/foo': { version: '1.1.0' } };
+            });
+
+            itReturnsError(
+                `${chalk.yellow('foo@1.1.0')} does not match ${chalk.yellow('~1.0.0, ^2.0.0')}`
+            );
+
+            test('fix uses highest version', () => {
+                fixSubject();
+
+                expect(execSync).toHaveBeenCalledWith(
+                    'npm pkg set dependencies["foo"]="^2.0.0"',
+                    expect.anything()
+                );
+            });
+        });
+    });
+
+    describe('when multiple packages have mismatched versions', () => {
+        beforeEach(() => {
+            dependencies = {
+                foo: { '~1.0.0': ['lib1'] },
+                bar: { '>=2 <3': ['lib2'] },
+                baz: { '>=3 <4': ['lib3'] },
+            };
+            packageLock.packages = {
+                'node_modules/foo': { version: '1.1.0' }, // error
+                'node_modules/bar': { version: '2.0.1' }, // ok
+                'node_modules/baz': { version: '4.0.0' }, // error
+            };
+        });
+
+        itReturnsError(
+            `${chalk.yellow('foo@1.1.0')} does not match ${chalk.yellow('~1.0.0')}`,
+            `${chalk.yellow('baz@4.0.0')} does not match ${chalk.yellow('>=3 <4')}`
+        );
+
+        test('fixes all errors', () => {
+            fixSubject();
+
+            expectCalls(
+                ...[
+                    'npm pkg set dependencies["foo"]="~1.0.0"',
+                    'npm pkg set dependencies["baz"]=">=3 <4"',
+                    'npx startup install --fix --quiet',
+                    'npm pkg delete dependencies["foo"]',
+                    'npm pkg delete dependencies["baz"]',
+                ].map(command => [execSync, command, { stdio: 'inherit' }])
+            );
+        });
+    });
+});

package/src/cli/commands/review/rules/__tests__/require-servicetitan-scope.test.ts

@@ -0,0 +1,83 @@
+import { ErrorSeverity, Package, ReviewConfiguration } from '../../types';
+import { mockConfig, mockProject } from '../__mocks__';
+
+import { RequireServiceTitanScope } from '../require-servicetitan-scope';
+
+describe(`[startup] Review ${RequireServiceTitanScope.name}`, () => {
+    const id = 'require-servicetitan-scope';
+    const rule = new RequireServiceTitanScope();
+    const basePackage: Package = { name: 'lib', location: 'packages/lib', cli: { webpack: false } };
+    let config: ReviewConfiguration;
+    let packages: Package[];
+
+    beforeEach(() => {
+        config = {};
+        packages = [basePackage];
+    });
+
+    const subject = () => rule.run(mockProject({ config, packages }));
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toEqual([]);
+        });
+    }
+
+    test('returns warning', () => {
+        expect(subject()).toEqual([
+            {
+                id,
+                message: `package "${packages[0].name}" should have @servicetitan scope`,
+                severity: ErrorSeverity.warning,
+                location: packages[0].location,
+            },
+        ]);
+    });
+
+    describe('when config excludes package', () => {
+        beforeEach(() => (config = mockConfig({ id, exclude: packages[0].name })));
+
+        itReturnsNothing();
+    });
+
+    describe('when package name has @servicetitan scope', () => {
+        beforeEach(() => {
+            packages = [{ ...basePackage, name: `@servicetitan/${basePackage.name}` }];
+        });
+
+        itReturnsNothing();
+    });
+
+    describe('when package is private', () => {
+        beforeEach(() => (packages = [{ ...basePackage, private: true }]));
+
+        itReturnsNothing();
+    });
+
+    describe('when package is an application', () => {
+        beforeEach(() => (packages = [{ ...basePackage, cli: undefined }]));
+
+        itReturnsNothing();
+    });
+
+    describe('when multiple packages are missing scope', () => {
+        beforeEach(() => {
+            packages = [
+                { ...basePackage, name: 'lib1' }, // error
+                { ...basePackage, name: '@servicetitan/lib2' }, // ok
+                { ...basePackage, name: 'lib3' }, // error
+            ];
+        });
+
+        test('returns multiple warnings', () => {
+            expect(subject()).toEqual([
+                expect.objectContaining({
+                    message: `package "${packages[0].name}" should have @servicetitan scope`,
+                }),
+                expect.objectContaining({
+                    message: `package "${packages[2].name}" should have @servicetitan scope`,
+                }),
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import { PackageRule } from '../types';
+import { NoTypescriptEntryPoint } from './no-typescript-entry-point';
+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 { 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 RequireOneUikitVersion(),
+    new RequireOneAnvilUikitContribVersion(),
+    new RequireProjectVersionInRootNodeModules(),
+    new NoTypescriptEntryPoint(),
+    new RequireServiceTitanScope(),
+    new RequireExplicitSideEffects(),
+    new RequireNpmrc(),
+];