@servicetitan/startup 36.1.1 → 36.1.2-canary.2

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

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { execSync } from 'child_process';
-import { expectCalls } from '../../__mocks__';
+import { expectCalls, MockPackageManager } from '../../__mocks__';
 import { FixCategory, Package, PackageError, Project, ReviewConfiguration } from '../../types';
 import { setVersion } from '../../utils';
 import { mockConfig, mockPackages, mockProject } from '../__mocks__';
@@ -15,23 +15,45 @@ jest.mock('../../utils', () => ({
 const JS_CLIENT_SDK = 'launchdarkly-js-client-sdk';
 const LD_SERVICE = '@servicetitan/launchdarkly-service';
 
+interface LockFile {
+    packages: Record<string, { version?: string; dependencies?: Record<string, string> }>;
+    location: string;
+}
+
 describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
     const id = 'require-compatible-launch-darkly-sdk';
     const rule = new RequireCompatibleLaunchDarklySdk();
+    const mockPackageManager = new MockPackageManager();
     let config: ReviewConfiguration;
     let dependencies: Project['dependencies'];
-    let packageLock: Project['packageLock'];
+    let lockFile: LockFile;
     let packages: Package[];
 
+    beforeAll(() => {
+        jest.spyOn(mockPackageManager, 'getResolvedVersion').mockImplementation(
+            ({ dependency }) => lockFile.packages[dependency]?.version
+        );
+        jest.spyOn(mockPackageManager, 'getDeclaredVersion').mockImplementation(
+            ({ declaredBy, dependency }) =>
+                lockFile.packages[declaredBy]?.dependencies?.[dependency]
+        );
+    });
+
     beforeEach(() => {
         config = {};
         dependencies = {};
         packages = [];
-        packageLock = { packages: {}, location: './package-lock.json' };
+        lockFile = { packages: {}, location: mockPackageManager.lockFileName };
         jest.clearAllMocks();
     });
 
-    const project = () => mockProject({ config, dependencies, packageLock, packages });
+    const project = () =>
+        mockProject({
+            config,
+            dependencies,
+            packageManager: mockPackageManager as any,
+            packages,
+        });
 
     const subject = () => rule.run(project());
 
@@ -74,11 +96,11 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
         beforeEach(() => {
             dependencies = { [JS_CLIENT_SDK]: { [sdkVersions.package]: [packageName] } };
             packages = mockPackages(dependencies);
-            packageLock.packages = {
-                [`node_modules/${JS_CLIENT_SDK}`]: {
+            lockFile.packages = {
+                [JS_CLIENT_SDK]: {
                     version: sdkVersions.lockfile,
                 },
-                [`node_modules/${LD_SERVICE}`]: {
+                [LD_SERVICE]: {
                     version: '1.0.0',
                     dependencies: { [JS_CLIENT_SDK]: sdkVersions.ldService },
                 },
@@ -112,47 +134,15 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
             itReturnsNothing();
         });
 
-        function mergePackageLock(
-            key: string,
-            data: Partial<(typeof packageLock)['packages'][string]>
-        ) {
-            packageLock.packages[key] = { ...packageLock.packages[key], ...data };
+        function mergePackageLock(key: string, data: Partial<LockFile['packages'][string]>) {
+            lockFile.packages[key] = { ...lockFile.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}`, {
+                mergePackageLock(LD_SERVICE, {
                     dependencies: { [JS_CLIENT_SDK]: compatibleRange },
                 });
             });
@@ -164,7 +154,7 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
             const incompatibleRange = `<${sdkVersions.ldService}`;
 
             beforeEach(() => {
-                mergePackageLock(`node_modules/${LD_SERVICE}`, {
+                mergePackageLock(LD_SERVICE, {
                     dependencies: { [JS_CLIENT_SDK]: incompatibleRange },
                 });
             });
@@ -198,7 +188,7 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
 
         describe(`when ${JS_CLIENT_SDK} is not in lockfile`, () => {
             beforeEach(() => {
-                delete packageLock.packages[`node_modules/${JS_CLIENT_SDK}`];
+                delete lockFile.packages[JS_CLIENT_SDK];
             });
 
             itReturnsNothing();
@@ -206,7 +196,7 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
 
         describe(`when ${LD_SERVICE} is not in lockfile`, () => {
             beforeEach(() => {
-                delete packageLock.packages[`node_modules/${LD_SERVICE}`];
+                delete lockFile.packages[LD_SERVICE];
             });
 
             itReturnsNothing();
@@ -217,11 +207,11 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
         const sdkVersions = { lockfile: '1.1.0', ldService: '1.0.1' };
 
         beforeEach(() => {
-            packageLock.packages = {
-                [`node_modules/${JS_CLIENT_SDK}`]: {
+            lockFile.packages = {
+                [JS_CLIENT_SDK]: {
                     version: sdkVersions.lockfile,
                 },
-                [`node_modules/${LD_SERVICE}`]: {
+                [LD_SERVICE]: {
                     version: '1.0.0',
                     dependencies: { [JS_CLIENT_SDK]: sdkVersions.ldService },
                 },
@@ -231,7 +221,7 @@ describe(`[startup] Review ${RequireCompatibleLaunchDarklySdk.name}`, () => {
         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,
+            location: lockFile.location,
             fixable: FixCategory.lockFile,
         }));
 

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

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { execSync } from 'child_process';
-import { expectCalls } from '../../__mocks__';
+import { expectCalls, MockPackageManager } 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';
@@ -10,20 +10,35 @@ jest.mock('child_process', () => ({ execSync: jest.fn() }));
 describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () => {
     const id = 'require-project-version-in-root-node-modules';
     const rule = new RequireProjectVersionInRootNodeModules();
+    const mockPackageManager = new MockPackageManager();
     let config: ReviewConfiguration;
     let dependencies: Project['dependencies'];
-    let packageLock: Project['packageLock'];
+    let resolvedRootVersions: Record<string, string>;
     let packages: Package[];
 
+    beforeAll(() => {
+        jest.spyOn(mockPackageManager, 'getResolvedVersion').mockImplementation(
+            ({ workspacePackage, dependency }) =>
+                workspacePackage === '' ? resolvedRootVersions[dependency] : undefined
+        );
+    });
+
     beforeEach(() => {
         config = {};
         dependencies = { foo: { '~1.0.0': ['lib'] } };
         packages = [{ name: 'root', location: '.' }, ...mockPackages(dependencies)];
-        packageLock = { packages: {}, location: './package-lock.json' };
+        resolvedRootVersions = {};
+        mockPackageManager.command = 'npm';
         jest.clearAllMocks();
     });
 
-    const project = () => mockProject({ config, dependencies, packageLock, packages });
+    const project = () =>
+        mockProject({
+            config,
+            dependencies,
+            packageManager: mockPackageManager as any,
+            packages,
+        });
 
     const subject = () => rule.run(project());
 
@@ -39,7 +54,7 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
                     id,
                     message: 'project has unexpected version in root node_modules',
                     details,
-                    location: packageLock.location,
+                    location: mockPackageManager.lockFileName,
                     fixable: FixCategory.lockFile,
                 })
             );
@@ -61,17 +76,13 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
     }
 
     describe('when root matches project version', () => {
-        beforeEach(() => {
-            packageLock.packages = { 'node_modules/foo': { version: '1.0.1' } };
-        });
+        beforeEach(() => (resolvedRootVersions = { foo: '1.0.1' }));
 
         itReturnsNothing();
     });
 
     describe('when root does not match project version', () => {
-        beforeEach(() => {
-            packageLock.packages = { 'node_modules/foo': { version: '1.1.0' } };
-        });
+        beforeEach(() => (resolvedRootVersions = { foo: '1.1.0' }));
 
         itReturnsError(`${chalk.yellow('foo@1.1.0')} does not match ${chalk.yellow('~1.0.0')}`);
 
@@ -81,6 +92,12 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
             itReturnsNothing();
         });
 
+        describe('when package manager is pnpm', () => {
+            beforeEach(() => (mockPackageManager.command = 'pnpm'));
+
+            itReturnsNothing();
+        });
+
         test('fixes error', () => {
             fixSubject();
 
@@ -113,7 +130,7 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
     });
 
     describe('with no root version', () => {
-        beforeEach(() => (packageLock.packages = {}));
+        beforeEach(() => (resolvedRootVersions = {}));
 
         itReturnsNothing();
     });
@@ -122,17 +139,13 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
         beforeEach(() => (dependencies = { foo: { '~1.0.0': ['lib1'], '^2.0.0': ['lib2'] } }));
 
         describe('when root matches version', () => {
-            beforeEach(() => {
-                packageLock.packages = { 'node_modules/foo': { version: '2.1.0' } };
-            });
+            beforeEach(() => (resolvedRootVersions = { foo: '2.1.0' }));
 
             itReturnsNothing();
         });
 
         describe('when root does not match any version', () => {
-            beforeEach(() => {
-                packageLock.packages = { 'node_modules/foo': { version: '1.1.0' } };
-            });
+            beforeEach(() => (resolvedRootVersions = { foo: '1.1.0' }));
 
             itReturnsError(
                 `${chalk.yellow('foo@1.1.0')} does not match ${chalk.yellow('~1.0.0, ^2.0.0')}`
@@ -156,10 +169,10 @@ describe(`[startup] Review ${RequireProjectVersionInRootNodeModules.name}`, () =
                 bar: { '>=2 <3': ['lib2'] },
                 baz: { '>=3 <4': ['lib3'] },
             };
-            packageLock.packages = {
-                'node_modules/foo': { version: '1.1.0' }, // error
-                'node_modules/bar': { version: '2.0.1' }, // ok
-                'node_modules/baz': { version: '4.0.0' }, // error
+            resolvedRootVersions = {
+                foo: '1.1.0', // error
+                bar: '2.0.1', // ok
+                baz: '4.0.0', // error
             };
         });
 

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

@@ -70,8 +70,8 @@ export class RequireCompatibleLaunchDarklySdk implements PackageRule {
             return;
         }
 
-        const actualVersion = this.getActualJsClientSdkVersion(name);
-        const targetVersion = this.getTargetJsClientSdkVersion(name);
+        const actualVersion = this.getActualJsClientSdkVersion(location);
+        const targetVersion = this.getTargetJsClientSdkVersion(location);
         if (actualVersion && targetVersion && !satisfies(actualVersion, targetVersion)) {
             return this.createError({
                 message: `package "${name}" depends on an incompatible version of ${JS_CLIENT_SDK}`,
@@ -87,7 +87,7 @@ export class RequireCompatibleLaunchDarklySdk implements PackageRule {
         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,
+                location: this.#project.packageManager.lockFileName,
                 data: { actualVersion, targetVersion },
             });
         }
@@ -109,33 +109,18 @@ export class RequireCompatibleLaunchDarklySdk implements PackageRule {
         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 getActualJsClientSdkVersion(workspacePackage = '') {
+        return this.#project.packageManager.getResolvedVersion({
+            workspacePackage,
+            dependency: JS_CLIENT_SDK,
+        });
     }
 
-    private getTargetJsClientSdkVersion(packageName?: string) {
-        const { dependencies = {}, peerDependencies = {} } = this.getResolvedDependency({
-            packageName,
-            dependency: LD_SERVICE,
+    private getTargetJsClientSdkVersion(workspacePackage = '') {
+        return this.#project.packageManager.getDeclaredVersion({
+            workspacePackage,
+            declaredBy: LD_SERVICE,
+            dependency: JS_CLIENT_SDK,
         });
-
-        return dependencies[JS_CLIENT_SDK] ?? peerDependencies[JS_CLIENT_SDK];
     }
 }

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

@@ -21,6 +21,11 @@ export class RequireProjectVersionInRootNodeModules implements PackageRule {
     }
 
     run(project: Project): PackageError<ErrorData> | undefined {
+        // pnpm isolates each package's dependencies, so root version mismatches are harmless
+        if (project.packageManager.command === 'pnpm') {
+            return;
+        }
+
         const mismatches = this.findMismatches(project);
         if (!mismatches.length) {
             return;
@@ -31,7 +36,7 @@ export class RequireProjectVersionInRootNodeModules implements PackageRule {
             message: 'project has unexpected version in root node_modules',
             details: this.formatDetails(mismatches),
             fixable: FixCategory.lockFile,
-            location: project.packageLock.location,
+            location: project.packageManager.lockFileName,
             data: { mismatches },
         };
     }
@@ -80,9 +85,11 @@ export class RequireProjectVersionInRootNodeModules implements PackageRule {
     }
 
     private findMismatches(project: Project) {
-        const { packageLock } = project;
         return this.getDependencies(project).reduce((result, [name, versions]) => {
-            const rootVersion = packageLock.packages[`node_modules/${name}`]?.version;
+            const rootVersion = project.packageManager.getResolvedVersion({
+                workspacePackage: '',
+                dependency: name,
+            });
             if (rootVersion) {
                 const projectVersions = Object.keys(versions);
                 if (!projectVersions.some(version => satisfies(rootVersion, version))) {

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

@@ -1,3 +1,5 @@
+import { PackageManager } from '@servicetitan/install';
+
 export abstract class PackageRule {
     abstract get id(): string;
     abstract run(project: Project): PackageError | PackageError[] | undefined;
@@ -7,18 +9,7 @@ export abstract class PackageRule {
 export interface Project {
     config: ReviewConfiguration;
     dependencies: Dependencies;
-    // Only using this subset of package-lock.json
-    packageLock: {
-        packages: Record<
-            string,
-            {
-                version: string;
-                dependencies?: Record<string, string>;
-                peerDependencies?: Record<string, string>;
-            }
-        >;
-        location: string;
-    };
+    packageManager: PackageManager;
     packages: Package[];
 }
 

package/src/cli/utils/index.ts

@@ -5,10 +5,17 @@ export * from './cli-git';
 export * from './cli-npm';
 export * from './cli-os';
 export * from './compile';
-export * from './compile-less';
-export * from './compile-sass';
+/*
+ * These modules eagerly load heavy dependencies (less, sass). Importing them
+ * from the barrel causes every test that touches cli/utils to pay that cost
+ * and spams "Less has finished and no sheets were loaded" in test output.
+ * Import directly from the module instead (e.g., import { copyFiles } from './copy-files').
+ *
+ * export * from './compile-less';
+ * export * from './compile-sass';
+ * export * from './copy-files';
+ */
 export * from './constants';
-export * from './copy-files';
 export * from './eslint';
 export * from './get-module-type';
 export * from './is-module-installed';

package/src/cypress/config/__tests__/webpack-config.test.ts

@@ -45,15 +45,6 @@ describe(`[startup/cypress-config] ${webpackConfig.name}`, () => {
         );
     });
 
-    test('enables code coverage', () => {
-        subject();
-
-        expect(rulesConfig).toHaveBeenCalledWith(
-            expect.objectContaining({ codeCoverage: true }),
-            expect.anything()
-        );
-    });
-
     test('includes all rules from rulesConfig', () => {
         const result = subject();
 

package/src/cypress/config/webpack-config.ts

@@ -27,7 +27,6 @@ export function webpackConfig(overrides?: Overrides): Configuration {
 
 function getContext(): Context {
     return {
-        codeCoverage: true,
         destination: '',
         isProduction: false,
         name: '',

package/src/postinstall.js

@@ -1,26 +1,118 @@
+/**
+ * Applies patch-package patches after startup is installed in a consumer project.
+ *
+ * Under npm, patch-package finds packages directly in node_modules/. Under pnpm,
+ * packages live in the .pnpm store and aren't at their expected node_modules/<pkg>
+ * paths. This script bridges the gap by creating temporary symlinks so
+ * patch-package can locate and patch them, then cleans up the symlinks afterward.
+ *
+ * Only runs when startup is installed inside a project directory (not globally
+ * or in an npx cache). Failures are logged as warnings to avoid blocking installs.
+ */
 const { execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
-const cwd = process.env.INIT_CWD;
-const patchDir = path.resolve('patches');
-const relativePatchDir = path.relative(cwd, patchDir);
-const isInstalledInCurrentDirectory = patchDir.startsWith(path.resolve(cwd));
-console.log({ cwd, patchDir, relativePatchDir, isInstalledInCurrentDirectory }); // eslint-disable-line no-console
+/**
+ * Parse patch filenames and resolve each package's install location in the
+ * .pnpm store. Returns an array of { pkg, link, target } for packages that
+ * need a temporary symlink (i.e., not already at node_modules/<pkg>).
+ *
+ * Expected filename format (patch-package convention):
+ *   <name>+<version>.patch           — e.g., jsdom+26.1.0.patch
+ *   <name>+<version>.dev.patch       — e.g., jsdom+26.1.0.dev.patch
+ *   @<scope>+<name>+<version>.patch  — e.g., @babel+core+7.28.5.patch
+ */
+function getPnpmPatchTargets(cwd, patchDir) {
+    const pnpmDir = path.join(cwd, 'node_modules', '.pnpm');
+    if (!fs.existsSync(pnpmDir)) {
+        return [];
+    }
+
+    const targets = [];
+    for (const file of fs.readdirSync(patchDir).filter(f => f.endsWith('.patch'))) {
+        const match = file.match(/^(?<name>.+)\+\d/);
+        if (!match?.groups) {
+            continue;
+        }
+
+        const { name } = match.groups;
+        const pkg = name.replace(/\+/, '/'); // @scope+name -> @scope/name
+        const link = path.join(cwd, 'node_modules', pkg);
+        if (fs.existsSync(link)) {
+            // already exists
+            continue;
+        }
+
+        const entry = fs.readdirSync(pnpmDir).find(e => e.startsWith(`${name}@`));
+        if (!entry) {
+            // package not installed (e.g., .dev patch in production install)
+            continue;
+        }
+
+        targets.push({
+            pkg,
+            link,
+            target: path.join(pnpmDir, entry, 'node_modules', pkg),
+        });
+    }
+    return targets;
+}
+
+/*
+ * For pnpm, patch-package can't find packages because they live in the .pnpm
+ * store instead of node_modules/<pkg>. We create temporary symlinks so
+ * patch-package can find them, then clean up after.
+ */
+function addPnpmSymlinks(targets) {
+    for (const { link, target } of targets) {
+        fs.mkdirSync(path.dirname(link), { recursive: true });
+        fs.symlinkSync(target, link);
+    }
+}
+
+function removePnpmSymlinks(targets) {
+    for (const { link } of targets) {
+        fs.unlinkSync(link);
+    }
+}
+
+function main() {
+    const cwd = process.env.INIT_CWD;
+    const patchDir = path.resolve('patches');
+    const relativePatchDir = path.relative(cwd, patchDir);
+    const isInstalledInCurrentDirectory = patchDir.startsWith(path.resolve(cwd));
 
-try {
     // Only apply patches when installed in project (as opposed to globally or in npx cache)
-    if (fs.existsSync('package.json') && isInstalledInCurrentDirectory) {
-        execFileSync('npx', ['patch-package', '--error-on-fail', '--patch-dir', relativePatchDir], {
+    if (!fs.existsSync('package.json') || !isInstalledInCurrentDirectory) {
+        return;
+    }
+
+    const patchTargets = getPnpmPatchTargets(cwd, patchDir);
+    addPnpmSymlinks(patchTargets);
+    try {
+        execFileSync('patch-package', ['--error-on-fail', '--patch-dir', relativePatchDir], {
             cwd,
             shell: process.platform === 'win32',
             stdio: 'inherit',
         });
+    } finally {
+        removePnpmSymlinks(patchTargets);
     }
-} catch (e) {
-    /*
-     * To avoid disrupting workflows only log warning when postinstall fails.
-     * To see detailed error, run npm with --foreground-scripts option.
-     */
-    console.warn(`postinstall failed`, e); // eslint-disable-line no-console
 }
+
+// Only run when executed directly (e.g., `node postinstall.js`), not when imported (e.g., in tests).
+/* istanbul ignore next */
+if (require.main === module) {
+    try {
+        main();
+    } catch (e) {
+        /*
+         * To avoid disrupting workflows only log warning when postinstall fails.
+         * To see detailed error, run npm with --foreground-scripts option.
+         */
+        console.warn(`postinstall failed`, e); // eslint-disable-line no-console
+    }
+}
+
+module.exports = { main };