@servicetitan/startup 33.1.1 → 34.0.0

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

@@ -3,22 +3,14 @@ import { execSync } from 'child_process';
 import { fs, vol } from 'memfs';
 import path from 'path';
 import terminalLink from 'terminal-link';
-
+import type { ProjectPackage } from '../../../../utils';
 import { findPackages, getReviewConfiguration, log } from '../../../../utils';
 import { expectCalls } from '../__mocks__';
+import { Review } from '../review';
 import { rules } from '../rules';
-import {
-    ErrorSeverity,
-    FixCategory,
-    Level,
-    Package,
-    PackageError,
-    ReviewConfiguration,
-} from '../types';
+import { ErrorSeverity, FixCategory, Level, PackageError, ReviewConfiguration } from '../types';
 import { indent } from '../utils';
 
-import { Review } from '../review';
-
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
 jest.mock('fs', () => fs);
 jest.mock('terminal-link', () => jest.fn());
@@ -68,6 +60,10 @@ describe(`[startup] ${Review.name}`, () => {
         });
     }
 
+    test('allows running from global location', () => {
+        expect(Review.allowRunFromGlobal).toBe(true);
+    });
+
     describe('when not run from workspace root', () => {
         beforeEach(() => vol.fromJSON({}));
 
@@ -77,15 +73,17 @@ describe(`[startup] ${Review.name}`, () => {
     describe('when run from workspace root', () => {
         const rootPackageJSON = { name: 'root', workspaces: ['packages/*'] };
         const packageLockJSON = { packages: {} };
-        const packages: Package[] = [
+        const packages: ProjectPackage[] = [
             {
                 name: 'a',
+                version: '1.0.0',
                 dependencies: { foo: '1.0.1', bar: '1.0.0' },
                 devDependencies: { qux: 'file:.yalc/qux' }, // test ignores non-version dependencies
                 location: 'a',
             },
             {
                 name: 'b',
+                version: '1.0.0',
                 dependencies: { foo: '1.0.0', bar: '1.0.0' },
                 devDependencies: { baz: '1.0.0' },
                 location: 'b',
@@ -152,13 +150,13 @@ describe(`[startup] ${Review.name}`, () => {
         });
 
         describe('with --rule option', () => {
-            beforeEach(() => (args.rule = rules[0].id));
+            beforeEach(() => (args.rule = [rules[0].id]));
 
             test('runs only specified rule', async () => {
                 await subject();
 
                 rules.forEach(rule => {
-                    if (args.rule === rule.id) {
+                    if (args.rule?.includes(rule.id)) {
                         expect(rule.run).toHaveBeenCalled();
                     } else {
                         expect(rule.run).not.toHaveBeenCalled();
@@ -278,9 +276,10 @@ describe(`[startup] ${Review.name}`, () => {
                     test('regenerates lockfile', async () => {
                         await subject();
 
-                        expect(execSync).toHaveBeenCalledWith('npx startup install --fix --quiet', {
-                            stdio: 'inherit',
-                        });
+                        expect(execSync).toHaveBeenCalledWith(
+                            'npx @servicetitan/install --fix --quiet',
+                            { stdio: 'inherit' }
+                        );
                     });
 
                     test('summarizes fixes and remaining problems', async () => {
@@ -452,7 +451,7 @@ describe(`[startup] ${Review.name}`, () => {
 
                         const execStartupInstallWithFixOption = [
                             execSync,
-                            'npx startup install --fix --quiet',
+                            'npx @servicetitan/install --fix --quiet',
                             { stdio: 'inherit' },
                         ];
 
@@ -467,7 +466,7 @@ describe(`[startup] ${Review.name}`, () => {
                     });
 
                     describe('with --rule option', () => {
-                        beforeEach(() => (args.rule = rules[1].id));
+                        beforeEach(() => (args.rule = [rules[1].id]));
 
                         test('fixes only specified rule', async () => {
                             await subject();

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

@@ -9,8 +9,8 @@ import {
     readJsonSafe,
     toArray,
 } from '../../../utils';
-import { Command, CommandArgs } from '../types';
-
+import { Command, CommandOptions } from '../types';
+import { rules } from './rules';
 import {
     ErrorSeverity,
     FixCategory,
@@ -29,21 +29,18 @@ import {
     pluralize,
     summarize,
 } from './utils';
-import { rules } from './rules';
 
 const collator = new Intl.Collator();
 
-interface Args extends CommandArgs {
-    fix?: boolean;
-    rule?: string | string[];
-}
+const options = {
+    fix: { boolean: true, description: 'Fix detected problems' },
+    rule: { array: true, string: true, description: 'Limit checks to specified rule(s)' },
+} satisfies CommandOptions;
 
-export class Review extends Command<Args> {
+export class Review extends Command<typeof options> {
+    static readonly allowRunFromGlobal = true;
     static readonly description = 'Check project for configuration errors';
-    static readonly options = {
-        fix: { boolean: true, description: 'Fix detected problems' },
-        rule: { array: true, description: 'Limit checks to specified rule(s)' },
-    };
+    static readonly options = options;
 
     private readonly severityToLabel: Record<ErrorSeverity, string> = {
         [ErrorSeverity.warning]: chalk.yellow('warning'),
@@ -121,7 +118,7 @@ export class Review extends Command<Args> {
                 }
             });
 
-            execSync('npx startup install --fix --quiet', { stdio: 'inherit' });
+            execSync('npx @servicetitan/install --fix --quiet', { stdio: 'inherit' });
             project = this.createProject();
             errors = this.findErrors(project);
         }
@@ -225,13 +222,7 @@ export class Review extends Command<Args> {
 
     private getSelectedRules() {
         const rule = this.args.rule;
-        if (typeof rule === 'string' && rule) {
-            return new Set([rule]);
-        }
-        if (Array.isArray(rule)) {
-            return new Set(rule.filter(id => !!id));
-        }
-        return undefined;
+        return rule ? new Set(rule.filter(id => !!id)) : undefined;
     }
 }
 

package/src/cli/commands/review/rules/__tests__/no-deprecated-content-base.test.ts

@@ -1,5 +1,6 @@
 import { execSync } from 'child_process';
 import path from 'path';
+import { expectCalls } from '../../__mocks__';
 import {
     ErrorSeverity,
     FixCategory,
@@ -7,7 +8,6 @@ import {
     PackageError,
     ReviewConfiguration,
 } from '../../types';
-import { expectCalls } from '../../__mocks__';
 import { mockConfig, mockProject } from '../__mocks__';
 import { NoDeprecatedContentBase } from '../no-deprecated-content-base';
 

package/src/cli/commands/review/rules/__tests__/no-deprecated-startup-install.test.ts

@@ -1,7 +1,6 @@
 import { execSync } from 'child_process';
 import { FixCategory, Package, PackageError, ReviewConfiguration } from '../../types';
 import { mockProject } from '../__mocks__';
-
 import { NoDeprecatedStartupInstall } from '../no-deprecated-startup-install';
 
 jest.mock('child_process', () => ({ execSync: jest.fn() }));

package/src/cli/commands/review/rules/__tests__/no-direct-peer-dependencies.test.ts

@@ -1,7 +1,7 @@
 import { execSync } from 'child_process';
 import path from 'path';
-import { FixCategory, Package, PackageError, ReviewConfiguration } from '../../types';
 import { expectCalls } from '../../__mocks__';
+import { FixCategory, Package, PackageError, ReviewConfiguration } from '../../types';
 import { mockConfig, mockProject } from '../__mocks__';
 import { NoDirectPeerDependencies } from '../no-direct-peer-dependencies';
 

package/src/cli/commands/review/rules/__tests__/no-typescript-entry-point.test.ts

@@ -3,7 +3,6 @@ import path from 'path';
 import { getFolders } from '../../../../../utils';
 import { FixCategory, Package, ReviewConfiguration } from '../../types';
 import { mockConfig, mockProject } from '../__mocks__';
-
 import { NoTypescriptEntryPoint } from '../no-typescript-entry-point';
 
 jest.mock('child_process', () => ({ execSync: jest.fn() }));

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

@@ -1,7 +1,6 @@
 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', () => ({

package/src/cli/commands/review/rules/__tests__/require-compatible-launch-darkly-sdk.test.ts

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import { execSync } from 'child_process';
+import { expectCalls } from '../../__mocks__';
 import { FixCategory, Package, PackageError, Project, ReviewConfiguration } from '../../types';
 import { setVersion } from '../../utils';
-import { expectCalls } from '../../__mocks__';
 import { mockConfig, mockPackages, mockProject } from '../__mocks__';
 import { RequireCompatibleLaunchDarklySdk } from '../require-compatible-launch-darkly-sdk';
 
@@ -241,7 +241,7 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
             expectCalls(
                 ...[
                     `npm pkg set dependencies["${JS_CLIENT_SDK}"]=${sdkVersions.ldService}`,
-                    'npx startup install --fix --quiet',
+                    'npx @servicetitan/install --fix --quiet',
                     `npm pkg delete dependencies["${JS_CLIENT_SDK}"]`,
                 ].map(command => [execSync, command, { stdio: 'inherit' }])
             );

package/src/cli/commands/review/rules/__tests__/require-explicit-side-effects.test.ts

@@ -1,6 +1,5 @@
 import { ErrorSeverity, Package, ReviewConfiguration } from '../../types';
 import { mockConfig, mockProject } from '../__mocks__';
-
 import { RequireExplicitSideEffects } from '../require-explicit-side-effects';
 
 describe(`[startup] Review ${RequireExplicitSideEffects.name}`, () => {

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

@@ -1,6 +1,5 @@
 import { execSync } from 'child_process';
 import { ErrorSeverity, FixCategory } from '../../types';
-
 import { RequireNpmrc } from '../require-npmrc';
 
 jest.mock('child_process', () => ({ execSync: jest.fn() }));

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

@@ -1,6 +1,5 @@
-import { RequireOneCollectionVersion } from '../require-one-collection-version';
-
 import { RequireOneAnvilUikitContribVersion } from '../require-one-anvil-uikit-contrib-version';
+import { RequireOneCollectionVersion } from '../require-one-collection-version';
 
 jest.mock('../require-one-collection-version');
 

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

@@ -3,7 +3,6 @@ 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', () => ({

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

@@ -3,7 +3,6 @@ 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('../../utils', () => ({

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

@@ -1,5 +1,4 @@
 import { RequireOneCollectionVersion } from '../require-one-collection-version';
-
 import { RequireOneReactVersion } from '../require-one-react-version';
 
 jest.mock('../require-one-collection-version');

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

@@ -1,5 +1,4 @@
 import { RequireOneCollectionVersion } from '../require-one-collection-version';
-
 import { RequireOneUikitVersion } from '../require-one-uikit-version';
 
 jest.mock('../require-one-collection-version');
@@ -21,6 +20,7 @@ describe(`[startup] Review ${RequireOneUikitVersion.name}`, () => {
         '@servicetitan/react-ioc',
         '@servicetitan/restrict-imports',
         '@servicetitan/startup',
+        '@servicetitan/startup-utils',
         '@servicetitan/stylelint-config',
         '@servicetitan/suppress-warnings',
         '@servicetitan/web-components',

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

@@ -3,7 +3,6 @@ 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() }));
@@ -88,7 +87,7 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
             expectCalls(
                 ...[
                     'npm pkg set dependencies["foo"]="~1.0.0"',
-                    'npx startup install --fix --quiet',
+                    'npx @servicetitan/install --fix --quiet',
                     'npm pkg delete dependencies["foo"]',
                 ].map(command => [execSync, command, { stdio: 'inherit' }])
             );
@@ -176,7 +175,7 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
                 ...[
                     'npm pkg set dependencies["foo"]="~1.0.0"',
                     'npm pkg set dependencies["baz"]=">=3 <4"',
-                    'npx startup install --fix --quiet',
+                    'npx @servicetitan/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

@@ -1,6 +1,5 @@
 import { ErrorSeverity, Package, ReviewConfiguration } from '../../types';
 import { mockConfig, mockProject } from '../__mocks__';
-
 import { RequireServiceTitanScope } from '../require-servicetitan-scope';
 
 describe(`[startup] Review ${RequireServiceTitanScope.name}`, () => {

package/src/cli/commands/review/rules/__tests__/require-tsconfig-references.test.ts

@@ -0,0 +1,315 @@
+import { fs, vol } from 'memfs';
+import path from 'node:path';
+import { Package, ReviewConfiguration } from '../../types';
+import { mockProject } from '../__mocks__';
+
+import { prettifySync } from '../../../../../utils';
+import { RequireTsconfigReferences } from '../require-tsconfig-references';
+
+jest.mock('node:fs', () => fs);
+jest.mock('node:child_process', () => ({
+    execSync: jest.fn(),
+}));
+jest.mock('../../../../../utils', () => ({
+    ...jest.requireActual('../../../../../utils'),
+    prettifySync: jest.fn(),
+}));
+
+describe(`[startup] Review ${RequireTsconfigReferences.name}`, () => {
+    let rule: RequireTsconfigReferences;
+    let config: ReviewConfiguration;
+    let packages: Package[];
+
+    beforeEach(() => {
+        rule = new RequireTsconfigReferences();
+        config = {};
+        packages = [];
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = () => rule.run(mockProject({ config, packages }));
+    const fixSubject = () => {
+        const ruleErrors = subject();
+
+        ruleErrors.forEach(rule.fix);
+    };
+
+    function setupPackages(pkgs: Package[], tsconfigFiles: Record<string, object>) {
+        packages = pkgs;
+        vol.fromJSON(
+            Object.fromEntries(
+                Object.entries(tsconfigFiles).map(([filePath, content]) => [
+                    filePath,
+                    JSON.stringify(content, null, 4),
+                ])
+            )
+        );
+    }
+
+    describe('when package has local dependency with correct tsconfig reference', () => {
+        beforeEach(() => {
+            setupPackages(
+                [
+                    {
+                        name: '@servicetitan/runtime',
+                        location: path.normalize('packages/runtime'),
+                        dependencies: {
+                            '@servicetitan/log-service': '1.0.0',
+                        },
+                    },
+                    {
+                        name: '@servicetitan/log-service',
+                        location: path.normalize('packages/log-service'),
+                    },
+                ],
+                {
+                    [path.normalize('packages/runtime/tsconfig.json')]: {
+                        references: [{ path: '../log-service/tsconfig.json' }],
+                    },
+                    [path.normalize('packages/log-service/tsconfig.json')]: {},
+                }
+            );
+        });
+
+        test('reports no errors', () => {
+            expect(subject()).toEqual([]);
+        });
+    });
+
+    describe('when tsconfig files are missing references', () => {
+        beforeEach(() => {
+            setupPackages(
+                [
+                    {
+                        name: '@servicetitan/runtime',
+                        location: path.normalize('packages/runtime'),
+                        dependencies: {
+                            '@servicetitan/log-service': '1.0.0',
+                        },
+                    },
+                    {
+                        name: '@servicetitan/log-service',
+                        location: path.normalize('packages/log-service'),
+                    },
+                ],
+                {
+                    [path.normalize('packages/runtime/tsconfig.json')]: {},
+                    [path.normalize('packages/runtime/tsconfig.build.json')]: {},
+                    [path.normalize('packages/log-service/tsconfig.json')]: {},
+                }
+            );
+        });
+
+        test('reports errors for tsconfig files', () => {
+            expect(subject()).toEqual(
+                expect.arrayContaining([
+                    {
+                        id: 'require-tsconfig-references',
+                        message: 'missing reference for dependency: @servicetitan/log-service',
+                        location: path.normalize('packages/runtime/tsconfig.json'),
+                        fixable: 'normal',
+                        data: {
+                            tsconfigPath: path.normalize('packages/runtime/tsconfig.json'),
+                            missingReference: '@servicetitan/log-service',
+                            expectedPath: '../log-service/tsconfig.json',
+                        },
+                    },
+                    {
+                        id: 'require-tsconfig-references',
+                        message: 'missing reference for dependency: @servicetitan/log-service',
+                        location: path.normalize('packages/runtime/tsconfig.build.json'),
+                        fixable: 'normal',
+                        data: {
+                            tsconfigPath: path.normalize('packages/runtime/tsconfig.build.json'),
+                            missingReference: '@servicetitan/log-service',
+                            expectedPath: '../log-service/tsconfig.json',
+                        },
+                    },
+                ])
+            );
+        });
+    });
+
+    describe('when package dependencies are in devDependencies and peerDependencies', () => {
+        beforeEach(() => {
+            setupPackages(
+                [
+                    {
+                        name: '@servicetitan/runtime',
+                        location: path.normalize('packages/runtime'),
+                        devDependencies: { '@servicetitan/log-service': '1.0.0' },
+                    },
+                    {
+                        name: '@servicetitan/examples',
+                        location: path.normalize('packages/examples'),
+                        peerDependencies: { '@servicetitan/log-service': '1.0.0' },
+                    },
+                    {
+                        name: '@servicetitan/log-service',
+                        location: path.normalize('packages/log-service'),
+                    },
+                ],
+                {
+                    [path.normalize('packages/runtime/tsconfig.json')]: {},
+                    [path.normalize('packages/examples/tsconfig.json')]: {},
+                    [path.normalize('packages/log-service/tsconfig.json')]: {},
+                }
+            );
+        });
+
+        test('reports missing reference errors', () => {
+            expect(subject()).toEqual([
+                {
+                    id: 'require-tsconfig-references',
+                    message: 'missing reference for dependency: @servicetitan/log-service',
+                    location: path.normalize('packages/runtime/tsconfig.json'),
+                    fixable: 'normal',
+                    data: {
+                        tsconfigPath: path.normalize('packages/runtime/tsconfig.json'),
+                        missingReference: '@servicetitan/log-service',
+                        expectedPath: '../log-service/tsconfig.json',
+                    },
+                },
+                {
+                    id: 'require-tsconfig-references',
+                    message: 'missing reference for dependency: @servicetitan/log-service',
+                    location: path.normalize('packages/examples/tsconfig.json'),
+                    fixable: 'normal',
+                    data: {
+                        tsconfigPath: path.normalize('packages/examples/tsconfig.json'),
+                        missingReference: '@servicetitan/log-service',
+                        expectedPath: '../log-service/tsconfig.json',
+                    },
+                },
+            ]);
+        });
+    });
+
+    describe('when fix is called with non-existent tsconfig file', () => {
+        const tsconfigPath = path.normalize('packages/nonexistent/tsconfig.json');
+
+        beforeEach(() => {
+            setupPackages(
+                [
+                    {
+                        name: '@servicetitan/runtime',
+                        location: path.normalize('packages/runtime'),
+                        devDependencies: { '@servicetitan/log-service': '1.0.0' },
+                    },
+                    {
+                        name: '@servicetitan/log-service',
+                        location: path.normalize('packages/log-service'),
+                    },
+                ],
+                {}
+            );
+        });
+
+        test('file remains non-existent', () => {
+            fixSubject();
+
+            expect(fs.existsSync(tsconfigPath)).toBe(false);
+        });
+    });
+
+    describe('when fix is called on tsconfig that already has references', () => {
+        const tsconfigFilePath = path.normalize('packages/runtime/tsconfig.json');
+
+        beforeEach(() => {
+            setupPackages(
+                [
+                    {
+                        name: '@servicetitan/runtime',
+                        location: path.normalize('packages/runtime'),
+                        dependencies: {
+                            '@servicetitan/log-service': '1.0.0',
+                        },
+                    },
+                    {
+                        name: '@servicetitan/log-service',
+                        location: path.normalize('packages/log-service'),
+                    },
+                ],
+                {
+                    [tsconfigFilePath]: {
+                        references: [{ path: '../existing/tsconfig.json' }],
+                    },
+                }
+            );
+        });
+
+        test('appends to existing references', () => {
+            fixSubject();
+
+            const content = JSON.parse(fs.readFileSync(tsconfigFilePath, 'utf8') as string);
+            expect(content.references).toContainEqual({ path: '../existing/tsconfig.json' });
+            expect(content.references).toContainEqual({ path: '../log-service/tsconfig.json' });
+        });
+
+        test('runs prettier on the modified file', () => {
+            fixSubject();
+
+            expect(prettifySync).toHaveBeenCalled();
+        });
+    });
+
+    describe('when tsconfig reference omits .json extension', () => {
+        beforeEach(() => {
+            setupPackages(
+                [
+                    {
+                        name: '@servicetitan/runtime',
+                        location: path.normalize('packages/runtime'),
+                        dependencies: {
+                            '@servicetitan/log-service': '1.0.0',
+                        },
+                    },
+                    {
+                        name: '@servicetitan/log-service',
+                        location: path.normalize('packages/log-service'),
+                    },
+                ],
+                {
+                    [path.normalize('packages/runtime/tsconfig.json')]: {
+                        references: [{ path: '../log-service/tsconfig' }],
+                    },
+                    [path.normalize('packages/log-service/tsconfig.json')]: {},
+                }
+            );
+        });
+
+        test('reports no errors', () => {
+            expect(subject()).toEqual([]);
+        });
+    });
+
+    describe('when package is a workspace root', () => {
+        beforeEach(() => {
+            setupPackages(
+                [
+                    {
+                        name: 'my-monorepo',
+                        location: '.',
+                        workspaces: ['packages/*'],
+                        dependencies: {
+                            '@servicetitan/log-service': '1.0.0',
+                        },
+                    },
+                    {
+                        name: '@servicetitan/log-service',
+                        location: path.normalize('packages/log-service'),
+                    },
+                ],
+                {
+                    'tsconfig.json': {},
+                    [path.normalize('packages/log-service/tsconfig.json')]: {},
+                }
+            );
+        });
+
+        test('skips the workspace root package', () => {
+            expect(subject()).toEqual([]);
+        });
+    });
+});

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

@@ -14,6 +14,7 @@ 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';
+import { RequireTsconfigReferences } from './require-tsconfig-references';
 
 export const rules: PackageRule[] = [
     new RequireAllReactDependencies(),
@@ -31,4 +32,5 @@ export const rules: PackageRule[] = [
     new RequireServiceTitanScope(),
     new RequireExplicitSideEffects(),
     new RequireNpmrc(),
+    new RequireTsconfigReferences(),
 ];