@servicetitan/startup 34.0.0 → 34.1.0

package/src/cli/commands/__tests__/mfe-list.test.ts

@@ -13,8 +13,6 @@ jest.mock('fs', () => require('memfs').fs);
 jest.mock('readline/promises', () => ({
     createInterface: jest.fn(),
 }));
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),

package/src/cli/commands/__tests__/mfe-package-publish.test.ts

@@ -15,8 +15,6 @@ import { MFEPackagePublish } from '../mfe-package-publish';
 import { ROLLBACK_TAG_SUFFIX } from '../utils';
 
 jest.mock('fs', () => fs);
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),

package/src/cli/commands/__tests__/mfe-package-rollback.test.ts

@@ -2,8 +2,6 @@ import { log, readJson } from '../../../utils';
 import { npmTagVersion, npmView } from '../../utils';
 import { MFEPackageRollback } from '../mfe-package-rollback';
 
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     log: {

package/src/cli/commands/__tests__/mfe-publish.test.ts

@@ -8,8 +8,6 @@ import { MFEPackageRollback } from '../mfe-package-rollback';
 import { MFEPublish } from '../mfe-publish';
 
 jest.mock('fs', () => fs);
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../utils');
 jest.mock('../../../utils', () => ({

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

@@ -1,9 +1,6 @@
 import { copyFiles } from '../../utils';
 import { PreparePackage } from '../prepare-package';
 
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
-
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     copyFiles: jest.fn(),

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

@@ -3,9 +3,6 @@ import { Package, PackageType, getPackages, log } from '../../../utils';
 import { compile, lernaExec, typeCheck, watchStdout } from '../../utils';
 import { Start } from '../start';
 
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
-
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     getPackages: jest.fn(),

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

@@ -9,8 +9,6 @@ import { UploadSourcemaps } from '../upload-sourcemaps';
 jest.mock('@servicetitan/install');
 jest.mock('fs', () => require('memfs').fs);
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),

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

@@ -1,9 +1,9 @@
 import { fs, vol } from 'memfs';
 import path from 'node:path';
-import { Package, ReviewConfiguration } from '../../types';
-import { mockProject } from '../__mocks__';
-
+import { createPackage } from '../../../../../__mocks__';
 import { prettifySync } from '../../../../../utils';
+import { Package } from '../../types';
+import { mockProject } from '../__mocks__';
 import { RequireTsconfigReferences } from '../require-tsconfig-references';
 
 jest.mock('node:fs', () => fs);
@@ -17,299 +17,177 @@ jest.mock('../../../../../utils', () => ({
 
 describe(`[startup] Review ${RequireTsconfigReferences.name}`, () => {
     let rule: RequireTsconfigReferences;
-    let config: ReviewConfiguration;
     let packages: Package[];
 
     beforeEach(() => {
         rule = new RequireTsconfigReferences();
-        config = {};
-        packages = [];
+        packages = [
+            // Note, tests assume the "app" that depends on local package(s) is first
+            createPackage({ name: 'app', dependencies: { utils: '1.0.0' } }),
+            createPackage({ name: 'utils' }),
+        ];
     });
 
     afterEach(() => vol.reset());
 
-    const subject = () => rule.run(mockProject({ config, packages }));
-    const fixSubject = () => {
-        const ruleErrors = subject();
+    const subject = () => rule.run(mockProject({ packages }));
 
-        ruleErrors.forEach(rule.fix);
-    };
+    function appTsConfig() {
+        return path.join(packages[0].location, 'tsconfig.json');
+    }
 
-    function setupPackages(pkgs: Package[], tsconfigFiles: Record<string, object>) {
-        packages = pkgs;
+    function volFromJSON(json: Record<string, any>) {
         vol.fromJSON(
             Object.fromEntries(
-                Object.entries(tsconfigFiles).map(([filePath, content]) => [
+                Object.entries(json).map(([filePath, content]) => [
                     filePath,
-                    JSON.stringify(content, null, 4),
+                    JSON.stringify(content),
                 ])
             )
         );
     }
 
-    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')]: {},
-                }
-            );
-        });
-
+    function itReportsNoErrors() {
         test('reports no errors', () => {
             expect(subject()).toEqual([]);
         });
-    });
+    }
 
-    describe('when tsconfig files are missing references', () => {
+    describe('when package has 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')]: {},
-                    [path.normalize('packages/runtime/tsconfig.build.json')]: {},
-                    [path.normalize('packages/log-service/tsconfig.json')]: {},
-                }
-            );
+            volFromJSON({
+                [appTsConfig()]: { references: [{ path: '../utils/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',
-                        },
-                    },
-                ])
-            );
-        });
+        itReportsNoErrors();
     });
 
-    describe('when package dependencies are in devDependencies and peerDependencies', () => {
+    describe('when reference is build config', () => {
         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')]: {},
-                }
-            );
+            volFromJSON({
+                [appTsConfig()]: { references: [{ path: '../utils/tsconfig.build.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',
-                    },
-                },
-            ]);
-        });
+        itReportsNoErrors();
     });
 
-    describe('when fix is called with non-existent tsconfig file', () => {
-        const tsconfigPath = path.normalize('packages/nonexistent/tsconfig.json');
-
+    describe('when reference omits .json extension', () => {
         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'),
-                    },
-                ],
-                {}
-            );
+            volFromJSON({
+                [appTsConfig()]: { references: [{ path: '../utils/tsconfig' }] },
+            });
         });
 
-        test('file remains non-existent', () => {
-            fixSubject();
+        itReportsNoErrors();
+    });
 
-            expect(fs.existsSync(tsconfigPath)).toBe(false);
+    describe('when reference is directory', () => {
+        beforeEach(() => {
+            volFromJSON({
+                [appTsConfig()]: { references: [{ path: '../utils' }] },
+                'packages/utils/tsconfig.json': {}, // ensures directory exists
+            });
         });
-    });
 
-    describe('when fix is called on tsconfig that already has references', () => {
-        const tsconfigFilePath = path.normalize('packages/runtime/tsconfig.json');
+        itReportsNoErrors();
+    });
 
+    describe('when package is missing 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'),
-                    },
-                ],
-                {
-                    [tsconfigFilePath]: {
-                        references: [{ path: '../existing/tsconfig.json' }],
-                    },
-                }
-            );
+            volFromJSON({ [appTsConfig()]: {} });
         });
 
-        test('appends to existing references', () => {
-            fixSubject();
+        function itReportsError() {
+            test('reports error', () => {
+                expect(subject()).toEqual([
+                    expect.objectContaining({
+                        id: 'require-tsconfig-references',
+                        message: 'missing reference for dependency: utils',
+                        location: appTsConfig(),
+                        fixable: 'normal',
+                    }),
+                ]);
+            });
+        }
+
+        itReportsError();
+
+        describe.each(['devDependencies', 'peerDependencies'])(
+            'when dependency is in %s',
+            (key: keyof Package) => {
+                beforeEach(() => {
+                    const appPackage = packages[0];
+                    appPackage[key] = appPackage.dependencies;
+                    delete appPackage.dependencies;
+                });
+
+                itReportsError();
+            }
+        );
+
+        describe('when package is workspace root', () => {
+            beforeEach(() => (packages[0].location = '.'));
 
-            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' });
+            itReportsNoErrors();
         });
 
-        test('runs prettier on the modified file', () => {
-            fixSubject();
+        describe('fix', () => {
+            const fixSubject = () => {
+                const ruleErrors = subject();
+                ruleErrors.forEach(rule.fix);
+            };
 
-            expect(prettifySync).toHaveBeenCalled();
-        });
-    });
+            function expectReferences(references: Record<string, string>[]) {
+                const json = fs.readFileSync(appTsConfig(), { encoding: 'utf-8' }).toString();
+                expect(JSON.parse(json)).toEqual({ references });
+            }
 
-    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('fixes error', () => {
+                fixSubject();
 
-        test('reports no errors', () => {
-            expect(subject()).toEqual([]);
-        });
-    });
+                expectReferences([{ path: '../utils' }]);
+            });
 
-    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('prettifies output', () => {
+                fixSubject();
 
-        test('skips the workspace root package', () => {
-            expect(subject()).toEqual([]);
+                expect(prettifySync).toHaveBeenCalledWith(appTsConfig());
+            });
+
+            describe('when reference is build config', () => {
+                beforeEach(() => {
+                    volFromJSON({
+                        [appTsConfig()]: {},
+                        'packages/utils/tsconfig.build.json': {},
+                    });
+                });
+
+                test('references build config', () => {
+                    fixSubject();
+
+                    expectReferences([{ path: '../utils/tsconfig.build.json' }]);
+                });
+            });
+
+            describe('when package has other references', () => {
+                const references = [{ path: '../foo' }];
+
+                beforeEach(() => {
+                    volFromJSON({ [appTsConfig()]: { references } });
+                });
+
+                test('preserves other references', () => {
+                    fixSubject();
+
+                    expectReferences([...references, { path: '../utils' }]);
+                });
+            });
+
+            test('ignores invalid data', () => {
+                expect(() => rule.fix({} as any)).not.toThrow();
+            });
         });
     });
 });

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

@@ -1,7 +1,7 @@
 import { globSync } from 'glob';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getTsConfig, prettifySync, readJsonSafe } from '../../../../utils';
+import { getTsConfig, prettifySync, readJson, readJsonSafe } from '../../../../utils';
 import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
 import { checkPackages } from '../utils';
 
@@ -44,10 +44,7 @@ export class RequireTsconfigReferences implements PackageRule {
         }
 
         const { tsconfigPath, expectedPath } = data;
-        const tsconfig = readJsonSafe<TsConfig>(tsconfigPath);
-        if (!tsconfig) {
-            return;
-        }
+        const tsconfig = readJson<TsConfig>(tsconfigPath);
 
         const references = tsconfig.references ?? [];
         references.push({ path: expectedPath });
@@ -70,6 +67,9 @@ export class RequireTsconfigReferences implements PackageRule {
     }
 
     private normalizeTsConfigPath(filePath: string): string {
+        if (this.isDirectory(filePath)) {
+            return path.join(filePath, 'tsconfig.json');
+        }
         return filePath.endsWith('.json') ? filePath : `${filePath}.json`;
     }
 
@@ -83,8 +83,9 @@ export class RequireTsconfigReferences implements PackageRule {
         const referencedPackages = new Set<string>();
 
         for (const reference of config.references) {
-            const normalizedPath = this.normalizeTsConfigPath(reference.path);
-            const resolvedRefPath = path.resolve(tsconfigDir, normalizedPath);
+            const resolvedRefPath = this.normalizeTsConfigPath(
+                path.resolve(tsconfigDir, reference.path)
+            );
             const refDir = path.dirname(resolvedRefPath);
             const packageName = this.locationToPackageName.get(refDir);
 
@@ -100,8 +101,11 @@ export class RequireTsconfigReferences implements PackageRule {
         const relativePath = path.relative(fromLocation, toLocation);
         const tsconfigFile = getTsConfig(toLocation);
         const tsconfigName = path.basename(tsconfigFile);
+        const referencePath = this.isDefaultTsConfig(tsconfigName)
+            ? relativePath
+            : path.join(relativePath, tsconfigName);
 
-        return path.join(relativePath, tsconfigName).replaceAll('\\', '/');
+        return referencePath.replaceAll('\\', '/');
     }
 
     private collectTsConfigFiles(location: string): string[] {
@@ -154,4 +158,16 @@ export class RequireTsconfigReferences implements PackageRule {
             this.findMissingDependencyReferences(pkg, tsconfigPath, localDependencies)
         );
     };
+
+    private isDefaultTsConfig(name: string) {
+        return name === 'tsconfig.json';
+    }
+
+    private isDirectory(file: string) {
+        try {
+            return fs.statSync(file).isDirectory();
+        } catch {
+            return false;
+        }
+    }
 }

package/src/cli/commands/run-task.test.ts

@@ -1,12 +1,7 @@
 import { log } from '../../utils';
-import { SwcCompilePackage } from '../tasks/swc-compile-package';
-import { TscCompile } from '../tasks/tsc-compile';
-import { TscCompilePackage } from '../tasks/tsc-compile-package';
+import { SwcCompilePackage, TscCompile, TscCompilePackage } from '../tasks';
 import { RunTask } from './run-task';
 
-jest.mock('yargs', () => jest.fn());
-jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
-
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     log: { error: jest.fn(), text: jest.fn() },

package/src/cli/commands/run-task.ts

@@ -1,9 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { log, logErrors } from '../../utils';
-import { SwcCompilePackage } from '../tasks/swc-compile-package';
+import { SwcCompilePackage, TscCompile, TscCompilePackage } from '../tasks';
 import { Task } from '../tasks/task';
-import { TscCompile } from '../tasks/tsc-compile';
-import { TscCompilePackage } from '../tasks/tsc-compile-package';
 import { Command, CommandOptions } from './types';
 
 const options = {

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

@@ -13,7 +13,7 @@ type JestArgs = ConstructorParameters<typeof Jest>[0];
 describe(`[startup] Test ${Jest.name}`, () => {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     const args: JestArgs = { _: ['foo'], $0: 'bar' };
-    const jestConfig: JestArgs = { ...args, setupFilesAfterEnv: ['./setupTests.js'] };
+    const jestConfig: JestArgs = { ...args, setupFilesAfterEnv: ['./jest.setup.ts'] };
 
     beforeAll(() => {
         jest.mocked(getJestConfigCLI).mockReturnValue(jestConfig);

package/src/cli/tasks/index.ts

@@ -0,0 +1,3 @@
+export * from './swc-compile-package';
+export * from './tsc-compile';
+export * from './tsc-compile-package';