sea: allow requiring core modules with the "node:" prefix

Previously, the `require()` function exposed to the embedded SEA code
was calling the internal `require()` function if the module name
belonged to the list of public core modules but the internal `require()`
function does not support loading modules with the "node:" prefix, so
this change forwards the calls to another `require()` function that
supports this.

Fixes: nodejs/single-executable#69
Signed-off-by: Darshan Sen <[email protected]>
PR-URL: #47779
Reviewed-By: Colin Ihrig <[email protected]>
Reviewed-By: Luigi Pinca <[email protected]>
Reviewed-By: Michael Dawson <[email protected]>
Reviewed-By: Joyee Cheung <[email protected]>

Author: RaisinTen

lib/internal/bootstrap/realm.js

@@ -285,6 +285,20 @@ class BuiltinModule {
     return canBeRequiredByUsersWithoutSchemeList.has(id);
   }
 
+  static normalizeRequirableId(id) {
+    let normalizedId = id;
+    if (StringPrototypeStartsWith(id, 'node:')) {
+      normalizedId = StringPrototypeSlice(id, 5);
+    }
+
+    if (!BuiltinModule.canBeRequiredByUsers(normalizedId) ||
+        (id === normalizedId && !BuiltinModule.canBeRequiredWithoutScheme(normalizedId))) {
+      return undefined;
+    }
+
+    return normalizedId;
+  }
+
   static isBuiltin(id) {
     return BuiltinModule.canBeRequiredWithoutScheme(id) || (
       typeof id === 'string' &&

lib/internal/main/mksnapshot.js

@@ -7,12 +7,10 @@ const {
   ObjectSetPrototypeOf,
   SafeArrayIterator,
   SafeSet,
-  StringPrototypeStartsWith,
-  StringPrototypeSlice,
 } = primordials;
 
 const binding = internalBinding('mksnapshot');
-const { BuiltinModule } = require('internal/bootstrap/realm');
+const { BuiltinModule: { normalizeRequirableId } } = require('internal/bootstrap/realm');
 const {
   getEmbedderEntryFunction,
   compileSerializeMain,
@@ -98,13 +96,8 @@ function supportedInUserSnapshot(id) {
 }
 
 function requireForUserSnapshot(id) {
-  let normalizedId = id;
-  if (StringPrototypeStartsWith(id, 'node:')) {
-    normalizedId = StringPrototypeSlice(id, 5);
-  }
-  if (!BuiltinModule.canBeRequiredByUsers(normalizedId) ||
-      (id !== normalizedId &&
-        !BuiltinModule.canBeRequiredWithoutScheme(normalizedId))) {
+  const normalizedId = normalizeRequirableId(id);
+  if (!normalizedId) {
     // eslint-disable-next-line no-restricted-syntax
     const err = new Error(
       `Cannot find module '${id}'. `,

lib/internal/util/embedding.js

@@ -1,5 +1,6 @@
 'use strict';
 const { codes: { ERR_UNKNOWN_BUILTIN_MODULE } } = require('internal/errors');
+const { BuiltinModule: { normalizeRequirableId } } = require('internal/bootstrap/realm');
 const { Module, wrapSafe } = require('internal/modules/cjs/loader');
 
 // This is roughly the same as:
@@ -36,12 +37,12 @@ function embedderRunCjs(contents) {
     customDirname);
 }
 
-function embedderRequire(path) {
-  if (!Module.isBuiltin(path)) {
-    throw new ERR_UNKNOWN_BUILTIN_MODULE(path);
+function embedderRequire(id) {
+  const normalizedId = normalizeRequirableId(id);
+  if (!normalizedId) {
+    throw new ERR_UNKNOWN_BUILTIN_MODULE(id);
   }
-
-  return require(path);
+  return require(normalizedId);
 }
 
 module.exports = { embedderRequire, embedderRunCjs };

test/fixtures/sea.js

@@ -9,8 +9,23 @@ expectWarning('ExperimentalWarning',
               'Single executable application is an experimental feature and ' +
               'might change at any time');
 
+// Should be possible to require core modules that optionally require the
+// "node:" scheme.
 const { deepStrictEqual, strictEqual, throws } = require('assert');
-const { dirname } = require('path');
+const { dirname } = require('node:path');
+
+// Should be possible to require a core module that requires using the "node:"
+// scheme.
+{
+  const { test } = require('node:test');
+  strictEqual(typeof test, 'function');
+}
+
+// Should not be possible to require a core module without the "node:" scheme if
+// it requires using the "node:" scheme.
+throws(() => require('test'), {
+  code: 'ERR_UNKNOWN_BUILTIN_MODULE',
+});
 
 deepStrictEqual(process.argv, [process.execPath, process.execPath, '-a', '--b=c', 'd']);