Skip to content

Commit 652a74f

Browse files
aduh95aduh95
committed
esm: add back globalPreload tests and fix failing ones
This reverts commit 938341a.
1 parent 86a75f4 commit 652a74f

File tree

7 files changed

+474
-31
lines changed

7 files changed

+474
-31
lines changed

‎lib/internal/main/eval_string.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ markBootstrapComplete();
2424

2525
const source = getOptionValue('--eval');
2626
const print = getOptionValue('--print');
27-
const loadESM = getOptionValue('--import').length > 0;
27+
const loadESM = getOptionValue('--import').length > 0 || getOptionValue('--experimental-loader').length > 0;
2828
if (getOptionValue('--input-type') === 'module')
2929
evalModule(source, print);
3030
else {

‎lib/internal/modules/esm/hooks.js

Lines changed: 52 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ const {
1010
Promise,
1111
SafeSet,
1212
StringPrototypeSlice,
13+
StringPrototypeStartsWith,
1314
StringPrototypeToUpperCase,
1415
globalThis,
1516
} = primordials;
@@ -30,6 +31,7 @@ const {
3031
ERR_INVALID_RETURN_PROPERTY_VALUE,
3132
ERR_INVALID_RETURN_VALUE,
3233
ERR_LOADER_CHAIN_INCOMPLETE,
34+
ERR_UNKNOWN_BUILTIN_MODULE,
3335
ERR_WORKER_UNSERIALIZABLE_ERROR,
3436
} = require('internal/errors').codes;
3537
const { exitCodes: { kUnfinishedTopLevelAwait } } = internalBinding('errors');
@@ -521,14 +523,14 @@ class HooksProxy {
521523
this.#worker.on('exit', process.exit);
522524
}
523525

524-
#waitForWorker() {
526+
waitForWorker() {
525527
if (!this.#isReady) {
526528
const { kIsOnline } = require('internal/worker');
527529
if (!this.#worker[kIsOnline]) {
528530
debug('wait for signal from worker');
529531
AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0);
530532
const response = this.#worker.receiveMessageSync();
531-
if (response.message.status === 'exit') { return; }
533+
if (response == null || response.message.status === 'exit') { return; }
532534
const { preloadScripts } = this.#unwrapMessage(response);
533535
this.#executePreloadScripts(preloadScripts);
534536
}
@@ -538,7 +540,7 @@ class HooksProxy {
538540
}
539541

540542
async makeAsyncRequest(method, ...args) {
541-
this.#waitForWorker();
543+
this.waitForWorker();
542544

543545
MessageChannel ??= require('internal/worker/io').MessageChannel;
544546
const asyncCommChannel = new MessageChannel();
@@ -578,7 +580,7 @@ class HooksProxy {
578580
}
579581

580582
makeSyncRequest(method, ...args) {
581-
this.#waitForWorker();
583+
this.waitForWorker();
582584

583585
// Pass work to the worker.
584586
debug('post sync message to worker', { method, args });
@@ -620,35 +622,66 @@ class HooksProxy {
620622
}
621623
}
622624

625+
#importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
626+
627+
importMetaInitialize(meta, context, loader) {
628+
this.#importMetaInitializer(meta, context, loader);
629+
}
630+
623631
#executePreloadScripts(preloadScripts) {
624632
for (let i = 0; i < preloadScripts.length; i++) {
625633
const { code, port } = preloadScripts[i];
626634
const { compileFunction } = require('vm');
627635
const preloadInit = compileFunction(
628636
code,
629-
['getBuiltin', 'port'],
637+
['getBuiltin', 'port', 'setImportMetaCallback'],
630638
{
631639
filename: '<preload>',
632640
},
633641
);
642+
let finished = false;
643+
let replacedImportMetaInitializer = false;
644+
let next = this.#importMetaInitializer;
634645
const { BuiltinModule } = require('internal/bootstrap/realm');
635646
// Calls the compiled preload source text gotten from the hook
636647
// Since the parameters are named we use positional parameters
637648
// see compileFunction above to cross reference the names
638-
FunctionPrototypeCall(
639-
preloadInit,
640-
globalThis,
641-
// Param getBuiltin
642-
(builtinName) => {
643-
if (BuiltinModule.canBeRequiredByUsers(builtinName) &&
644-
BuiltinModule.canBeRequiredWithoutScheme(builtinName)) {
645-
return require(builtinName);
646-
}
647-
throw new ERR_INVALID_ARG_VALUE('builtinName', builtinName);
648-
},
649-
// Param port
650-
port,
651-
);
649+
try {
650+
FunctionPrototypeCall(
651+
preloadInit,
652+
globalThis,
653+
// Param getBuiltin
654+
(builtinName) => {
655+
if (StringPrototypeStartsWith(builtinName, 'node:')) {
656+
builtinName = StringPrototypeSlice(builtinName, 5);
657+
} else if (!BuiltinModule.canBeRequiredWithoutScheme(builtinName)) {
658+
throw new ERR_UNKNOWN_BUILTIN_MODULE(builtinName);
659+
}
660+
if (BuiltinModule.canBeRequiredByUsers(builtinName)) {
661+
return require(builtinName);
662+
}
663+
throw new ERR_UNKNOWN_BUILTIN_MODULE(builtinName);
664+
},
665+
// Param port
666+
port,
667+
// setImportMetaCallback
668+
(fn) => {
669+
if (finished || typeof fn !== 'function') {
670+
throw new ERR_INVALID_ARG_TYPE('fn', fn);
671+
}
672+
replacedImportMetaInitializer = true;
673+
const parent = next;
674+
next = (meta, context) => {
675+
return fn(meta, context, parent);
676+
};
677+
},
678+
);
679+
} finally {
680+
finished = true;
681+
if (replacedImportMetaInitializer) {
682+
this.#importMetaInitializer = next;
683+
}
684+
}
652685
}
653686
}
654687
}

‎lib/internal/modules/esm/loader.js

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -277,6 +277,11 @@ class DefaultModuleLoader {
277277
meta = importMetaInitializer(meta, context, this);
278278
return meta;
279279
}
280+
281+
/**
282+
* No-op when no hooks have been supplied.
283+
*/
284+
forceLoadHooks() {}
280285
}
281286
ObjectSetPrototypeOf(DefaultModuleLoader.prototype, null);
282287

@@ -349,6 +354,14 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
349354

350355
return result;
351356
}
357+
358+
importMetaInitialize(meta, context) {
359+
hooksProxy.importMetaInitialize(meta, context, this);
360+
}
361+
362+
forceLoadHooks() {
363+
hooksProxy.waitForWorker();
364+
}
352365
}
353366

354367

‎lib/internal/process/esm_loader.js

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,8 @@ module.exports = {
3636
parentURL,
3737
kEmptyObject,
3838
));
39+
} else {
40+
esmLoader.forceLoadHooks();
3941
}
4042
await callback(esmLoader);
4143
} catch (err) {

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

Lines changed: 112 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
import { spawnPromisified } from '../common/index.mjs';
22
import * as fixtures from '../common/fixtures.mjs';
33
import assert from 'node:assert';
4+
import os from 'node:os';
45
import { execPath } from 'node:process';
56
import { describe, it } from 'node:test';
67

@@ -422,18 +423,118 @@ describe('Loader hooks', { concurrency: true }, () => {
422423
});
423424
});
424425

425-
it('should handle globalPreload returning undefined', async () => {
426-
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
427-
'--no-warnings',
428-
'--experimental-loader',
429-
'data:text/javascript,export function globalPreload(){}',
430-
fixtures.path('empty.js'),
431-
]);
426+
describe('globalPreload', () => {
427+
it('should handle globalPreload returning undefined', async () => {
428+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
429+
'--no-warnings',
430+
'--experimental-loader',
431+
'data:text/javascript,export function globalPreload(){}',
432+
fixtures.path('empty.js'),
433+
]);
432434

433-
assert.strictEqual(stderr, '');
434-
assert.strictEqual(stdout, '');
435-
assert.strictEqual(code, 0);
436-
assert.strictEqual(signal, null);
435+
assert.strictEqual(stderr, '');
436+
assert.strictEqual(stdout, '');
437+
assert.strictEqual(code, 0);
438+
assert.strictEqual(signal, null);
439+
});
440+
441+
it('should handle loading node:test', async () => {
442+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
443+
'--no-warnings',
444+
'--experimental-loader',
445+
'data:text/javascript,export function globalPreload(){return `getBuiltin("node:test")()`}',
446+
fixtures.path('empty.js'),
447+
]);
448+
449+
assert.strictEqual(stderr, '');
450+
assert.match(stdout, /\n# pass 1\r?\n/);
451+
assert.strictEqual(code, 0);
452+
assert.strictEqual(signal, null);
453+
});
454+
455+
it('should handle loading node:os with node: prefix', async () => {
456+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
457+
'--no-warnings',
458+
'--experimental-loader',
459+
'data:text/javascript,export function globalPreload(){return `console.log(getBuiltin("node:os").arch())`}',
460+
fixtures.path('empty.js'),
461+
]);
462+
463+
assert.strictEqual(stderr, '');
464+
assert.strictEqual(stdout.trim(), os.arch());
465+
assert.strictEqual(code, 0);
466+
assert.strictEqual(signal, null);
467+
});
468+
469+
it('should handle loading node:os without node: prefix', async () => {
470+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
471+
'--no-warnings',
472+
'--experimental-loader',
473+
'data:text/javascript,export function globalPreload(){return `console.log(getBuiltin("os").arch())`}',
474+
fixtures.path('empty.js'),
475+
]);
476+
477+
assert.strictEqual(stderr, '');
478+
assert.strictEqual(stdout.trim(), os.arch());
479+
assert.strictEqual(code, 0);
480+
assert.strictEqual(signal, null);
481+
});
482+
483+
it('should throw when loading node:test without node: prefix', async () => {
484+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
485+
'--no-warnings',
486+
'--experimental-loader',
487+
'data:text/javascript,export function globalPreload(){return `getBuiltin("test")()`}',
488+
fixtures.path('empty.js'),
489+
]);
490+
491+
assert.match(stderr, /ERR_UNKNOWN_BUILTIN_MODULE/);
492+
assert.strictEqual(stdout, '');
493+
assert.strictEqual(code, 1);
494+
assert.strictEqual(signal, null);
495+
});
496+
497+
it('should register globals set from globalPreload', async () => {
498+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
499+
'--no-warnings',
500+
'--experimental-loader',
501+
'data:text/javascript,export function globalPreload(){return "this.myGlobal=4"}',
502+
'--print', 'myGlobal',
503+
]);
504+
505+
assert.strictEqual(stderr, '');
506+
assert.strictEqual(stdout.trim(), '4');
507+
assert.strictEqual(code, 0);
508+
assert.strictEqual(signal, null);
509+
});
510+
511+
it('should log console.log calls returned from globalPreload', async () => {
512+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
513+
'--no-warnings',
514+
'--experimental-loader',
515+
'data:text/javascript,export function globalPreload(){return `console.log("Hello from globalPreload")`}',
516+
fixtures.path('empty.js'),
517+
]);
518+
519+
assert.strictEqual(stderr, '');
520+
assert.strictEqual(stdout.trim(), 'Hello from globalPreload');
521+
assert.strictEqual(code, 0);
522+
assert.strictEqual(signal, null);
523+
});
524+
525+
it('should crash if globalPreload returns code that throws', async () => {
526+
const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
527+
'--no-warnings',
528+
'--experimental-loader',
529+
'data:text/javascript,export function globalPreload(){return `throw new Error("error from globalPreload")`}',
530+
fixtures.path('empty.js'),
531+
]);
532+
533+
assert.match(stderr, /error from globalPreload/);
534+
assert.strictEqual(stdout, '');
535+
assert.strictEqual(code, 1);
536+
assert.strictEqual(signal, null);
537+
});
437538
});
438539

439540
it('should be fine to call `process.removeAllListeners("beforeExit")` from the main thread', async () => {

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

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
// Flags: --loader ./test/fixtures/es-module-loaders/mock-loader.mjs
2+
import '../common/index.mjs';
3+
import assert from 'assert/strict';
4+
5+
// This is provided by test/fixtures/es-module-loaders/mock-loader.mjs
6+
import mock from 'node:mock';
7+
8+
mock('node:events', {
9+
EventEmitter: 'This is mocked!'
10+
});
11+
12+
// This resolves to node:events
13+
// It is intercepted by mock-loader and doesn't return the normal value
14+
assert.deepStrictEqual(await import('events'), Object.defineProperty({
15+
__proto__: null,
16+
EventEmitter: 'This is mocked!'
17+
}, Symbol.toStringTag, {
18+
enumerable: false,
19+
value: 'Module'
20+
}));
21+
22+
const mutator = mock('node:events', {
23+
EventEmitter: 'This is mocked v2!'
24+
});
25+
26+
// It is intercepted by mock-loader and doesn't return the normal value.
27+
// This is resolved separately from the import above since the specifiers
28+
// are different.
29+
const mockedV2 = await import('node:events');
30+
assert.deepStrictEqual(mockedV2, Object.defineProperty({
31+
__proto__: null,
32+
EventEmitter: 'This is mocked v2!'
33+
}, Symbol.toStringTag, {
34+
enumerable: false,
35+
value: 'Module'
36+
}));
37+
38+
mutator.EventEmitter = 'This is mocked v3!';
39+
assert.deepStrictEqual(mockedV2, Object.defineProperty({
40+
__proto__: null,
41+
EventEmitter: 'This is mocked v3!'
42+
}, Symbol.toStringTag, {
43+
enumerable: false,
44+
value: 'Module'
45+
}));

0 commit comments

Comments
 (0)