Run only Vitest tests related to changed TypeScript files with ts-morph

README.md

Run only Vitest tests related to changed files

A small, dependency-graph based approach for local pre-commit checks in a React + TypeScript + Vite/Vitest app.

The goal is similar to lint-staged, but with one important difference: changed source files should trigger tests that depend on them, even when those test files were not changed locally.

How it works

1. Get changed files from git:

   • staged files for pre-commit: git diff --cached --name-only
   • or branch changes: git diff origin/main...HEAD --name-only

2. Load the TypeScript project with ts-morph using tsconfig.json.

3. Build a reverse import/export graph:

   src/lib/money.ts
     <- src/components/MoneyCell.tsx
     <- src/components/MoneyCell.test.tsx

4. Walk from changed files through reverse dependencies.

5. Collect matching test files: *.test.ts, *.test.tsx, *.spec.ts, *.spec.tsx.

6. Run:

   vitest run <related test files>

If a global/config file changes, or no related tests are found, the script defaults to running the full suite. This makes it safer for pre-commit use.

Install for a Bun project

bun add -d ts-morph vitest @types/node lint-staged
mkdir -p scripts
cp scripts/related-tests.mjs ./scripts/related-tests.mjs
chmod +x scripts/related-tests.mjs

Add scripts to package.json:

{
  "scripts": {
    "lint": "eslint .",
    "test": "vitest run",
    "test:related": "bun scripts/related-tests.mjs --staged --run",
    "test:related:branch": "bun scripts/related-tests.mjs --base origin/main --run"
  },
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "eslint --fix"
    ]
  }
}

Run locally:

bun run test:related

Preview without running tests:

bun scripts/related-tests.mjs --staged

Get machine-readable output:

bun scripts/related-tests.mjs --staged --json

Pre-commit setup with plain git hooks

This does not require Husky. Save the included pre-commit file as .git/hooks/pre-commit and make it executable:

cp pre-commit .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

Example .git/hooks/pre-commit:

#!/usr/bin/env sh
set -e

bunx lint-staged
bun run test:related

That gives you two layers:

1. lint-staged runs fast file-oriented checks/fixes on staged files.
2. test:related asks git for the staged files, uses ts-morph to find dependent test files, then runs those tests.

lint-staged config

The simplest package.json config keeps lint-staged focused on file-oriented lint/format work:

{
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "eslint --fix"
    ]
  }
}

If you want more control, use the included lint-staged.config.mjs instead:

export default {
  '*.{js,jsx,ts,tsx}': (files) => [
    `eslint --fix ${files.map((file) => JSON.stringify(file)).join(' ')}`,
  ],
}

Then your pre-commit hook can run:

bunx lint-staged --config lint-staged.config.mjs
bun run test:related

You can put bun run test:related inside lint-staged if you prefer. The script ignores extra file arguments when using --staged. Just avoid also running it separately in the pre-commit hook, or it will run twice.

Why not only use lint-staged?

lint-staged is great for commands that operate on the changed files themselves. Tests often need the opposite lookup: given a changed implementation file, find unmodified tests that import it directly or indirectly.

This script computes that dependent test set using TypeScript import resolution.

Safety fallbacks

The script runs the full test suite when files like these change:

• package.json
• Bun/npm/yarn/pnpm lockfiles
• vite.config.ts
• vitest.config.ts
• vitest.setup.ts
• tsconfig*.json

You can customize fullSuitePatterns in scripts/related-tests.mjs for generated files, app-wide providers, test utilities, theme files, API clients, etc.

Commands

# staged files, suitable for pre-commit
bun scripts/related-tests.mjs --staged --run

# compare current branch to origin/main
bun scripts/related-tests.mjs --base origin/main --run

# inspect related tests without running them
bun scripts/related-tests.mjs --staged

# pass explicit files
bun scripts/related-tests.mjs --files src/foo.ts src/components/Button.tsx --run

# avoid full-suite fallback when no related tests are found
bun scripts/related-tests.mjs --staged --run --allow-empty

Limitations

This is intentionally lightweight. It handles normal TypeScript import/export declarations and barrel files, but you may want full-suite fallbacks for:

• dynamic imports
• generated clients
• path aliases with unusual TypeScript config
• test setup files
• CSS/assets that affect component snapshots
• shared providers or app bootstrap files

For CI-scale affected-project orchestration, tools like Nx or Turborepo are more complete. For fast local pre-commit validation in a Vite/Vitest TypeScript app, this approach is usually enough.

lint-staged.config.mjs

/**
 * Optional lint-staged config.
 *
 * Keep lint-staged focused on file-oriented work. The git pre-commit hook can
 * run related tests once after lint-staged succeeds.
 */
export default {
  '*.{js,jsx,ts,tsx}': (files) => [
    `eslint --fix ${files.map((file) => JSON.stringify(file)).join(' ')}`,
  ],
}

package.json.snippet

{
  "devDependencies": {
    "@types/node": "latest",
    "lint-staged": "latest",
    "ts-morph": "latest",
    "vitest": "latest"
  },
  "scripts": {
    "lint": "eslint .",
    "test": "vitest run",
    "test:related": "bun scripts/related-tests.mjs --staged --run",
    "test:related:branch": "bun scripts/related-tests.mjs --base origin/main --run"
  },
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "eslint --fix"
    ]
  }
}

pre-commit

#!/usr/bin/env sh
# Save as .git/hooks/pre-commit and chmod +x .git/hooks/pre-commit
#
# This uses lint-staged for formatting/linting staged files and then runs
# related tests for the staged changes.

set -e

bunx lint-staged
bun run test:related

related-tests.mjs

#!/usr/bin/env node
/**
 * Run only Vitest tests related to changed TypeScript/JavaScript files.
 *
 * Works by building a reverse import/export graph with ts-morph:
 * changed source file -> files that import it -> ... -> test files
 *
 * Usage:
 *   bun scripts/related-tests.mjs --staged --run
 *   bun scripts/related-tests.mjs --base origin/main --run
 *   bun scripts/related-tests.mjs --files src/foo.ts src/bar.tsx --run
 */
import { spawnSync } from 'node:child_process'
import fs from 'node:fs'
import path from 'node:path'
import { Project } from 'ts-morph'

const args = process.argv.slice(2)
const has = (flag) => args.includes(flag)
const valueOf = (flag, fallback) => {
  const index = args.indexOf(flag)
  return index >= 0 && args[index + 1] ? args[index + 1] : fallback
}

const cwd = path.resolve(valueOf('--cwd', process.cwd()))
const tsconfig = path.resolve(cwd, valueOf('--tsconfig', 'tsconfig.json'))
const base = valueOf('--base', 'origin/main')
const run = has('--run')
const json = has('--json')
const allowEmpty = has('--allow-empty')
const packageRunner = valueOf('--runner', detectRunner(cwd))
const testCommand = valueOf('--test-command', 'vitest run')

// Files that should invalidate dependency analysis and run the whole suite.
const fullSuitePatterns = [
  /^package\.json$/,
  /^bun\.lockb$/,
  /^bun\.lock$/,
  /^pnpm-lock\.yaml$/,
  /^yarn\.lock$/,
  /^package-lock\.json$/,
  /^vite\.config\.[cm]?[jt]s$/,
  /^vitest\.config\.[cm]?[jt]s$/,
  /^vitest\.setup\.[cm]?[jt]s$/,
  /^tsconfig(\..*)?\.json$/,
]

const sourceExtensions = /\.[cm]?[jt]sx?$/
const testFilePattern = /(^|[/.])(test|spec)\.[cm]?[jt]sx?$/

function main() {
  if (!fs.existsSync(tsconfig)) {
    fail(`Could not find tsconfig at ${tsconfig}`)
  }

  const changedFiles = getChangedFiles()
    .map((file) => normalize(file))
    .filter(Boolean)
    .filter((file) => fs.existsSync(path.join(cwd, file)))

  if (changedFiles.length === 0) {
    log('No changed files found.')
    process.exit(0)
  }

  if (changedFiles.some(shouldRunFullSuite)) {
    log('Global/config file changed. Running full test suite.')
    return maybeRun([])
  }

  const project = new Project({
    tsConfigFilePath: tsconfig,
    skipAddingFilesFromTsConfig: false,
  })

  const sourceFiles = project.getSourceFiles()
  const pathToSourceFile = new Map()
  for (const sourceFile of sourceFiles) {
    pathToSourceFile.set(normalize(path.relative(cwd, sourceFile.getFilePath())), sourceFile)
  }

  const reverseDeps = buildReverseDependencyGraph(sourceFiles, cwd)
  const relatedTests = findRelatedTests(changedFiles, reverseDeps)

  const result = {
    changedFiles,
    relatedTests: [...relatedTests].sort(),
    command:
      relatedTests.size > 0
        ? `${testCommand} ${[...relatedTests].sort().join(' ')}`
        : null,
  }

  if (json) console.log(JSON.stringify(result, null, 2))
  else {
    log(`Changed files:\n${changedFiles.map((f) => `  - ${f}`).join('\n')}`)
    if (relatedTests.size > 0) {
      log(`Related tests:\n${[...relatedTests].sort().map((f) => `  - ${f}`).join('\n')}`)
    } else {
      log('No related tests found.')
    }
  }

  if (relatedTests.size === 0) {
    if (allowEmpty) process.exit(0)
    log('No related tests found; running full suite as a safe fallback.')
    return maybeRun([])
  }

  return maybeRun([...relatedTests].sort())
}

function getChangedFiles() {
  const explicitFilesIndex = args.indexOf('--files')
  if (explicitFilesIndex >= 0) {
    return args.slice(explicitFilesIndex + 1).filter((arg) => !arg.startsWith('--'))
  }

  if (has('--staged')) {
    return git(['diff', '--cached', '--name-only', '--diff-filter=ACMR'])
  }

  if (has('--worktree')) {
    return git(['diff', '--name-only', '--diff-filter=ACMR'])
  }

  return git(['diff', '--name-only', '--diff-filter=ACMR', `${base}...HEAD`])
}

function buildReverseDependencyGraph(sourceFiles, cwd) {
  const reverseDeps = new Map()

  for (const sourceFile of sourceFiles) {
    const importer = normalize(path.relative(cwd, sourceFile.getFilePath()))
    const referenced = new Set()

    for (const decl of sourceFile.getImportDeclarations()) {
      const target = decl.getModuleSpecifierSourceFile()
      if (target) referenced.add(normalize(path.relative(cwd, target.getFilePath())))
    }

    // Include `export * from './x'` and `export { foo } from './x'` for barrel files.
    for (const decl of sourceFile.getExportDeclarations()) {
      const target = decl.getModuleSpecifierSourceFile()
      if (target) referenced.add(normalize(path.relative(cwd, target.getFilePath())))
    }

    for (const dependency of referenced) {
      if (!reverseDeps.has(dependency)) reverseDeps.set(dependency, new Set())
      reverseDeps.get(dependency).add(importer)
    }
  }

  return reverseDeps
}

function findRelatedTests(changedFiles, reverseDeps) {
  const queue = changedFiles.filter((file) => sourceExtensions.test(file))
  const seen = new Set(queue)
  const tests = new Set(queue.filter((file) => testFilePattern.test(file)))

  while (queue.length > 0) {
    const current = queue.shift()
    const importers = reverseDeps.get(current) ?? new Set()

    for (const importer of importers) {
      if (seen.has(importer)) continue
      seen.add(importer)

      if (testFilePattern.test(importer)) tests.add(importer)
      queue.push(importer)
    }
  }

  return tests
}

function shouldRunFullSuite(file) {
  return fullSuitePatterns.some((pattern) => pattern.test(file))
}

function maybeRun(testFiles) {
  if (!run) return

  const command = testFiles.length > 0 ? `${testCommand} ${testFiles.join(' ')}` : testCommand
  log(`Running: ${packageRunner} ${command}`)

  const result = spawnSync(packageRunner, command.split(' '), {
    cwd,
    stdio: 'inherit',
    shell: process.platform === 'win32',
  })

  process.exit(result.status ?? 1)
}

function git(gitArgs) {
  const result = spawnSync('git', gitArgs, { cwd, encoding: 'utf8' })
  if (result.status !== 0) fail(result.stderr || `git ${gitArgs.join(' ')} failed`)
  return result.stdout.split('\n').map((line) => line.trim()).filter(Boolean)
}

function normalize(file) {
  return file.replaceAll(path.sep, '/').replace(/^\.\//, '')
}

function detectRunner(cwd) {
  if (fs.existsSync(path.join(cwd, 'bun.lockb')) || fs.existsSync(path.join(cwd, 'bun.lock'))) return 'bunx'
  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) return 'pnpm'
  if (fs.existsSync(path.join(cwd, 'yarn.lock'))) return 'yarn'
  return 'npx'
}

function log(message) {
  if (!json) console.log(`[related-tests] ${message}`)
}

function fail(message) {
  console.error(`[related-tests] ${message}`)
  process.exit(1)
}

main()