@servicetitan/startup 36.1.1 → 36.1.2-canary.2

package/src/__tests__/postinstall.test.ts

@@ -0,0 +1,173 @@
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import { vol } from 'memfs';
+import path from 'path';
+
+jest.mock('fs', () => require('memfs').fs);
+jest.mock('child_process');
+
+const { main } = require('../postinstall');
+
+/*
+ * Node 22's path.resolve uses a native binding that bypasses jest.spyOn on
+ * process.cwd. Re-wire path.resolve so it picks up the mocked cwd.
+ */
+const realResolve = path.resolve.bind(path);
+
+describe('[startup] postinstall', () => {
+    const projectDir = '/project';
+    const nodeModulesDir = path.join(projectDir, 'node_modules');
+    const startupDir = path.join(nodeModulesDir, '@servicetitan', 'startup');
+    const patchDir = path.join(startupDir, 'patches');
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(process, 'cwd').mockReturnValue(startupDir);
+        jest.spyOn(path, 'resolve').mockImplementation((...args: string[]) =>
+            realResolve(process.cwd(), ...args)
+        );
+        process.env.INIT_CWD = projectDir;
+    });
+
+    afterEach(() => {
+        vol.reset();
+        delete process.env.INIT_CWD;
+    });
+
+    describe(main.name, () => {
+        const pkg = { name: 'jsdom', version: '26.1.0' };
+
+        beforeEach(() => {
+            vol.fromJSON({
+                [path.join(nodeModulesDir, pkg.name, 'index.js')]: '',
+                [path.join(startupDir, 'package.json')]: '{}',
+                [path.join(patchDir, `${pkg.name}+${pkg.version}.patch`)]: '',
+            });
+        });
+
+        const subject = () => main();
+
+        function itRunsPatchPackage() {
+            test('runs patch-package', () => {
+                subject();
+
+                expect(execFileSync).toHaveBeenCalledWith(
+                    'patch-package',
+                    ['--error-on-fail', '--patch-dir', path.relative(projectDir, patchDir)],
+                    expect.objectContaining({ cwd: projectDir })
+                );
+            });
+        }
+
+        function itDoesNothing() {
+            test('does not run patch-package', () => {
+                subject();
+
+                expect(execFileSync).not.toHaveBeenCalled();
+            });
+        }
+
+        itRunsPatchPackage();
+
+        describe('when package.json does not exist', () => {
+            beforeEach(() => fs.rmSync(path.join(startupDir, 'package.json')));
+
+            itDoesNothing();
+        });
+
+        describe('when patches are outside project directory', () => {
+            beforeEach(() => (process.env.INIT_CWD = '/other'));
+
+            itDoesNothing();
+        });
+
+        describe('with pnpm project', () => {
+            const npmPath = path.join(nodeModulesDir, pkg.name);
+            const pnpmStore = path.join(nodeModulesDir, '.pnpm');
+            const pnpmPath = path.join(
+                pnpmStore,
+                `${pkg.name}@${pkg.version}`,
+                'node_modules',
+                pkg.name
+            );
+            let createdSymlink: boolean;
+
+            beforeEach(() => {
+                createdSymlink = false;
+                fs.rmSync(npmPath, { recursive: true });
+                fs.mkdirSync(pnpmPath, { recursive: true });
+                fs.writeFileSync(path.join(pnpmPath, 'index.js'), '');
+                jest.mocked(execFileSync).mockImplementation((): any => {
+                    createdSymlink = fs.existsSync(npmPath);
+                });
+            });
+
+            itRunsPatchPackage();
+
+            test('creates transient symlink for patch-package', () => {
+                subject();
+
+                expect(createdSymlink).toBe(true);
+                expect(fs.existsSync(npmPath)).toBe(false);
+            });
+
+            describe('when package already exists in node_modules', () => {
+                beforeEach(() => {
+                    fs.mkdirSync(npmPath, { recursive: true });
+                    fs.writeFileSync(path.join(npmPath, 'index.js'), '');
+                });
+
+                test('does not replace it with a symlink', () => {
+                    subject();
+
+                    expect(fs.lstatSync(npmPath).isSymbolicLink()).toBe(false);
+                });
+            });
+
+            function itDoesNotCreateSymlink() {
+                test('does not create symlink', () => {
+                    subject();
+
+                    expect(createdSymlink).toBe(false);
+                });
+            }
+
+            describe('when package is not in .pnpm store', () => {
+                beforeEach(() => {
+                    fs.rmSync(path.join(pnpmStore, `${pkg.name}@${pkg.version}`), {
+                        recursive: true,
+                    });
+                });
+
+                itDoesNotCreateSymlink();
+            });
+
+            describe('when patch filename is not valid', () => {
+                beforeEach(() => {
+                    fs.renameSync(
+                        path.join(patchDir, `${pkg.name}+${pkg.version}.patch`),
+                        path.join(patchDir, `${pkg.name}.patch`)
+                    );
+                });
+
+                itDoesNotCreateSymlink();
+            });
+
+            describe('when patch-package throws', () => {
+                beforeEach(() => {
+                    jest.mocked(execFileSync).mockImplementation(() => {
+                        createdSymlink = fs.existsSync(npmPath);
+                        throw new Error('patch failed');
+                    });
+                });
+
+                test('removes symlink', () => {
+                    expect(() => subject()).toThrow();
+
+                    expect(createdSymlink).toBe(true);
+                    expect(fs.existsSync(npmPath)).toBe(false);
+                });
+            });
+        });
+    });
+});

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

@@ -1,9 +1,11 @@
+import { getPackageManager } from '@servicetitan/install';
 import { fs, vol } from 'memfs';
 import { exec, ExecException, execSync } from 'node:child_process';
 import { log } from '../../../utils';
 import { Clean } from '../clean';
 import { entry } from '../registry/clean';
 
+jest.mock('@servicetitan/install', () => ({ getPackageManager: jest.fn() }));
 jest.mock('node:fs', () => fs);
 jest.mock('node:child_process', () => ({
     execSync: jest.fn(),
@@ -15,6 +17,7 @@ type ExecCallback = (error: ExecException | null, stdout: string, stderr: string
 describe(`[startup] ${Clean.name}`, () => {
     const cachePath = '/test-npm-cache';
     const npxCacheDirectoryName = '_npx';
+    const packageManager: Partial<ReturnType<typeof getPackageManager>> = { clearCache: jest.fn() };
 
     beforeEach(() => {
         jest.clearAllMocks();
@@ -23,6 +26,7 @@ describe(`[startup] ${Clean.name}`, () => {
         jest.mocked(execSync).mockImplementation((cmd: string) =>
             cmd === 'npm config get cache' ? cachePath : ''
         );
+        jest.mocked(getPackageManager).mockReturnValue(packageManager as any);
         // @ts-expect-error this is a valid exec overload but TS shows an error
         jest.mocked(exec).mockImplementation((_cmd: string, callback?: ExecCallback) => {
             if (callback) {
@@ -77,14 +81,17 @@ describe(`[startup] ${Clean.name}`, () => {
         });
     }
 
-    test.each(['npx nx reset', 'npx jest --clearCache', 'npm cache clear --force'])(
-        'runs "%s"',
-        async command => {
-            await subject();
+    test.each(['nx reset', 'jest --clearCache'])('runs "%s"', async command => {
+        await subject();
+
+        expect(exec).toHaveBeenCalledWith(command, expect.any(Function));
+    });
 
-            expect(exec).toHaveBeenCalledWith(command, expect.any(Function));
-        }
-    );
+    test('clears package manager cache', async () => {
+        await subject();
+
+        expect(packageManager.clearCache).toHaveBeenCalled();
+    });
 
     itRunsGitClean();
 
@@ -94,22 +101,33 @@ describe(`[startup] ${Clean.name}`, () => {
         expect(vol.existsSync(`${cachePath}/${npxCacheDirectoryName}`)).toBe(false);
     });
 
-    describe('when "npx nx reset" fails', () => {
+    describe('when "nx reset" fails', () => {
         beforeEach(() => {
-            failExecOn('npx nx reset');
+            failExecOn('nx reset');
         });
 
-        itLogsError('Error running npx nx reset');
+        itLogsError('Error running nx reset');
         itRunsGitClean();
 
         test('runs remaining commands', async () => {
             await subject();
 
-            expect(exec).toHaveBeenCalledWith('npx jest --clearCache', expect.any(Function));
-            expect(exec).toHaveBeenCalledWith('npm cache clear --force', expect.any(Function));
+            expect(exec).toHaveBeenCalledWith('jest --clearCache', expect.any(Function));
+            expect(packageManager.clearCache).toHaveBeenCalled();
         });
     });
 
+    describe('when clearing package manager cache fails', () => {
+        beforeEach(() => {
+            jest.spyOn(packageManager, 'clearCache').mockImplementation(() => {
+                throw new Error('Oops!');
+            });
+        });
+
+        itLogsError('Error clearing package manager cache');
+        itRunsGitClean();
+    });
+
     describe('when clearing npx cache fails', () => {
         beforeEach(() => {
             jest.mocked(execSync).mockImplementation(cmd => {

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

@@ -29,7 +29,9 @@ describe(`${Install.name}`, () => {
     test('runs install', async () => {
         await subject();
 
-        expect(execSync).toHaveBeenCalledWith(`npx @servicetitan/install`, { stdio: 'inherit' });
+        expect(execSync).toHaveBeenCalledWith(`npx --yes @servicetitan/install`, {
+            stdio: 'inherit',
+        });
     });
 
     const keys = ['fix', 'quiet', 'token'] satisfies (keyof typeof args)[];

package/src/cli/commands/__tests__/kendo-ui-license.test.ts

@@ -33,8 +33,8 @@ describe(`${kendoUILicense.name}`, () => {
 
         expect(log.info).toHaveBeenCalledWith('Activating Kendo UI with embedded license...');
         expect(execa).toHaveBeenCalledWith(
-            'npx',
-            ['kendo-ui-license', 'activate', '--no-install'],
+            'kendo-ui-license',
+            ['activate', '--no-install'],
             expect.objectContaining({
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 env: { KENDO_UI_LICENSE: expect.anything() },
@@ -54,8 +54,8 @@ describe(`${kendoUILicense.name}`, () => {
                 'Activating Kendo UI with license from environment...'
             );
             expect(execa).toHaveBeenCalledWith(
-                'npx',
-                ['kendo-ui-license', 'activate', '--no-install'],
+                'kendo-ui-license',
+                ['activate', '--no-install'],
                 expect.objectContaining({ env: undefined })
             );
         });

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

@@ -1,8 +1,7 @@
-import { copyFiles } from '../../utils';
+import { copyFiles } from '../../utils/copy-files';
 import { PreparePackage } from '../prepare-package';
 
-jest.mock('../../utils', () => ({
-    ...jest.requireActual('../../utils'),
+jest.mock('../../utils/copy-files', () => ({
     copyFiles: jest.fn(),
 }));
 

package/src/cli/commands/clean.ts

@@ -1,3 +1,4 @@
+import { getPackageManager } from '@servicetitan/install';
 import { exec as execAsync, execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -10,11 +11,11 @@ import { Command } from './types';
 const exec = promisify(execAsync);
 
 enum CleanProcesses {
-    ResetNx,
+    CleanGitWorkingTree,
     ClearJestCache,
-    ClearNpmCache,
     ClearNpxCache,
-    CleanGitWorkingTree,
+    ClearPackageManagerCache,
+    ResetNx,
 }
 
 export class Clean extends Command<typeof entry> {
@@ -22,12 +23,10 @@ export class Clean extends Command<typeof entry> {
     async execute() {
         const processTree = new ProcessTree<typeof CleanProcesses>();
 
-        processTree.add(CleanProcesses.ResetNx, () => this.runCommand('npx nx reset'));
-        processTree.add(CleanProcesses.ClearJestCache, () =>
-            this.runCommand('npx jest --clearCache')
-        );
-        processTree.add(CleanProcesses.ClearNpmCache, () =>
-            this.runCommand('npm cache clear --force')
+        processTree.add(CleanProcesses.ResetNx, () => this.runCommand('nx reset'));
+        processTree.add(CleanProcesses.ClearJestCache, () => this.runCommand('jest --clearCache'));
+        processTree.add(CleanProcesses.ClearPackageManagerCache, () =>
+            Promise.resolve(this.clearPackageManagerCache())
         );
         processTree.add(CleanProcesses.ClearNpxCache, () => this.clearNpxCache());
 
@@ -63,4 +62,14 @@ export class Clean extends Command<typeof entry> {
             log.error(`Error clearing npx cache: ${error}`);
         }
     }
+
+    private clearPackageManagerCache() {
+        try {
+            const packageManager = getPackageManager();
+            log.info(`Clearing ${packageManager.command} cache`);
+            packageManager.clearCache();
+        } catch (error) {
+            log.error(`Error clearing package manager cache: ${error}`);
+        }
+    }
 }

package/src/cli/commands/install.ts

@@ -17,7 +17,7 @@ export class Install extends Command<typeof entry> {
             this.args.token === false ? '--no-token' : '',
         ].filter(option => !!option);
 
-        const command = `npx @servicetitan/install ${options.join(' ')}`.trim();
+        const command = `npx --yes @servicetitan/install ${options.join(' ')}`.trim();
 
         log.debug('install', command);
 

package/src/cli/commands/kendo-ui-license.ts

@@ -51,7 +51,7 @@ export class KendoUILicense extends Command<typeof entry> {
         );
 
         try {
-            await execa('npx', ['kendo-ui-license', 'activate', '--no-install'], {
+            await execa('kendo-ui-license', ['activate', '--no-install'], {
                 env,
                 stdio: 'inherit',
             });

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

@@ -1,5 +1,5 @@
 import { logErrors } from '../../utils';
-import { copyFiles } from '../utils';
+import { copyFiles } from '../utils/copy-files';
 import type { entry } from './registry/prepare-package';
 import { Command } from './types';
 

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

@@ -1 +1,2 @@
 export * from './expect-calls';
+export * from './mock-package-manager';

package/src/cli/commands/review/__mocks__/mock-package-manager.ts

@@ -0,0 +1,20 @@
+import type { DeclaredVersionQuery, ResolvedVersionQuery } from '@servicetitan/install';
+
+export class MockPackageManager {
+    command = 'test';
+    lockFileName = 'test-lock.json';
+
+    getDeclaredVersion(_query: DeclaredVersionQuery): string | undefined {
+        return undefined;
+    }
+
+    getResolvedVersion(_query: ResolvedVersionQuery): string | undefined {
+        return undefined;
+    }
+
+    hasValidLockFile(): boolean {
+        return true;
+    }
+
+    installPackages() {}
+}

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

@@ -1,18 +1,18 @@
+import { getPackageManager, PackageManager } from '@servicetitan/install';
 import chalk from 'chalk';
-import { execSync } from 'child_process';
 import { fs, vol } from 'memfs';
 import path from 'path';
 import terminalLink from 'terminal-link';
 import type { ProjectPackage } from '../../../../utils';
 import { findPackages, getReviewConfiguration, log } from '../../../../utils';
 import { entry } from '../../registry/review';
-import { expectCalls } from '../__mocks__';
+import { expectCalls, MockPackageManager } from '../__mocks__';
 import { Review } from '../review';
 import { rules } from '../rules';
 import { ErrorSeverity, FixCategory, Level, PackageError, ReviewConfiguration } from '../types';
 import { indent } from '../utils';
 
-jest.mock('child_process', () => ({ execSync: jest.fn() }));
+jest.mock('@servicetitan/install', () => ({ getPackageManager: jest.fn() }));
 jest.mock('fs', () => fs);
 jest.mock('terminal-link', () => jest.fn());
 jest.mock('../../../../utils', () => ({
@@ -73,7 +73,6 @@ describe(`[startup] ${Review.name}`, () => {
 
     describe('when run from workspace root', () => {
         const rootPackageJSON = { name: 'root', workspaces: ['packages/*'] };
-        const packageLockJSON = { packages: {} };
         const packages: ProjectPackage[] = [
             {
                 name: 'a',
@@ -96,11 +95,12 @@ describe(`[startup] ${Review.name}`, () => {
             foo: { '1.0.0': ['b'], '1.0.1': ['a'] },
         };
         let config: ReviewConfiguration;
+        let packageManager: PackageManager;
 
         function project() {
             return {
                 config: {},
-                packageLock: { ...packageLockJSON, location: './package-lock.json' },
+                packageManager,
                 packages: [{ ...rootPackageJSON, location: '.' }, ...packages],
                 dependencies: expectedDependencies,
             };
@@ -108,12 +108,15 @@ describe(`[startup] ${Review.name}`, () => {
 
         beforeEach(() => {
             config = {};
+            packageManager = new MockPackageManager() as any;
             vol.fromJSON({
                 'package.json': JSON.stringify(rootPackageJSON),
-                'package-lock.json': JSON.stringify(packageLockJSON),
+                [packageManager.lockFileName]: JSON.stringify({}),
             });
             jest.resetAllMocks();
+            jest.spyOn(packageManager, 'installPackages');
             jest.mocked(findPackages).mockImplementation(() => packages);
+            jest.mocked(getPackageManager).mockReturnValue(packageManager);
             jest.mocked(getReviewConfiguration).mockImplementation(() => config);
         });
 
@@ -133,21 +136,10 @@ describe(`[startup] ${Review.name}`, () => {
 
         itReportsNoErrors();
 
-        describe('with no package-lock.json', () => {
-            beforeEach(() => fs.rmSync('package-lock.json'));
+        describe('when lock file is missing or invalid', () => {
+            beforeEach(() => jest.spyOn(packageManager, 'hasValidLockFile').mockReturnValue(false));
 
-            itThrowsError(/must be run with valid package-lock\.json/);
-        });
-
-        describe('when package-lock.json omits "packages"', () => {
-            beforeEach(() => {
-                vol.fromJSON({
-                    'package.json': JSON.stringify(rootPackageJSON),
-                    'package-lock.json': JSON.stringify({}),
-                });
-            });
-
-            itThrowsError(/must be run with valid package-lock\.json/);
+            itThrowsError(/missing or invalid lock file/);
         });
 
         describe('with --rule option', () => {
@@ -277,8 +269,8 @@ describe(`[startup] ${Review.name}`, () => {
                     test('regenerates lockfile', async () => {
                         await subject();
 
-                        expect(execSync).toHaveBeenCalledWith(
-                            'npx @servicetitan/install --fix --quiet',
+                        expect(packageManager.installPackages).toHaveBeenCalledWith(
+                            { fix: true },
                             { stdio: 'inherit' }
                         );
                     });
@@ -349,10 +341,10 @@ describe(`[startup] ${Review.name}`, () => {
                     expectOutput(location(error), message(error, { indent: { label: 1 } }));
                 });
 
-                describe('when location is package-lock.json', () => {
-                    beforeEach(() => (error.location = project().packageLock.location));
+                describe('when location is lock file', () => {
+                    beforeEach(() => (error.location = project().packageManager.lockFileName));
 
-                    test('outputs package-lock.json as location', async () => {
+                    test('outputs lock file as location', async () => {
                         await subject();
 
                         expectOutput(chalk.underline(path.relative('.', error.location!)));
@@ -450,19 +442,19 @@ describe(`[startup] ${Review.name}`, () => {
                                 ]);
                         };
 
-                        const execStartupInstallWithFixOption = [
-                            execSync,
-                            'npx @servicetitan/install --fix --quiet',
+                        const installPackagesWithFixOption = [
+                            packageManager.installPackages,
+                            { fix: true },
                             { stdio: 'inherit' },
                         ];
 
                         expectCalls(
                             ...fixesForCategory(FixCategory.isolated),
-                            execStartupInstallWithFixOption,
+                            installPackagesWithFixOption,
                             ...fixesForCategory(FixCategory.normal),
-                            execStartupInstallWithFixOption,
+                            installPackagesWithFixOption,
                             ...fixesForCategory(FixCategory.lockFile),
-                            execStartupInstallWithFixOption
+                            installPackagesWithFixOption
                         );
                     });
 

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

@@ -1,5 +1,5 @@
+import { getPackageManager } from '@servicetitan/install';
 import chalk from 'chalk';
-import { execSync } from 'child_process';
 import terminalLink from 'terminal-link';
 import {
     findPackages,
@@ -57,13 +57,12 @@ export class Review extends Command<typeof entry> {
             throw new Error('this command must be run from the workspace root directory');
         }
 
-        const packageLock = readJsonSafe<Project['packageLock']>('package-lock.json');
-        if (!packageLock?.packages) {
-            throw new Error('this command must be run with valid package-lock.json');
+        const packageManager = getPackageManager();
+        if (!packageManager.hasValidLockFile()) {
+            throw new Error(`missing or invalid lock file: ${packageManager.lockFileName}`);
         }
 
         root.location = '.'; // identifies the root package.json for rules that care
-        packageLock.location = './package-lock.json';
 
         const config = getReviewConfiguration();
         const packages: Package[] = [root, ...findPackages()];
@@ -71,7 +70,12 @@ export class Review extends Command<typeof entry> {
         this.debug('review:packages', packages);
         this.debug('review:dependencies', dependencies);
 
-        return { config, dependencies, packageLock, packages };
+        return {
+            config,
+            dependencies,
+            packageManager,
+            packages,
+        };
     }
 
     private debug(namespace: string, data: any) {
@@ -110,7 +114,7 @@ export class Review extends Command<typeof entry> {
                 }
             });
 
-            execSync('npx @servicetitan/install --fix --quiet', { stdio: 'inherit' });
+            project.packageManager.installPackages({ fix: true }, { stdio: 'inherit' });
             project = this.createProject();
             errors = this.findErrors(project);
         }

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

@@ -1,10 +1,11 @@
+import { MockPackageManager } from '../../__mocks__';
 import { Project } from '../../types';
 
 export function mockProject(project: Partial<Project>): Project {
     return {
         config: {},
         dependencies: {},
-        packageLock: { packages: {}, location: './package-lock.json' },
+        packageManager: new MockPackageManager() as any,
         packages: [],
         ...project,
     };