esm: rename flag --esm-specifier-resolution

There are currently two supported values
"none" and "node"

Also fixed a lot of bugs

Author: MylesBorins

src/module_wrap.cc

@@ -43,7 +43,13 @@ using v8::String;
 using v8::Undefined;
 using v8::Value;
 
-static const char* const EXTENSIONS[] = {".mjs", ".js", ".json", ".node"};
+static const char* const EXTENSIONS[] = {
+  ".mjs",
+  ".cjs",
+  ".js",
+  ".json",
+  ".node"
+};
 
 ModuleWrap::ModuleWrap(Environment* env,
                        Local<Object> object,
@@ -699,15 +705,23 @@ inline Maybe<URL> ResolveIndex(const URL& search) {
 Maybe<URL> FinalizeResolution(Environment* env,
                               const URL& resolved,
                               const URL& base) {
-  if (env->options()->legacy_resolution) {
+  if (env->options()->es_module_specifier_resolution == "node") {
     Maybe<URL> file = ResolveExtensions<TRY_EXACT_NAME>(resolved);
     if (!file.IsNothing()) {
       return file;
     }
     if (resolved.path().back() != '/') {
-      ResolveIndex(URL(resolved.path() + "/", &base));
+      file = ResolveIndex(URL(resolved.path() + "/", &base));
+    } else {
+      file = ResolveIndex(resolved);
+    }
+    if (!file.IsNothing()) {
+      return file;
     }
-    return ResolveIndex(resolved);
+    std::string msg = "Cannot find module '" + resolved.path() +
+        "' imported from " + base.ToFilePath();
+    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
+    return Nothing<URL>();
   }
 
   const std::string& path = resolved.ToFilePath();
@@ -734,6 +748,7 @@ Maybe<URL> PackageMainResolve(Environment* env,
     return Nothing<URL>();
   }
   if (pcfg.has_main == HasMain::Yes &&
+      pcfg.main.substr(pcfg.main.length() - 4, 4) != ".cjs" &&
       (pcfg.main.substr(pcfg.main.length() - 4, 4) == ".mjs" ||
       pcfg.esm == IsESM::Yes)) {
     return FinalizeResolution(env, URL(pcfg.main, pjson_url), base);
@@ -742,6 +757,10 @@ Maybe<URL> PackageMainResolve(Environment* env,
   Maybe<URL> resolved = LegacyMainResolve(pjson_url, pcfg);
   // Legacy main resolution error
   if (resolved.IsNothing()) {
+    std::string msg = "Cannot find main entry point for '" +
+        URL(".", pjson_url).ToFilePath() + "' imported from " +
+        base.ToFilePath();
+    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
     return Nothing<URL>();
   }
   return resolved;

src/node_options.cc

@@ -236,9 +236,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "(default: llhttp).",
             &EnvironmentOptions::http_parser,
             kAllowedInEnvironment);
-  AddOption("--legacy-resolution",
-            "legacy extension and folder resolution for ES Modules",
-            &EnvironmentOptions::legacy_resolution,
+  AddOption("--es-module-specifier-resolution",
+            "Select extension resolution algorithm for es modules; "
+            "either 'none' or 'node'",
+            &EnvironmentOptions::es_module_specifier_resolution,
             kAllowedInEnvironment);
   AddOption("--no-deprecation",
             "silence deprecation warnings",

src/node_options.h

@@ -86,7 +86,7 @@ class EnvironmentOptions : public Options {
  public:
   bool abort_on_uncaught_exception = false;
   bool experimental_modules = false;
-  bool legacy_resolution = false;
+  std::string es_module_specifier_resolution = "none";
   std::string module_type;
   std::string experimental_policy;
   bool experimental_repl_await = false;

test/es-module/test-esm-package-scope.mjs

@@ -0,0 +1,35 @@
+// Flags: --experimental-modules --es-module-specifier-resolution=node
+import { mustNotCall } from '../common';
+import assert from 'assert';
+
+// commonJS index.js
+import commonjs from '../fixtures/es-module-specifiers/package-type-commonjs';
+// esm index.js
+import module from '../fixtures/es-module-specifiers/package-type-module';
+// notice the trailing slash
+import success, { explicit, implicit, implicitModule, getImplicitCommonjs }
+  from '../fixtures/es-module-specifiers/';
+
+assert.strictEqual(commonjs, 'commonjs');
+assert.strictEqual(module, 'module');
+assert.strictEqual(success, 'success');
+assert.strictEqual(explicit, 'esm');
+assert.strictEqual(implicit, 'cjs');
+assert.strictEqual(implicitModule, 'esm');
+
+async function main() {
+  try {
+    await import('../fixtures/es-module-specifiers/do-not-exist.js');
+  } catch (e) {
+    // Files that do not exist should throw
+    assert.strictEqual(e.name, 'Error');
+  }
+  try {
+    await getImplicitCommonjs();
+  } catch (e) {
+    // Legacy loader cannot resolve .mjs automatically from main
+    assert.strictEqual(e.name, 'Error');
+  }
+}
+
+main().catch(mustNotCall);

test/es-module/test-esm-specifiers.mjs

@@ -0,0 +1,10 @@
+import explicit from 'explicit-main';
+import implicit from 'implicit-main';
+import implicitModule from 'implicit-main-type-module';
+
+function getImplicitCommonjs () {
+  return import('implicit-main-type-commonjs');
+}
+
+export {explicit, implicit, implicitModule, getImplicitCommonjs};
+export default 'success';