implement spec

Author: guybedford

lib/internal/errors.js

@@ -764,7 +764,7 @@ E('ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK',
  'dynamicInstantiate function was provided', Error);
 E('ERR_MISSING_MODULE', 'Cannot find module %s', Error);
 E('ERR_MODULE_RESOLUTION_LEGACY',
- '%s not found by import in %s.' +
+ 'Cannot find module \'%s\' imported from %s.' +
  ' Legacy behavior in require() would have found it at %s',
  Error);
 E('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times', Error);

lib/internal/modules/esm/default_resolve.js

@@ -14,7 +14,6 @@ const {
  ERR_UNKNOWN_FILE_EXTENSION
 } = require('internal/errors').codes;
 const { resolve: moduleWrapResolve } = internalBinding('module_wrap');
-const StringStartsWith = Function.call.bind(String.prototype.startsWith);
 const { pathToFileURL, fileURLToPath } = require('internal/url');
 
 const realpathCache = new Map();
@@ -35,8 +34,8 @@ function search(target, base) {
  tmpMod.paths = CJSmodule._nodeModulePaths(
  new URL('./', questionedBase).pathname);
  const found = CJSmodule._resolveFilename(target, tmpMod);
- error = new ERR_MODULE_RESOLUTION_LEGACY(target, base, found);
- } catch (problemChecking) {
+ error = new ERR_MODULE_RESOLUTION_LEGACY(target, fileURLToPath(base), found);
+ } catch {
  // ignore
  }
  throw error;
@@ -56,16 +55,8 @@ function resolve(specifier, parentURL) {
  };
  }
 
- let url;
- try {
- url = search(specifier,
- parentURL || pathToFileURL(`${process.cwd()}/`).href);
- } catch (e) {
- if (typeof e.message === 'string' &&
- StringStartsWith(e.message, 'Cannot find module'))
- e.code = 'MODULE_NOT_FOUND';
- throw e;
- }
+ let url = search(specifier,
+ parentURL || pathToFileURL(`${process.cwd()}/`).href);
 
  const isMain = parentURL === undefined;
 

src/module_wrap.cc

@@ -467,104 +467,108 @@ std::string ReadFile(uv_file file) {
  return contents;
 }
 
-enum CheckFileOptions {
- LEAVE_OPEN_AFTER_CHECK,
- CLOSE_AFTER_CHECK
+enum DescriptorType {
+ NONE,
+ FILE,
+ DIRECTORY
 };
 
-Maybe<uv_file> CheckFile(const std::string& path,
- CheckFileOptions opt = CLOSE_AFTER_CHECK) {
+DescriptorType CheckDescriptor(const std::string& path) {
  uv_fs_t fs_req;
- if (path.empty()) {
- return Nothing<uv_file>();
- }
-
- uv_file fd = uv_fs_open(nullptr, &fs_req, path.c_str(), O_RDONLY, 0, nullptr);
- uv_fs_req_cleanup(&fs_req);
-
- if (fd < 0) {
- return Nothing<uv_file>();
- }
-
- uv_fs_fstat(nullptr, &fs_req, fd, nullptr);
- uint64_t is_directory = fs_req.statbuf.st_mode & S_IFDIR;
- uv_fs_req_cleanup(&fs_req);
-
- if (is_directory) {
- CHECK_EQ(0, uv_fs_close(nullptr, &fs_req, fd, nullptr));
- uv_fs_req_cleanup(&fs_req);
- return Nothing<uv_file>();
- }
-
- if (opt == CLOSE_AFTER_CHECK) {
- CHECK_EQ(0, uv_fs_close(nullptr, &fs_req, fd, nullptr));
+ int rc = uv_fs_stat(nullptr, &fs_req, path.c_str(), nullptr);
+ if (rc == 0) {
+ uint64_t is_directory = fs_req.statbuf.st_mode & S_IFDIR;
  uv_fs_req_cleanup(&fs_req);
+ return is_directory ? DIRECTORY : FILE;
  }
-
- return Just(fd);
+ uv_fs_req_cleanup(&fs_req);
+ return NONE;
 }
 
-enum ResolveExtensionsOptions {
- TRY_EXACT_NAME,
- ONLY_VIA_EXTENSIONS
-};
-
-inline bool ResolvesToFile(const URL& search) {
- std::string filePath = search.ToFilePath();
- Maybe<uv_file> check = CheckFile(filePath);
- return !check.IsNothing();
+inline Maybe<URL> PackageMainResolve(const URL& search) {
+ std::string path = search.path();
+ std::string last_segment = path.substr(path.find_last_of('/') + 1);
+ URL main_url = URL("./" + last_segment + "/index.mjs", search);
+ if (CheckDescriptor(main_url.ToFilePath()) == FILE)
+ return Just(main_url);
+ return Nothing<URL>();
 }
 
-template <ResolveExtensionsOptions options>
-Maybe<URL> ResolveExtensions(const URL& search) {
- if (options == TRY_EXACT_NAME) {
- std::string filePath = search.ToFilePath();
- Maybe<uv_file> check = CheckFile(filePath);
- if (!check.IsNothing()) {
- return Just(search);
- }
- }
-
- for (const char* extension : EXTENSIONS) {
- URL guess(search.path() + extension, &search);
- Maybe<uv_file> check = CheckFile(guess.ToFilePath());
- if (!check.IsNothing()) {
- return Just(guess);
+Maybe<URL> PackageResolve(Environment* env,
+ const std::string& specifier,
+ const URL& base) {
+ if (specifier.length() == 0) return Nothing<URL>();
+ size_t sep_index = specifier.find('/');
+ if (specifier[0] == '@') {
+ if (sep_index == std::string::npos) {
+ std::string msg = "Invalid package name '" + specifier +
+ "' imported from " + base.ToFilePath();
+ node::THROW_ERR_INVALID_PACKAGE_NAME(env, msg.c_str());
+ return Nothing<URL>();
  }
+ sep_index = specifier.find('/', sep_index + 1);
+ }
+ std::string pkg_name = specifier.substr(0, 
+ sep_index == std::string::npos ? std::string::npos : sep_index);
+ std::string pkg_path;
+ if (sep_index == std::string::npos ||
+ sep_index == specifier.length() - 1) {
+ pkg_path = "";
+ } else {
+ pkg_path = specifier.substr(sep_index);
  }
-
- return Nothing<URL>();
-}
-
-inline Maybe<URL> ResolveIndex(const URL& search) {
- return ResolveExtensions<ONLY_VIA_EXTENSIONS>(URL("index", search));
-}
-
-Maybe<URL> ResolveModule(Environment* env,
- const std::string& specifier,
- const URL& base) {
  URL parent(".", base);
- URL dir("");
+ std::string last_path;
  do {
- dir = parent;
- Maybe<URL> check =
- Resolve(env, "./node_modules/" + specifier, dir);
- if (!check.IsNothing()) {
- const size_t limit = specifier.find('/');
- const size_t spec_len =
- limit == std::string::npos ? specifier.length() :
- limit + 1;
- std::string chroot =
- dir.path() + "node_modules/" + specifier.substr(0, spec_len);
- if (check.FromJust().path().substr(0, chroot.length()) != chroot) {
- return Nothing<URL>();
+ URL pkg_url("./node_modules/" + pkg_name, &parent);
+ URL url;
+ if (pkg_path.length()) {
+ url = URL("./node_modules/" + pkg_name + "/" + pkg_path, &parent);
+ } else {
+ url = pkg_url;
+ }
+ if (pkg_path.length()) {
+ DescriptorType check = CheckDescriptor(url.ToFilePath());
+ if (check == FILE) {
+ return Just(url);
+ } else if (check == DIRECTORY) {
+ Maybe<URL> main_url = PackageMainResolve(url);
+ if (!main_url.IsNothing()) return main_url;
  }
- return check;
  } else {
- // TODO(bmeck) PREVENT FALLTHROUGH
+ Maybe<URL> main_url = PackageMainResolve(url);
+ if (!main_url.IsNothing()) return main_url;
+ }
+ // throw not found if we did match a package directory
+ DescriptorType check = CheckDescriptor(pkg_url.ToFilePath());
+ if (check == DIRECTORY) {
+ std::string msg = "Cannot find module '" + url.ToFilePath() +
+ "' imported from " + base.ToFilePath();
+ node::THROW_ERR_MISSING_MODULE(env, msg.c_str());
+ return Nothing<URL>();
  }
- parent = URL("..", &dir);
- } while (parent.path() != dir.path());
+ last_path = parent.path();
+ parent = URL("..", &parent);
+ // cross-platform root check
+ } while (parent.path() != last_path);
+ return Nothing<URL>();
+}
+
+Maybe<URL> PathResolve (Environment* env, 
+ const URL& url,
+ const URL& base) {
+ std::string path = url.ToFilePath();
+ DescriptorType check = CheckDescriptor(path);
+ if (check == FILE) return Just(url);
+
+ if (check == DIRECTORY) {
+ Maybe<URL> url_main = PackageMainResolve(url);
+ if (!url_main.IsNothing()) return url_main;
+ }
+
+ std::string msg = "Cannot find module '" + path +
+ "' imported from " + base.ToFilePath();
+ node::THROW_ERR_MISSING_MODULE(env, msg.c_str());
  return Nothing<URL>();
 }
 
@@ -575,24 +579,13 @@ Maybe<URL> Resolve(Environment* env,
  const URL& base) {
  URL pure_url(specifier);
  if (!(pure_url.flags() & URL_FLAGS_FAILED)) {
- // just check existence, without altering
- Maybe<uv_file> check = CheckFile(pure_url.ToFilePath());
- if (check.IsNothing()) {
- return Nothing<URL>();
- }
- return Just(pure_url);
- }
- if (specifier.length() == 0) {
- return Nothing<URL>();
+ return PathResolve(env, pure_url, base);
  }
  if (ShouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
  URL resolved(specifier, base);
- if (ResolvesToFile(resolved))
- return Just(resolved);
- return Nothing<URL>();
- } else {
- return ResolveModule(env, specifier, base);
+ return PathResolve(env, resolved, base);
  }
+ return PackageResolve(env, specifier, base);
 }
 
 void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
@@ -613,11 +606,18 @@ void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
  return node::THROW_ERR_INVALID_ARG_TYPE(
  env, "second argument is not a URL string");
  }
-
+ 
+ TryCatch try_catch(env->isolate());
  Maybe<URL> result = node::loader::Resolve(env, specifier_std, url);
- if (result.IsNothing() || (result.FromJust().flags() & URL_FLAGS_FAILED)) {
- std::string msg = "Cannot find module " + specifier_std;
- return node::THROW_ERR_MISSING_MODULE(env, msg.c_str());
+ if (try_catch.HasCaught()) {
+ try_catch.ReThrow();
+ return;
+ } else if (result.IsNothing() || (result.FromJust().flags() & URL_FLAGS_FAILED)) {
+ std::string msg = "Cannot find module '" + specifier_std + 
+ "' imported from " + url.ToFilePath();
+ node::THROW_ERR_MISSING_MODULE(env, msg.c_str());
+ try_catch.ReThrow();
+ return;
  }
 
  args.GetReturnValue().Set(result.FromJust().ToObject(env));

src/node_errors.h

@@ -28,6 +28,7 @@ namespace node {
  V(ERR_CONSTRUCT_CALL_REQUIRED, Error) \
  V(ERR_INVALID_ARG_VALUE, TypeError) \
  V(ERR_INVALID_ARG_TYPE, TypeError) \
+ V(ERR_INVALID_PACKAGE_NAME, Error) \
  V(ERR_INVALID_TRANSFER_OBJECT, TypeError) \
  V(ERR_MEMORY_ALLOCATION_FAILED, Error) \
  V(ERR_MISSING_ARGS, TypeError) \