esm: add back globalPreload tests and fix failing ones

PR-URL: #48779Fixes: #48778Fixes: #48516 Refs: #46402 Reviewed-By: Geoffrey Booth <[email protected]> Reviewed-By: Jacob Smith <[email protected]>

Author: aduh95

lib/internal/main/eval_string.js

@@ -24,7 +24,7 @@ markBootstrapComplete();
 
 constsource=getOptionValue('--eval');
 constprint=getOptionValue('--print');
-constloadESM=getOptionValue('--import').length>0;
+constloadESM=getOptionValue('--import').length>0||getOptionValue('--experimental-loader').length>0;
 if(getOptionValue('--input-type')==='module')
 evalModule(source,print);
 else{

lib/internal/modules/esm/hooks.js

@@ -10,6 +10,7 @@ const{
  Promise,
  SafeSet,
  StringPrototypeSlice,
+ StringPrototypeStartsWith,
  StringPrototypeToUpperCase,
  globalThis,
 }=primordials;
@@ -30,6 +31,7 @@ const{
 ERR_INVALID_RETURN_PROPERTY_VALUE,
 ERR_INVALID_RETURN_VALUE,
 ERR_LOADER_CHAIN_INCOMPLETE,
+ERR_UNKNOWN_BUILTIN_MODULE,
 ERR_WORKER_UNSERIALIZABLE_ERROR,
 }=require('internal/errors').codes;
 const{exitCodes: { kUnfinishedTopLevelAwait }}=internalBinding('errors');
@@ -521,14 +523,14 @@ class HooksProxy{
 this.#worker.on('exit',process.exit);
 }
 
-#waitForWorker(){
+waitForWorker(){
 if(!this.#isReady){
 const{ kIsOnline }=require('internal/worker');
 if(!this.#worker[kIsOnline]){
 debug('wait for signal from worker');
 AtomicsWait(this.#lock,WORKER_TO_MAIN_THREAD_NOTIFICATION,0);
 constresponse=this.#worker.receiveMessageSync();
-if(response.message.status==='exit'){return;}
+if(response==null||response.message.status==='exit'){return;}
 const{ preloadScripts }=this.#unwrapMessage(response);
 this.#executePreloadScripts(preloadScripts);
 }
@@ -538,7 +540,7 @@ class HooksProxy{
 }
 
 asyncmakeAsyncRequest(method, ...args){
-this.#waitForWorker();
+this.waitForWorker();
 
 MessageChannel??=require('internal/worker/io').MessageChannel;
 constasyncCommChannel=newMessageChannel();
@@ -578,7 +580,7 @@ class HooksProxy{
 }
 
 makeSyncRequest(method, ...args){
-this.#waitForWorker();
+this.waitForWorker();
 
 // Pass work to the worker.
 debug('post sync message to worker',{ method, args });
@@ -620,35 +622,66 @@ class HooksProxy{
 }
 }
 
+ #importMetaInitializer =require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
+
+importMetaInitialize(meta,context,loader){
+this.#importMetaInitializer(meta,context,loader);
+}
+
  #executePreloadScripts(preloadScripts){
 for(leti=0;i<preloadScripts.length;i++){
 const{ code, port }=preloadScripts[i];
 const{ compileFunction }=require('vm');
 constpreloadInit=compileFunction(
 code,
-['getBuiltin','port'],
+['getBuiltin','port','setImportMetaCallback'],
 {
 filename: '<preload>',
 },
 );
+letfinished=false;
+letreplacedImportMetaInitializer=false;
+letnext=this.#importMetaInitializer;
 const{ BuiltinModule }=require('internal/bootstrap/realm');
 // Calls the compiled preload source text gotten from the hook
 // Since the parameters are named we use positional parameters
 // see compileFunction above to cross reference the names
-FunctionPrototypeCall(
-preloadInit,
-globalThis,
-// Param getBuiltin
-(builtinName)=>{
-if(BuiltinModule.canBeRequiredByUsers(builtinName)&&
-BuiltinModule.canBeRequiredWithoutScheme(builtinName)){
-returnrequire(builtinName);
-}
-thrownewERR_INVALID_ARG_VALUE('builtinName',builtinName);
-},
-// Param port
-port,
-);
+try{
+FunctionPrototypeCall(
+preloadInit,
+globalThis,
+// Param getBuiltin
+(builtinName)=>{
+if(StringPrototypeStartsWith(builtinName,'node:')){
+builtinName=StringPrototypeSlice(builtinName,5);
+}elseif(!BuiltinModule.canBeRequiredWithoutScheme(builtinName)){
+thrownewERR_UNKNOWN_BUILTIN_MODULE(builtinName);
+}
+if(BuiltinModule.canBeRequiredByUsers(builtinName)){
+returnrequire(builtinName);
+}
+thrownewERR_UNKNOWN_BUILTIN_MODULE(builtinName);
+},
+// Param port
+port,
+// setImportMetaCallback
+(fn)=>{
+if(finished||typeoffn!=='function'){
+thrownewERR_INVALID_ARG_TYPE('fn',fn);
+}
+replacedImportMetaInitializer=true;
+constparent=next;
+next=(meta,context)=>{
+returnfn(meta,context,parent);
+};
+},
+);
+}finally{
+finished=true;
+if(replacedImportMetaInitializer){
+this.#importMetaInitializer =next;
+}
+}
 }
 }
 }

lib/internal/modules/esm/loader.js

@@ -277,6 +277,11 @@ class DefaultModuleLoader{
 meta=importMetaInitializer(meta,context,this);
 returnmeta;
 }
+
+/**
+ * No-op when no hooks have been supplied.
+ */
+forceLoadHooks(){}
 }
 ObjectSetPrototypeOf(DefaultModuleLoader.prototype,null);
 
@@ -349,6 +354,14 @@ class CustomizedModuleLoader extends DefaultModuleLoader{
 
 returnresult;
 }
+
+importMetaInitialize(meta,context){
+hooksProxy.importMetaInitialize(meta,context,this);
+}
+
+forceLoadHooks(){
+hooksProxy.waitForWorker();
+}
 }
 
 

lib/internal/process/esm_loader.js

@@ -36,6 +36,8 @@ module.exports ={
 parentURL,
 kEmptyObject,
 ));
+}else{
+esmLoader.forceLoadHooks();
 }
 awaitcallback(esmLoader);
 }catch(err){

test/es-module/test-esm-loader-hooks.mjs

@@ -1,6 +1,7 @@
 import{spawnPromisified}from'../common/index.mjs';
 import*asfixturesfrom'../common/fixtures.mjs';
 importassertfrom'node:assert';
+importosfrom'node:os';
 import{execPath}from'node:process';
 import{describe,it}from'node:test';
 
@@ -422,18 +423,119 @@ describe('Loader hooks',{concurrency: true }, () =>{
 });
 });
 
-it('should handle globalPreload returning undefined',async()=>{
-const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
-'--no-warnings',
-'--experimental-loader',
-'data:text/javascript,export function globalPreload(){}',
-fixtures.path('empty.js'),
-]);
+describe('globalPreload',()=>{
+it('should handle globalPreload returning undefined',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){}',
+fixtures.path('empty.js'),
+]);
 
-assert.strictEqual(stderr,'');
-assert.strictEqual(stdout,'');
-assert.strictEqual(code,0);
-assert.strictEqual(signal,null);
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout,'');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
+it('should handle loading node:test',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){return `getBuiltin("node:test")()`}',
+fixtures.path('empty.js'),
+]);
+
+assert.strictEqual(stderr,'');
+assert.match(stdout,/\n#pass1\r?\n/);
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
+it('should handle loading node:os with node: prefix',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){return `console.log(getBuiltin("node:os").arch())`}',
+fixtures.path('empty.js'),
+]);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),os.arch());
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
+// `os` is used here because it's simple and not mocked (the builtin module otherwise doesn't matter).
+it('should handle loading builtin module without node: prefix',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){return `console.log(getBuiltin("os").arch())`}',
+fixtures.path('empty.js'),
+]);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),os.arch());
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
+it('should throw when loading node:test without node: prefix',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){return `getBuiltin("test")()`}',
+fixtures.path('empty.js'),
+]);
+
+assert.match(stderr,/ERR_UNKNOWN_BUILTIN_MODULE/);
+assert.strictEqual(stdout,'');
+assert.strictEqual(code,1);
+assert.strictEqual(signal,null);
+});
+
+it('should register globals set from globalPreload',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){return "this.myGlobal=4"}',
+'--print','myGlobal',
+]);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'4');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
+it('should log console.log calls returned from globalPreload',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){return `console.log("Hello from globalPreload")`}',
+fixtures.path('empty.js'),
+]);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'Hello from globalPreload');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
+it('should crash if globalPreload returns code that throws',async()=>{
+const{ code, signal, stdout, stderr }=awaitspawnPromisified(execPath,[
+'--no-warnings',
+'--experimental-loader',
+'data:text/javascript,export function globalPreload(){return `throw new Error("error from globalPreload")`}',
+fixtures.path('empty.js'),
+]);
+
+assert.match(stderr,/errorfromglobalPreload/);
+assert.strictEqual(stdout,'');
+assert.strictEqual(code,1);
+assert.strictEqual(signal,null);
+});
 });
 
 it('should be fine to call `process.removeAllListeners("beforeExit")` from the main thread',async()=>{

test/es-module/test-esm-loader-mock.mjs

@@ -0,0 +1,45 @@
+// Flags: --loader ./test/fixtures/es-module-loaders/mock-loader.mjs
+import'../common/index.mjs';
+importassertfrom'assert/strict';
+
+// This is provided by test/fixtures/es-module-loaders/mock-loader.mjs
+importmockfrom'node:mock';
+
+mock('node:events',{
+EventEmitter: 'This is mocked!'
+});
+
+// This resolves to node:events
+// It is intercepted by mock-loader and doesn't return the normal value
+assert.deepStrictEqual(awaitimport('events'),Object.defineProperty({
+__proto__: null,
+EventEmitter: 'This is mocked!'
+},Symbol.toStringTag,{
+enumerable: false,
+value: 'Module'
+}));
+
+constmutator=mock('node:events',{
+EventEmitter: 'This is mocked v2!'
+});
+
+// It is intercepted by mock-loader and doesn't return the normal value.
+// This is resolved separately from the import above since the specifiers
+// are different.
+constmockedV2=awaitimport('node:events');
+assert.deepStrictEqual(mockedV2,Object.defineProperty({
+__proto__: null,
+EventEmitter: 'This is mocked v2!'
+},Symbol.toStringTag,{
+enumerable: false,
+value: 'Module'
+}));
+
+mutator.EventEmitter='This is mocked v3!';
+assert.deepStrictEqual(mockedV2,Object.defineProperty({
+__proto__: null,
+EventEmitter: 'This is mocked v3!'
+},Symbol.toStringTag,{
+enumerable: false,
+value: 'Module'
+}));