module: use symbol in WeakMap to manage host defined options · nodejs/node@a86a2e1

ObjectFreeze,

} = primordials;

const {

privateSymbols: {

host_defined_option_symbol,

},

} = internalBinding('util');

const {

ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING,

ERR_INVALID_ARG_VALUE,

setImportModuleDynamicallyCallback,

setInitializeImportMetaObjectCallback,

} = internalBinding('module_wrap');

const {

getModuleFromWrap,

} = require('internal/vm/module');

const assert = require('internal/assert');

const callbackMap = new SafeWeakMap();

function setCallbackForWrap(wrap, data) {

callbackMap.set(wrap, data);

}

let defaultConditions;

/**

* Returns the default conditions for ES module loading.

return getDefaultConditionsSet();

}

/**

* @callback ImportModuleDynamicallyCallback

* @param {string} specifier

* @param {ModuleWrap|ContextifyScript|Function|vm.Module} callbackReferrer

* @param {object} attributes

* @returns { Promise<void> }

*/

/**

* @callback InitializeImportMetaCallback

* @param {object} meta

* @param {ModuleWrap|ContextifyScript|Function|vm.Module} callbackReferrer

*/

/**

* @typedef {{

* callbackReferrer: ModuleWrap|ContextifyScript|Function|vm.Module

* initializeImportMeta? : InitializeImportMetaCallback,

* importModuleDynamically? : ImportModuleDynamicallyCallback

* }} ModuleRegistry

*/

/**

* @type {WeakMap<symbol, ModuleRegistry>}

*/

const moduleRegistries = new SafeWeakMap();

/**

* V8 would make sure that as long as import() can still be initiated from

* the referrer, the symbol referenced by |host_defined_option_symbol| should

* be alive, which in term would keep the settings object alive through the

* WeakMap, and in turn that keeps the referrer object alive, which would be

* passed into the callbacks.

* The reference goes like this:

* [v8::internal::Script] (via host defined options) ----1--> [idSymbol]

* [callbackReferrer] (via host_defined_option_symbol) ------2------^ |

* ^----------3---- (via WeakMap)------

* 1+3 makes sure that as long as import() can still be initiated, the

* referrer wrap is still around and can be passed into the callbacks.

* 2 is only there so that we can get the id symbol to configure the

* weak map.

* @param {ModuleWrap|ContextifyScript|Function} referrer The referrer to

* get the id symbol from. This is different from callbackReferrer which

* could be set by the caller.

* @param {ModuleRegistry} registry

*/

function registerModule(referrer, registry) {

const idSymbol = referrer[host_defined_option_symbol];

// To prevent it from being GC'ed.

registry.callbackReferrer ??= referrer;

moduleRegistries.set(idSymbol, registry);

}

/**

* Defines the `import.meta` object for a given module.

* @param {object} wrap - Reference to the module.

* @param {symbol} symbol - Reference to the module.

* @param {Record<string, string | Function>} meta - The import.meta object to initialize.

*/

function initializeImportMetaObject(wrap, meta) {

if (callbackMap.has(wrap)) {

const { initializeImportMeta } = callbackMap.get(wrap);

function initializeImportMetaObject(symbol, meta) {

if (moduleRegistries.has(symbol)) {

const { initializeImportMeta, callbackReferrer } = moduleRegistries.get(symbol);

if (initializeImportMeta !== undefined) {

meta = initializeImportMeta(meta, getModuleFromWrap(wrap) || wrap);

meta = initializeImportMeta(meta, callbackReferrer);

}

}

}

/**

* Asynchronously imports a module dynamically using a callback function. The native callback.

* @param {object} wrap - Reference to the module.

* @param {symbol} symbol - Reference to the module.

* @param {string} specifier - The module specifier string.

* @param {Record<string, string>} attributes - The import attributes object.

* @returns {Promise<import('internal/modules/esm/loader.js').ModuleExports>} - The imported module object.

* @throws {ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING} - If the callback function is missing.

*/

async function importModuleDynamicallyCallback(wrap, specifier, attributes) {

if (callbackMap.has(wrap)) {

const { importModuleDynamically } = callbackMap.get(wrap);

async function importModuleDynamicallyCallback(symbol, specifier, attributes) {

if (moduleRegistries.has(symbol)) {

const { importModuleDynamically, callbackReferrer } = moduleRegistries.get(symbol);

if (importModuleDynamically !== undefined) {

return importModuleDynamically(

specifier, getModuleFromWrap(wrap) || wrap, attributes);

return importModuleDynamically(specifier, callbackReferrer, attributes);

}

}

throw new ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING();

}

module.exports = {

setCallbackForWrap,

registerModule,

initializeESM,

initializeHooks,

getDefaultConditions,