@servicetitan/startup 32.0.0 → 32.1.0

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

@@ -0,0 +1,256 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+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';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    setVersion: jest.fn(),
+}));
+
+const JS_CLIENT_SDK = 'launchdarkly-js-client-sdk';
+const LD_SERVICE = '@servicetitan/launchdarkly-service';
+
+describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
+    const id = 'require-compatible-launch-darkly-sdk';
+    const rule = new RequireCompatibleLaunchDarklySdk();
+    let config: ReviewConfiguration;
+    let dependencies: Project['dependencies'];
+    let packageLock: Project['packageLock'];
+    let packages: Package[];
+
+    beforeEach(() => {
+        config = {};
+        dependencies = {};
+        packages = [];
+        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();
+        const result = rule.run(testProject);
+        const error = Array.isArray(result) ? result[0] : result!;
+        rule.fix(error, testProject);
+    };
+
+    function itReturnsError(error: Partial<PackageError> | (() => Partial<PackageError>)) {
+        test('returns error', () => {
+            const expected = expect.objectContaining({
+                id,
+                message: `package "${packages[0]?.name}" depends on an incompatible version of ${JS_CLIENT_SDK}`,
+                location: packages[0]?.location,
+                fixable: FixCategory.isolated,
+                ...(typeof error === 'function' ? error() : error),
+            });
+            const result = subject();
+            expect(result).toEqual(Array.isArray(result) ? [expected] : expected);
+        });
+    }
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            const result = subject();
+            expect(result === undefined || (Array.isArray(result) && result.length === 0)).toBe(
+                true
+            );
+        });
+    }
+
+    itReturnsNothing();
+
+    describe(`when package depends on different version of ${JS_CLIENT_SDK} from ${LD_SERVICE}`, () => {
+        const sdkVersions = { package: '^1.0.0', lockfile: '1.1.0', ldService: '1.0.1' };
+        const packageName = 'lib1';
+
+        beforeEach(() => {
+            dependencies = { [JS_CLIENT_SDK]: { [sdkVersions.package]: [packageName] } };
+            packages = mockPackages(dependencies);
+            packageLock.packages = {
+                [`node_modules/${JS_CLIENT_SDK}`]: {
+                    version: sdkVersions.lockfile,
+                },
+                [`node_modules/${LD_SERVICE}`]: {
+                    version: '1.0.0',
+                    dependencies: { [JS_CLIENT_SDK]: sdkVersions.ldService },
+                },
+            };
+        });
+
+        itReturnsError({
+            details: `${chalk.yellow(sdkVersions.lockfile)} does not match ${sdkVersions.ldService}`,
+        });
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expect(setVersion).toHaveBeenCalledWith({
+                project: project(),
+                packageName: packages[0].name,
+                dependency: JS_CLIENT_SDK,
+                version: sdkVersions.ldService,
+            });
+        });
+
+        test('fix ignores invalid error', () => {
+            rule.fix({} as any, project());
+
+            expect(setVersion).not.toHaveBeenCalled();
+        });
+
+        describe('when config excludes package', () => {
+            beforeEach(() => (config = mockConfig({ id, exclude: packages[0].name })));
+
+            itReturnsNothing();
+        });
+
+        function mergePackageLock(
+            key: string,
+            data: Partial<(typeof packageLock)['packages'][string]>
+        ) {
+            packageLock.packages[key] = { ...packageLock.packages[key], ...data };
+        }
+
+        describe(`when ${JS_CLIENT_SDK} is private package dependency`, () => {
+            const privateLockfileVersion = '1.2.0';
+
+            beforeEach(() => {
+                mergePackageLock(`node_modules/${packageName}/node_modules/${JS_CLIENT_SDK}`, {
+                    version: privateLockfileVersion,
+                });
+            });
+
+            itReturnsError({
+                details: `${chalk.yellow(privateLockfileVersion)} does not match ${sdkVersions.ldService}`,
+            });
+        });
+
+        describe(`when ${JS_CLIENT_SDK} is peer dependency of ${LD_SERVICE}`, () => {
+            const peerLDServiceVersion = '1.0.2';
+
+            beforeEach(() => {
+                mergePackageLock(`node_modules/${LD_SERVICE}`, {
+                    peerDependencies: { [JS_CLIENT_SDK]: peerLDServiceVersion },
+                    dependencies: undefined,
+                });
+            });
+
+            itReturnsError({
+                details: `${chalk.yellow(sdkVersions.lockfile)} does not match ${peerLDServiceVersion}`,
+            });
+        });
+
+        describe(`when ${LD_SERVICE} dependency is a compatible range`, () => {
+            const compatibleRange = `^${sdkVersions.ldService}`;
+
+            beforeEach(() => {
+                mergePackageLock(`node_modules/${LD_SERVICE}`, {
+                    dependencies: { [JS_CLIENT_SDK]: compatibleRange },
+                });
+            });
+
+            itReturnsNothing();
+        });
+
+        describe(`when dependency is an incompatible range`, () => {
+            const incompatibleRange = `<${sdkVersions.ldService}`;
+
+            beforeEach(() => {
+                mergePackageLock(`node_modules/${LD_SERVICE}`, {
+                    dependencies: { [JS_CLIENT_SDK]: incompatibleRange },
+                });
+            });
+
+            itReturnsError({
+                details: `${chalk.yellow(sdkVersions.lockfile)} does not match ${incompatibleRange}`,
+            });
+        });
+
+        describe('when multiple packages depend on incompatible version', () => {
+            const otherPackageName = 'lib2';
+
+            beforeEach(() => {
+                dependencies[JS_CLIENT_SDK][sdkVersions.package].push(otherPackageName);
+                packages = mockPackages(dependencies);
+            });
+
+            test('returns multiple errors', () => {
+                expect(subject()).toEqual([
+                    expect.objectContaining({
+                        message: `package "${packages[0].name}" depends on an incompatible version of ${JS_CLIENT_SDK}`,
+                        location: packages[0].location,
+                    }),
+                    expect.objectContaining({
+                        message: `package "${packages[1].name}" depends on an incompatible version of ${JS_CLIENT_SDK}`,
+                        location: packages[1].location,
+                    }),
+                ]);
+            });
+        });
+
+        describe(`when ${JS_CLIENT_SDK} is not in lockfile`, () => {
+            beforeEach(() => {
+                delete packageLock.packages[`node_modules/${JS_CLIENT_SDK}`];
+            });
+
+            itReturnsNothing();
+        });
+
+        describe(`when ${LD_SERVICE} is not in lockfile`, () => {
+            beforeEach(() => {
+                delete packageLock.packages[`node_modules/${LD_SERVICE}`];
+            });
+
+            itReturnsNothing();
+        });
+    });
+
+    describe(`when project depends on different version of ${JS_CLIENT_SDK} from ${LD_SERVICE}`, () => {
+        const sdkVersions = { lockfile: '1.1.0', ldService: '1.0.1' };
+
+        beforeEach(() => {
+            packageLock.packages = {
+                [`node_modules/${JS_CLIENT_SDK}`]: {
+                    version: sdkVersions.lockfile,
+                },
+                [`node_modules/${LD_SERVICE}`]: {
+                    version: '1.0.0',
+                    dependencies: { [JS_CLIENT_SDK]: sdkVersions.ldService },
+                },
+            };
+        });
+
+        itReturnsError(() => ({
+            message: `project depends on an incompatible version of ${JS_CLIENT_SDK}`,
+            details: `${chalk.yellow(sdkVersions.lockfile)} does not match ${sdkVersions.ldService}`,
+            location: packageLock.location,
+            fixable: FixCategory.lockFile,
+        }));
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expectCalls(
+                ...[
+                    `npm pkg set dependencies["${JS_CLIENT_SDK}"]=${sdkVersions.ldService}`,
+                    'npx startup install --fix --quiet',
+                    `npm pkg delete dependencies["${JS_CLIENT_SDK}"]`,
+                ].map(command => [execSync, command, { stdio: 'inherit' }])
+            );
+        });
+
+        test('fix ignores invalid error', () => {
+            rule.fix({} as any, project());
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -1,6 +1,10 @@
 import { PackageRule } from '../types';
+import { NoDeprecatedContentBase } from './no-deprecated-content-base';
+import { NoDirectPeerDependencies } from './no-direct-peer-dependencies';
 import { NoTypescriptEntryPoint } from './no-typescript-entry-point';
+import { PreferOpenEndedPeerDependencies } from './prefer-open-ended-peer-dependencies';
 import { RequireAllReactDependencies } from './require-all-react-dependencies';
+import { RequireCompatibleLaunchDarklySdk } from './require-compatible-launch-darkly-sdk';
 import { RequireExplicitSideEffects } from './require-explicit-side-effects';
 import { RequireNpmrc } from './require-npmrc';
 import { RequireOneAnvilUikitContribVersion } from './require-one-anvil-uikit-contrib-version';
@@ -11,13 +15,17 @@ import { RequireProjectVersionInRootNodeModules } from './require-project-versio
 import { RequireServiceTitanScope } from './require-servicetitan-scope';
 
 export const rules: PackageRule[] = [
-    new RequireOnePackageVersion(),
     new RequireAllReactDependencies(),
-    new RequireOneUikitVersion(),
     new RequireOneAnvilUikitContribVersion(),
+    new RequireOnePackageVersion(),
     new RequireOneReactVersion(),
+    new RequireOneUikitVersion(),
     new RequireProjectVersionInRootNodeModules(),
+    new RequireCompatibleLaunchDarklySdk(),
+    new NoDeprecatedContentBase(),
+    new NoDirectPeerDependencies(),
     new NoTypescriptEntryPoint(),
+    new PreferOpenEndedPeerDependencies(),
     new RequireServiceTitanScope(),
     new RequireExplicitSideEffects(),
     new RequireNpmrc(),

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

@@ -0,0 +1,50 @@
+import { execSync } from 'child_process';
+import { ErrorSeverity, FixCategory, Package, PackageError, PackageRule, Project } from '../types';
+import { checkPackages } from '../utils';
+
+interface ErrorData {
+    contentBase: string;
+}
+
+type RuleError = PackageError<ErrorData>;
+
+export class NoDeprecatedContentBase implements PackageRule {
+    get id() {
+        return 'no-deprecated-content-base';
+    }
+
+    run(project: Project): RuleError[] | undefined {
+        return checkPackages(this, project, this.checkPackage);
+    }
+
+    fix({ data, location }: RuleError) {
+        const { contentBase } = data ?? {};
+        if (!location || contentBase === undefined) {
+            return;
+        }
+
+        const setCommands = Array.isArray(contentBase)
+            ? contentBase.map((directory, index) => {
+                  return `npm pkg set cli.webpack.static[${index}].directory="${directory}" -w ${location}`;
+              })
+            : [`npm pkg set cli.webpack.static.directory="${contentBase}" -w ${location}`];
+
+        [...setCommands, `npm pkg delete cli.webpack.contentBase -w ${location}`].forEach(command =>
+            execSync(command, { stdio: 'inherit' })
+        );
+    }
+
+    private readonly checkPackage = (pkg: Package): RuleError | undefined => {
+        const { webpack = {} } = pkg.cli ?? {};
+        if (webpack && typeof webpack === 'object' && Object.hasOwn(webpack, 'contentBase')) {
+            return {
+                id: this.id,
+                message: `package "${pkg.name}" uses deprecated cli.webpack.contentBase configuration`,
+                location: pkg.location,
+                fixable: FixCategory.isolated,
+                severity: ErrorSeverity.warning,
+                data: { contentBase: webpack.contentBase },
+            };
+        }
+    };
+}

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

@@ -0,0 +1,58 @@
+import { execSync } from 'child_process';
+import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
+import { checkPackages, formatList } from '../utils';
+
+interface ErrorData {
+    dependencies: Record<string, string>;
+    directPeerDependencies: string[];
+}
+
+type RuleError = PackageError<ErrorData>;
+
+export class NoDirectPeerDependencies implements PackageRule {
+    get id() {
+        return 'no-direct-peer-dependencies';
+    }
+
+    run(project: Project): RuleError[] | undefined {
+        return checkPackages(this, project, this.checkPackage);
+    }
+
+    fix({ data, location }: RuleError) {
+        const { dependencies, directPeerDependencies } = data ?? {};
+        if (!(location && dependencies && directPeerDependencies)) {
+            return;
+        }
+
+        directPeerDependencies.forEach(name => {
+            [
+                `npm pkg set devDependencies["${name}"]="${dependencies[name]}" -w ${location}`,
+                `npm pkg delete dependencies["${name}"] -w ${location}`,
+            ].forEach(command => execSync(command, { stdio: 'inherit' }));
+        });
+    }
+
+    private readonly checkPackage = (pkg: Package): RuleError | undefined => {
+        const { dependencies = {}, peerDependencies = {} } = pkg;
+        const directPeerDependencies = Object.keys(peerDependencies).filter(
+            peerDependency => !!dependencies[peerDependency]
+        );
+        if (directPeerDependencies.length) {
+            return {
+                id: this.id,
+                message: this.formatMessage(pkg.name, directPeerDependencies),
+                location: pkg.location,
+                fixable: FixCategory.isolated,
+                data: { dependencies, directPeerDependencies },
+            };
+        }
+    };
+
+    private formatMessage(name: string, dependencies: string[]) {
+        if (dependencies.length === 1) {
+            return `package "${name}" lists "${dependencies[0]}" as both a direct and a peer dependency`;
+        }
+        const list = formatList(dependencies.map(name => `"${name}"`));
+        return `package "${name}" lists ${list} as both direct and peer dependencies`;
+    }
+}

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

@@ -2,7 +2,7 @@ import { execSync } from 'child_process';
 import path from 'path';
 import { getFolders, log } from '../../../../utils';
 import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
-import { applyFilter } from '../utils';
+import { checkPackages } from '../utils';
 
 interface ErrorData {
     key: string;
@@ -14,11 +14,8 @@ export class NoTypescriptEntryPoint implements PackageRule {
         return 'no-typescript-entry-point';
     }
 
-    run({ config, packages }: Project): PackageError<ErrorData>[] {
-        const ruleConfig = config.rules?.[this.id];
-        return applyFilter(ruleConfig, packages, ({ name }) => name).flatMap(pkg =>
-            this.checkEntryPoints(pkg)
-        );
+    run(project: Project): PackageError<ErrorData>[] {
+        return checkPackages(this, project, this.checkEntryPoints);
     }
 
     fix({ data, location }: PackageError<ErrorData>) {
@@ -35,7 +32,7 @@ export class NoTypescriptEntryPoint implements PackageRule {
         execSync(command);
     }
 
-    private checkEntryPoints(pkg: Package) {
+    private readonly checkEntryPoints = (pkg: Package) => {
         const errors: PackageError<ErrorData>[] = [];
         const addError = (message: string, data: ErrorData) =>
             errors.push({
@@ -70,7 +67,7 @@ export class NoTypescriptEntryPoint implements PackageRule {
         }
 
         return errors;
-    }
+    };
 
     private isTypescriptEntryPoint(str: string) {
         return str.endsWith('.ts') && !str.endsWith('.d.ts');

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

@@ -0,0 +1,89 @@
+import { execSync } from 'child_process';
+import { satisfies } from 'semver';
+import { ErrorSeverity, FixCategory, Package, PackageError, PackageRule, Project } from '../types';
+import { checkPackages } from '../utils';
+
+interface ErrorData {
+    dependency: string;
+    version: string;
+}
+
+type RuleError = PackageError<ErrorData>;
+
+export class PreferOpenEndedPeerDependencies implements PackageRule {
+    #project!: Project;
+
+    get id() {
+        return 'prefer-open-ended-peer-dependencies';
+    }
+
+    run(project: Project): RuleError[] | undefined {
+        this.#project = project;
+        return checkPackages(this, project, this.checkPackage);
+    }
+
+    fix({ data, location }: RuleError) {
+        const { dependency, version } = data ?? {};
+        if (!(location && dependency && version)) {
+            return;
+        }
+
+        const openEndedVersion = version.replace(/^[\^~]/, '>=');
+        const command = `npm pkg set peerDependencies["${dependency}"]="${openEndedVersion}" -w ${location}`;
+        execSync(command, { stdio: 'inherit' });
+    }
+
+    private readonly checkPackage = (pkg: Package): RuleError[] | undefined => {
+        return Object.entries(pkg.peerDependencies ?? {}).reduce<RuleError[]>(
+            (result, [dependency, version]) => {
+                if (this.isViolation(pkg, { dependency, version })) {
+                    result.push({
+                        id: this.id,
+                        message: `package "${pkg.name}" has closed-ended peer dependency on "${dependency}@${version}"`,
+                        location: pkg.location,
+                        severity: ErrorSeverity.warning,
+                        ...(this.isFixable(version)
+                            ? { fixable: FixCategory.isolated, data: { dependency, version } }
+                            : {}),
+                    });
+                }
+                return result;
+            },
+            []
+        );
+    };
+
+    private isExactVersion(version: string) {
+        return /^\d/.test(version);
+    }
+
+    private isExcluded({ name }: Package, dependency: string) {
+        const ruleConfig = this.#project.config.rules?.[this.id];
+        if (Array.isArray(ruleConfig)) {
+            const { exclude } = ruleConfig[1] ?? {};
+            if (typeof exclude === 'object' && !Array.isArray(exclude)) {
+                return exclude[name]?.includes(dependency);
+            }
+        }
+        return false;
+    }
+
+    private isOpenEndedVersion(version: string) {
+        return satisfies('999.999.999', version);
+    }
+
+    private isFixable(version: string) {
+        return /^[\^~]\d+(\.\d+){0,2}$/.test(version);
+    }
+
+    private isViolation(
+        pkg: Package,
+        { dependency, version }: { dependency: string; version: string }
+    ) {
+        return (
+            !this.isExactVersion(version) &&
+            !this.isOpenEndedVersion(version) &&
+            !this.isExcluded(pkg, dependency)
+        );
+    }
+}

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

@@ -0,0 +1,141 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { satisfies } from 'semver';
+import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
+import { applyFilter, checkPackages, setVersion } from '../utils';
+
+const JS_CLIENT_SDK = 'launchdarkly-js-client-sdk';
+const LD_SERVICE = '@servicetitan/launchdarkly-service';
+
+interface ErrorData {
+    name?: string;
+    actualVersion: string;
+    targetVersion: string;
+}
+
+type RuleError = PackageError<ErrorData>;
+
+export class RequireCompatibleLaunchDarklySdk implements PackageRule {
+    #project!: Project;
+
+    get id() {
+        return 'require-compatible-launch-darkly-sdk';
+    }
+
+    run(project: Project): RuleError | RuleError[] | undefined {
+        this.#project = project;
+
+        /*
+         * Pass an empty filter object to checkPackages to disable its filtering.
+         * The project-level check is only useful when there are no package-level
+         * errors so we need an accurate count.
+         */
+        const errors = checkPackages({}, project, this.checkPackage);
+
+        if (!errors.length) {
+            return this.checkProject();
+        }
+
+        return applyFilter(project.config.rules?.[this.id], errors, ({ data }) => data!.name!);
+    }
+
+    fix({ data }: RuleError, project: Project) {
+        const { name, targetVersion } = data ?? {};
+        if (!targetVersion) {
+            return;
+        }
+        if (name) {
+            setVersion({
+                project,
+                packageName: name,
+                dependency: JS_CLIENT_SDK,
+                version: targetVersion,
+            });
+            return;
+        }
+
+        [
+            `npm pkg set dependencies["${JS_CLIENT_SDK}"]=${targetVersion}`,
+            'npx startup install --fix --quiet',
+            `npm pkg delete dependencies["${JS_CLIENT_SDK}"]`,
+        ].forEach(command => execSync(command, { stdio: 'inherit' }));
+    }
+
+    private readonly checkPackage = ({
+        dependencies = {},
+        location,
+        name,
+    }: Package): RuleError | undefined => {
+        if (!dependencies[JS_CLIENT_SDK]) {
+            return;
+        }
+
+        const actualVersion = this.getActualJsClientSdkVersion(name);
+        const targetVersion = this.getTargetJsClientSdkVersion(name);
+        if (actualVersion && targetVersion && !satisfies(actualVersion, targetVersion)) {
+            return this.createError({
+                message: `package "${name}" depends on an incompatible version of ${JS_CLIENT_SDK}`,
+                location,
+                data: { name, actualVersion, targetVersion },
+            });
+        }
+    };
+
+    private checkProject() {
+        const actualVersion = this.getActualJsClientSdkVersion();
+        const targetVersion = this.getTargetJsClientSdkVersion();
+        if (actualVersion && targetVersion && !satisfies(actualVersion, targetVersion)) {
+            return this.createError({
+                message: `project depends on an incompatible version of ${JS_CLIENT_SDK}`,
+                location: this.#project.packageLock.location,
+                data: { actualVersion, targetVersion },
+            });
+        }
+    }
+
+    private createError(params: { message: string; location: string; data: ErrorData }): RuleError {
+        const { message, data, location } = params;
+        return {
+            id: this.id,
+            message,
+            details: this.formatDetails(data),
+            location,
+            fixable: data.name ? FixCategory.isolated : FixCategory.lockFile,
+            data,
+        };
+    }
+
+    private formatDetails({ actualVersion, targetVersion }: ErrorData) {
+        return `${chalk.yellow(actualVersion)} does not match ${targetVersion}`;
+    }
+
+    private getActualJsClientSdkVersion(packageName?: string) {
+        return this.getResolvedDependency({ packageName, dependency: JS_CLIENT_SDK }).version;
+    }
+
+    private getResolvedDependency({
+        packageName,
+        dependency,
+    }: {
+        packageName?: string;
+        dependency: string;
+    }) {
+        const { packages } = this.#project.packageLock;
+        return (
+            (packageName
+                ? packages[`node_modules/${packageName}/node_modules/${dependency}`]
+                : undefined) ??
+            packages[`node_modules/${dependency}`] ??
+            {}
+        );
+    }
+
+    private getTargetJsClientSdkVersion(packageName?: string) {
+        const { dependencies = {}, peerDependencies = {} } = this.getResolvedDependency({
+            packageName,
+            dependency: LD_SERVICE,
+        });
+
+        return dependencies[JS_CLIENT_SDK] ?? peerDependencies[JS_CLIENT_SDK];
+    }
+}