Feat: warn when the package from resolved alias is not available (#160)

Breaking change: The "npm:" prefix has been removed.

package.json

@@ -62,7 +62,8 @@
   "jest": {
     "testRegex": "/test/.*\\.test\\.js$",
     "collectCoverageFrom": [
-      "src/**/*.js"
+      "src/**/*.js",
+      "!src/log.js"
     ]
   },
   "greenkeeper": {

src/getRealPath.js

@@ -1,25 +1,17 @@
 import path from 'path';
 
-import resolve from 'resolve';
+import { warn } from './log';
 import mapToRelative from './mapToRelative';
-import { toLocalPath, toPosixPath, replaceExtension } from './utils';
+import { nodeResolvePath, replaceExtension, toLocalPath, toPosixPath } from './utils';
 
 
 function findPathInRoots(sourcePath, { extensions, root }) {
   // Search the source path inside every custom root directory
   let resolvedSourceFile;
 
   root.some((basedir) => {
-    try {
-      // Check if the file exists (will throw if not)
-      resolvedSourceFile = resolve.sync(`./${sourcePath}`, {
-        basedir,
-        extensions,
-      });
-      return true;
-    } catch (e) {
-      return false;
-    }
+    resolvedSourceFile = nodeResolvePath(`./${sourcePath}`, basedir, extensions);
+    return resolvedSourceFile !== null;
   });
 
   return resolvedSourceFile;
@@ -43,40 +35,17 @@ function getRealPathFromRootConfig(sourcePath, currentFile, opts) {
   )));
 }
 
-function getRealPathFromAliasConfig(sourcePath, currentFile, { alias, cwd }) {
-  const moduleSplit = sourcePath.split('/');
-  let aliasPath;
-
-  while (moduleSplit.length) {
-    const m = moduleSplit.join('/');
-    if ({}.hasOwnProperty.call(alias, m)) {
-      aliasPath = alias[m];
-      break;
-    }
-    moduleSplit.pop();
-  }
-
-  // no alias mapping found
-  if (!aliasPath) {
-    return null;
-  }
-
-  // remove legacy "npm:" prefix for npm packages
-  aliasPath = aliasPath.replace(/^(npm:)/, '');
-  const newPath = sourcePath.replace(moduleSplit.join('/'), aliasPath);
-
-  // alias to npm module don't need relative mapping
-  if (aliasPath[0] !== '.') {
-    return newPath;
+function checkIfPackageExists(modulePath, currentFile, extensions) {
+  const resolvedPath = nodeResolvePath(modulePath, currentFile, extensions);
+  if (resolvedPath === null) {
+    warn(`Could not resolve "${modulePath}" in file ${currentFile}.`);
   }
-
-  return toLocalPath(toPosixPath(mapToRelative(cwd, currentFile, newPath)));
 }
 
-function getRealPathFromRegExpConfig(sourcePath, currentFile, { regExps }) {
+function getRealPathFromAliasConfig(sourcePath, currentFile, opts) {
   let aliasedSourceFile;
 
-  regExps.find(([regExp, substitute]) => {
+  opts.alias.find(([regExp, substitute]) => {
     const execResult = regExp.exec(sourcePath);
 
     if (execResult === null) {
@@ -87,13 +56,26 @@ function getRealPathFromRegExpConfig(sourcePath, currentFile, { regExps }) {
     return true;
   });
 
+  if (!aliasedSourceFile) {
+    return null;
+  }
+
+  if (aliasedSourceFile[0] === '.') {
+    return toLocalPath(toPosixPath(
+      mapToRelative(opts.cwd, currentFile, aliasedSourceFile)),
+    );
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    checkIfPackageExists(aliasedSourceFile, currentFile, opts.extensions);
+  }
+
   return aliasedSourceFile;
 }
 
 const resolvers = [
   getRealPathFromRootConfig,
   getRealPathFromAliasConfig,
-  getRealPathFromRegExpConfig,
 ];
 
 export default function getRealPath(sourcePath, { file, opts }) {

src/log.js

@@ -0,0 +1,7 @@
+// This module exists only for abstracting logging away and making testing easier
+
+// eslint-disable-next-line import/prefer-default-export
+export function warn(...args) {
+  // eslint-disable-next-line no-console
+  console.warn(...args);
+}

src/normalizeOptions.js

@@ -60,29 +60,32 @@ function normalizeRoot(opts) {
   }
 }
 
-function normalizeAlias(opts) {
-  opts.regExps = [];
-
-  if (opts.alias) {
-    Object.keys(opts.alias)
-      .filter(isRegExp)
-      .forEach((key) => {
-        const parts = opts.alias[key].split('\\\\');
-
-        function substitute(execResult) {
-          return parts
-            .map(part =>
-              part.replace(/\\\d+/g, number => execResult[number.slice(1)] || ''),
-            )
-            .join('\\');
-        }
+function getAliasPair(key, value) {
+  const parts = value.split('\\\\');
+
+  function substitute(execResult) {
+    return parts
+      .map(part =>
+        part.replace(/\\\d+/g, number => execResult[number.slice(1)] || ''),
+      )
+      .join('\\');
+  }
 
-        opts.regExps.push([new RegExp(key), substitute]);
+  return [new RegExp(key), substitute];
+}
 
-        delete opts.alias[key];
-      });
+function normalizeAlias(opts) {
+  if (opts.alias) {
+    const { alias } = opts;
+    const aliasKeys = Object.keys(alias);
+
+    opts.alias = aliasKeys.map(key => (
+      isRegExp(key) ?
+        getAliasPair(key, alias[key]) :
+        getAliasPair(`^${key}((?:/|).*)`, `${alias[key]}\\1`)
+    ));
   } else {
-    opts.alias = {};
+    opts.alias = [];
   }
 }
 

src/utils.js

@@ -1,8 +1,17 @@
 import path from 'path';
 
+import resolve from 'resolve';
 import getRealPath from './getRealPath';
 
 
+export function nodeResolvePath(modulePath, basedir, extensions) {
+  try {
+    return resolve.sync(modulePath, { basedir, extensions });
+  } catch (e) {
+    return null;
+  }
+}
+
 export function toPosixPath(modulePath) {
   return modulePath.replace(/\\/g, '/');
 }

test/import.test.js

@@ -84,6 +84,7 @@ describe('import and export statement', () => {
         root: './test/testproject/src',
         alias: {
           test: './test/testproject/test',
+          'babel-core': 'babel-core/lib',
         },
       }],
     ],
@@ -121,6 +122,15 @@ describe('import and export statement', () => {
     );
   });
 
+  describe('should only apply the alias once', () => {
+    // If this test breaks, consider selecting another package used by the plugin
+    testImports(
+      'babel-core/store',
+      'babel-core/lib/store',
+      transformerOpts,
+    );
+  });
+
   describe('should ignore the call if a non-import statement is used', () => {
     const code = stripIndent`
       function test() {