module: add prefix-only modules to `module.builtinModules` · nodejs/node@b5a2c07

- v9.3.0

- v8.10.0

- v6.13.0

changes:

- version: REPLACEME

pr-url: https://github.com/nodejs/node/pull/56185

description: The list now also contains prefix-only modules.

-->

* {string\[]}

A list of the names of all modules provided by Node.js. Can be used to verify

if a module is maintained by a third party or not.

Note: the list doesn't contain [prefix-only modules][] like `node:test`.

`module` in this context isn't the same object that's provided

by the [module wrapper][]. To access it, require the `Module` module:

[load hook]: #loadurl-context-nextload

[module compile cache]: #module-compile-cache

[module wrapper]: modules.md#the-module-wrapper

[prefix-only modules]: modules.md#built-in-modules-with-mandatory-node-prefix

[realm]: https://tc39.es/ecma262/#realm

[resolve hook]: #resolvespecifier-context-nextresolve

[source map include directives]: https://sourcemaps.info/spec.html#h.lmz475t4mvbx

passed to `require()`. For instance, `require('http')` will always

return the built-in HTTP module, even if there is a file by that name. The list

of built-in modules that can be loaded without using the `node:` prefix is exposed

as [`module.builtinModules`][].

in [`module.builtinModules`][], listed without the prefix.

### Built-in modules with mandatory `node:` prefix

* [`node:test`][]

* [`node:test/reporters`][]

The list of these modules is exposed in [`module.builtinModules`][], including the prefix.

## Cycles

<!--type=misc-->

ArrayPrototypeIncludes,

ArrayPrototypeMap,

ArrayPrototypePush,

ArrayPrototypePushApply,

ArrayPrototypeSlice,

Error,

ObjectDefineProperty,

);

}

static getCanBeRequiredByUsersWithoutSchemeList() {

return ArrayFrom(canBeRequiredByUsersWithoutSchemeList);

}

static getSchemeOnlyModuleNames() {

return ArrayFrom(schemelessBlockList);

}

static getAllBuiltinModuleIds() {

const allBuiltins = ArrayFrom(canBeRequiredByUsersWithoutSchemeList);

ArrayPrototypePushApply(allBuiltins, ArrayFrom(schemelessBlockList, (x) => `node:${x}`));

return allBuiltins;

}

// Used by user-land module loaders to compile and load builtins.

compileForPublicLoader() {

if (!BuiltinModule.canBeRequiredByUsers(this.id)) {

*/

function initializeCJS() {

// This need to be done at runtime in case --expose-internals is set.

const builtinModules = BuiltinModule.getCanBeRequiredByUsersWithoutSchemeList();

Module.builtinModules = ObjectFreeze(builtinModules);

Module.builtinModules = ObjectFreeze(BuiltinModule.getAllBuiltinModuleIds());

initializeCjsConditions();

const CJSModule = require('internal/modules/cjs/loader').Module;

let _builtinLibs = ArrayPrototypeFilter(

CJSModule.builtinModules,

(e) => e[0] !== '_',

(e) => e[0] !== '_' && !StringPrototypeStartsWith(e, 'node:'),

);

const nodeSchemeBuiltinLibs = ArrayPrototypeMap(

_builtinLibs, (lib) => `node:${lib}`);

});

} else {

require(id);

if (!id.startsWith('node:')) {

require(`node:${id}`);

}

publicModules.add(id);

}

}

}

// Check that import(id).default returns the same thing as process.getBuiltinModule(id).

for (const id of publicBuiltins) {

const imported = await import(`node:${id}`);

assert.strictEqual(process.getBuiltinModule(id), imported.default);

if (!id.startsWith('node:')) {

const imported = await import(`node:${id}`);

assert.strictEqual(process.getBuiltinModule(id), imported.default);

}

}

// publicBuiltins does not include 'test' which requires the node: prefix.

const ids = publicBuiltins.add('test');

// Check that import(id).default returns the same thing as process.getBuiltinModule(id).

for (const id of ids) {

const prefixed = `node:${id}`;

const imported = await import(prefixed);

assert.strictEqual(process.getBuiltinModule(prefixed), imported.default);

if (!id.startsWith('node:')) {

const prefixed = `node:${id}`;

const imported = await import(prefixed);

assert.strictEqual(process.getBuiltinModule(prefixed), imported.default);

}

}

const fixtures = require('../common/fixtures');

const assert = require('assert');

const { builtinModules } = require('module');

const publicModules = builtinModules.filter((lib) => !lib.startsWith('_'));

const publicUnprefixedModules = builtinModules.filter((lib) => !lib.startsWith('_') && !lib.startsWith('node:'));

if (!common.isMainThread)

common.skip('process.chdir is not available in Workers');

// Tab complete provides built in libs for import()

testMe.complete('import(\'', common.mustCall((error, data) => {

assert.strictEqual(error, null);

publicModules.forEach((lib) => {

publicUnprefixedModules.forEach((lib) => {

assert(

data[0].includes(lib) && data[0].includes(`node:${lib}`),

`${lib} not found`,

// import(...) completions include `node:` URL modules:

let lastIndex = -1;

publicModules.forEach((lib, index) => {

publicUnprefixedModules.forEach((lib, index) => {

lastIndex = completions.indexOf(`node:${lib}`);

assert.notStrictEqual(lastIndex, -1);

});

assert.strictEqual(error, null);

publicModules.forEach((lib) => {

assert(

data[0].includes(lib) && data[0].includes(`node:${lib}`),

data[0].includes(lib) && (lib.startsWith('node:') || data[0].includes(`node:${lib}`)),

`${lib} not found`

);

});

// require(...) completions include `node:`-prefixed modules:

let lastIndex = -1;

publicModules.forEach((lib, index) => {

publicModules.filter((lib) => !lib.startsWith('node:')).forEach((lib, index) => {

lastIndex = data[0].indexOf(`node:${lib}`);

assert.notStrictEqual(lastIndex, -1);

});

// builtinModules.

builtinModules.forEach((mod) => {

assert.strictEqual(require.resolve.paths(mod), null);

});

builtinModules.forEach((mod) => {

assert.strictEqual(require.resolve.paths(`node:${mod}`), null);

if (!mod.startsWith('node:')) {

assert.strictEqual(require.resolve.paths(`node:${mod}`), null);

}

});

// node_modules.