esm: add --es-module-specifier-resolution

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

Author: MylesBorins

src/module_wrap.cc

@@ -43,6 +43,14 @@ using v8::String;
 using v8::Undefined;
 using v8::Value;
 
+static const char* const EXTENSIONS[] = {
+  ".mjs",
+  ".cjs",
+  ".js",
+  ".json",
+  ".node"
+};
+
 ModuleWrap::ModuleWrap(Environment* env,
                        Local<Object> object,
                        Local<Module> module,
@@ -667,13 +675,57 @@ Maybe<URL> LegacyMainResolve(const URL& pjson_url,
   return Nothing<URL>();
 }
 
+enum ResolveExtensionsOptions {
+  TRY_EXACT_NAME,
+  ONLY_VIA_EXTENSIONS
+};
+
+template <ResolveExtensionsOptions options>
+Maybe<URL> ResolveExtensions(const URL& search) {
+  if (options == TRY_EXACT_NAME) {
+    if (FileExists(search)) {
+      return Just(search);
+    }
+  }
+
+  for (const char* extension : EXTENSIONS) {
+    URL guess(search.path() + extension, &search);
+    if (FileExists(guess)) {
+      return Just(guess);
+    }
+  }
+
+  return Nothing<URL>();
+}
+
+inline Maybe<URL> ResolveIndex(const URL& search) {
+  return ResolveExtensions<ONLY_VIA_EXTENSIONS>(URL("index", search));
+}
+
 Maybe<URL> FinalizeResolution(Environment* env,
-                                           const URL& resolved,
-                                           const URL& base,
-                                           bool check_exists) {
-  const std::string& path = resolved.ToFilePath();
+                              const URL& resolved,
+                              const URL& base) {
+  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() != '/') {
+      file = ResolveIndex(URL(resolved.path() + "/", &base));
+    } else {
+      file = ResolveIndex(resolved);
+    }
+    if (!file.IsNothing()) {
+      return file;
+    }
+    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>();
+  }
 
-  if (check_exists && CheckDescriptorAtPath(path) != FILE) {
+  const std::string& path = resolved.ToFilePath();
+  if (CheckDescriptorAtPath(path) != FILE) {
     std::string msg = "Cannot find module '" + path +
         "' imported from " + base.ToFilePath();
     node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
@@ -696,17 +748,19 @@ Maybe<URL> PackageMainResolve(Environment* env,
     return Nothing<URL>();
   }
   if (pcfg.has_main == HasMain::Yes &&
-      pcfg.main.substr(pcfg.main.length() - 4, 4) == ".mjs") {
-    return FinalizeResolution(env, URL(pcfg.main, pjson_url), base, true);
-  }
-  if (pcfg.esm == IsESM::Yes &&
-      pcfg.main.substr(pcfg.main.length() - 3, 3) == ".js") {
-    return FinalizeResolution(env, URL(pcfg.main, pjson_url), base, true);
+      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);
   }
 
   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;
@@ -759,7 +813,7 @@ Maybe<URL> PackageResolve(Environment* env,
     if (!pkg_subpath.length()) {
       return PackageMainResolve(env, pjson_url, *pcfg.FromJust(), base);
     } else {
-      return FinalizeResolution(env, URL(pkg_subpath, pjson_url), base, true);
+      return FinalizeResolution(env, URL(pkg_subpath, pjson_url), base);
     }
     CHECK(false);
     // Cross-platform root check.
@@ -789,7 +843,7 @@ Maybe<URL> Resolve(Environment* env,
       return PackageResolve(env, specifier, base);
     }
   }
-  return FinalizeResolution(env, resolved, base, true);
+  return FinalizeResolution(env, resolved, base);
 }
 
 void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {

src/node_options.cc

@@ -236,6 +236,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "(default: llhttp).",
             &EnvironmentOptions::http_parser,
             kAllowedInEnvironment);
+  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",
             &EnvironmentOptions::no_deprecation,

src/node_options.h

@@ -86,6 +86,7 @@ class EnvironmentOptions : public Options {
  public:
   bool abort_on_uncaught_exception = false;
   bool experimental_modules = 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';

test/fixtures/es-module-specifiers/index.mjs

@@ -5,7 +5,7 @@ import {b} from './b.mjs';
 // import 'c.cjs';
 import cjs from './c.cjs';
 // proves cross boundary fun bits
-import jsAsEsm from '../new-loader/a.js';
+import jsAsEsm from '../package-type-module/a.js';
 
 // named export from core
 import {strictEqual, deepStrictEqual} from 'assert';
@@ -18,4 +18,4 @@ deepStrictEqual(cjs, {
   three: 3
 });
 
-export default 'legacy-loader';
+export default 'commonjs';

test/fixtures/es-module-specifiers/node_modules/explicit-main/entry.mjs

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

test/fixtures/es-module-specifiers/node_modules/explicit-main/package.json

@@ -5,7 +5,7 @@ import {b} from './b.mjs';
 // import 'c.cjs';
 import cjs from './c.cjs';
 // import across boundaries
-import jsAsCjs from '../legacy-loader/a.js'
+import jsAsCjs from '../package-type-commonjs/a.js'
 
 // named export from core
 import {strictEqual, deepStrictEqual} from 'assert';
@@ -18,4 +18,4 @@ deepStrictEqual(cjs, {
   three: 3
 });
 
-export default 'new-loader';
+export default 'module';

test/fixtures/es-module-specifiers/node_modules/implicit-main/entry.js

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

test/fixtures/es-module-specifiers/node_modules/implicit-main/entry.mjs

@@ -0,0 +1 @@
+{}