module: expose getPackageJSON utility

doc/api/module.md

@@ -217,6 +217,39 @@ added: v22.8.0
 * Returns: {string|undefined} Path to the [module compile cache][] directory if it is enabled,
   or `undefined` otherwise.
 
+### `module.getPackageJSON(startPath[, everything])`
+
+<!-- YAML
+added: VERSION
+-->
+
+> Stability: 1.1 - Active Development
+
+* `startPath` {URL['pathname']} Where to start looking
+* `everything` {boolean} Whether to return the full contents of the found package.json
+* Returns: {undefined | {
+  data: {
+    name?: string,
+    type?: 'commonjs' | 'module' | 'none',
+    exports?: string | string[] | Record<string, unknown>,
+    imports?: string | string[] | Record<string, unknown>,
+    [key: string]?: unknown,
+  },
+  path: URL['pathname'],
+}}
+
+In addition to being available to users, this utility is used internally when
+resolving various aspects about a module.
+
+```mjs
+import { getPackageJSON } from 'node:module';
+
+const pjson = getPackageJSON(import.meta.resolve('some-package'), true)?.data;
+
+pjson?.name; // 'some-package-real-name'
+pjson?.types; // './index.d.ts'
+```
+
 ### `module.isBuiltin(moduleName)`
 
 <!-- YAML

lib/internal/modules/cjs/loader.js

@@ -604,11 +604,11 @@ function trySelf(parentPath, request) {
   try {
     const { packageExportsResolve } = require('internal/modules/esm/resolve');
     return finalizeEsmResolution(packageExportsResolve(
-      pathToFileURL(pkg.path + '/package.json'), expansion, pkg.data,
+      pathToFileURL(pkg.path), expansion, pkg.data,
       pathToFileURL(parentPath), getCjsConditions()), parentPath, pkg.path);
   } catch (e) {
     if (e.code === 'ERR_MODULE_NOT_FOUND') {
-      throw createEsmNotFoundErr(request, pkg.path + '/package.json');
+      throw createEsmNotFoundErr(request, pkg.path);
     }
     throw e;
   }
@@ -1219,9 +1219,10 @@ Module._resolveFilename = function(request, parent, isMain, options) {
       try {
         const { packageImportsResolve } = require('internal/modules/esm/resolve');
         return finalizeEsmResolution(
-          packageImportsResolve(request, pathToFileURL(parentPath),
-                                getCjsConditions()), parentPath,
-          pkg.path);
+          packageImportsResolve(request, pathToFileURL(parentPath), getCjsConditions()),
+          parentPath,
+          pkg.path,
+        );
       } catch (e) {
         if (e.code === 'ERR_MODULE_NOT_FOUND') {
           throw createEsmNotFoundErr(request);
@@ -1281,8 +1282,7 @@ function finalizeEsmResolution(resolved, parentPath, pkgPath) {
   if (actual) {
     return actual;
   }
-  const err = createEsmNotFoundErr(filename,
-                                   path.resolve(pkgPath, 'package.json'));
+  const err = createEsmNotFoundErr(filename, pkgPath);
   throw err;
 }
 
@@ -1614,7 +1614,7 @@ function loadTS(module, filename) {
 
     const parent = module[kModuleParent];
     const parentPath = parent?.filename;
-    const packageJsonPath = path.resolve(pkg.path, 'package.json');
+    const packageJsonPath = pkg.path;
     const usesEsm = containsModuleSyntax(content, filename);
     const err = new ERR_REQUIRE_ESM(filename, usesEsm, parentPath,
                                     packageJsonPath);
@@ -1673,7 +1673,7 @@ Module._extensions['.js'] = function(module, filename) {
       // This is an error path because `require` of a `.js` file in a `"type": "module"` scope is not allowed.
       const parent = module[kModuleParent];
       const parentPath = parent?.filename;
-      const packageJsonPath = path.resolve(pkg.path, 'package.json');
+      const packageJsonPath = pkg.path;
       const usesEsm = containsModuleSyntax(content, filename);
       const err = new ERR_REQUIRE_ESM(filename, usesEsm, parentPath,
                                       packageJsonPath);

lib/internal/modules/esm/resolve.js

@@ -191,7 +191,7 @@ const legacyMainResolveExtensionsIndexes = {
  * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
  * 5. NOT_FOUND
  * @param {URL} packageJSONUrl
- * @param {import('typings/internalBinding/modules').PackageConfig} packageConfig
+ * @param {import('typings/internalBinding/modules').RecognisedPackageConfig} packageConfig
  * @param {string | URL | undefined} base
  * @returns {URL}
  */

lib/internal/modules/package_json_reader.js

@@ -4,17 +4,26 @@ const {
   ArrayIsArray,
   JSONParse,
   ObjectDefineProperty,
-  StringPrototypeLastIndexOf,
-  StringPrototypeSlice,
 } = primordials;
 const modulesBinding = internalBinding('modules');
-const { resolve, sep } = require('path');
+const { resolve } = require('path');
 const { kEmptyObject } = require('internal/util');
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+  },
+} = require('internal/errors');
+
+/**
+ * @typedef {import('typings/internalBinding/modules').FullPackageConfig} FullPackageConfig
+ * @typedef {import('typings/internalBinding/modules').RecognisedPackageConfig} RecognisedPackageConfig
+ * @typedef {import('typings/internalBinding/modules').SerializedPackageConfig} SerializedPackageConfig
+ */
 
 /**
  * @param {string} path
- * @param {import('typings/internalBinding/modules').SerializedPackageConfig} contents
- * @returns {import('typings/internalBinding/modules').PackageConfig}
+ * @param {SerializedPackageConfig} contents
+ * @returns {RecognisedPackageConfig}
  */
 function deserializePackageJSON(path, contents) {
   if (contents === undefined) {
@@ -51,19 +60,23 @@ function deserializePackageJSON(path, contents) {
     exists: true,
     pjsonPath,
     name,
-    main,
-    type,
-    // This getters are used to lazily parse the imports and exports fields.
-    get imports() {
-      const value = requiresJSONParse(plainImports) ? JSONParse(plainImports) : plainImports;
-      ObjectDefineProperty(this, 'imports', { __proto__: null, value });
-      return this.imports;
-    },
-    get exports() {
-      const value = requiresJSONParse(plainExports) ? JSONParse(plainExports) : plainExports;
-      ObjectDefineProperty(this, 'exports', { __proto__: null, value });
-      return this.exports;
-    },
+    ...(main != null && { main }),
+    ...(type != null && { type }),
+    ...(plainImports != null && {
+      // This getters are used to lazily parse the imports and exports fields.
+      get imports() {
+        const value = requiresJSONParse(plainImports) ? JSONParse(plainImports) : plainImports;
+        ObjectDefineProperty(this, 'imports', { __proto__: null, value });
+        return this.imports;
+      },
+    }),
+    ...(plainExports != null && {
+      get exports() {
+        const value = requiresJSONParse(plainExports) ? JSONParse(plainExports) : plainExports;
+        ObjectDefineProperty(this, 'exports', { __proto__: null, value });
+        return this.exports;
+      },
+    }),
   };
 }
 
@@ -75,7 +88,7 @@ function deserializePackageJSON(path, contents) {
  *   specifier?: URL | string,
  *   isESM?: boolean,
  * }} options
- * @returns {import('typings/internalBinding/modules').PackageConfig}
+ * @returns {RecognisedPackageConfig}
  */
 function read(jsonPath, { base, specifier, isESM } = kEmptyObject) {
   // This function will be called by both CJS and ESM, so we need to make sure
@@ -94,7 +107,7 @@ function read(jsonPath, { base, specifier, isESM } = kEmptyObject) {
  * @deprecated Expected to be removed in favor of `read` in the future.
  * Behaves the same was as `read`, but appends package.json to the path.
  * @param {string} requestPath
- * @return {PackageConfig}
+ * @return {RecognisedPackageConfig}
  */
 function readPackage(requestPath) {
   // TODO(@anonrig): Remove this function.
@@ -104,29 +117,56 @@ function readPackage(requestPath) {
 /**
  * Get the nearest parent package.json file from a given path.
  * Return the package.json data and the path to the package.json file, or undefined.
- * @param {string} checkPath The path to start searching from.
- * @returns {undefined | {data: import('typings/internalBinding/modules').PackageConfig, path: string}}
+ * @param {URL['href'] | URL['pathname']} startPath The path to start searching from.
+ * @param {boolean} everything Whether to include the full contents of the package.json.
+ * @returns {undefined | {
+ *   data: everything extends true ? FullPackageConfig : RecognisedPackageConfig,
+ *   path: URL['pathname'],
+ * }}
  */
-function getNearestParentPackageJSON(checkPath) {
-  const result = modulesBinding.getNearestParentPackageJSON(checkPath);
+function getNearestParentPackageJSON(startPath, everything = false) {
+  if (typeof startPath !== 'string') {
+    throw new ERR_INVALID_ARG_TYPE('startPath', 'string', startPath);
+  }
+  if (
+    everything !== undefined &&
+    typeof everything !== 'boolean'
+  ) {
+    throw new ERR_INVALID_ARG_TYPE('everything', 'boolean', everything);
+  }
+
+  if (everything) {
+    const result = modulesBinding.getNearestRawParentPackageJSON(startPath);
+
+    return {
+      data: {
+        __proto__: null,
+        ...JSONParse(result[0]),
+      },
+      path: result[1],
+    };
+  }
+
+  const result = modulesBinding.getNearestParentPackageJSON(startPath);
 
   if (result === undefined) {
     return undefined;
   }
 
-  const data = deserializePackageJSON(checkPath, result);
+  const data = deserializePackageJSON(startPath, result);
+
+  const { pjsonPath: path } = data;
 
-  // Path should be the root folder of the matched package.json
-  // For example for ~/path/package.json, it should be ~/path
-  const path = StringPrototypeSlice(data.pjsonPath, 0, StringPrototypeLastIndexOf(data.pjsonPath, sep));
+  delete data.exists;
+  delete data.pjsonPath;
 
   return { data, path };
 }
 
 /**
  * Returns the package configuration for the given resolved URL.
  * @param {URL | string} resolved - The resolved URL.
- * @returns {import('typings/internalBinding/modules').PackageConfig} - The package configuration.
+ * @returns {RecognisedPackageConfig} - The package configuration.
  */
 function getPackageScopeConfig(resolved) {
   const result = modulesBinding.getPackageScopeConfig(`${resolved}`);

lib/module.js

@@ -10,6 +10,9 @@ const {
   flushCompileCache,
   getCompileCacheDir,
 } = require('internal/modules/helpers');
+const {
+  getNearestParentPackageJSON,
+} = require('internal/modules/package_json_reader');
 
 Module.findSourceMap = findSourceMap;
 Module.register = register;
@@ -19,4 +22,5 @@ Module.enableCompileCache = enableCompileCache;
 Module.flushCompileCache = flushCompileCache;
 
 Module.getCompileCacheDir = getCompileCacheDir;
+Module.getPackageJSON = getNearestParentPackageJSON;
 module.exports = Module;

src/node_modules.cc

@@ -313,6 +313,32 @@ const BindingData::PackageConfig* BindingData::TraverseParent(
   return nullptr;
 }
 
+void BindingData::GetNearestRawParentPackageJSON(
+  const v8::FunctionCallbackInfo<v8::Value>& args
+) {
+  CHECK_GE(args.Length(), 1);
+  CHECK(args[0]->IsString());
+
+  Realm* realm = Realm::GetCurrent(args);
+  BufferValue path_value(realm->isolate(), args[0]);
+
+  // Required for long paths in Windows
+  ToNamespacedPath(realm->env(), &path_value);
+
+  auto package_json = TraverseParent(
+    realm,
+    std::filesystem::path(path_value.ToString()));
+
+  if (package_json != nullptr) {
+    Local<Value> result[2] = {
+      ToV8Value(realm->context(), package_json->raw_json).ToLocalChecked(),
+      ToV8Value(realm->context(), package_json->file_path).ToLocalChecked(),
+    };
+
+    args.GetReturnValue().Set(Array::New(realm->isolate(), result, 2));
+  }
+}
+
 void BindingData::GetNearestParentPackageJSON(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_GE(args.Length(), 1);
@@ -494,6 +520,10 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
             target,
             "getNearestParentPackageJSON",
             GetNearestParentPackageJSON);
+  SetMethod(isolate,
+            target,
+            "getNearestRawParentPackageJSON",
+            GetNearestRawParentPackageJSON);
   SetMethod(isolate, target, "getPackageScopeConfig", GetPackageScopeConfig);
   SetMethod(isolate, target, "enableCompileCache", EnableCompileCache);
   SetMethod(isolate, target, "getCompileCacheDir", GetCompileCacheDir);
@@ -527,6 +557,7 @@ void BindingData::RegisterExternalReferences(
   registry->Register(ReadPackageJSON);
   registry->Register(GetNearestParentPackageJSONType);
   registry->Register(GetNearestParentPackageJSON);
+  registry->Register(GetNearestRawParentPackageJSON);
   registry->Register(GetPackageScopeConfig);
   registry->Register(EnableCompileCache);
   registry->Register(GetCompileCacheDir);

src/node_modules.h

@@ -59,6 +59,8 @@ class BindingData : public SnapshotableObject {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetNearestParentPackageJSONType(
       const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetNearestRawParentPackageJSON(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetPackageScopeConfig(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetPackageJSONScripts(

test/fixtures/packages/nested-types-field/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "package-with-unrecognised-fields",
+  "type": "module",
+  "exports": {
+    "default": "./index.js",
+    "types": "./index.d.ts"
+  },
+  "unrecognised": true
+}

test/fixtures/packages/root-types-field/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "package-with-unrecognised-fields",
+  "type": "module",
+  "types": "./index.d.ts"
+}