vm: add importModuleDynamically option to compileFunction

Fixes: #31860

PR-URL: #32985
Reviewed-By: Anna Henningsen <[email protected]>
Reviewed-By: Michaël Zasso <[email protected]>

Author: devsnek

doc/api/vm.md

@@ -88,7 +88,7 @@ changes:
     This option is part of the experimental modules API, and should not be
     considered stable.
     * `specifier` {string} specifier passed to `import()`
-    * `module` {vm.Module}
+    * `script` {vm.Script}
     * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
       recommended in order to take advantage of error tracking, and to avoid
       issues with namespaces that contain `then` function exports.
@@ -773,6 +773,10 @@ const vm = require('vm');
 ## `vm.compileFunction(code[, params[, options]])`
 <!-- YAML
 added: v10.10.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/32985
+    description: The `importModuleDynamically` option is now supported.
 -->
 
 * `code` {string} The body of the function to compile.
@@ -795,6 +799,16 @@ added: v10.10.0
   * `contextExtensions` {Object[]} An array containing a collection of context
     extensions (objects wrapping the current scope) to be applied while
     compiling. **Default:** `[]`.
+  * `importModuleDynamically` {Function} Called during evaluation of this module
+    when `import()` is called. If this option is not specified, calls to
+    `import()` will reject with [`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`][].
+    This option is part of the experimental modules API, and should not be
+    considered stable.
+    * `specifier` {string} specifier passed to `import()`
+    * `function` {Function}
+    * Returns: {Module Namespace Object|vm.Module} Returning a `vm.Module` is
+      recommended in order to take advantage of error tracking, and to avoid
+      issues with namespaces that contain `then` function exports.
 * Returns: {Function}
 
 Compiles the given code into the provided context (if no context is

lib/internal/modules/cjs/loader.js

@@ -77,7 +77,6 @@ const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
 const manifest = getOptionValue('--experimental-policy') ?
   require('internal/process/policy').manifest :
   null;
-const { compileFunction } = internalBinding('contextify');
 
 // Whether any user-provided CJS modules had been loaded (executed).
 // Used for internal assertions.
@@ -1100,40 +1099,25 @@ function wrapSafe(filename, content, cjsModuleInstance) {
       },
     });
   }
-  let compiled;
   try {
-    compiled = compileFunction(
-      content,
+    return vm.compileFunction(content, [
+      'exports',
+      'require',
+      'module',
+      '__filename',
+      '__dirname',
+    ], {
       filename,
-      0,
-      0,
-      undefined,
-      false,
-      undefined,
-      [],
-      [
-        'exports',
-        'require',
-        'module',
-        '__filename',
-        '__dirname',
-      ]
-    );
+      importModuleDynamically(specifier) {
+        const loader = asyncESM.ESMLoader;
+        return loader.import(specifier, normalizeReferrerURL(filename));
+      },
+    });
   } catch (err) {
     if (process.mainModule === cjsModuleInstance)
       enrichCJSError(err);
     throw err;
   }
-
-  const { callbackMap } = internalBinding('module_wrap');
-  callbackMap.set(compiled.cacheKey, {
-    importModuleDynamically: async (specifier) => {
-      const loader = asyncESM.ESMLoader;
-      return loader.import(specifier, normalizeReferrerURL(filename));
-    }
-  });
-
-  return compiled.function;
 }
 
 // Run the file contents in the correct scope or sandbox. Expose

lib/vm.js

@@ -313,6 +313,7 @@ function compileFunction(code, params, options = {}) {
     produceCachedData = false,
     parsingContext = undefined,
     contextExtensions = [],
+    importModuleDynamically,
   } = options;
 
   validateString(filename, 'options.filename');
@@ -360,6 +361,22 @@ function compileFunction(code, params, options = {}) {
     result.function.cachedData = result.cachedData;
   }
 
+  if (importModuleDynamically !== undefined) {
+    if (typeof importModuleDynamically !== 'function') {
+      throw new ERR_INVALID_ARG_TYPE('options.importModuleDynamically',
+                                     'function',
+                                     importModuleDynamically);
+    }
+    const { importModuleDynamicallyWrap } =
+      require('internal/vm/module');
+    const { callbackMap } = internalBinding('module_wrap');
+    const wrapped = importModuleDynamicallyWrap(importModuleDynamically);
+    const func = result.function;
+    callbackMap.set(result.cacheKey, {
+      importModuleDynamically: (s, _k) => wrapped(s, func),
+    });
+  }
+
   return result.function;
 }
 

test/parallel/test-vm-module-basic.js

@@ -8,7 +8,8 @@ const {
   Module,
   SourceTextModule,
   SyntheticModule,
-  createContext
+  createContext,
+  compileFunction,
 } = require('vm');
 const util = require('util');
 
@@ -147,3 +148,19 @@ const util = require('util');
     name: 'TypeError'
   });
 }
+
+// Test compileFunction importModuleDynamically
+{
+  const module = new SyntheticModule([], () => {});
+  module.link(() => {});
+  const f = compileFunction('return import("x")', [], {
+    importModuleDynamically(specifier, referrer) {
+      assert.strictEqual(specifier, 'x');
+      assert.strictEqual(referrer, f);
+      return module;
+    },
+  });
+  f().then((ns) => {
+    assert.strictEqual(ns, module.namespace);
+  });
+}

tools/doc/type-parser.js

@@ -148,6 +148,7 @@ const customTypesMap = {
   'URLSearchParams': 'url.html#url_class_urlsearchparams',
 
   'vm.Module': 'vm.html#vm_class_vm_module',
+  'vm.Script': 'vm.html#vm_class_vm_script',
   'vm.SourceTextModule': 'vm.html#vm_class_vm_sourcetextmodule',
 
   'MessagePort': 'worker_threads.html#worker_threads_class_messageport',