Feat: warn when the package from resolved alias is not available

package.json

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

src/getRealPath.js

@@ -43,40 +43,10 @@ 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;
-  }
-
-  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 +57,27 @@ function getRealPathFromRegExpConfig(sourcePath, currentFile, { regExps }) {
     return true;
   });
 
+  if (!aliasedSourceFile) {
+    return null;
+  }
+
+  if (aliasedSourceFile[0] === '.') {
+    return toLocalPath(toPosixPath(
+      mapToRelative(opts.cwd, currentFile, aliasedSourceFile)),
+    );
+  }
+
+  const realPathFromRoot = getRealPathFromRootConfig(aliasedSourceFile, currentFile, opts);
+  if (realPathFromRoot) {
+    return realPathFromRoot;
+  }
+
   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

@@ -3,6 +3,7 @@ import path from 'path';
 
 import findBabelConfig from 'find-babel-config';
 import glob from 'glob';
+import { warn } from './log';
 
 
 const defaultExtensions = ['.js', '.jsx', '.es', '.es6'];
@@ -51,29 +52,46 @@ function normalizeRoot(opts) {
   }
 }
 
-function normalizeAlias(opts) {
-  opts.regExps = [];
+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('\\');
+  }
+
+  return [new RegExp(key), substitute];
+}
 
+function normalizeAlias(opts) {
   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('\\');
+    const { alias } = opts;
+    const aliasKeys = Object.keys(alias);
+    let warnedAboutNpmPrefix = false;
+
+    const nonRegExpAliases = aliasKeys
+      .filter(key => !isRegExp(key))
+      .map((key) => {
+        let value = alias[key];
+
+        if (value.startsWith('npm:') && !warnedAboutNpmPrefix) {
+          warnedAboutNpmPrefix = true;
+          warn('The "npm:" prefix in an alias is deprecated and will be removed in the next major version release.');
+          value = value.slice('npm:'.length);
         }
+        return getAliasPair(`^${key}((?:/|).*)`, `${value}\\1`);
+      });
 
-        opts.regExps.push([new RegExp(key), substitute]);
+    const regExpAliases = aliasKeys
+      .filter(isRegExp)
+      .map(key => getAliasPair(key, alias[key]));
 
-        delete opts.alias[key];
-      });
+    opts.alias = [...nonRegExpAliases, ...regExpAliases];
   } else {
-    opts.alias = {};
+    opts.alias = [];
   }
 }
 

test/index.test.js

@@ -209,6 +209,28 @@ describe('module-resolver', () => {
         );
       });
     });
+
+    describe('root and alias', () => {
+      const rootTransformerOpts = {
+        babelrc: false,
+        plugins: [
+          [plugin, {
+            root: './test/testproject/src',
+            alias: {
+              constants: 'constants/actions',
+            },
+          }],
+        ],
+      };
+
+      it('should resolve the path using root first and alias otherwise', () => {
+        testWithImport(
+          'constants',
+          './test/testproject/src/constants',
+          rootTransformerOpts,
+        );
+      });
+    });
   });
 
   describe('alias', () => {
@@ -221,7 +243,6 @@ describe('module-resolver', () => {
             components: './test/testproject/src/components',
             '~': './test/testproject/src',
             'awesome/components': './test/testproject/src/components',
-            abstract: 'npm:concrete',
             underscore: 'lodash',
             prefix: 'prefix/lib',
             '^@namespace/foo-(.+)': 'packages/\\1',
@@ -306,12 +327,48 @@ describe('module-resolver', () => {
       });
     });
 
-    it('(legacy) should support aliasing a node module with "npm:"', () => {
-      testWithImport(
-        'abstract/thing',
-        'concrete/thing',
-        aliasTransformerOpts,
-      );
+    describe('should handle the deprecated "npm:" prefix', () => {
+      const mockWarn = jest.fn();
+      jest.mock('../src/log', () => ({
+        warn: mockWarn,
+      }));
+      jest.resetModules();
+      const pluginWithMock = require.requireActual('../src').default;
+
+      const depreactedAliasTransformerOpts = {
+        plugins: [
+          [pluginWithMock, {
+            alias: {
+              abstract: 'npm:concrete',
+              second: 'npm:another',
+              nonNpmPrefix: 'normal',
+            },
+          }],
+        ],
+      };
+
+      beforeEach(() => {
+        mockWarn.mockClear();
+      });
+
+      it('should print a warning once if "npm:" is encountered in the config', () => {
+        testWithImport(
+          'nonNpmPrefix/thing',
+          'normal/thing',
+          depreactedAliasTransformerOpts,
+        );
+
+        expect(mockWarn.mock.calls.length).toBe(1);
+        expect(mockWarn).toBeCalledWith('The "npm:" prefix in an alias is deprecated and will be removed in the next major version release.');
+      });
+
+      it('should strip the "npm:" prefix from the resolved path', () => {
+        testWithImport(
+          'abstract/thing',
+          'concrete/thing',
+          depreactedAliasTransformerOpts,
+        );
+      });
     });
 
     it('should support aliasing a node modules', () => {
@@ -433,34 +490,34 @@ describe('module-resolver', () => {
         );
       });
 
-      it('should alias the relative path while ignoring cwd and root', () => {
+      it('should alias the relative path while honoring cwd and ignoring root', () => {
         testWithImport(
           'constantsRelative/actions',
           './test/constants/actions',
           transformerOpts,
         );
       });
 
-      it('should alias the non-relative path while ignoring cwd and root', () => {
+      it('should alias the non-relative path while honoring cwd and root', () => {
         testWithImport(
           'constantsNonRelative/actions',
-          'constants/actions',
+          './test/testproject/src/constants/actions',
           transformerOpts,
         );
       });
 
-      it('should alias the relative path while ignoring cwd and root', () => {
+      it('should alias the relative path while honoring cwd and ignoring root', () => {
         testWithImport(
           'constantsRegExpRelative/actions',
-          './constants/actions',
+          './test/constants/actions',
           transformerOpts,
         );
       });
 
-      it('should alias the non-relative path while ignoring cwd and root', () => {
+      it('should alias the non-relative path while honoring cwd and root', () => {
         testWithImport(
           'constantsNonRelative/actions',
-          'constants/actions',
+          './test/testproject/src/constants/actions',
           transformerOpts,
         );
       });
@@ -533,7 +590,7 @@ describe('module-resolver', () => {
     it('should alias the sub file path', () => {
       testWithImport(
         'actions',
-        'constants/actions',
+        './constants/actions',
         transformerOpts,
       );
     });