esm: add `ERR_REQUIRE_ESM_RACE_CONDITION` · nodejs/node@ddf1f01

ERR_REQUIRE_ASYNC_MODULE,

ERR_REQUIRE_CYCLE_MODULE,

ERR_REQUIRE_ESM,

ERR_REQUIRE_ESM_RACE_CONDITION,

ERR_UNKNOWN_MODULE_FORMAT,

} = require('internal/errors').codes;

const { getOptionValue } = require('internal/options');

kEvaluating,

kEvaluationPhase,

kInstantiated,

kUninstantiated,

kErrored,

kSourcePhase,

throwIfPromiseRejected,

const { defaultResolve } = require('internal/modules/esm/resolve');

const { defaultLoadSync, throwUnknownModuleFormat } = require('internal/modules/esm/load');

/**

* Generate message about potential race condition caused by requiring a cached module that has started

* async linking.

* @param {string} filename Filename of the module being required.

* @param {string|undefined} parentFilename Filename of the module calling require().

* @param {boolean} isForAsyncLoaderHookWorker Whether this is for the async loader hook worker.

* @returns {string} Error message.

*/

function getRaceMessage(filename, parentFilename, isForAsyncLoaderHookWorker) {

let raceMessage = `Cannot require() ES Module ${filename} because it is not yet fully loaded.\n`;

raceMessage += 'This may be caused by a race condition if the module is simultaneously dynamically ';

raceMessage += 'import()-ed via Promise.all().\n';

raceMessage += 'Try await-ing the import() sequentially in a loop instead.\n';

raceMessage += ` (From ${parentFilename ? `${parentFilename} in ` : ' '}`;

raceMessage += `${isForAsyncLoaderHookWorker ? 'loader hook worker thread' : 'non-loader-hook thread'})`;

return raceMessage;

}

/**

* @typedef {import('../cjs/loader.js').Module} CJSModule

*/

const parentFilename = urlToFilename(parent?.filename);

// This race should only be possible on the loader hook thread. See https://github.com/nodejs/node/issues/59666

if (!job.module) {

assert.fail(getRaceMessage(filename, parentFilename), this.isForAsyncLoaderHookWorker);

throw new ERR_REQUIRE_ESM_RACE_CONDITION(filename, parentFilename, this.isForAsyncLoaderHookWorker);

}

const status = job.module.getStatus();

debug('Module status', job, status);

throwIfPromiseRejected(job.instantiated);

}

if (status !== kEvaluating) {

assert.fail(`Unexpected module status ${status}. ` +

getRaceMessage(filename, parentFilename));

assert(status === kUninstantiated, `Unexpected module status ${status}`);

throw new ERR_REQUIRE_ESM_RACE_CONDITION(filename, parentFilename, false);

}

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

if (parentFilename) {

#checkCachedJobForRequireESM(specifier, url, parentURL, job) {

// This race should only be possible on the loader hook thread. See https://github.com/nodejs/node/issues/59666

if (!job.module) {

assert.fail(getRaceMessage(url, parentURL, this.isForAsyncLoaderHookWorker));

throw new ERR_REQUIRE_ESM_RACE_CONDITION(url, parentURL, this.isForAsyncLoaderHookWorker);

}

// This module is being evaluated, which means it's imported in a previous link

// in a cycle.