nodejs · aduh95 · Mar 19, 2021 · Feb 6, 2021 · Feb 6, 2021 · richardlau
diff --git a/doc/api/esm.md b/doc/api/esm.md
@@ -204,6 +204,10 @@ import _ from 'data:application/json,"world!"';
 added:
   - v14.13.1
   - v12.20.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37246
+    description: Added `node:` import support to `require(...)`.
 -->
 
 `node:` URLs are supported as an alternative means to load Node.js builtin

diff --git a/doc/api/modules.md b/doc/api/modules.md
@@ -280,6 +280,12 @@
 ## Core modules
 
 <!--type=misc-->
+<!-- YAML
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/37246
+    description: Added `node:` import support to `require(...)`.
+-->
 
 Node.js has several modules compiled into the binary. These modules are
 described in greater detail elsewhere in this documentation.
@@ -291,6 +297,11 @@
 passed to `require()`. For instance, `require('http')` will always
 return the built in HTTP module, even if there is a file by that name.
 
+Core modules can also be identified using the `node:` prefix, in which case
+it bypasses the `require` cache. For instance, `require('node:http')` will
+always return the built in HTTP module, even if there is `require.cache` entry
+by that name.
+
 ## Cycles
 
 <!--type=misc-->
@@ -642,8 +653,19 @@
 
 Adding or replacing entries is also possible. This cache is checked before
 native modules and if a name matching a native module is added to the cache,
-no require call is
-going to receive the native module anymore. Use with care!
+only `node:`-prefixed require calls are going to receive the native module.
+Use with care!
+
+```js
+const assert = require('assert');
+const realFs = require('fs');
+
+const fakeFs = {};
+require.cache.fs = { exports: fakeFs };
+
+assert.strictEqual(require('fs'), fakeFs);
+assert.strictEqual(require('node:fs'), realFs);
+```
 
 #### `require.extensions`
 <!-- YAML

diff --git a/lib/internal/modules/cjs/helpers.js b/lib/internal/modules/cjs/helpers.js
@@ -34,8 +34,9 @@ const cjsConditions = new SafeSet(['require', 'node', ...userConditions]);
 
 function loadNativeModule(filename, request) {
   const mod = NativeModule.map.get(filename);
-  if (mod) {
+  if (mod?.canBeRequiredByUsers) {
     debug('load native module %s', request);
+    // compileForPublicLoader() throws if mod.canBeRequiredByUsers is false:
     mod.compileForPublicLoader();
     return mod;
   }

diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
@@ -110,7 +110,8 @@ let hasLoadedAnyUserCJSModule = false;
 const {
   ERR_INVALID_ARG_VALUE,
   ERR_INVALID_MODULE_SPECIFIER,
-  ERR_REQUIRE_ESM
+  ERR_REQUIRE_ESM,
+  ERR_UNKNOWN_BUILTIN_MODULE,
 } = require('internal/errors').codes;
 const { validateString } = require('internal/validators');
 const pendingDeprecation = getOptionValue('--pending-deprecation');
@@ -770,6 +771,17 @@ Module._load = function(request, parent, isMain) {
   }
 
   const filename = Module._resolveFilename(request, parent, isMain);
+  if (StringPrototypeStartsWith(filename, 'node:')) {
+    // Slice 'node:' prefix
+    const id = StringPrototypeSlice(filename, 5);
+
+    const module = loadNativeModule(id, request);
+    if (!module?.canBeRequiredByUsers) {
+      throw new ERR_UNKNOWN_BUILTIN_MODULE(filename);
+    }
+
+    return module.exports;
+  }
 
   const cachedModule = Module._cache[filename];
   if (cachedModule !== undefined) {
@@ -841,7 +853,8 @@ Module._load = function(request, parent, isMain) {
 };
 
 Module._resolveFilename = function(request, parent, isMain, options) {
-  if (NativeModule.canBeRequiredByUsers(request)) {
+  if (StringPrototypeStartsWith(request, 'node:') ||
+      NativeModule.canBeRequiredByUsers(request)) {
     return request;
   }
 

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
@@ -282,7 +282,7 @@ translators.set('builtin', async function builtinStrategy(url) {
   debug(`Translating BuiltinModule ${url}`);
   // Slice 'node:' scheme
   const id = StringPrototypeSlice(url, 5);
-  const module = loadNativeModule(id, url, true);
+  const module = loadNativeModule(id, url);
   if (!StringPrototypeStartsWith(url, 'node:') || !module) {
     throw new ERR_UNKNOWN_BUILTIN_MODULE(url);
   }

diff --git a/lib/repl.js b/lib/repl.js
@@ -1113,7 +1113,7 @@ REPLServer.prototype.setPrompt = function setPrompt(prompt) {
 };
 
 const importRE = /\bimport\s*\(\s*['"`](([\w@./:-]+\/)?(?:[\w@./:-]*))(?![^'"`])$/;
-const requireRE = /\brequire\s*\(\s*['"`](([\w@./-]+\/)?(?:[\w@./-]*))(?![^'"`])$/;
+const requireRE = /\brequire\s*\(\s*['"`](([\w@./:-]+\/)?(?:[\w@./:-]*))(?![^'"`])$/;
 const fsAutoCompleteRE = /fs(?:\.promises)?\.\s*[a-z][a-zA-Z]+\(\s*["'](.*)/;
 const simpleExpressionRE =
     /(?:[a-zA-Z_$](?:\w|\$)*\??\.)*[a-zA-Z_$](?:\w|\$)*\??\.?$/;
@@ -1275,7 +1275,7 @@ function complete(line, callback) {
     }
 
     if (!subdir) {
-      ArrayPrototypePush(completionGroups, _builtinLibs);
+      ArrayPrototypePush(completionGroups, _builtinLibs, nodeSchemeBuiltinLibs);
     }
   } else if (RegExpPrototypeTest(importRE, line) &&
              this.allowBlockingCompletions) {

diff --git a/test/es-module/test-esm-dynamic-import.js b/test/es-module/test-esm-dynamic-import.js
@@ -51,6 +51,8 @@ function expectFsNamespace(result) {
 
   expectModuleError(import('node:unknown'),
                     'ERR_UNKNOWN_BUILTIN_MODULE');
+  expectModuleError(import('node:internal/test/binding'),
+                    'ERR_UNKNOWN_BUILTIN_MODULE');
   expectModuleError(import('./not-an-existing-module.mjs'),
                     'ERR_MODULE_NOT_FOUND');
   expectModuleError(import('http://example.com/foo.js'),

diff --git a/test/parallel/test-repl-tab-complete.js b/test/parallel/test-repl-tab-complete.js
@@ -31,6 +31,10 @@ const assert = require('assert');
 const path = require('path');
 const fixtures = require('../common/fixtures');
 const { builtinModules } = require('module');
+const publicModules = builtinModules.filter(
+  (lib) => !lib.startsWith('_') && !lib.includes('/'),
+);
+
 const hasInspector = process.features.inspector;
 
 if (!common.isMainThread)
@@ -239,9 +243,9 @@ putIn.run(['.clear']);
 
 testMe.complete('require(\'', common.mustCall(function(error, data) {
   assert.strictEqual(error, null);
-  builtinModules.forEach((lib) => {
+  publicModules.forEach((lib) => {
     assert(
-      data[0].includes(lib) || lib.startsWith('_') || lib.includes('/'),
+      data[0].includes(lib) && data[0].includes(`node:${lib}`),
       `${lib} not found`
     );
   });
@@ -258,11 +262,15 @@ testMe.complete("require\t( 'n", common.mustCall(function(error, data) {
   assert.strictEqual(error, null);
   assert.strictEqual(data.length, 2);
   assert.strictEqual(data[1], 'n');
+  // require(...) completions include `node:`-prefixed modules:
+  publicModules.forEach((lib, index) =>
+    assert.strictEqual(data[0][index], `node:${lib}`));
+  assert.strictEqual(data[0][publicModules.length], '');
   // There is only one Node.js module that starts with n:
-  assert.strictEqual(data[0][0], 'net');
-  assert.strictEqual(data[0][1], '');
+  assert.strictEqual(data[0][publicModules.length + 1], 'net');
+  assert.strictEqual(data[0][publicModules.length + 2], '');
   // It's possible to pick up non-core modules too
-  data[0].slice(2).forEach((completion) => {
+  data[0].slice(publicModules.length + 3).forEach((completion) => {
     assert.match(completion, /^n/);
   });
 }));

diff --git a/test/parallel/test-require-node-prefix.js b/test/parallel/test-require-node-prefix.js
@@ -0,0 +1,42 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+const errUnknownBuiltinModuleRE = /^No such built-in module: /u;
+
+// For direct use of require expressions inside of CJS modules,
+// all kinds of specifiers should work without issue.
+{
+  assert.strictEqual(require('fs'), fs);
+  assert.strictEqual(require('node:fs'), fs);
+
+  assert.throws(
+    () => require('node:unknown'),
+    {
+      code: 'ERR_UNKNOWN_BUILTIN_MODULE',
+      message: errUnknownBuiltinModuleRE,
+    },
+  );
+
+  assert.throws(
+    () => require('node:internal/test/binding'),
+    {
+      code: 'ERR_UNKNOWN_BUILTIN_MODULE',
+      message: errUnknownBuiltinModuleRE,
+    },
+  );
+}
+
+// `node:`-prefixed `require(...)` calls bypass the require cache:
 if (redirects) { 
 if (redirects) { 
+{
+  const fakeModule = {};
+
+  require.cache.fs = { exports: fakeModule };
+
+  assert.strictEqual(require('fs'), fakeModule);
+  assert.strictEqual(require('node:fs'), fs);
+
+  delete require.cache.fs;
+}