fix: take context.cwd into account for cache key (#388)

Author: JounQin

.changeset/major-apples-invent.md

@@ -0,0 +1,5 @@
+---
+"eslint-plugin-import-x": patch
+---
+
+fix: take `context.cwd` into account for cache key

src/node-resolver.ts

@@ -1,4 +1,4 @@
-import module from 'node:module'
+import { isBuiltin } from 'node:module'
 import path from 'node:path'
 
 import { ResolverFactory } from 'unrs-resolver'
@@ -25,11 +25,7 @@ export function createNodeResolver({
     interfaceVersion: 3,
     name: 'eslint-plugin-import-x:node',
     resolve(modulePath, sourceFile) {
-      if (module.isBuiltin(modulePath)) {
-        return { found: true, path: null }
-      }
-
-      if (modulePath.startsWith('data:')) {
+      if (isBuiltin(modulePath) || modulePath.startsWith('data:')) {
         return { found: true, path: null }
       }
 
@@ -38,10 +34,10 @@ export function createNodeResolver({
         if (resolved.path) {
           return { found: true, path: resolved.path }
         }
-        return { found: false }
       } catch {
-        return { found: false }
+        //
       }
+      return { found: false }
     },
   }
 }

src/types.ts

@@ -1,5 +1,9 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils'
-import type { PluginName, PluginSettings } from 'eslint-import-context'
+import type {
+  ImportSettings,
+  PluginName,
+  PluginSettings,
+} from 'eslint-import-context'
 import type { MinimatchOptions } from 'minimatch'
 
 import type { ImportType as ImportType_ } from './utils/index.js'
@@ -159,3 +163,8 @@ export interface CjsRequire extends NodeJS.Require {
 
 export type SetValue<T extends Set<unknown>> =
   T extends Set<infer U> ? U : never
+
+export interface NormalizedCacheSettings
+  extends NonNullable<ImportSettings['cache']> {
+  lifetime: number
+}

src/utils/export-map.ts

@@ -1105,36 +1105,52 @@ function childContext(
   path: string,
   context: RuleContext | ChildContext,
 ): ChildContext {
-  const { settings, parserOptions, parserPath, languageOptions } = context
+  const {
+    settings,
+    parserOptions,
+    parserPath,
+    languageOptions,
+    cwd,
+    filename,
+    physicalFilename,
+  } = context
 
   return {
-    cacheKey: makeContextCacheKey(context) + path,
+    cacheKey: makeContextCacheKey(context) + '\0' + path,
     settings,
     parserOptions,
     parserPath,
     languageOptions,
     path,
-    cwd: context.cwd,
-    filename: context.filename,
-    physicalFilename: context.physicalFilename,
+    cwd,
+    filename,
+    physicalFilename,
   }
 }
 
 export function makeContextCacheKey(context: RuleContext | ChildContext) {
-  const { settings, parserPath, parserOptions, languageOptions } = context
+  const { settings, parserPath, parserOptions, languageOptions, cwd } = context
 
   let hash =
+    cwd +
+    '\0' +
     stableHash(settings) +
+    '\0' +
     stableHash(languageOptions?.parserOptions ?? parserOptions)
 
   if (languageOptions) {
     hash +=
-      String(languageOptions.ecmaVersion) + String(languageOptions.sourceType)
+      '\0' +
+      String(languageOptions.ecmaVersion) +
+      '\0' +
+      String(languageOptions.sourceType)
   }
 
-  hash += stableHash(
-    parserPath ?? languageOptions?.parser?.meta ?? languageOptions?.parser,
-  )
+  hash +=
+    '\0' +
+    stableHash(
+      parserPath ?? languageOptions?.parser?.meta ?? languageOptions?.parser,
+    )
 
   return hash
 }

src/utils/module-cache.ts

@@ -1,20 +1,18 @@
 import debug from 'debug'
 
-import type { ImportSettings, PluginSettings } from '../types.js'
+import type { NormalizedCacheSettings, PluginSettings } from '../types.js'
 
 const log = debug('eslint-plugin-import-x:utils:ModuleCache')
 
-export type CacheKey = unknown
-
 export interface CacheObject {
   result: unknown
   lastSeen: ReturnType<typeof process.hrtime>
 }
 
 export class ModuleCache {
-  constructor(public map: Map<CacheKey, CacheObject> = new Map()) {}
+  constructor(public map: Map<string, CacheObject> = new Map()) {}
 
-  set(cacheKey: CacheKey, result: unknown) {
+  set(cacheKey: string, result: unknown) {
     this.map.set(cacheKey, {
       result,
       lastSeen: process.hrtime(),
@@ -23,13 +21,12 @@ export class ModuleCache {
     return result
   }
 
-  get<T>(cacheKey: CacheKey, settings: ImportSettings['cache']): T | undefined {
-    if (this.map.has(cacheKey)) {
-      const f = this.map.get(cacheKey)
+  get<T>(cacheKey: string, settings: NormalizedCacheSettings): T | undefined {
+    const cache = this.map.get(cacheKey)
+    if (cache) {
       // check freshness
-      // @ts-expect-error TS can't narrow properly from `has` and `get`
-      if (process.hrtime(f.lastSeen)[0] < settings.lifetime) {
-        return f!.result as T
+      if (process.hrtime(cache.lastSeen)[0] < settings.lifetime) {
+        return cache.result as T
       }
     } else {
       log('cache miss for', cacheKey)
@@ -51,8 +48,6 @@ export class ModuleCache {
       cacheSettings.lifetime = Number.POSITIVE_INFINITY
     }
 
-    return cacheSettings as ImportSettings['cache'] & {
-      lifetime: number
-    }
+    return cacheSettings as NormalizedCacheSettings
   }
 }

src/utils/resolve.ts

@@ -9,10 +9,10 @@ import { createNodeResolver } from '../node-resolver.js'
 import { cjsRequire } from '../require.js'
 import type {
   ChildContext,
-  ImportSettings,
   LegacyResolver,
   NewResolver,
   NodeResolverOptions,
+  NormalizedCacheSettings,
   PluginSettings,
   RuleContext,
 } from '../types.js'
@@ -47,7 +47,7 @@ export const fileExistsCache = new ModuleCache()
 // https://stackoverflow.com/a/27382838
 export function fileExistsWithCaseSync(
   filepath: string | null,
-  cacheSettings?: ImportSettings['cache'],
+  cacheSettings: NormalizedCacheSettings,
   strict?: boolean,
 ): boolean {
   // don't care if the FS is case-sensitive

test/utils/resolve.spec.ts

@@ -9,7 +9,11 @@ import type { TSESLint } from '@typescript-eslint/utils'
 import { testContext, testFilePath } from '../utils.js'
 
 import { importXResolverCompat } from 'eslint-plugin-import-x'
-import type { CjsRequire, NewResolver } from 'eslint-plugin-import-x'
+import type {
+  CjsRequire,
+  NewResolver,
+  NormalizedCacheSettings,
+} from 'eslint-plugin-import-x'
 import {
   CASE_SENSITIVE_FS,
   fileExistsWithCaseSync,
@@ -450,7 +454,9 @@ describe('resolve', () => {
       'import-x/cache': { lifetime: 0 },
     })
 
-    const cacheSettings = context.settings['import-x/cache']
+    const cacheSettings = context.settings[
+      'import-x/cache'
+    ] as NormalizedCacheSettings
 
     const file = resolve(
       // Note the case difference 'MyUncoolComponent' vs 'MyUnCoolComponent'