test: test against the new version of resolver design

Author: SukkaW

src/types.ts

@@ -4,26 +4,29 @@ import type { MinimatchOptions } from 'minimatch'
 import type { KebabCase } from 'type-fest'
 
 import type { ImportType as ImportType_, PluginName } from './utils'
-import type { LegacyImportResolver, LegacyResolver } from './utils/legacy-resolver-settings'
+import type {
+  LegacyImportResolver,
+  LegacyResolver,
+} from './utils/legacy-resolver-settings'
 
 export type {
   LegacyResolver,
-
+  // ResolverName
   LegacyResolverName,
   LegacyResolverName as ResolverName,
-
+  // ImportResolver
   LegacyImportResolver,
   LegacyImportResolver as ImportResolver,
-
+  // ResolverResolve
   LegacyResolverResolve,
   LegacyResolverResolve as ResolverResolve,
-
+  // ResolverResolveImport
   LegacyResolverResolveImport,
   LegacyResolverResolveImport as ResolverResolveImport,
-
+  // ResolverRecord
   LegacyResolverRecord,
   LegacyResolverRecord as ResolverRecord,
-
+  // ResolverObject
   LegacyResolverObject,
   LegacyResolverObject as ResolverObject,
 } from './utils/legacy-resolver-settings'
@@ -57,10 +60,10 @@ export type NewResolverResolve = (
 
 // TODO: remove prefix New in the next major version
 export type NewResolver = {
-  interfaceVersion: 3,
+  interfaceVersion: 3
   /** optional name for the resolver, this is used in logs/debug output */
-  name?: string,
-  resolve: NewResolverResolve,
+  name?: string
+  resolve: NewResolverResolve
 }
 
 export type FileExtension = `.${string}`
@@ -96,6 +99,7 @@ export type ImportSettings = {
   parsers?: Record<string, readonly FileExtension[]>
   resolve?: NodeResolverOptions
   resolver?: LegacyImportResolver
+  'resolver-legacy'?: LegacyImportResolver
   'resolver-next'?: NewResolver[]
 }
 

src/utils/legacy-resolver-settings.ts

@@ -1,12 +1,19 @@
 // Although the new import resolver settings is still `import-x/resolver-next`, but it won't stop us from calling existing ones legacy~
 
-import type { LiteralUnion } from "type-fest"
-
 import { createRequire } from 'node:module'
-import type { NodeResolverOptions, ResolvedResult, TsResolverOptions, WebpackResolverOptions } from "../types"
-import path from "path"
-import { IMPORT_RESOLVE_ERROR_NAME } from "./resolve"
+import path from 'node:path'
+
+import type { LiteralUnion } from 'type-fest'
+
+import type {
+  NodeResolverOptions,
+  ResolvedResult,
+  TsResolverOptions,
+  WebpackResolverOptions,
+} from '../types'
+
 import { pkgDir } from './pkg-dir'
+import { IMPORT_RESOLVE_ERROR_NAME } from './resolve'
 
 export type LegacyResolverName = LiteralUnion<
   'node' | 'typescript' | 'webpack',
@@ -40,10 +47,10 @@ export type LegacyResolverObject = {
 
   // Options passed to the resolver
   options?:
-  | NodeResolverOptions
-  | TsResolverOptions
-  | WebpackResolverOptions
-  | unknown
+    | NodeResolverOptions
+    | TsResolverOptions
+    | WebpackResolverOptions
+    | unknown
 
   // Any object satisfied Resolver type
   resolver: LegacyResolver
@@ -62,9 +69,14 @@ export type LegacyImportResolver =
   | LegacyResolverObject
   | LegacyResolverName[]
   | LegacyResolverRecord[]
-  | LegacyResolverObject[];
+  | LegacyResolverObject[]
 
-export function resolveWithLegacyResolver(resolver: LegacyResolver, config: unknown, modulePath: string, sourceFile: string): ResolvedResult {
+export function resolveWithLegacyResolver(
+  resolver: LegacyResolver,
+  config: unknown,
+  modulePath: string,
+  sourceFile: string,
+): ResolvedResult {
   if (resolver.interfaceVersion === 2) {
     return resolver.resolve(modulePath, sourceFile, config)
   }
@@ -202,7 +214,6 @@ function tryRequire<T>(
   return require(resolved)
 }
 
-
 function getBaseDir(sourceFile: string): string {
   return pkgDir(sourceFile) || process.cwd()
 }

src/utils/resolve.ts

@@ -5,15 +5,16 @@ import stableHash from 'stable-hash'
 
 import type {
   ImportSettings,
+  NewResolver,
   PluginSettings,
   RuleContext,
-  Resolver,
-  LegacyResolver,
-  ResolvedResult,
 } from '../types'
 
+import {
+  normalizeConfigResolvers,
+  resolveWithLegacyResolver,
+} from './legacy-resolver-settings'
 import { ModuleCache } from './module-cache'
-import { normalizeConfigResolvers, resolveWithLegacyResolver } from './legacy-resolver-settings'
 
 export const CASE_SENSITIVE_FS = !fs.existsSync(
   path.resolve(
@@ -26,7 +27,6 @@ export const IMPORT_RESOLVE_ERROR_NAME = 'EslintPluginImportResolveError'
 
 export const fileExistsCache = new ModuleCache()
 
-
 // https://stackoverflow.com/a/27382838
 export function fileExistsWithCaseSync(
   filepath: string | null,
@@ -69,6 +69,38 @@ export function fileExistsWithCaseSync(
 let prevSettings: PluginSettings | null = null
 let memoizedHash: string
 
+function isNamedResolver(resolver: unknown): resolver is { name: string } {
+  return !!(
+    typeof resolver === 'object' &&
+    resolver &&
+    'name' in resolver &&
+    typeof resolver.name === 'string'
+  )
+}
+
+function isValidNewResolver(resolver: unknown): resolver is NewResolver {
+  if (typeof resolver !== 'object' || resolver == null) {
+    return false
+  }
+
+  if (!('resolve' in resolver) || !('interfaceVersion' in resolver)) {
+    return false
+  }
+
+  if (
+    typeof resolver.interfaceVersion !== 'number' ||
+    resolver.interfaceVersion !== 3
+  ) {
+    return false
+  }
+
+  if (typeof resolver.resolve !== 'function') {
+    return false
+  }
+
+  return true
+}
+
 function fullResolve(
   modulePath: string,
   sourceFile: string,
@@ -99,10 +131,24 @@ function fullResolve(
     return { found: true, path: cachedPath }
   }
 
-  if (Object.prototype.hasOwnProperty.call(settings, 'import-x/resolver-next') && settings['import-x/resolver-next']) {
+  if (
+    Object.prototype.hasOwnProperty.call(settings, 'import-x/resolver-next') &&
+    settings['import-x/resolver-next']
+  ) {
     const configResolvers = settings['import-x/resolver-next']
 
-    for (const resolver of configResolvers) {
+    for (let i = 0, len = configResolvers.length; i < len; i++) {
+      const resolver = configResolvers[i]
+      const resolverName = isNamedResolver(resolver)
+        ? resolver.name
+        : `settings['import-x/resolver-next'][${i}]`
+
+      if (!isValidNewResolver(resolver)) {
+        const err = new TypeError(`${resolverName} is not a valid import resolver for eslint-plugin-import-x!`)
+        err.name = IMPORT_RESOLVE_ERROR_NAME
+        throw err
+      }
+
       const resolved = resolver.resolve(modulePath, sourceFile)
       if (!resolved.found) {
         continue
@@ -113,16 +159,25 @@ function fullResolve(
       return resolved
     }
   } else {
-    const configResolvers = settings['import-x/resolver'] || {
-      node: settings['import-x/resolve'],
-    } // backward compatibility
-
-    for (const { enable, options, resolver } of normalizeConfigResolvers(configResolvers, sourceFile)) {
+    const configResolvers = settings['import-x/resolver-legacy'] ||
+      settings['import-x/resolver'] || {
+        node: settings['import-x/resolve'],
+      } // backward compatibility
+
+    for (const { enable, options, resolver } of normalizeConfigResolvers(
+      configResolvers,
+      sourceFile,
+    )) {
       if (!enable) {
         continue
       }
 
-      const resolved = resolveWithLegacyResolver(resolver, options, modulePath, sourceFile)
+      const resolved = resolveWithLegacyResolver(
+        resolver,
+        options,
+        modulePath,
+        sourceFile,
+      )
       if (!resolved.found) {
         continue
       }
@@ -178,5 +233,3 @@ export function resolve(p: string, context: RuleContext) {
     }
   }
 }
-
-

test/fixtures/foo-bar-resolver-v3.js

@@ -0,0 +1,16 @@
+var path = require('path')
+
+exports.foobarResolver = (/** @type {import('eslint-plugin-import-x/types').NewResolver} */ {
+  name: 'resolver-foo-bar',
+  interfaceVersion: 3,
+  resolve: function (modulePath, sourceFile) {
+    var sourceFileName = path.basename(sourceFile)
+    if (sourceFileName === 'foo.js') {
+      return { found: true, path: path.join(__dirname, 'bar.jsx') }
+    }
+    if (sourceFileName === 'exception.js') {
+      throw new Error('foo-bar-resolver-v3 resolve test exception')
+    }
+    return { found: false }
+  }
+})