src: move package resolver to c++

Co-authored-by: Daniel Lemire <daniel@lemire.me>
PR-URL: #50322
Reviewed-By: Jacob Smith <jacob@frende.me>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Geoffrey Booth <webadmin@geoffreybooth.com>

Author: 2 people

lib/internal/modules/cjs/loader.js

@@ -427,7 +427,7 @@ ObjectDefineProperty(Module, '_readPackage', {
  * @param {string} originalPath The specifier passed to `require`
  */
 functiontryPackage(requestPath,exts,isMain,originalPath){
-constpkg=_readPackage(requestPath).main;
+const{main: pkg, pjsonPath }=_readPackage(requestPath);
 
 if(!pkg){
 returntryExtensions(path.resolve(requestPath,'index'),exts,isMain);
@@ -446,14 +446,13 @@ function tryPackage(requestPath, exts, isMain, originalPath) {
 'Please verify that the package.json has a valid "main" entry',
 );
 err.code='MODULE_NOT_FOUND';
-err.path=path.resolve(requestPath,'package.json');
+err.path=pjsonPath;
 err.requestPath=originalPath;
 // TODO(BridgeAR): Add the requireStack as well.
 throwerr;
 }else{
-constjsonPath=path.resolve(requestPath,'package.json');
 process.emitWarning(
-`Invalid 'main' field in '${jsonPath}' of '${pkg}'. `+
+`Invalid 'main' field in '${pjsonPath}' of '${pkg}'. `+
 'Please either fix that or report it to the module author',
 'DeprecationWarning',
 'DEP0128',
@@ -539,28 +538,28 @@ function trySelfParentPath(parent) {
 functiontrySelf(parentPath,request){
 if(!parentPath){returnfalse;}
 
-const{data: pkg,path: pkgPath}=packageJsonReader.readPackageScope(parentPath);
-if(!pkg||pkg.exports==null||pkg.name===undefined){
+constpkg=packageJsonReader.getNearestParentPackageJSON(parentPath);
+if(pkg?.data.exports===undefined||pkg.data.name===undefined){
 returnfalse;
 }
 
 letexpansion;
-if(request===pkg.name){
+if(request===pkg.data.name){
 expansion='.';
-}elseif(StringPrototypeStartsWith(request,`${pkg.name}/`)){
-expansion='.'+StringPrototypeSlice(request,pkg.name.length);
+}elseif(StringPrototypeStartsWith(request,`${pkg.data.name}/`)){
+expansion='.'+StringPrototypeSlice(request,pkg.data.name.length);
 }else{
 returnfalse;
 }
 
 try{
 const{ packageExportsResolve }=require('internal/modules/esm/resolve');
 returnfinalizeEsmResolution(packageExportsResolve(
-pathToFileURL(pkgPath+'/package.json'),expansion,pkg,
-pathToFileURL(parentPath),getCjsConditions()),parentPath,pkgPath);
+pathToFileURL(pkg.path+'/package.json'),expansion,pkg.data,
+pathToFileURL(parentPath),getCjsConditions()),parentPath,pkg.path);
 }catch(e){
 if(e.code==='ERR_MODULE_NOT_FOUND'){
-throwcreateEsmNotFoundErr(request,pkgPath+'/package.json');
+throwcreateEsmNotFoundErr(request,pkg.path+'/package.json');
 }
 throwe;
 }
@@ -1099,7 +1098,7 @@ Module._resolveFilename = function(request, parent, isMain, options) {
 
 if(request[0]==='#'&&(parent?.filename||parent?.id==='<repl>')){
 constparentPath=parent?.filename??process.cwd()+path.sep;
-constpkg=packageJsonReader.readPackageScope(parentPath)||{__proto__: null};
+constpkg=packageJsonReader.getNearestParentPackageJSON(parentPath)||{__proto__: null};
 if(pkg.data?.imports!=null){
 try{
 const{ packageImportsResolve }=require('internal/modules/esm/resolve');
@@ -1397,9 +1396,9 @@ Module._extensions['.js'] = function(module, filename) {
 content=fs.readFileSync(filename,'utf8');
 }
 if(StringPrototypeEndsWith(filename,'.js')){
-constpkg=packageJsonReader.readPackageScope(filename)||{__proto__: null};
+constpkg=packageJsonReader.getNearestParentPackageJSON(filename);
 // Function require shouldn't be used in ES modules.
-if(pkg.data?.type==='module'){
+if(pkg?.data.type==='module'){
 // This is an error path because `require` of a `.js` file in a `"type": "module"` scope is not allowed.
 constparent=moduleParentCache.get(module);
 constparentPath=parent?.filename;

lib/internal/modules/esm/get_format.js

@@ -19,7 +19,7 @@ const {
 constexperimentalNetworkImports=
 getOptionValue('--experimental-network-imports');
 const{ containsModuleSyntax }=internalBinding('contextify');
-const{ getPackageType }=require('internal/modules/esm/resolve');
+const{ getPackageType }=require('internal/modules/esm/package_config');
 const{ fileURLToPath }=require('internal/url');
 const{ERR_UNKNOWN_FILE_EXTENSION}=require('internal/errors').codes;
 

lib/internal/modules/esm/module_job.js

@@ -228,7 +228,7 @@ class ModuleJob {
 constpackageConfig=
 StringPrototypeStartsWith(this.module.url,'file://')&&
 RegExpPrototypeExec(/\.js(\?[^#]*)?(#.*)?$/,this.module.url)!==null&&
-require('internal/modules/esm/resolve')
+require('internal/modules/esm/package_config')
 .getPackageScopeConfig(this.module.url);
 if(packageConfig.type==='module'){
 e.message+=

lib/internal/modules/esm/package_config.js

@@ -1,69 +1,44 @@
 'use strict';
 
-const{
- StringPrototypeEndsWith,
-}=primordials;
-const{URL, fileURLToPath }=require('internal/url');
-constpackageJsonReader=require('internal/modules/package_json_reader');
+const{ ArrayIsArray }=primordials;
+constmodulesBinding=internalBinding('modules');
+const{ deserializePackageJSON }=require('internal/modules/package_json_reader');
 
-/**
- * @typedef {object} PackageConfig
- * @property {string} pjsonPath - The path to the package.json file.
- * @property {boolean} exists - Whether the package.json file exists.
- * @property {'none' | 'commonjs' | 'module'} type - The type of the package.
- * @property {string} [name] - The name of the package.
- * @property {string} [main] - The main entry point of the package.
- * @property {PackageTarget} [exports] - The exports configuration of the package.
- * @property {Record<string, string | Record<string, string>>} [imports] - The imports configuration of the package.
- */
-/**
- * @typedef {string | string[] | Record<string, string | Record<string, string>>} PackageTarget
- */
+// TODO(@anonrig): Merge this file with internal/esm/package_json_reader.js
 
 /**
  * Returns the package configuration for the given resolved URL.
  * @param {URL | string} resolved - The resolved URL.
- * @returns {PackageConfig} - The package configuration.
+ * @returns {import('typings/internalBinding/modules').PackageConfig} - The package configuration.
  */
 functiongetPackageScopeConfig(resolved){
-letpackageJSONUrl=newURL('./package.json',resolved);
-while(true){
-constpackageJSONPath=packageJSONUrl.pathname;
-if(StringPrototypeEndsWith(packageJSONPath,'node_modules/package.json')){
-break;
-}
-constpackageConfig=packageJsonReader.read(fileURLToPath(packageJSONUrl),{
-__proto__: null,
-specifier: resolved,
-isESM: true,
-});
-if(packageConfig.exists){
-returnpackageConfig;
-}
-
-constlastPackageJSONUrl=packageJSONUrl;
-packageJSONUrl=newURL('../package.json',packageJSONUrl);
+constresult=modulesBinding.getPackageScopeConfig(`${resolved}`);
 
-// Terminates at root where ../package.json equals ../../package.json
-// (can't just check "/package.json" for Windows support).
-if(packageJSONUrl.pathname===lastPackageJSONUrl.pathname){
-break;
-}
+if(ArrayIsArray(result)){
+returndeserializePackageJSON(`${resolved}`,result,false/* checkIntegrity */);
 }
-constpackageJSONPath=fileURLToPath(packageJSONUrl);
+
+// This means that the response is a string
+// and it is the path to the package.json file
 return{
 __proto__: null,
-pjsonPath: packageJSONPath,
+pjsonPath: result,
 exists: false,
-main: undefined,
-name: undefined,
 type: 'none',
-exports: undefined,
-imports: undefined,
 };
 }
 
+/**
+ * Returns the package type for a given URL.
+ * @param {URL} url - The URL to get the package type for.
+ */
+functiongetPackageType(url){
+// TODO(@anonrig): Write a C++ function that returns only "type".
+returngetPackageScopeConfig(url).type;
+}
+
 
 module.exports={
  getPackageScopeConfig,
+ getPackageType,
 };

lib/internal/modules/esm/resolve.js

@@ -198,7 +198,7 @@ const legacyMainResolveExtensionsIndexes = {
  * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
  * 5. NOT_FOUND
  * @param {URL} packageJSONUrl
- * @param {PackageConfig} packageConfig
+ * @param {import('typings/internalBinding/modules').PackageConfig} packageConfig
  * @param {string | URL | undefined} base
  * @returns {URL}
  */
@@ -502,7 +502,7 @@ function resolvePackageTarget(packageJSONUrl, target, subpath, packageSubpath,
 }
 returnresolveResult;
 }
-if(lastException===undefined||lastException===null){
+if(lastException==null){
 returnlastException;
 }
 throwlastException;
@@ -575,7 +575,7 @@ function isConditionalExportsMainSugar(exports, packageJSONUrl, base) {
  */
 functionpackageExportsResolve(
 packageJSONUrl,packageSubpath,packageConfig,base,conditions){
-letexports=packageConfig.exports;
+let{exports }=packageConfig;
 if(isConditionalExportsMainSugar(exports,packageJSONUrl,base)){
 exports={'.': exports};
 }
@@ -740,15 +740,6 @@ function packageImportsResolve(name, base, conditions) {
 throwimportNotDefined(name,packageJSONUrl,base);
 }
 
-/**
- * Returns the package type for a given URL.
- * @param {URL} url - The URL to get the package type for.
- */
-functiongetPackageType(url){
-constpackageConfig=getPackageScopeConfig(url);
-returnpackageConfig.type;
-}
-
 /**
  * Parse a package name from a specifier.
  * @param {string} specifier - The import specifier.
@@ -796,6 +787,7 @@ function parsePackageName(specifier, base) {
  * @returns {URL} - The resolved URL.
  */
 functionpackageResolve(specifier,base,conditions){
+// TODO(@anonrig): Move this to a C++ function.
 if(BuiltinModule.canBeRequiredWithoutScheme(specifier)){
 returnnewURL('node:'+specifier);
 }
@@ -1179,8 +1171,6 @@ module.exports = {
  decorateErrorWithCommonJSHints,
  defaultResolve,
  encodedSepRegEx,
- getPackageScopeConfig,
- getPackageType,
  packageExportsResolve,
  packageImportsResolve,
  throwIfInvalidParentURL,