module: Set dynamic import callback

This is an initial implementation to support dynamic import in both scripts and modules. It's off by default since support for dynamic import is still flagged in V8. Without setting the V8 flag, this code won't be executed. This initial version does not support importing into vm contexts. Backport-PR-URL: #17823 PR-URL: #15713 Reviewed-By: Timothy Gu <[email protected]> Reviewed-By: Bradley Farias <[email protected]>

Author: Jan Krems

.eslintignore

@@ -1,6 +1,7 @@
 lib/internal/v8_prof_polyfill.js
 lib/punycode.js
 test/addons/??_*
+test/es-module/test-esm-dynamic-import.js
 test/fixtures
 test/message/esm_display_syntax_error.mjs
 tools/node_modules

lib/internal/loader/Loader.js

@@ -1,8 +1,12 @@
 'use strict';
 
-const{ getURLFromFilePath }=require('internal/url');
+constpath=require('path');
+const{ getURLFromFilePath,URL}=require('internal/url');
 
-const{ createDynamicModule }=require('internal/loader/ModuleWrap');
+const{
+ createDynamicModule,
+ setImportModuleDynamicallyCallback
+}=require('internal/loader/ModuleWrap');
 
 constModuleMap=require('internal/loader/ModuleMap');
 constModuleJob=require('internal/loader/ModuleJob');
@@ -24,6 +28,13 @@ function getURLStringForCwd(){
 }
 }
 
+functionnormalizeReferrerURL(referrer){
+if(typeofreferrer==='string'&&path.isAbsolute(referrer)){
+returngetURLFromFilePath(referrer).href;
+}
+returnnewURL(referrer).href;
+}
+
 /* A Loader instance is used as the main entry point for loading ES modules.
  * Currently, this is a singleton -- there is only one used for loading
  * the main module and everything in its dependency graph. */
@@ -129,6 +140,12 @@ class Loader{
 constmodule=awaitjob.run();
 returnmodule.namespace();
 }
+
+staticregisterImportDynamicallyCallback(loader){
+setImportModuleDynamicallyCallback(async(referrer,specifier)=>{
+returnloader.import(specifier,normalizeReferrerURL(referrer));
+});
+}
 }
 Loader.validFormats=['esm','cjs','builtin','addon','json','dynamic'];
 Object.setPrototypeOf(Loader.prototype,null);

lib/internal/loader/ModuleWrap.js

@@ -1,6 +1,9 @@
 'use strict';
 
-const{ ModuleWrap }=internalBinding('module_wrap');
+const{
+ ModuleWrap,
+ setImportModuleDynamicallyCallback
+}=internalBinding('module_wrap');
 constdebug=require('util').debuglog('esm');
 constArrayJoin=Function.call.bind(Array.prototype.join);
 constArrayMap=Function.call.bind(Array.prototype.map);
@@ -59,5 +62,6 @@ const createDynamicModule = (exports, url = '', evaluate) =>{
 
 module.exports={
  createDynamicModule,
+ setImportModuleDynamicallyCallback,
  ModuleWrap
 };

lib/module.js

@@ -469,6 +469,7 @@ Module._load = function(request, parent, isMain){
 ESMLoader.hook(hooks);
 }
 }
+Loader.registerImportDynamicallyCallback(ESMLoader);
 awaitESMLoader.import(getURLFromFilePath(request).pathname);
 })()
 .catch((e)=>{

src/env.h

@@ -283,6 +283,7 @@ class ModuleWrap;
 V(async_hooks_binding, v8::Object) \
 V(buffer_prototype_object, v8::Object) \
 V(context, v8::Context) \
+V(host_import_module_dynamically_callback, v8::Function) \
 V(http2ping_constructor_template, v8::ObjectTemplate) \
 V(http2stream_constructor_template, v8::ObjectTemplate) \
 V(http2settings_constructor_template, v8::ObjectTemplate) \

src/module_wrap.cc

@@ -566,6 +566,62 @@ void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args){
  args.GetReturnValue().Set(result.FromJust().ToObject(env));
 }
 
+static MaybeLocal<Promise> ImportModuleDynamically(
+ Local<Context> context,
+ Local<v8::ScriptOrModule> referrer,
+ Local<String> specifier){
+ Isolate* iso = context->GetIsolate();
+ Environment* env = Environment::GetCurrent(context);
+ v8::EscapableHandleScope handle_scope(iso);
+
+if (env->context() != context){
+auto maybe_resolver = Promise::Resolver::New(context);
+ Local<Promise::Resolver> resolver;
+if (maybe_resolver.ToLocal(&resolver)){
+// TODO(jkrems): Turn into proper error object w/ code
+ Local<Value> error = v8::Exception::Error(
+OneByteString(iso, "import() called outside of main context"));
+if (resolver->Reject(context, error).IsJust()){
+return handle_scope.Escape(resolver.As<Promise>());
+ }
+ }
+return MaybeLocal<Promise>();
+ }
+
+ Local<Function> import_callback =
+ env->host_import_module_dynamically_callback();
+ Local<Value> import_args[] ={
+ referrer->GetResourceName(),
+ Local<Value>(specifier)
+ };
+ MaybeLocal<Value> maybe_result = import_callback->Call(context,
+v8::Undefined(iso),
+2,
+ import_args);
+
+ Local<Value> result;
+if (maybe_result.ToLocal(&result)){
+return handle_scope.Escape(result.As<Promise>());
+ }
+return MaybeLocal<Promise>();
+}
+
+voidModuleWrap::SetImportModuleDynamicallyCallback(
+const FunctionCallbackInfo<Value>& args){
+ Isolate* iso = args.GetIsolate();
+ Environment* env = Environment::GetCurrent(args);
+ HandleScope handle_scope(iso);
+if (!args[0]->IsFunction()){
+ env->ThrowError("first argument is not a function");
+return;
+ }
+
+ Local<Function> import_callback = args[0].As<Function>();
+ env->set_host_import_module_dynamically_callback(import_callback);
+
+ iso->SetHostImportModuleDynamicallyCallback(ImportModuleDynamically);
+}
+
 voidModuleWrap::Initialize(Local<Object> target,
  Local<Value> unused,
  Local<Context> context){
@@ -583,6 +639,9 @@ void ModuleWrap::Initialize(Local<Object> target,
 
  target->Set(FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"), tpl->GetFunction());
  env->SetMethod(target, "resolve", node::loader::ModuleWrap::Resolve);
+ env->SetMethod(target,
+"setImportModuleDynamicallyCallback",
+ node::loader::ModuleWrap::SetImportModuleDynamicallyCallback);
 }
 
 } // namespace loader

src/module_wrap.h

@@ -39,6 +39,8 @@ class ModuleWrap : public BaseObject{
 staticvoidGetUrl(v8::Local<v8::String> property,
 const v8::PropertyCallbackInfo<v8::Value>& info);
 staticvoidResolve(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidSetImportModuleDynamicallyCallback(
+const v8::FunctionCallbackInfo<v8::Value>& args);
 static v8::MaybeLocal<v8::Module> ResolveCallback(
  v8::Local<v8::Context> context,
  v8::Local<v8::String> specifier,

test/es-module/test-esm-dynamic-import.js

@@ -0,0 +1,113 @@
+// Flags: --experimental-modules --harmony-dynamic-import
+'use strict';
+constcommon=require('../common');
+constassert=require('assert');
+const{URL}=require('url');
+constvm=require('vm');
+
+common.crashOnUnhandledRejection();
+
+constrelativePath='./test-esm-ok.mjs';
+constabsolutePath=require.resolve('./test-esm-ok.mjs');
+consttargetURL=newURL('file:///');
+targetURL.pathname=absolutePath;
+
+functionexpectErrorProperty(result,propertyKey,value){
+Promise.resolve(result)
+.catch(common.mustCall(error=>{
+assert.equal(error[propertyKey],value);
+}));
+}
+
+functionexpectMissingModuleError(result){
+expectErrorProperty(result,'code','MODULE_NOT_FOUND');
+}
+
+functionexpectInvalidUrlError(result){
+expectErrorProperty(result,'code','ERR_INVALID_URL');
+}
+
+functionexpectInvalidReferrerError(result){
+expectErrorProperty(result,'code','ERR_INVALID_URL');
+}
+
+functionexpectInvalidProtocolError(result){
+expectErrorProperty(result,'code','ERR_INVALID_PROTOCOL');
+}
+
+functionexpectInvalidContextError(result){
+expectErrorProperty(result,
+'message','import() called outside of main context');
+}
+
+functionexpectOkNamespace(result){
+Promise.resolve(result)
+.then(common.mustCall(ns=>{
+// Can't deepStrictEqual because ns isn't a normal object
+assert.deepEqual(ns,{default: true});
+}));
+}
+
+functionexpectFsNamespace(result){
+Promise.resolve(result)
+.then(common.mustCall(ns=>{
+assert.equal(typeofns.default.writeFile,'function');
+}));
+}
+
+// For direct use of import expressions inside of CJS or ES modules, including
+// via eval, all kinds of specifiers should work without issue.
+(functiontestScriptOrModuleImport(){
+// Importing another file, both direct & via eval
+// expectOkNamespace(import(relativePath));
+expectOkNamespace(eval.call(null,`import("${relativePath}")`));
+expectOkNamespace(eval(`import("${relativePath}")`));
+expectOkNamespace(eval.call(null,`import("${targetURL}")`));
+
+// Importing a built-in, both direct & via eval
+expectFsNamespace(import("fs"));
+expectFsNamespace(eval('import("fs")'));
+expectFsNamespace(eval.call(null,'import("fs")'));
+
+expectMissingModuleError(import("./not-an-existing-module.mjs"));
+// TODO(jkrems): Right now this doesn't hit a protocol error because the
+// module resolution step already rejects it. These arguably should be
+// protocol errors.
+expectMissingModuleError(import("node:fs"));
+expectMissingModuleError(import('http://example.com/foo.js'));
+})();
+
+// vm.runInThisContext:
+// * Supports built-ins, always
+// * Supports imports if the script has a known defined origin
+(functiontestRunInThisContext(){
+// Succeeds because it's got an valid base url
+expectFsNamespace(vm.runInThisContext(`import("fs")`,{
+filename: __filename,
+}));
+expectOkNamespace(vm.runInThisContext(`import("${relativePath}")`,{
+filename: __filename,
+}));
+// Rejects because it's got an invalid referrer URL.
+// TODO(jkrems): Arguably the first two (built-in + absolute URL) could work
+// with some additional effort.
+expectInvalidReferrerError(vm.runInThisContext('import("fs")'));
+expectInvalidReferrerError(vm.runInThisContext(`import("${targetURL}")`));
+expectInvalidReferrerError(vm.runInThisContext(`import("${relativePath}")`));
+})();
+
+// vm.runInNewContext is currently completely unsupported, pending well-defined
+// semantics for per-context/realm module maps in node.
+(functiontestRunInNewContext(){
+// Rejects because it's running in the wrong context
+expectInvalidContextError(
+vm.runInNewContext(`import("${targetURL}")`,undefined,{
+filename: __filename,
+})
+);
+
+// Rejects because it's running in the wrong context
+expectInvalidContextError(vm.runInNewContext(`import("fs")`,undefined,{
+filename: __filename,
+}));
+})();