'use strict';
// Covers --vfs-load: running a mounted directory's entry point with require()
// resolving inside the mount, a provider registered by either a -r (CJS) or an
// --import (ESM) preload backing a non-directory source, a ZIP archive claimed
// by the built-in provider, and a worker reaching the mount, whether it
// inherits the options or is given them itself.
//
// Native addon loading from a mount is not exercised here (it needs a compiled
// .node), only the startup wiring around it.
const common = require('../common');
const tmpdir = require('../common/tmpdir');
const assert = require('assert');
const fs = require('fs');
const path = require('path');
const { pathToFileURL } = require('url');
const { spawnSync } = require('child_process');
tmpdir.refresh();
let id = 0;
function fixture(name) { return path.join(tmpdir.path, `${id++}-${name}`); }
function run(args) {
return spawnSync(process.execPath, args, { encoding: 'utf8' });
}
// Node.js can be built without NODE_OPTIONS support, in which case the
// environment cannot carry a flag at all and there is nothing to assert.
const hasNodeOptions = !process.config.variables.node_without_node_options;
// NODE_OPTIONS is tokenized with shell-like quoting, so a path holding a space
// or a quote - as the checkout directory does on some CI machines - has to be
// quoted and escaped rather than interpolated raw.
function envArg(flag, value) {
return `"${flag}=${value.replace(/[\\"]/g, '\\$&')}"`;
}
// A directory source: the entry point runs and require() resolves inside it.
{
const dir = fixture('app');
fs.mkdirSync(path.join(dir, 'lib'), { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'),
"console.log(require('./lib/greet')());\n");
fs.writeFileSync(path.join(dir, 'lib', 'greet.js'),
"module.exports = () => 'hello from inside the mount';\n");
const res = run([`--vfs-load=${dir}`]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /hello from inside the mount/);
}
// --no-experimental-vfs disables --vfs-load.
{
const dir = fixture('disabled');
fs.mkdirSync(dir, { recursive: true });
const res = run(['--no-experimental-vfs', `--vfs-load=${dir}`]);
assert.notStrictEqual(res.status, 0);
assert.match(res.stderr, /--vfs-load requires node:vfs to be enabled/);
}
// A provider registered by a -r (CommonJS) preload backs a custom file format.
{
const providerModule = fixture('provider.js');
fs.writeFileSync(providerModule, `
'use strict';
const fs = require('fs');
const vfs = require('node:vfs');
const MAGIC = Buffer.from('CUSTOMFMT');
vfs.registerProvider({
name: 'customfmt',
canHandle(p, stats) {
if (!stats.isFile()) return false;
const fd = fs.openSync(p, 'r');
try {
const buf = Buffer.alloc(MAGIC.length);
fs.readSync(fd, buf, 0, MAGIC.length, 0);
return buf.equals(MAGIC);
} finally { fs.closeSync(fd); }
},
create(p) {
const body = fs.readFileSync(p).subarray(MAGIC.length).toString('utf8');
const provider = new vfs.MemoryProvider();
provider.writeFileSync('/index.js', body);
return provider;
},
});
`);
const target = fixture('app.customfmt');
fs.writeFileSync(target, Buffer.concat([
Buffer.from('CUSTOMFMT'),
Buffer.from("console.log('hello from custom provider');"),
]));
const res = run(['-r', providerModule, `--vfs-load=${target}`]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /hello from custom provider/);
}
// A provider registered by an --import (ES module) preload: this only works
// because mounting is deferred until after the --import loop has run.
{
const providerModule = fixture('provider.mjs');
fs.writeFileSync(providerModule, `
import fs from 'node:fs';
import { registerProvider, MemoryProvider } from 'node:vfs';
const MAGIC = Buffer.from('ESMFMT');
registerProvider({
name: 'esmfmt',
canHandle(p, stats) {
if (!stats.isFile()) return false;
return fs.readFileSync(p).subarray(0, MAGIC.length).equals(MAGIC);
},
create(p) {
const body = fs.readFileSync(p).subarray(MAGIC.length).toString('utf8');
const provider = new MemoryProvider();
provider.writeFileSync('/index.js', body);
return provider;
},
});
`);
const target = fixture('app.esmfmt');
fs.writeFileSync(target, Buffer.concat([
Buffer.from('ESMFMT'),
Buffer.from("console.log('hello from ESM-imported provider');"),
]));
const res = run([
'--import', pathToFileURL(providerModule).href,
`--vfs-load=${target}`,
]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /hello from ESM-imported provider/);
}
// A ZIP archive is claimed by the built-in provider (detected by opening it,
// not by extension).
{
const zlib = require('zlib');
const zipPath = fixture('app.zip');
const entry = zlib.ZipEntry.createSync(
'index.js', Buffer.from("console.log('hello from zip archive');"));
const chunks = [];
for (const chunk of zlib.createZipArchiveSync([entry])) chunks.push(chunk);
fs.writeFileSync(zipPath, Buffer.concat(chunks));
const res = run([`--vfs-load=${zipPath}`]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /hello from zip archive/);
}
// A worker inherits the mount, so a worker script that lives inside it
// (addressed here via the entry's own __dirname) resolves and runs.
{
const dir = fixture('worker-app');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'), `
'use strict';
const path = require('path');
const { Worker } = require('worker_threads');
const w = new Worker(path.join(__dirname, 'worker.js'));
w.on('message', (m) => { console.log(m); process.exit(0); });
w.on('error', (e) => { console.error(e); process.exit(1); });
`);
fs.writeFileSync(path.join(dir, 'worker.js'), `
'use strict';
require('worker_threads').parentPort.postMessage('hello from worker in mount');
`);
const res = run([`--vfs-load=${dir}`]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /hello from worker in mount/);
}
// The same, for a worker whose nearest package.json inside the mount says
// "module": the entry point's type is read from the mount rather than from
// the real file system above the reserved mount point.
{
const dir = fixture('worker-esm-app');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'package.json'),
'{"type":"module","main":"index.js"}\n');
fs.writeFileSync(path.join(dir, 'index.js'), `
import path from 'node:path';
import { Worker } from 'node:worker_threads';
import { fileURLToPath } from 'node:url';
const here = path.dirname(fileURLToPath(import.meta.url));
const w = new Worker(path.join(here, 'worker.js'));
w.on('message', (m) => { console.log(m); process.exit(0); });
w.on('error', (e) => { console.error(e); process.exit(1); });
`);
// No extension hint and no CJS wrapper: this only parses if the worker is
// loaded as ESM, which takes reading "type" out of the mount's package.json.
fs.writeFileSync(path.join(dir, 'worker.js'), `
import { parentPort } from 'node:worker_threads';
parentPort.postMessage('hello from esm worker in mount');
`);
const res = run([`--vfs-load=${dir}`]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /hello from esm worker in mount/);
}
// A worker created with its own execArgv does not inherit the parent's options,
// so it has to be given the mount itself. Because the loaded source is always
// the first file system a thread mounts, it lands at the same reserved mount
// point in both threads, and a worker path the parent built still resolves.
{
const dir = fixture('worker-execargv-app');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'), `
'use strict';
const path = require('path');
const { Worker } = require('worker_threads');
const w = new Worker(path.join(__dirname, 'worker.js'), {
execArgv: ['--vfs-load=' + process.argv[1]],
});
w.on('message', (m) => { console.log(m); process.exit(0); });
w.on('error', (e) => { console.error(e); process.exit(1); });
`);
fs.writeFileSync(path.join(dir, 'worker.js'), `
'use strict';
require('worker_threads').parentPort.postMessage('worker ran from ' + __dirname);
`);
// A preload that mounts a file system of its own runs before the --vfs-load
// source is mounted, and still does not move it.
const preload = fixture('mounting-preload.js');
fs.writeFileSync(preload, `
'use strict';
require('node:vfs').create().mount();
`);
const seen = new Set();
for (const args of [[`--vfs-load=${dir}`], ['-r', preload, `--vfs-load=${dir}`]]) {
const res = run(args);
assert.strictEqual(res.status, 0, res.stderr);
const [, dirname] = /worker ran from (\S+)/.exec(res.stdout);
seen.add(dirname);
}
// The worker resolved a path the main thread built, in both runs, and that
// path did not move between them.
assert.strictEqual(seen.size, 1, [...seen].join());
}
// Without that flag the worker has no mount to load from, so a script in the
// mount cannot be its entry point.
{
const dir = fixture('worker-execargv-missing');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'), `
'use strict';
const path = require('path');
const { Worker } = require('worker_threads');
const w = new Worker(path.join(__dirname, 'worker.js'), { execArgv: [] });
w.on('message', (m) => { console.log('ran:' + m); process.exit(0); });
w.on('error', (e) => { console.log('failed:' + e.code); process.exit(0); });
`);
fs.writeFileSync(path.join(dir, 'worker.js'), `
'use strict';
require('worker_threads').parentPort.postMessage('unexpected');
`);
const res = run([`--vfs-load=${dir}`]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /failed:/);
assert.doesNotMatch(res.stdout, /ran:/);
}
// --vfs-load names the source it loads, so it always takes a value.
{
const res = run(['--vfs-load']);
assert.notStrictEqual(res.status, 0);
assert.match(res.stderr, /--vfs-load requires an argument/);
}
// The value may also be given as a separate argument.
{
const dir = fixture('spaced-value');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'), "console.log('ran:spaced');\n");
const res = run(['--vfs-load', dir]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /ran:spaced/);
}
// A source whose path holds spaces or quotes is mounted as given. Windows
// forbids `"` in a file name, so only the spaces and the `$` are exercised
// there.
{
const oddName = common.isWindows ? `${id++}-od d $x` : `${id++}-od d "q" $x`;
const dir = path.join(tmpdir.path, oddName);
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'), 'console.log("ran:odd");\n');
const res = run([`--vfs-load=${dir}`]);
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /ran:odd/);
}
// --vfs-load may only be given once: a second one would otherwise quietly
// replace the first.
{
const dirs = {};
for (const name of ['once-a', 'once-b']) {
dirs[name] = fixture(name);
fs.mkdirSync(dirs[name], { recursive: true });
fs.writeFileSync(path.join(dirs[name], 'index.js'),
`console.log('ran:${name}');\n`);
}
const twice = run([`--vfs-load=${dirs['once-a']}`,
`--vfs-load=${dirs['once-b']}`]);
assert.notStrictEqual(twice.status, 0);
assert.match(twice.stderr, /--vfs-load may only be given once/);
}
// --vfs-load picks the entry point, so it is refused in NODE_OPTIONS: the
// environment must not be able to redirect what a `node <args>` run executes.
// Everything but the flag under test is passed on the command line, so a build
// that ignores NODE_OPTIONS cannot make this pass for the wrong reason.
if (hasNodeOptions) {
const dir = fixture('env-refused');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'), 'console.log("ran");\n');
// On its own, and alongside a --vfs-load the command line legitimately gave:
// the environment is refused either way rather than merged.
for (const args of [[], [`--vfs-load=${dir}`]]) {
const res = spawnSync(process.execPath, args, {
encoding: 'utf8',
env: { ...process.env, NODE_OPTIONS: envArg('--vfs-load', dir) },
});
assert.notStrictEqual(res.status, 0);
assert.match(res.stderr, /--vfs-load.* is not allowed in NODE_OPTIONS/);
}
}
// The old --experimental-vfs option remains accepted in NODE_OPTIONS. Its
// positive form no longer gates --vfs-load, and its negated form disables it.
if (hasNodeOptions) {
const dir = fixture('env-flag-cli-load');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'), 'console.log("ran");\n');
const res = spawnSync(process.execPath, [`--vfs-load=${dir}`], {
encoding: 'utf8',
env: { ...process.env, NODE_OPTIONS: '--experimental-vfs' },
});
assert.strictEqual(res.status, 0, res.stderr);
assert.match(res.stdout, /ran/);
const disabled = spawnSync(process.execPath, [`--vfs-load=${dir}`], {
encoding: 'utf8',
env: { ...process.env, NODE_OPTIONS: '--no-experimental-vfs' },
});
assert.notStrictEqual(disabled.status, 0);
assert.match(disabled.stderr, /--vfs-load requires node:vfs to be enabled/);
}
// Under --vfs-load the entry point comes from the mount, so no positional
// argument is consumed as one: every positional reaches the program verbatim
// from argv[2] onward, and argv[1] reports the mounted source.
{
const dir = fixture('argv-app');
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, 'index.js'),
'console.log(JSON.stringify(process.argv.slice(1)));\n');
for (const extra of [[], ['alpha'], ['alpha', 'beta']]) {
const res = run([`--vfs-load=${dir}`, ...extra]);
assert.strictEqual(res.status, 0, res.stderr);
assert.deepStrictEqual(JSON.parse(res.stdout), [dir, ...extra]);
}
// A path-like argument must not be resolved against the real file system the
// way a genuine entry-point argument would be.
const res = run([`--vfs-load=${dir}`, './not/an/entry.js']);
assert.strictEqual(res.status, 0, res.stderr);
assert.deepStrictEqual(JSON.parse(res.stdout), [dir, './not/an/entry.js']);
}