perf: reuse jest file system cache for isolatedModules: false (#2189)

Jest 27 passes `cacheFS` from runtime to transformer. Since TypeScript `LanguageService` performs some file reads, we should use and update that cache so that Jest won't attempt to reread those files, improves performance.

Author: ahnpnl

README.md

@@ -21,13 +21,13 @@ It supports all features of TypeScript including type-checking. [Read more about
 | We are not doing semantic versioning and `23.10` is a re-write, run `npm i -D ts-jest@"<23.10.0"` to go back to the previous version |
 |---|
 
-[<img src="./docs/assets/img/documentation.png" align="left" height="24"> View the online documentation (usage & technical)](https://kulshekhar.github.io/ts-jest)
+[<img src="./docs/static/img/documentation.png" align="left" height="24"> View the online documentation (usage & technical)](https://kulshekhar.github.io/ts-jest)
 
-[<img src="./docs/assets/img/slack.png" align="left" height="24"> Ask for some help in the `ts-jest` community of Slack](https://bit.ly/3bRHFPQ)
+[<img src="./docs/static/img/slack.png" align="left" height="24"> Ask for some help in the `ts-jest` community of Slack](https://bit.ly/3bRHFPQ)
 
-[<img src="./docs/assets/img/troubleshooting.png" align="left" height="24"> Before reporting any issue, be sure to check the troubleshooting page](TROUBLESHOOTING.md)
+[<img src="./docs/static/img/troubleshooting.png" align="left" height="24"> Before reporting any issue, be sure to check the troubleshooting page](TROUBLESHOOTING.md)
 
-[<img src="./docs/assets/img/pull-request.png" align="left" height="24"> We're looking for collaborators! Want to help improve `ts-jest`?](https://github.com/kulshekhar/ts-jest/issues/223)
+[<img src="./docs/static/img/pull-request.png" align="left" height="24"> We're looking for collaborators! Want to help improve `ts-jest`?](https://github.com/kulshekhar/ts-jest/issues/223)
 
 ---
 

e2e/__tests__/__snapshots__/logger.test.ts.snap

@@ -22,16 +22,12 @@ Array [
   "[level:20] file caching disabled",
   "[level:20] created language service",
   "[level:20] computing cache key for <cwd>/Hello.spec.ts",
-  "[level:20] getting resolved modules from TypeScript API for <cwd>/Hello.spec.ts",
-  "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] processing <cwd>/Hello.spec.ts",
   "[level:20] getCompiledOutput(): compiling using language service",
   "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] visitSourceFileNode(): hoisting",
   "[level:20] getCompiledOutput(): computing diagnostics using language service",
   "[level:20] computing cache key for <cwd>/Hello.ts",
-  "[level:20] getting resolved modules from TypeScript API for <cwd>/Hello.ts",
-  "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] processing <cwd>/Hello.ts",
   "[level:20] getCompiledOutput(): compiling using language service",
   "[level:20] updateMemoryCache: update memory cache for language service",
@@ -66,17 +62,13 @@ Array [
   "[level:20] file caching disabled",
   "[level:20] created language service",
   "[level:20] computing cache key for <cwd>/Hello.spec.ts",
-  "[level:20] getting resolved modules from TypeScript API for <cwd>/Hello.spec.ts",
-  "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] processing <cwd>/Hello.spec.ts",
   "[level:20] getCompiledOutput(): compiling using language service",
   "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] visitSourceFileNode(): hoisting",
   "[level:20] getCompiledOutput(): computing diagnostics using language service",
   "[level:20] calling babel-jest processor",
   "[level:20] computing cache key for <cwd>/Hello.ts",
-  "[level:20] getting resolved modules from TypeScript API for <cwd>/Hello.ts",
-  "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] processing <cwd>/Hello.ts",
   "[level:20] getCompiledOutput(): compiling using language service",
   "[level:20] updateMemoryCache: update memory cache for language service",
@@ -113,17 +105,13 @@ Array [
   "[level:20] file caching disabled",
   "[level:20] created language service",
   "[level:20] computing cache key for <cwd>/Hello.spec.ts",
-  "[level:20] getting resolved modules from TypeScript API for <cwd>/Hello.spec.ts",
-  "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] processing <cwd>/Hello.spec.ts",
   "[level:20] getCompiledOutput(): compiling using language service",
   "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] visitSourceFileNode(): hoisting",
   "[level:20] getCompiledOutput(): computing diagnostics using language service",
   "[level:20] calling babel-jest processor",
   "[level:20] computing cache key for <cwd>/Hello.ts",
-  "[level:20] getting resolved modules from TypeScript API for <cwd>/Hello.ts",
-  "[level:20] updateMemoryCache: update memory cache for language service",
   "[level:20] processing <cwd>/Hello.ts",
   "[level:20] getCompiledOutput(): compiling using language service",
   "[level:20] updateMemoryCache: update memory cache for language service",

package-lock.json

@@ -3,7 +3,7 @@ import type { Logger } from 'bs-logger'
 import { resolve } from 'path'
 
 import { ConfigSet } from '../config/config-set'
-import type { TsJestGlobalOptions } from '../types'
+import type { StringMap, TsJestGlobalOptions } from '../types'
 import type { ImportReasons } from '../utils/messages'
 import { TsJestCompiler } from '../compiler/ts-jest-compiler'
 
@@ -59,15 +59,18 @@ export function createConfigSet({
 }
 
 // not really unit-testing here, but it's hard to mock all those values :-D
-export function makeCompiler({
-  jestConfig,
-  tsJestConfig,
-  parentConfig,
-}: {
-  jestConfig?: Partial<Config.ProjectConfig>
-  tsJestConfig?: TsJestGlobalOptions
-  parentConfig?: TsJestGlobalOptions
-} = {}): TsJestCompiler {
+export function makeCompiler(
+  {
+    jestConfig,
+    tsJestConfig,
+    parentConfig,
+  }: {
+    jestConfig?: Partial<Config.ProjectConfig>
+    tsJestConfig?: TsJestGlobalOptions
+    parentConfig?: TsJestGlobalOptions
+  } = {},
+  jestCacheFS: StringMap = new Map<string, string>(),
+): TsJestCompiler {
   tsJestConfig = { ...tsJestConfig }
   tsJestConfig.diagnostics = {
     ...(tsJestConfig.diagnostics as any),
@@ -82,5 +85,5 @@ export function makeCompiler({
   }
   const cs = createConfigSet({ jestConfig, tsJestConfig, parentConfig, resolve: null })
 
-  return new TsJestCompiler(cs)
+  return new TsJestCompiler(cs, jestCacheFS)
 }

src/__helpers__/fakers.ts

@@ -1,5 +1,6 @@
 import { readFileSync } from 'fs'
 import { LogLevels } from 'bs-logger'
+import { join } from 'path'
 
 import { TS_JEST_OUT_DIR } from '../config/config-set'
 import { makeCompiler } from '../__helpers__/fakers'
@@ -163,6 +164,7 @@ const t: string = f(5)
 
   describe('isolatedModule false', () => {
     const baseTsJestConfig = { tsconfig: require.resolve('../../tsconfig.spec.json') }
+    const jestCacheFS = new Map<string, string>()
 
     beforeEach(() => {
       logTarget.clear()
@@ -171,21 +173,28 @@ const t: string = f(5)
     describe('allowJs option', () => {
       const fileName = 'test-allow-js.js'
       const source = 'export default 42'
+      jestCacheFS.set(fileName, source)
 
       it('should compile js file for allowJs true with outDir', () => {
-        const compiler = makeCompiler({
-          tsJestConfig: { tsconfig: { allowJs: true, outDir: '$$foo$$' } },
-        })
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: { tsconfig: { allowJs: true, outDir: '$$foo$$' } },
+          },
+          jestCacheFS,
+        )
 
         const compiled = compiler.getCompiledOutput(source, fileName)
 
         expect(new ProcessedSource(compiled, fileName)).toMatchSnapshot()
       })
 
       it('should compile js file for allowJs true without outDir', () => {
-        const compiler = makeCompiler({
-          tsJestConfig: { tsconfig: { allowJs: true } },
-        })
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: { tsconfig: { allowJs: true } },
+          },
+          jestCacheFS,
+        )
         const compiled = compiler.getCompiledOutput(source, fileName)
 
         expect(new ProcessedSource(compiled, fileName)).toMatchSnapshot()
@@ -199,29 +208,36 @@ const t: string = f(5)
           return <>Test</>
         }
       `
+      jestCacheFS.set(fileName, source)
 
       it('should compile tsx file for jsx preserve', () => {
-        const compiler = makeCompiler({
-          tsJestConfig: {
-            tsconfig: {
-              jsx: 'preserve' as any,
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: {
+              tsconfig: {
+                jsx: 'preserve' as any,
+              },
             },
           },
-        })
+          jestCacheFS,
+        )
 
         const compiled = compiler.getCompiledOutput(source, fileName)
 
         expect(new ProcessedSource(compiled, fileName)).toMatchSnapshot()
       })
 
       it('should compile tsx file for other jsx options', () => {
-        const compiler = makeCompiler({
-          tsJestConfig: {
-            tsconfig: {
-              jsx: 'react' as any,
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: {
+              tsconfig: {
+                jsx: 'react' as any,
+              },
             },
           },
-        })
+          jestCacheFS,
+        )
         const compiled = compiler.getCompiledOutput(source, fileName)
 
         expect(new ProcessedSource(compiled, fileName)).toMatchSnapshot()
@@ -231,9 +247,13 @@ const t: string = f(5)
     describe('source maps', () => {
       const source = 'const gsm = (v: number) => v\nconst h: number = gsm(5)'
       const fileName = 'test-source-map.ts'
+      jestCacheFS.set(fileName, source)
 
       it('should have correct source maps without mapRoot', () => {
-        const compiler = makeCompiler({ tsJestConfig: { tsconfig: require.resolve('../../tsconfig.spec.json') } })
+        const compiler = makeCompiler(
+          { tsJestConfig: { tsconfig: require.resolve('../../tsconfig.spec.json') } },
+          jestCacheFS,
+        )
         const compiled = compiler.getCompiledOutput(source, fileName)
 
         expect(new ProcessedSource(compiled, fileName).outputSourceMaps).toMatchObject({
@@ -244,13 +264,16 @@ const t: string = f(5)
       })
 
       it('should have correct source maps with mapRoot', () => {
-        const compiler = makeCompiler({
-          tsJestConfig: {
-            tsconfig: {
-              mapRoot: './',
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: {
+              tsconfig: {
+                mapRoot: './',
+              },
             },
           },
-        })
+          jestCacheFS,
+        )
         const compiled = compiler.getCompiledOutput(source, fileName)
 
         expect(new ProcessedSource(compiled, fileName).outputSourceMaps).toMatchObject({
@@ -278,25 +301,84 @@ const t: string = f(5)
       })
     })
 
-    describe('diagnostics', () => {
-      const importedFileName = require.resolve('../__mocks__/thing.ts')
-      const importedFileContent = readFileSync(importedFileName, 'utf-8')
+    describe('getResolvedModulesMap', () => {
+      const fileName = 'foo.ts'
+      const fileContent = 'const foo = 1'
 
-      it(`shouldn't report diagnostics when file name doesn't match diagnostic file pattern`, () => {
+      test('should return undefined when file name is not known to compiler', () => {
+        const compiler = makeCompiler({
+          tsJestConfig: baseTsJestConfig,
+        })
+
+        expect(compiler.getResolvedModulesMap(fileContent, fileName)).toBeUndefined()
+      })
+
+      test('should return undefined when it is isolatedModules true', () => {
         const compiler = makeCompiler({
           tsJestConfig: {
             ...baseTsJestConfig,
-            diagnostics: { pathRegex: 'foo.spec.ts' },
+            isolatedModules: true,
           },
         })
 
+        expect(compiler.getResolvedModulesMap(fileContent, fileName)).toBeUndefined()
+      })
+
+      test('should return undefined when file has no resolved modules', () => {
+        const jestCacheFS = new Map<string, string>()
+        jestCacheFS.set(fileName, fileContent)
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: baseTsJestConfig,
+          },
+          jestCacheFS,
+        )
+
+        expect(compiler.getResolvedModulesMap(fileContent, fileName)).toBeUndefined()
+      })
+
+      test('should return resolved modules when file has resolved modules', () => {
+        const jestCacheFS = new Map<string, string>()
+        const fileContentWithModules = readFileSync(join(__dirname, '..', '__mocks__', 'thing.spec.ts'), 'utf-8')
+        jestCacheFS.set(fileName, fileContentWithModules)
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: baseTsJestConfig,
+          },
+          jestCacheFS,
+        )
+
+        expect(compiler.getResolvedModulesMap(fileContentWithModules, fileName)).toBeDefined()
+      })
+    })
+
+    describe('diagnostics', () => {
+      const importedFileName = require.resolve('../__mocks__/thing.ts')
+      const importedFileContent = readFileSync(importedFileName, 'utf-8')
+
+      it(`shouldn't report diagnostics when file name doesn't match diagnostic file pattern`, () => {
+        jestCacheFS.set(importedFileName, importedFileContent)
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: {
+              ...baseTsJestConfig,
+              diagnostics: { pathRegex: 'foo.spec.ts' },
+            },
+          },
+          jestCacheFS,
+        )
+
         expect(() => compiler.getCompiledOutput(importedFileContent, importedFileName)).not.toThrowError()
       })
 
       it(`shouldn't report diagnostic when processing file isn't used by any test files`, () => {
-        const compiler = makeCompiler({
-          tsJestConfig: baseTsJestConfig,
-        })
+        jestCacheFS.set('foo.ts', importedFileContent)
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: baseTsJestConfig,
+          },
+          jestCacheFS,
+        )
         logTarget.clear()
 
         compiler.getCompiledOutput(importedFileContent, 'foo.ts')
@@ -311,9 +393,13 @@ const t: string = f(5)
           a: string
         }
       `
-        const compiler = makeCompiler({
-          tsJestConfig: baseTsJestConfig,
-        })
+        jestCacheFS.set(fileName, source)
+        const compiler = makeCompiler(
+          {
+            tsJestConfig: baseTsJestConfig,
+          },
+          jestCacheFS,
+        )
 
         expect(() => compiler.getCompiledOutput(source, fileName)).toThrowErrorMatchingSnapshot()
       })

src/compiler/ts-compiler.spec.ts

@@ -13,31 +13,28 @@ import type {
 import { updateOutput } from './compiler-utils'
 import type { ConfigSet } from '../config/config-set'
 import { LINE_FEED } from '../constants'
-import type { CompilerInstance, ResolvedModulesMap, TTypeScript } from '../types'
+import type { CompilerInstance, ResolvedModulesMap, StringMap, TTypeScript } from '../types'
 import { rootLogger } from '../utils/logger'
 import { Errors, interpolate } from '../utils/messages'
 
-interface TSFile {
-  text?: string
-  version: number
-}
-
 /**
  * @internal
  */
 export class TsCompiler implements CompilerInstance {
   private readonly _logger: Logger
   private readonly _ts: TTypeScript
   private readonly _parsedTsConfig: ParsedCommandLine
-  private readonly _cacheFS: Map<string, TSFile> = new Map<string, TSFile>()
-  private _cachedReadFile: any
+  private readonly _compilerCacheFS: Map<string, number> = new Map<string, number>()
+  private readonly _jestCacheFS: StringMap
+  private _cachedReadFile: ((fileName: string) => string | undefined) | undefined
   private _projectVersion = 1
   private _languageService: LanguageService | undefined
 
-  constructor(private readonly configSet: ConfigSet) {
+  constructor(readonly configSet: ConfigSet, readonly jestCacheFS: StringMap) {
     this._ts = configSet.compilerModule
     this._logger = rootLogger.child({ namespace: 'ts-compiler' })
     this._parsedTsConfig = this.configSet.parsedTsConfig as ParsedCommandLine
+    this._jestCacheFS = jestCacheFS
     if (!this.configSet.isolatedModules) {
       this._createLanguageService()
     }
@@ -52,11 +49,7 @@ export class TsCompiler implements CompilerInstance {
     // Initialize memory cache for typescript compiler
     this._parsedTsConfig.fileNames
       .filter((fileName) => !this.configSet.isTestFile(fileName))
-      .forEach((fileName) => {
-        this._cacheFS.set(fileName, {
-          version: 0,
-        })
-      })
+      .forEach((fileName) => this._compilerCacheFS.set(fileName, 0))
     this._cachedReadFile = this._logger.wrap(serviceHostTraceCtx, 'readFile', memoize(this._ts.sys.readFile))
     /* istanbul ignore next */
     const moduleResolutionHost = {
@@ -75,10 +68,10 @@ export class TsCompiler implements CompilerInstance {
     /* istanbul ignore next */
     const serviceHost: LanguageServiceHost = {
       getProjectVersion: () => String(this._projectVersion),
-      getScriptFileNames: () => [...this._cacheFS.keys()],
+      getScriptFileNames: () => [...this._compilerCacheFS.keys()],
       getScriptVersion: (fileName: string) => {
         const normalizedFileName = normalize(fileName)
-        const version = this._cacheFS.get(normalizedFileName)?.version
+        const version = this._compilerCacheFS.get(normalizedFileName)
 
         // We need to return `undefined` and not a string here because TypeScript will use
         // `getScriptVersion` and compare against their own version - which can be `undefined`.
@@ -95,12 +88,14 @@ export class TsCompiler implements CompilerInstance {
 
         // Read contents from TypeScript memory cache.
         if (!hit) {
-          this._cacheFS.set(normalizedFileName, {
-            text: this._cachedReadFile(normalizedFileName),
-            version: 1,
-          })
+          const fileContent =
+            this._jestCacheFS.get(normalizedFileName) ?? this._cachedReadFile?.(normalizedFileName) ?? undefined
+          if (fileContent) {
+            this._jestCacheFS.set(normalizedFileName, fileContent)
+            this._compilerCacheFS.set(normalizedFileName, 1)
+          }
         }
-        const contents = this._cacheFS.get(normalizedFileName)?.text
+        const contents = this._jestCacheFS.get(normalizedFileName)
 
         if (contents === undefined) return
 
@@ -140,7 +135,7 @@ export class TsCompiler implements CompilerInstance {
     this._updateMemoryCache(fileContent, fileName)
 
     // See https://github.com/microsoft/TypeScript/blob/master/src/compiler/utilities.ts#L164
-    return (this._languageService?.getProgram()?.getSourceFile(fileName) as any).resolvedModules
+    return (this._languageService?.getProgram()?.getSourceFile(fileName) as any)?.resolvedModules
   }
 
   getCompiledOutput(fileContent: string, fileName: string): string {
@@ -187,8 +182,11 @@ export class TsCompiler implements CompilerInstance {
   }
 
   private _isFileInCache(fileName: string): boolean {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return this._cacheFS.has(fileName) && this._cacheFS.get(fileName)!.version !== 0
+    return (
+      this._jestCacheFS.has(fileName) &&
+      this._compilerCacheFS.has(fileName) &&
+      this._compilerCacheFS.get(fileName) !== 0
+    )
   }
 
   /* istanbul ignore next */
@@ -198,21 +196,14 @@ export class TsCompiler implements CompilerInstance {
     let shouldIncrementProjectVersion = false
     const hit = this._isFileInCache(fileName)
     if (!hit) {
-      this._cacheFS.set(fileName, {
-        text: contents,
-        version: 1,
-      })
+      this._compilerCacheFS.set(fileName, 1)
       shouldIncrementProjectVersion = true
     } else {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const cachedFileName = this._cacheFS.get(fileName)!
-      const previousContents = cachedFileName.text
+      const prevVersion = this._compilerCacheFS.get(fileName) ?? 0
+      const previousContents = this._jestCacheFS.get(fileName)
       // Avoid incrementing cache when nothing has changed.
       if (previousContents !== contents) {
-        this._cacheFS.set(fileName, {
-          text: contents,
-          version: cachedFileName.version + 1,
-        })
+        this._compilerCacheFS.set(fileName, prevVersion + 1)
         // Only bump project version when file is modified in cache, not when discovered for the first time
         if (hit) shouldIncrementProjectVersion = true
       }

src/compiler/ts-compiler.ts

@@ -1,16 +1,16 @@
 import { TsCompiler } from './ts-compiler'
 import type { ConfigSet } from '../config/config-set'
-import type { CompilerInstance, ResolvedModulesMap } from '../types'
+import type { CompilerInstance, ResolvedModulesMap, StringMap } from '../types'
 
 /**
  * @internal
  */
 export class TsJestCompiler implements CompilerInstance {
   private readonly _compilerInstance: CompilerInstance
 
-  constructor(private readonly configSet: ConfigSet) {
+  constructor(readonly configSet: ConfigSet, readonly jestCacheFS: StringMap) {
     // Later we can add swc/esbuild or other typescript compiler instance here
-    this._compilerInstance = new TsCompiler(this.configSet)
+    this._compilerInstance = new TsCompiler(configSet, jestCacheFS)
   }
 
   getResolvedModulesMap(fileContent: string, fileName: string): ResolvedModulesMap {

src/compiler/ts-jest-compiler.ts

@@ -31,7 +31,7 @@ beforeEach(() => {
 describe('TsJestTransformer', () => {
   describe('_configsFor', () => {
     test('should return the same config set for same values with jest config string is not in configSetsIndex', () => {
-      const obj1 = { cwd: '/foo/.', rootDir: '/bar//dummy/..', globals: {} }
+      const obj1 = { config: { cwd: '/foo/.', rootDir: '/bar//dummy/..', globals: {} } }
       // @ts-expect-error testing purpose
       const cs3 = new TsJestTransformer()._configsFor(obj1 as any)
 
@@ -40,7 +40,7 @@ describe('TsJestTransformer', () => {
     })
 
     test('should return the same config set for same values with jest config string in configSetsIndex', () => {
-      const obj1 = { cwd: '/foo/.', rootDir: '/bar//dummy/..', globals: {} }
+      const obj1 = { config: { cwd: '/foo/.', rootDir: '/bar//dummy/..', globals: {} } }
       const obj2 = { ...obj1 }
       // @ts-expect-error testing purpose
       const cs1 = new TsJestTransformer()._configsFor(obj1 as any)
@@ -128,14 +128,25 @@ describe('TsJestTransformer', () => {
         rootDir: '/foo',
       },
     } as any
+    const transformOptionsWithCache = {
+      ...input.transformOptions,
+      config: {
+        ...input.transformOptions.config,
+        cache: true,
+        cacheDirectory: cacheDir,
+      },
+    }
     const depGraphs: ResolvedModulesMap = new Map<string, ResolvedModuleFull | undefined>()
 
     beforeEach(() => {
       depGraphs.clear()
+      // @ts-expect-error testing purpose
+      TsJestTransformer._cachedConfigSets = []
       tr = new TsJestTransformer()
     })
 
     afterEach(() => {
+      removeSync(cacheDir)
       jest.restoreAllMocks()
     })
 
@@ -165,8 +176,8 @@ describe('TsJestTransformer', () => {
       depGraphs.set(input.fileName, resolvedModule)
       jest.spyOn(TsJestCompiler.prototype, 'getResolvedModulesMap').mockReturnValueOnce(depGraphs)
 
-      const cacheKey1 = tr.getCacheKey(input.fileContent, input.fileName, input.transformOptions)
-      const cacheKey2 = tr.getCacheKey(input.fileContent, input.fileName, input.transformOptions)
+      const cacheKey1 = tr.getCacheKey(input.fileContent, input.fileName, transformOptionsWithCache)
+      const cacheKey2 = tr.getCacheKey(input.fileContent, input.fileName, transformOptionsWithCache)
 
       expect(cacheKey1).toEqual(cacheKey2)
       expect(TsJestCompiler.prototype.getResolvedModulesMap).toHaveBeenCalledTimes(1)
@@ -187,7 +198,7 @@ describe('TsJestTransformer', () => {
 
       jest.spyOn(TsJestCompiler.prototype, 'getResolvedModulesMap').mockReturnValueOnce(depGraphs)
       const tr1 = new TsJestTransformer()
-      const cacheKey2 = tr1.getCacheKey(input.fileContent, input.fileName, input.transformOptions)
+      const cacheKey2 = tr1.getCacheKey(input.fileContent, input.fileName, transformOptionsWithCache)
 
       expect(TsJestCompiler.prototype.getResolvedModulesMap).toHaveBeenCalledTimes(1)
       expect(TsJestCompiler.prototype.getResolvedModulesMap).toHaveBeenCalledWith(input.fileContent, input.fileName)
@@ -198,11 +209,11 @@ describe('TsJestTransformer', () => {
       depGraphs.set(input.fileName, resolvedModule)
       jest.spyOn(TsJestCompiler.prototype, 'getResolvedModulesMap').mockReturnValueOnce(depGraphs)
 
-      const cacheKey1 = tr.getCacheKey(input.fileContent, input.fileName, input.transformOptions)
+      const cacheKey1 = tr.getCacheKey(input.fileContent, input.fileName, transformOptionsWithCache)
 
       jest.spyOn(TsJestCompiler.prototype, 'getResolvedModulesMap').mockReturnValueOnce(depGraphs)
       const newFileContent = 'const foo = 1'
-      const cacheKey2 = tr.getCacheKey(newFileContent, input.fileName, input.transformOptions)
+      const cacheKey2 = tr.getCacheKey(newFileContent, input.fileName, transformOptionsWithCache)
 
       expect(cacheKey1).not.toEqual(cacheKey2)
       expect(TsJestCompiler.prototype.getResolvedModulesMap).toHaveBeenCalledTimes(2)
@@ -218,10 +229,10 @@ describe('TsJestTransformer', () => {
       depGraphs.set(input.fileName, resolvedModule)
       jest.spyOn(TsJestCompiler.prototype, 'getResolvedModulesMap').mockReturnValueOnce(depGraphs)
 
-      const cacheKey1 = tr.getCacheKey(input.fileContent, input.fileName, input.transformOptions)
+      const cacheKey1 = tr.getCacheKey(input.fileContent, input.fileName, transformOptionsWithCache)
 
       jest.spyOn(fs, 'existsSync').mockReturnValueOnce(false)
-      const cacheKey2 = tr.getCacheKey(input.fileContent, input.fileName, input.transformOptions)
+      const cacheKey2 = tr.getCacheKey(input.fileContent, input.fileName, transformOptionsWithCache)
 
       expect(cacheKey1).not.toEqual(cacheKey2)
       expect(TsJestCompiler.prototype.getResolvedModulesMap).toHaveBeenCalledTimes(1)

src/ts-jest-transformer.spec.ts

@@ -1,7 +1,7 @@
 import type { TransformedSource, Transformer, TransformOptions } from '@jest/transform'
 import type { Config } from '@jest/types'
 import type { Logger } from 'bs-logger'
-import { existsSync, readFileSync, statSync, writeFile } from 'fs'
+import { existsSync, readFileSync, statSync, writeFileSync } from 'fs'
 import mkdirp from 'mkdirp'
 import { join } from 'path'
 
@@ -53,9 +53,10 @@ export class TsJestTransformer implements Transformer {
     this._logger.debug('created new transformer')
   }
 
-  protected _configsFor(jestConfig: Config.ProjectConfig): ConfigSet {
+  protected _configsFor(transformOptions: TransformOptions): ConfigSet {
+    const { config, cacheFS } = transformOptions
     const ccs: CachedConfigSet | undefined = TsJestTransformer._cachedConfigSets.find(
-      (cs) => cs.jestConfig.value === jestConfig,
+      (cs) => cs.jestConfig.value === config,
     )
     let configSet: ConfigSet
     if (ccs) {
@@ -64,24 +65,24 @@ export class TsJestTransformer implements Transformer {
       configSet = ccs.configSet
     } else {
       // try to look-it up by stringified version
-      const serializedJestCfg = stringify(jestConfig)
+      const serializedJestCfg = stringify(config)
       const serializedCcs = TsJestTransformer._cachedConfigSets.find(
         (cs) => cs.jestConfig.serialized === serializedJestCfg,
       )
       if (serializedCcs) {
         // update the object so that we can find it later
         // this happens because jest first calls getCacheKey with stringified version of
         // the config, and then it calls the transformer with the proper object
-        serializedCcs.jestConfig.value = jestConfig
+        serializedCcs.jestConfig.value = config
         this._transformCfgStr = serializedCcs.transformerCfgStr
         this._compiler = serializedCcs.compiler
         configSet = serializedCcs.configSet
       } else {
         // create the new record in the index
         this._logger.info('no matching config-set found, creating a new one')
 
-        configSet = new ConfigSet(jestConfig)
-        const jest = { ...jestConfig }
+        configSet = new ConfigSet(config)
+        const jest = { ...config }
         // we need to remove some stuff from jest config
         // this which does not depend on config
         jest.name = undefined as any
@@ -95,9 +96,9 @@ export class TsJestTransformer implements Transformer {
             raw: configSet.parsedTsConfig.raw,
           },
         }).serialized
-        this._compiler = new TsJestCompiler(configSet)
+        this._compiler = new TsJestCompiler(configSet, cacheFS)
         TsJestTransformer._cachedConfigSets.push({
-          jestConfig: new JsonableValue(jestConfig),
+          jestConfig: new JsonableValue(config),
           configSet,
           transformerCfgStr: this._transformCfgStr,
           compiler: this._compiler,
@@ -117,7 +118,7 @@ export class TsJestTransformer implements Transformer {
 
     let result: string | TransformedSource
     const jestConfig = transformOptions.config
-    const configs = this._configsFor(jestConfig)
+    const configs = this._configsFor(transformOptions)
     const { hooks } = configs
     const shouldStringifyContent = configs.shouldStringifyContent(filePath)
     const babelJest = shouldStringifyContent ? undefined : configs.babelJestTransformer
@@ -177,7 +178,7 @@ export class TsJestTransformer implements Transformer {
    * @public
    */
   getCacheKey(fileContent: string, filePath: string, transformOptions: TransformOptions): string {
-    const configs = this._configsFor(transformOptions.config)
+    const configs = this._configsFor(transformOptions)
 
     this._logger.debug({ fileName: filePath, transformOptions }, 'computing cache key for', filePath)
 
@@ -194,7 +195,7 @@ export class TsJestTransformer implements Transformer {
       CACHE_KEY_EL_SEPARATOR,
       filePath,
     ]
-    if (!configs.isolatedModules) {
+    if (!configs.isolatedModules && this._tsResolvedModulesCachePath) {
       let resolvedModuleNames: string[]
       if (this._depGraphs.get(filePath)?.fileContent === fileContent) {
         this._logger.debug(
@@ -225,14 +226,7 @@ export class TsJestTransformer implements Transformer {
           fileContent,
           resolveModuleNames: resolvedModuleNames,
         })
-        /* istanbul ignore next */
-        if (this._tsResolvedModulesCachePath) {
-          // Cache resolved modules to disk so next run can reuse it
-          void (async () => {
-            // eslint-disable-next-line @typescript-eslint/await-thenable
-            await writeFile(this._tsResolvedModulesCachePath as string, stringify([...this._depGraphs]), () => {})
-          })()
-        }
+        writeFileSync(this._tsResolvedModulesCachePath, stringify([...this._depGraphs]))
       }
       resolvedModuleNames.forEach((moduleName) => {
         constructingCacheKeyElements.push(

src/ts-jest-transformer.ts

@@ -173,6 +173,10 @@ export interface TsJestConfig {
 }
 
 export type ResolvedModulesMap = Map<string, _ts.ResolvedModuleFull | undefined> | undefined
+/**
+ * @internal
+ */
+export type StringMap = Map<string, string>
 
 export interface CompilerInstance {
   getResolvedModulesMap(fileContent: string, fileName: string): ResolvedModulesMap