module: disallow CJS <-> ESM edges in a cycle from require(esm) · nodejs/node@51b88fa

Symbol,

} = primordials;

const { kEvaluated } = internalBinding('module_wrap');

// Map used to store CJS parsing data or for ESM loading.

const cjsSourceCache = new SafeWeakMap();

const importedCJSCache = new SafeWeakMap();

/**

* Map of already-loaded CJS modules to use.

*/

const cjsExportsCache = new SafeWeakMap();

const requiredESMSourceCache = new SafeWeakMap();

const kIsMainSymbol = Symbol('kIsMainSymbol');

const kIsCachedByESMLoader = Symbol('kIsCachedByESMLoader');

const kRequiredModuleSymbol = Symbol('kRequiredModuleSymbol');

const kIsExecuting = Symbol('kIsExecuting');

// Set first due to cycle with ESM loader functions.

module.exports = {

cjsExportsCache,

cjsSourceCache,

importedCJSCache,

initializeCJS,

Module,

wrapSafe,

kIsMainSymbol,

kIsCachedByESMLoader,

kRequiredModuleSymbol,

kIsExecuting,

};

const kIsMainSymbol = Symbol('kIsMainSymbol');

const { BuiltinModule } = require('internal/bootstrap/realm');

const {

maybeCacheSourceMap,

codes: {

ERR_INVALID_ARG_VALUE,

ERR_INVALID_MODULE_SPECIFIER,

ERR_REQUIRE_CYCLE_MODULE,

ERR_REQUIRE_ESM,

ERR_UNKNOWN_BUILTIN_MODULE,

},

* @param {Module} module The module instance

*/

function getExportsForCircularRequire(module) {

const requiredESM = module[kRequiredModuleSymbol];

if (requiredESM && requiredESM.getStatus() !== kEvaluated) {

let message = `Cannot require() ES Module ${module.id} in a cycle.`;

const parent = moduleParentCache.get(module);

if (parent) {

message += ` (from ${parent.filename})`;

}

throw new ERR_REQUIRE_CYCLE_MODULE(message);

}

if (module.exports &&

!isProxy(module.exports) &&

ObjectGetPrototypeOf(module.exports) === ObjectPrototype &&

if (cachedModule !== undefined) {

updateChildren(parent, cachedModule, true);

if (!cachedModule.loaded) {

const parseCachedModule = cjsSourceCache.get(cachedModule);

if (!parseCachedModule || parseCachedModule.loaded) {

// If it's not cached by the ESM loader, the loading request

// comes from required CJS, and we can consider it a circular

// dependency when it's cached.

if (!cachedModule[kIsCachedByESMLoader]) {

return getExportsForCircularRequire(cachedModule);

}

parseCachedModule.loaded = true;

// If it's cached by the ESM loader as a way to indirectly pass

// the module in to avoid creating it twice, the loading request

// come from imported CJS. In that case use the importedCJSCache

// to determine if it's loading or not.

const importedCJSMetadata = importedCJSCache.get(cachedModule);

if (importedCJSMetadata.loading) {

return getExportsForCircularRequire(cachedModule);

}

importedCJSMetadata.loading = true;

} else {

return cachedModule.exports;

}

// Don't call updateChildren(), Module constructor already does.

const module = cachedModule || new Module(filename, parent);

if (isMain) {

setOwnProperty(process, 'mainModule', module);

setOwnProperty(module.require, 'main', process.mainModule);

module.id = '.';

module[kIsMainSymbol] = true;

} else {

module[kIsMainSymbol] = false;

}

if (!cachedModule) {

if (isMain) {

setOwnProperty(process, 'mainModule', module);

setOwnProperty(module.require, 'main', process.mainModule);

module.id = '.';

module[kIsMainSymbol] = true;

} else {

module[kIsMainSymbol] = false;

}

reportModuleToWatchMode(filename);

reportModuleToWatchMode(filename);

Module._cache[filename] = module;

module[kIsCachedByESMLoader] = false;

}

Module._cache[filename] = module;

if (parent !== undefined) {

relativeResolveCache[relResolveCacheIdentifier] = filename;

}

const isMain = mod[kIsMainSymbol];

// TODO(joyeecheung): we may want to invent optional special handling for default exports here.

// For now, it's good enough to be identical to what `import()` returns.

mod.exports = cascadedLoader.importSyncForRequire(filename, source, isMain);

mod.exports = cascadedLoader.importSyncForRequire(mod, filename, source, isMain, moduleParentCache.get(mod));

}

/**

// Only modules being require()'d really need to avoid TLA.

if (loadAsESM) {

// Pass the source into the .mjs extension handler indirectly through the cache.

cjsSourceCache.set(this, { source: content });

requiredESMSourceCache.set(this, content);

loadESMFromCJS(this, filename);

return;

}

const module = this;

if (requireDepth === 0) { statCache = new SafeMap(); }

setHasStartedUserCJSExecution();

this[kIsExecuting] = true;

if (inspectorWrapper) {

result = inspectorWrapper(compiledWrapper, thisValue, exports,

require, module, filename, dirname);

} else {

result = ReflectApply(compiledWrapper, thisValue,

[exports, require, module, filename, dirname]);

}

this[kIsExecuting] = false;

if (requireDepth === 0) { statCache = null; }

return result;

};

* @returns {string}

*/

function getMaybeCachedSource(mod, filename) {

const cached = cjsSourceCache.get(mod);

const cached = importedCJSCache.get(mod);

let content;

if (cached?.source) {

content = cached.source;

cached.source = undefined;

} else {

// TODO(joyeecheung): we can read a buffer instead to speed up

// compilation.

content = fs.readFileSync(filename, 'utf8');

content = requiredESMSourceCache.get(mod) ?? fs.readFileSync(filename, 'utf8');

}

return content;

}