@servicetitan/startup 32.0.1 → 32.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/startup",
-    "version": "32.0.1",
+    "version": "32.2.0",
     "description": "",
     "homepage": "https://docs.st.dev/docs/frontend/startup",
     "repository": {
@@ -37,8 +37,8 @@
         "@jest/core": "~29.7.0",
         "@jest/types": "~29.6.3",
         "@jsdevtools/coverage-istanbul-loader": "^3.0.5",
-        "@servicetitan/eslint-config": "32.0.1",
-        "@servicetitan/stylelint-config": "32.0.1",
+        "@servicetitan/eslint-config": "32.2.0",
+        "@servicetitan/stylelint-config": "32.2.0",
         "@svgr/webpack": "^8.1.0",
         "@swc/cli": "^0.5.0",
         "@swc/core": "1.13.5",
@@ -52,7 +52,7 @@
         "debounce": "^2.2.0",
         "debug": "^4.4.3",
         "deepmerge": "~4.3.1",
-        "eslint": "~9.35.0",
+        "eslint": "~9.37.0",
         "execa": "~5.1.1",
         "glob": "~11.0.3",
         "html-webpack-plugin": "~5.6.4",
@@ -63,33 +63,34 @@
         "jest-environment-jsdom": "^29.7.0",
         "jest-fetch-mock": "~3.0.3",
         "json5": "^2.2.3",
-        "lerna": "~8.2.4",
-        "less": "~4.4.1",
+        "jwa": "^1.4.2",
+        "lerna": "~9.0.0",
+        "less": "~4.4.2",
         "less-loader": "~12.3.0",
         "less-plugin-npm-import": "~2.1.0",
         "lodash.memoize": "^4.1.2",
-        "memfs": "~4.38.2",
+        "memfs": "~4.49.0",
         "mini-css-extract-plugin": "~2.9.4",
         "moment-locales-webpack-plugin": "~1.2.0",
         "multimatch": "~5.0.0",
         "portfinder": "~1.0.38",
         "postcss": "~8.5.6",
         "prettier": "~3.6.2",
-        "sass": "~1.92.1",
+        "sass": "~1.93.2",
         "sass-loader": "~16.0.5",
-        "semver": "~7.7.2",
+        "semver": "~7.7.3",
         "source-map-loader": "~5.0.0",
         "style-loader": "~4.0.0",
-        "stylelint": "~16.24.0",
-        "terminal-link": "^4.0.0",
+        "stylelint": "~16.25.0",
+        "terminal-link": "^5.0.0",
         "terser-webpack-plugin": "^5.3.14",
-        "ts-jest": "29.4.1",
+        "ts-jest": "29.4.5",
         "ts-node": "~10.9.2",
         "typed-css-modules": "~0.9.1",
-        "typescript": "5.9.2",
+        "typescript": "5.9.3",
         "vitest": "^3.2.4",
-        "webpack": "~5.101.3",
-        "webpack-assets-manifest": "~6.2.2",
+        "webpack": "~5.102.1",
+        "webpack-assets-manifest": "~6.3.0",
         "webpack-bundle-analyzer": "^4.10.2",
         "webpack-dev-server": "~5.2.2",
         "webpack-filter-warnings-plugin": "~1.2.1",
@@ -101,7 +102,7 @@
         "yargs": "~17.7.2"
     },
     "peerDependencies": {
-        "moment": "^2.30.1"
+        "moment": ">=2.30.1"
     },
     "peerDependenciesMeta": {
         "moment": {
@@ -112,6 +113,10 @@
         "@swc/cli": [
             "Update when https://github.com/swc-project/swc/issues/10535 is resolved",
             "See also SwcCompilePackage.execute in file://./src/cli/tasks/swc-compile-package.ts"
+        ],
+        "jwa": [
+            "@progress/kendo-licensing@1.3.5 -> jsonwebtoken@9.0.2 -> jws@3.2.2 -> jwa@1.4.1",
+            "Forcing ^1.4.2 to fix Node v25 incompatibility in 1.4.1 (see https://github.com/auth0/node-jsonwebtoken/issues/992)"
         ]
     },
     "publishConfig": {
@@ -120,5 +125,5 @@
     "cli": {
         "webpack": false
     },
-    "gitHead": "2b74dd72d39c2023151699d1cf7a6e6130d64279"
+    "gitHead": "76a83fea33e04809b97c72720751878b1e3002d7"
 }

package/src/cli/commands/review/rules/__mocks__/mock-config.ts

@@ -8,7 +8,13 @@ export function mockConfig({
 }: {
     id: string;
     level?: 'error' | 'warn';
-    exclude: string | string[];
+    exclude: string | string[] | Record<string, string[]>;
 }): ReviewConfiguration {
-    return { rules: { [id]: exclude ? [level, { exclude: toArray(exclude) }] : [level] } };
+    return {
+        rules: {
+            [id]: exclude
+                ? [level, { exclude: typeof exclude === 'object' ? exclude : toArray(exclude) }]
+                : [level],
+        },
+    };
 }

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

@@ -0,0 +1,123 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import {
+    ErrorSeverity,
+    FixCategory,
+    Package,
+    PackageError,
+    ReviewConfiguration,
+} from '../../types';
+import { expectCalls } from '../../__mocks__';
+import { mockConfig, mockProject } from '../__mocks__';
+import { NoDeprecatedContentBase } from '../no-deprecated-content-base';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+
+describe(`[startup] Review ${NoDeprecatedContentBase.name}`, () => {
+    const id = 'no-deprecated-content-base';
+    const rule = new NoDeprecatedContentBase();
+    let config: ReviewConfiguration;
+    let pkg: Package;
+    let packages: Package[];
+
+    beforeEach(() => {
+        config = {};
+        pkg = { name: 'lib1', location: path.normalize('packages/lib') };
+        packages = [pkg];
+        jest.clearAllMocks();
+    });
+
+    const subject = () => rule.run(mockProject({ config, packages }));
+
+    const fixSubject = () => rule.fix(subject()![0]);
+
+    function itReturnsError() {
+        test('returns error', () => {
+            expect(subject()).toEqual([
+                expect.objectContaining({
+                    id,
+                    message: `package "${pkg.name}" uses deprecated cli.webpack.contentBase configuration`,
+                    location: pkg.location,
+                    fixable: FixCategory.isolated,
+                    severity: ErrorSeverity.warning,
+                } satisfies PackageError),
+            ]);
+        });
+    }
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toEqual([]);
+        });
+    }
+
+    itReturnsNothing();
+
+    describe('when package uses cli.webpack.contentBase', () => {
+        const contentBase = 'foo';
+
+        beforeEach(() => {
+            pkg.cli = { webpack: { contentBase } };
+        });
+
+        itReturnsError();
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expectCalls(
+                ...[
+                    `npm pkg set cli.webpack.static.directory="${contentBase}" -w ${pkg.location}`,
+                    `npm pkg delete cli.webpack.contentBase -w ${pkg.location}`,
+                ].map(command => [execSync, command, { stdio: 'inherit' }])
+            );
+        });
+
+        test('fix ignores invalid error', () => {
+            rule.fix({} as any);
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: pkg.name })));
+
+            itReturnsNothing();
+        });
+
+        describe('when multiple packages use cli.webpack.contentBase', () => {
+            beforeEach(() => {
+                packages.push({
+                    name: 'lib2',
+                    location: path.normalize('packages/lib2'),
+                    cli: { webpack: { contentBase: 'bar' } },
+                });
+            });
+
+            test('returns multiple errors', () => {
+                expect(subject()).toEqual([
+                    expect.objectContaining({ location: packages[0].location }),
+                    expect.objectContaining({ location: packages[1].location }),
+                ]);
+            });
+        });
+
+        describe('when cli.webpack.contentBase is an array', () => {
+            const contentBaseArray = ['foo', 'bar'];
+
+            beforeEach(() => (pkg.cli = { webpack: { contentBase: contentBaseArray } }));
+
+            test('fixes error', () => {
+                fixSubject();
+
+                expectCalls(
+                    ...[
+                        `npm pkg set cli.webpack.static[0].directory="${contentBaseArray[0]}" -w ${pkg.location}`,
+                        `npm pkg set cli.webpack.static[1].directory="${contentBaseArray[1]}" -w ${pkg.location}`,
+                        `npm pkg delete cli.webpack.contentBase -w ${pkg.location}`,
+                    ].map(command => [execSync, command, { stdio: 'inherit' }])
+                );
+            });
+        });
+    });
+});

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

@@ -0,0 +1,130 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { FixCategory, Package, PackageError, ReviewConfiguration } from '../../types';
+import { expectCalls } from '../../__mocks__';
+import { mockConfig, mockProject } from '../__mocks__';
+import { NoDirectPeerDependencies } from '../no-direct-peer-dependencies';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+
+describe(`[startup] Review ${NoDirectPeerDependencies.name}`, () => {
+    const id = 'no-direct-peer-dependencies';
+    const rule = new NoDirectPeerDependencies();
+    let config: ReviewConfiguration;
+    let pkg: Package;
+    let packages: Package[];
+
+    beforeEach(() => {
+        config = {};
+        pkg = { name: 'lib1', location: path.normalize('packages/lib') };
+        packages = [pkg];
+        jest.clearAllMocks();
+    });
+
+    const subject = () => rule.run(mockProject({ config, packages }));
+
+    const fixSubject = () => rule.fix(subject()![0]);
+
+    function itReturnsError(message: () => string) {
+        test('returns error', () => {
+            expect(subject()).toEqual([
+                expect.objectContaining({
+                    id,
+                    message: message(),
+                    location: pkg.location,
+                    fixable: FixCategory.isolated,
+                } satisfies PackageError),
+            ]);
+        });
+    }
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toEqual([]);
+        });
+    }
+
+    itReturnsNothing();
+
+    describe('when package is both peer and direct dependency', () => {
+        beforeEach(() => {
+            Object.assign(pkg, {
+                dependencies: { foo: '^1.0.0', baz: '1.0.0' },
+                peerDependencies: { foo: '>=1.0.0', qux: '^1.0.0' },
+            });
+        });
+
+        itReturnsError(() => {
+            return `package "${pkg.name}" lists "foo" as both a direct and a peer dependency`;
+        });
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expectCalls(
+                ...[
+                    `npm pkg set devDependencies["foo"]="${pkg.dependencies!.foo}" -w ${pkg.location}`,
+                    `npm pkg delete dependencies["foo"] -w ${pkg.location}`,
+                ].map(command => [execSync, command, { stdio: 'inherit' }])
+            );
+        });
+
+        test('fix ignores invalid error', () => {
+            rule.fix({} as any);
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: pkg.name })));
+
+            itReturnsNothing();
+        });
+
+        describe('when multiple packages violate the rule', () => {
+            beforeEach(() => {
+                packages = [
+                    pkg,
+                    {
+                        ...pkg,
+                        name: 'lib2',
+                        location: path.normalize('packages/lib2'),
+                    },
+                ];
+            });
+
+            test('returns multiple errors', () => {
+                expect(subject()).toEqual([
+                    expect.objectContaining({ location: packages[0].location }),
+                    expect.objectContaining({ location: packages[1].location }),
+                ]);
+            });
+        });
+    });
+
+    describe('when multiple packages are peer and direct dependencies', () => {
+        beforeEach(() => {
+            Object.assign(pkg, {
+                dependencies: { foo: '^1.0.0', bar: '~1.0.0', baz: '1.0.0' },
+                peerDependencies: { foo: '>= 1.0.0', bar: '^1.0.0', quz: '^1.0.0' },
+            });
+        });
+
+        itReturnsError(() => {
+            return `package "${pkg.name}" lists "foo" and "bar" as both direct and peer dependencies`;
+        });
+
+        test('fixes multiple errors', () => {
+            fixSubject();
+
+            expectCalls(
+                ...[
+                    `npm pkg set devDependencies["foo"]="${pkg.dependencies!.foo}" -w ${pkg.location}`,
+                    `npm pkg delete dependencies["foo"] -w ${pkg.location}`,
+                    `npm pkg set devDependencies["bar"]="${pkg.dependencies!.bar}" -w ${pkg.location}`,
+                    `npm pkg delete dependencies["bar"] -w ${pkg.location}`,
+                ].map(command => [execSync, command, { stdio: 'inherit' }])
+            );
+        });
+    });
+});

package/src/cli/commands/review/rules/__tests__/prefer-open-ended-peer-dependencies.test.ts

@@ -0,0 +1,121 @@
+import { execSync } from 'child_process';
+import { ErrorSeverity, FixCategory, Package, PackageError } from '../../types';
+import { mockConfig, mockProject } from '../__mocks__';
+import { PreferOpenEndedPeerDependencies } from '../prefer-open-ended-peer-dependencies';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+
+describe(`[startup] Review ${PreferOpenEndedPeerDependencies.name}`, () => {
+    const id = 'prefer-open-ended-peer-dependencies';
+    const rule = new PreferOpenEndedPeerDependencies();
+    let config: any;
+    let pkg: Package;
+    let packages: Package[];
+
+    beforeEach(() => {
+        config = {};
+        pkg = { name: 'lib1', location: 'packages/lib1' };
+        packages = [pkg];
+        jest.clearAllMocks();
+    });
+
+    const subject = () => rule.run(mockProject({ config, packages }));
+
+    const fixSubject = () => rule.fix(subject()![0]);
+
+    function itReturnsError(message: () => string) {
+        test('returns error', () => {
+            expect(subject()).toEqual([
+                expect.objectContaining({
+                    id,
+                    message: message(),
+                    location: pkg.location,
+                    severity: ErrorSeverity.warning,
+                    fixable: FixCategory.isolated,
+                } satisfies PackageError),
+            ]);
+        });
+    }
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toEqual([]);
+        });
+    }
+
+    itReturnsNothing();
+
+    describe('when a package has a closed-ended peer dependency', () => {
+        beforeEach(() => (pkg.peerDependencies = { foo: '^12.3.0' }));
+
+        itReturnsError(
+            () => `package "${pkg.name}" has closed-ended peer dependency on "foo@^12.3.0"`
+        );
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expect(execSync).toHaveBeenCalledWith(
+                `npm pkg set peerDependencies["foo"]=">=12.3.0" -w ${pkg.location}`,
+                { stdio: 'inherit' }
+            );
+        });
+
+        test('fix ignores invalid error', () => {
+            rule.fix({} as any);
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: pkg.name })));
+
+            itReturnsNothing();
+        });
+
+        describe('when peer is open-ended', () => {
+            beforeEach(() => (pkg.peerDependencies!.foo = '>=12.3.0'));
+
+            itReturnsNothing();
+        });
+
+        describe('when peer dependency is an exact version', () => {
+            beforeEach(() => (pkg.peerDependencies!.foo = '12.3.0'));
+
+            itReturnsNothing();
+        });
+
+        describe('with multiple closed-ended dependencies', () => {
+            beforeEach(() => (pkg.peerDependencies!.bar = '~12.3.4'));
+
+            test('returns multiple errors', () => {
+                expect(subject()).toEqual([
+                    expect.objectContaining({ message: expect.stringContaining('foo@^12.3.0') }),
+                    expect.objectContaining({ message: expect.stringContaining('bar@~12.3.4') }),
+                ]);
+            });
+
+            describe('when dependency is excluded', () => {
+                beforeEach(() => (config = mockConfig({ id, exclude: { [pkg.name]: ['foo'] } })));
+
+                test('omits excluded dependency', () => {
+                    expect(subject()).toEqual([
+                        expect.objectContaining({
+                            message: expect.stringContaining('bar@~12.3.4'),
+                        }),
+                    ]);
+                });
+            });
+        });
+
+        describe.each(['<1', '^1 || ^2', '>1 <2', '1.0 - 2.0'])('when version is "%s"', version => {
+            beforeEach(() => (pkg.peerDependencies!.foo = version));
+
+            test('error is not fixable', () => {
+                expect(subject()).not.toEqual([
+                    expect.objectContaining({ fixable: expect.anything() }),
+                ]);
+            });
+        });
+    });
+});