@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.1

package/dist/es2019/rules/import/no-barrel-entry-imports/index.js

@@ -2,7 +2,7 @@ import { dirname } from 'path';
 import { parseBarrelExports } from '../shared/barrel-parsing';
 import { DEFAULT_TARGET_FOLDERS, findWorkspaceRoot, isRelativeImport } from '../shared/file-system';
 import { findPackageInRegistry, isPackageInApplyToImportsFrom } from '../shared/package-registry';
-import { findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
+import { findCrossPackageBridgeExportPath, findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
 import { realFileSystem } from '../shared/types';
 
 /**
@@ -33,6 +33,10 @@ const ruleMeta = {
           type: 'string'
         },
         description: 'The folder paths (relative to workspace root) containing packages whose imports will be checked and autofixed.'
+      },
+      preferImportedPackageSubpath: {
+        type: 'boolean',
+        description: 'Prefer subpaths on the imported barrel package when they bridge to the dependency (e.g. @scope/pkg/subpath instead of @scope/dependency).'
       }
     },
     additionalProperties: false
@@ -110,20 +114,15 @@ function buildImportStatement({
  */
 
 /**
- * Resolves import context for barrel file analysis.
+ * Resolves import context for barrel file analysis from a module specifier string.
  * Returns null if the import should not be processed (relative import, not in target folder, etc.)
  */
-function resolveImportContext({
-  node,
+function resolveImportContextFromModulePath({
+  importPath,
   workspaceRoot,
   fs,
   applyToImportsFrom
 }) {
-  if (!node.source || typeof node.source.value !== 'string') {
-    return null;
-  }
-  const importPath = node.source.value;
-
   // Skip relative imports - this rule is for cross-package imports
   if (isRelativeImport(importPath)) {
     return null;
@@ -197,6 +196,27 @@ function resolveImportContext({
   };
 }
 
+/**
+ * Resolves import context for barrel file analysis.
+ * Returns null if the import should not be processed (relative import, not in target folder, etc.)
+ */
+function resolveImportContext({
+  node,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  if (!node.source || typeof node.source.value !== 'string') {
+    return null;
+  }
+  return resolveImportContextFromModulePath({
+    importPath: node.source.value,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+}
+
 /**
  * Classifies import specifiers by their target export paths.
  * Groups specifiers that can be remapped to more specific exports.
@@ -206,12 +226,14 @@ function classifySpecifiers({
   node,
   importContext,
   workspaceRoot,
-  fs
+  fs,
+  preferImportedPackageSubpath
 }) {
   const {
     currentExportPath,
     exportsMap,
-    exportMap
+    exportMap,
+    packageName: importedPackageName
   } = importContext;
   const specifiers = node.specifiers;
   const specifiersByTarget = new Map();
@@ -229,6 +251,7 @@ function classifySpecifiers({
     let kind = 'value';
     if (spec.type === 'ImportDefaultSpecifier') {
       nameInSource = 'default';
+      kind = node.importKind === 'type' ? 'type' : 'value';
     } else if (spec.type === 'ImportSpecifier') {
       nameInSource = getImportedName(spec);
       const parentImportKind = node.importKind;
@@ -238,12 +261,43 @@ function classifySpecifiers({
     }
     const exportInfo = exportMap.get(nameInSource);
     if (exportInfo) {
-      var _exportInfo$crossPack;
+      var _exportInfo$crossPack, _exportInfo$originalN2, _matchResult$exportPa2;
       const effectiveKind = kind === 'type' || exportInfo.isTypeOnly ? 'type' : 'value';
 
       // Check if this is a cross-package re-export
       const sourcePackageName = (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
       if (sourcePackageName) {
+        let targetKey;
+        let resolvedOriginalName = exportInfo.originalName;
+        if (preferImportedPackageSubpath) {
+          const bridge = findCrossPackageBridgeExportPath({
+            exportsMap,
+            crossPackageName: sourcePackageName,
+            exportedName: nameInSource,
+            fs
+          });
+          if (bridge) {
+            targetKey = importedPackageName + bridge.exportPath.slice(1);
+            if (bridge.entryPointExportName !== undefined) {
+              resolvedOriginalName = bridge.entryPointExportName === nameInSource ? undefined : bridge.entryPointExportName;
+            }
+            if (!specifiersByTarget.has(targetKey)) {
+              specifiersByTarget.set(targetKey, []);
+            }
+            specifiersByTarget.get(targetKey).push({
+              spec: {
+                ...spec,
+                importKind: effectiveKind
+              },
+              originalName: resolvedOriginalName,
+              targetExportPath: targetKey,
+              kind: effectiveKind,
+              sourcePackageName
+            });
+            continue;
+          }
+        }
+
         // For cross-package re-exports, find the most specific subpath in the source package
         // Note: Package resolution is not constrained by applyToImportsFrom - any package can be resolved
         let sourcePackageExportsMap = sourcePackageExportsMaps.get(sourcePackageName);
@@ -265,14 +319,22 @@ function classifySpecifiers({
         // Find the best export path in the source package
         let targetExportPath = null;
         if (sourcePackageExportsMap) {
-          targetExportPath = findExportForSourceFile({
+          var _exportInfo$originalN, _matchResult$exportPa;
+          const sourceExportName = (_exportInfo$originalN = exportInfo.originalName) !== null && _exportInfo$originalN !== void 0 ? _exportInfo$originalN : nameInSource;
+          const matchResult = findExportForSourceFile({
             sourceFilePath: exportInfo.path,
-            exportsMap: sourcePackageExportsMap
+            exportsMap: sourcePackageExportsMap,
+            fs,
+            sourceExportName
           });
+          targetExportPath = (_matchResult$exportPa = matchResult === null || matchResult === void 0 ? void 0 : matchResult.exportPath) !== null && _matchResult$exportPa !== void 0 ? _matchResult$exportPa : null;
+          if ((matchResult === null || matchResult === void 0 ? void 0 : matchResult.entryPointExportName) !== undefined) {
+            resolvedOriginalName = matchResult.entryPointExportName === nameInSource ? undefined : matchResult.entryPointExportName;
+          }
         }
 
         // Build the full import path: @package/subpath or just @package if no subpath found
-        const targetKey = targetExportPath ? sourcePackageName + targetExportPath.slice(1) // Remove leading '.' from subpath
+        targetKey = targetExportPath ? sourcePackageName + targetExportPath.slice(1) // Remove leading '.' from subpath
         : sourcePackageName;
         if (!specifiersByTarget.has(targetKey)) {
           specifiersByTarget.set(targetKey, []);
@@ -282,7 +344,7 @@ function classifySpecifiers({
             ...spec,
             importKind: effectiveKind
           },
-          originalName: exportInfo.originalName,
+          originalName: resolvedOriginalName,
           targetExportPath: targetKey,
           kind: effectiveKind,
           sourcePackageName
@@ -291,10 +353,18 @@ function classifySpecifiers({
       }
 
       // Find if there's a package.json export that points to this source file
-      const targetExportPath = findExportForSourceFile({
+      const sourceExportName = (_exportInfo$originalN2 = exportInfo.originalName) !== null && _exportInfo$originalN2 !== void 0 ? _exportInfo$originalN2 : nameInSource;
+      const matchResult = findExportForSourceFile({
         sourceFilePath: exportInfo.path,
-        exportsMap
+        exportsMap,
+        fs,
+        sourceExportName
       });
+      const targetExportPath = (_matchResult$exportPa2 = matchResult === null || matchResult === void 0 ? void 0 : matchResult.exportPath) !== null && _matchResult$exportPa2 !== void 0 ? _matchResult$exportPa2 : null;
+      let resolvedOriginalName2 = exportInfo.originalName;
+      if ((matchResult === null || matchResult === void 0 ? void 0 : matchResult.entryPointExportName) !== undefined) {
+        resolvedOriginalName2 = matchResult.entryPointExportName === nameInSource ? undefined : matchResult.entryPointExportName;
+      }
 
       // Get the file that the current export path resolves to
       const currentExportResolvedFile = exportsMap.get(currentExportPath);
@@ -314,7 +384,7 @@ function classifySpecifiers({
             ...spec,
             importKind: effectiveKind
           },
-          originalName: exportInfo.originalName,
+          originalName: resolvedOriginalName2,
           targetExportPath,
           kind: effectiveKind
         });
@@ -619,7 +689,8 @@ function createBarrelImportFix({
       }
     } else {
       // Create new import
-      const isTypeImport = node.importKind === 'type';
+      const allSpecsAreType = specsWithTarget.every(s => s.kind === 'type');
+      const isTypeImport = node.importKind === 'type' || allSpecsAreType;
       const importStatement = buildImportStatement({
         specs,
         path: newImportPath,
@@ -635,7 +706,8 @@ function createBarrelImportFix({
   // Handle unmapped specifiers - they stay in the original import
   if (unmappedSpecifiers.length > 0) {
     const unmappedSpecs = unmappedSpecifiers.map(u => u.spec);
-    const isTypeImport = node.importKind === 'type';
+    const allUnmappedAreType = unmappedSpecifiers.every(u => u.kind === 'type');
+    const isTypeImport = node.importKind === 'type' || allUnmappedAreType;
     const remainingImport = buildImportStatement({
       specs: unmappedSpecs,
       path: importPath,
@@ -686,6 +758,316 @@ function createBarrelImportFix({
   }
   return fixes;
 }
+function isPlainRequireCall(node) {
+  if (node.callee.type !== 'Identifier' || node.callee.name !== 'require') {
+    return false;
+  }
+  if (node.arguments.length !== 1) {
+    return false;
+  }
+  const arg = node.arguments[0];
+  return arg.type === 'Literal' && typeof arg.value === 'string';
+}
+function unwrapToRequireCall(expr) {
+  let e = expr;
+  for (;;) {
+    const wrapped = e;
+    if (wrapped.type !== 'ParenthesizedExpression' || !wrapped.expression) {
+      break;
+    }
+    e = wrapped.expression;
+  }
+  if (e.type !== 'CallExpression' || !isPlainRequireCall(e)) {
+    return null;
+  }
+  return e;
+}
+function buildSyntheticImportFromRequireAccess(exportPropertyName, modulePath) {
+  const specifiers = exportPropertyName === 'default' ? [{
+    type: 'ImportDefaultSpecifier',
+    local: {
+      type: 'Identifier',
+      name: '_r'
+    }
+  }] : [{
+    type: 'ImportSpecifier',
+    imported: {
+      type: 'Identifier',
+      name: exportPropertyName
+    },
+    local: {
+      type: 'Identifier',
+      name: exportPropertyName
+    }
+  }];
+  return {
+    type: 'ImportDeclaration',
+    source: {
+      type: 'Literal',
+      value: modulePath,
+      raw: `'${modulePath}'`
+    },
+    specifiers,
+    importKind: 'value'
+  };
+}
+function fullNewImportPathForTarget(targetKey, specsWithTarget, packageName) {
+  const isCrossPackage = specsWithTarget.some(s => s.sourcePackageName);
+  return isCrossPackage ? targetKey : packageName + targetKey.slice(1);
+}
+function getRhsPropertyAfterTransform(spec) {
+  if (spec.type === 'ImportDefaultSpecifier') {
+    return 'default';
+  }
+  return getImportedName(spec);
+}
+function appendAutomockFixesForPathMigration({
+  fixer,
+  sourceCode,
+  oldBarrelPath,
+  newPaths
+}) {
+  const automocks = findMatchingAutomocks({
+    sourceCode,
+    importPath: oldBarrelPath
+  });
+  if (automocks.length === 0 || newPaths.length === 0) {
+    return [];
+  }
+  const fixes = [];
+  for (const automock of automocks) {
+    const newAutomockStatements = newPaths.map(path => buildAutomockStatement({
+      path,
+      quoteChar: automock.quoteChar
+    }));
+    fixes.push(fixer.replaceTextRange(automock.statementNode.range, newAutomockStatements.join('\n')));
+  }
+  return fixes;
+}
+
+/**
+ * `require('barrel').default` or `require('barrel').namedExport`
+ */
+function handleRequireMemberExpression({
+  node,
+  context,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom,
+  preferImportedPackageSubpath
+}) {
+  if (node.computed || node.property.type !== 'Identifier') {
+    return;
+  }
+  const reqCall = unwrapToRequireCall(node.object);
+  if (!reqCall) {
+    return;
+  }
+  const modulePath = reqCall.arguments[0].value;
+  const importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  const exportPropertyName = node.property.name;
+  const synthetic = buildSyntheticImportFromRequireAccess(exportPropertyName, modulePath);
+  const {
+    specifiersByTarget,
+    hasNamespaceImport
+  } = classifySpecifiers({
+    node: synthetic,
+    importContext,
+    workspaceRoot,
+    fs,
+    preferImportedPackageSubpath
+  });
+  if (hasNamespaceImport || specifiersByTarget.size === 0) {
+    return;
+  }
+  const entries = [...specifiersByTarget.entries()];
+  if (entries.length !== 1) {
+    return;
+  }
+  const [targetKey, specsWithTarget] = entries[0];
+  if (specsWithTarget.length !== 1) {
+    return;
+  }
+  const st = specsWithTarget[0];
+  const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, importContext.packageName);
+  const transformed = transformSpecifierForExport({
+    spec: st.spec,
+    originalName: st.originalName,
+    kind: st.kind
+  });
+  const newRhs = getRhsPropertyAfterTransform(transformed);
+  const sourceCode = context.getSourceCode();
+  const quote = sourceCode.getText(reqCall.arguments[0])[0];
+  context.report({
+    node: node,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix(fixer) {
+      const fixes = [];
+      fixes.push(fixer.replaceText(node, `require(${quote}${newImportPath}${quote}).${newRhs}`));
+      if (st.kind === 'value') {
+        fixes.push(...appendAutomockFixesForPathMigration({
+          fixer,
+          sourceCode,
+          oldBarrelPath: modulePath,
+          newPaths: [newImportPath]
+        }));
+      }
+      return fixes;
+    }
+  });
+}
+
+/**
+ * `const { a, b } = require('barrel')`
+ */
+function handleRequireDestructuringDeclarator({
+  node,
+  context,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom,
+  preferImportedPackageSubpath
+}) {
+  if (node.id.type !== 'ObjectPattern' || !node.init || node.init.type !== 'CallExpression') {
+    return;
+  }
+  const initCall = node.init;
+  if (!isPlainRequireCall(initCall)) {
+    return;
+  }
+  const modulePath = initCall.arguments[0].value;
+  const importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  const specifiers = [];
+  for (const prop of node.id.properties) {
+    if (prop.type !== 'Property' || prop.computed) {
+      continue;
+    }
+    if (prop.key.type !== 'Identifier' || prop.value.type !== 'Identifier') {
+      continue;
+    }
+    const importedName = prop.key.name;
+    const localName = prop.value.name;
+    specifiers.push({
+      type: 'ImportSpecifier',
+      imported: {
+        type: 'Identifier',
+        name: importedName
+      },
+      local: {
+        type: 'Identifier',
+        name: localName
+      }
+    });
+  }
+  if (specifiers.length === 0) {
+    return;
+  }
+  const synthetic = {
+    type: 'ImportDeclaration',
+    source: {
+      type: 'Literal',
+      value: modulePath,
+      raw: `'${modulePath}'`
+    },
+    specifiers,
+    importKind: 'value'
+  };
+  const {
+    specifiersByTarget,
+    unmappedSpecifiers,
+    hasNamespaceImport
+  } = classifySpecifiers({
+    node: synthetic,
+    importContext,
+    workspaceRoot,
+    fs,
+    preferImportedPackageSubpath
+  });
+  if (hasNamespaceImport || specifiersByTarget.size === 0 || unmappedSpecifiers.length > 0) {
+    return;
+  }
+  const parentDecl = node.parent;
+  if (parentDecl.type !== 'VariableDeclaration') {
+    return;
+  }
+  if (specifiersByTarget.size > 1 && parentDecl.declarations.length !== 1) {
+    return;
+  }
+  const sourceCode = context.getSourceCode();
+  const quote = sourceCode.getText(initCall.arguments[0])[0];
+  const pkg = importContext.packageName;
+  const buildFixes = fixer => {
+    const fixes = [];
+    let hasValue = false;
+    const automockPaths = [];
+    if (specifiersByTarget.size === 1) {
+      const [targetKey, specsWithTarget] = [...specifiersByTarget.entries()][0];
+      const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, pkg);
+      if (specsWithTarget.some(s => s.kind === 'value')) {
+        hasValue = true;
+        automockPaths.push(newImportPath);
+      }
+      fixes.push(fixer.replaceText(initCall.arguments[0], `${quote}${newImportPath}${quote}`));
+    } else {
+      const lines = [];
+      for (const [targetKey, specsWithTarget] of specifiersByTarget) {
+        const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, pkg);
+        if (specsWithTarget.some(s => s.kind === 'value')) {
+          hasValue = true;
+          automockPaths.push(newImportPath);
+        }
+        for (const st of specsWithTarget) {
+          const transformed = transformSpecifierForExport({
+            spec: st.spec,
+            originalName: st.originalName,
+            kind: st.kind
+          });
+          const rhs = getRhsPropertyAfterTransform(transformed);
+          const local = st.spec.local.name;
+          lines.push(`${local} = require(${quote}${newImportPath}${quote}).${rhs}`);
+        }
+      }
+      const declText = lines.map(l => `${parentDecl.kind} ${l};`).join('\n');
+      fixes.push(fixer.replaceText(parentDecl, declText));
+    }
+    if (hasValue) {
+      fixes.push(...appendAutomockFixesForPathMigration({
+        fixer,
+        sourceCode,
+        oldBarrelPath: modulePath,
+        newPaths: [...new Set(automockPaths)]
+      }));
+    }
+    return fixes;
+  };
+  context.report({
+    node: initCall,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix: buildFixes
+  });
+}
 
 /**
  * Handles an ImportDeclaration node to check for barrel file imports.
@@ -696,7 +1078,8 @@ function handleImportDeclaration({
   context,
   workspaceRoot,
   fs,
-  applyToImportsFrom
+  applyToImportsFrom,
+  preferImportedPackageSubpath
 }) {
   // Resolve import context (validates and extracts package/export info)
   // applyToImportsFrom is used here to filter which packages the rule applies to
@@ -724,7 +1107,8 @@ function handleImportDeclaration({
     node,
     importContext,
     workspaceRoot,
-    fs
+    fs,
+    preferImportedPackageSubpath
   });
 
   // If namespace import, report without auto-fix if there are specific exports available
@@ -774,9 +1158,10 @@ export function createRule(fs) {
   return {
     meta: ruleMeta,
     create(context) {
-      var _options$applyToImpor;
+      var _options$applyToImpor, _options$preferImport;
       const options = context.options[0] || {};
       const applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      const preferImportedPackageSubpath = (_options$preferImport = options.preferImportedPackageSubpath) !== null && _options$preferImport !== void 0 ? _options$preferImport : false;
       const workspaceRoot = findWorkspaceRoot({
         startPath: dirname(context.filename),
         fs,
@@ -790,7 +1175,28 @@ export function createRule(fs) {
             context,
             workspaceRoot,
             fs,
-            applyToImportsFrom
+            applyToImportsFrom,
+            preferImportedPackageSubpath
+          });
+        },
+        MemberExpression(rawNode) {
+          handleRequireMemberExpression({
+            node: rawNode,
+            context,
+            workspaceRoot,
+            fs,
+            applyToImportsFrom,
+            preferImportedPackageSubpath
+          });
+        },
+        VariableDeclarator(rawNode) {
+          handleRequireDestructuringDeclarator({
+            node: rawNode,
+            context,
+            workspaceRoot,
+            fs,
+            applyToImportsFrom,
+            preferImportedPackageSubpath
           });
         }
       };