vfs: add remaining fs method interceptions and openAsBlob support

Add VFS interceptions for truncate, ftruncate, link, mkdtemp, opendir,
openAsBlob, chmod, and utimes. Create VirtualDir class for opendir
support. Fix cp/cpSync to bypass C++ fast paths (cpSyncCopyDir,
cpSyncOverrideFile, cpSyncCheckPaths, internalModuleStat) when operating
on VFS paths, since C++ bindings cannot see virtual files. Add chmod and
utimes as no-ops for VFS paths since VFS does not track permissions or
timestamps. Add hard link support to MemoryProvider. Add comprehensive
tests for all new interceptions including cp and glob on VFS.

Author: mcollina

lib/fs.js

@@ -665,6 +665,13 @@ function openAsBlob(path, options = kEmptyObject) {
   validateObject(options, 'options');
   const type = options.type || '';
   validateString(type, 'options.type');
+
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.openAsBlob(path, options);
+    if (result !== undefined) return PromiseResolve(result);
+  }
+
   // The underlying implementation here returns the Blob synchronously for now.
   // To give ourselves flexibility to maybe return the Blob asynchronously,
   // this API returns a Promise.
@@ -1206,6 +1213,21 @@ function truncate(path, len, callback) {
   validateInteger(len, 'len');
   len = MathMax(0, len);
   validateFunction(callback, 'cb');
+
+  const h = vfsState.handlers;
+  if (h !== null) {
+    try {
+      const result = h.truncateSync(path, len);
+      if (result !== undefined) {
+        process.nextTick(callback, null);
+        return;
+      }
+    } catch (err) {
+      process.nextTick(callback, err);
+      return;
+    }
+  }
+
   fs.open(path, 'r+', (er, fd) => {
     if (er) return callback(er);
     const req = new FSReqCallback();
@@ -1228,6 +1250,13 @@ function truncateSync(path, len) {
   if (len === undefined) {
     len = 0;
   }
+
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.truncateSync(path, len);
+    if (result !== undefined) return;
+  }
+
   // Allow error to be thrown, but still close fd.
   const fd = fs.openSync(path, 'r+');
   try {
@@ -1253,6 +1282,15 @@ function ftruncate(fd, len = 0, callback) {
   len = MathMax(0, len);
   callback = makeCallback(callback);
 
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.ftruncateSync(fd, len);
+    if (result !== undefined) {
+      process.nextTick(callback, null);
+      return;
+    }
+  }
+
   const req = new FSReqCallback();
   req.oncomplete = callback;
   binding.ftruncate(fd, len, req);
@@ -1266,6 +1304,13 @@ function ftruncate(fd, len = 0, callback) {
  */
 function ftruncateSync(fd, len = 0) {
   validateInteger(len, 'len');
+
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.ftruncateSync(fd, len < 0 ? 0 : len);
+    if (result !== undefined) return;
+  }
+
   binding.ftruncate(fd, len < 0 ? 0 : len);
 }
 
@@ -2233,6 +2278,20 @@ function symlinkSync(target, path, type) {
 function link(existingPath, newPath, callback) {
   callback = makeCallback(callback);
 
+  const h = vfsState.handlers;
+  if (h !== null) {
+    try {
+      const result = h.linkSync(existingPath, newPath);
+      if (result !== undefined) {
+        process.nextTick(callback, null);
+        return;
+      }
+    } catch (err) {
+      process.nextTick(callback, err);
+      return;
+    }
+  }
+
   existingPath = getValidatedPath(existingPath, 'existingPath');
   newPath = getValidatedPath(newPath, 'newPath');
 
@@ -2250,6 +2309,12 @@ function link(existingPath, newPath, callback) {
  * @returns {void}
  */
 function linkSync(existingPath, newPath) {
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.linkSync(existingPath, newPath);
+    if (result !== undefined) return;
+  }
+
   existingPath = getValidatedPath(existingPath, 'existingPath');
   newPath = getValidatedPath(newPath, 'newPath');
 
@@ -2392,6 +2457,15 @@ function chmod(path, mode, callback) {
   mode = parseFileMode(mode, 'mode');
   callback = makeCallback(callback);
 
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.chmodSync(path, mode);
+    if (result !== undefined) {
+      process.nextTick(callback, null);
+      return;
+    }
+  }
+
   const req = new FSReqCallback();
   req.oncomplete = callback;
   binding.chmod(path, mode, req);
@@ -2407,6 +2481,12 @@ function chmodSync(path, mode) {
   path = getValidatedPath(path);
   mode = parseFileMode(mode, 'mode');
 
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.chmodSync(path, mode);
+    if (result !== undefined) return;
+  }
+
   binding.chmod(path, mode);
 }
 
@@ -2529,6 +2609,15 @@ function utimes(path, atime, mtime, callback) {
   callback = makeCallback(callback);
   path = getValidatedPath(path);
 
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.utimesSync(path, atime, mtime);
+    if (result !== undefined) {
+      process.nextTick(callback, null);
+      return;
+    }
+  }
+
   const req = new FSReqCallback();
   req.oncomplete = callback;
   binding.utimes(
@@ -2548,8 +2637,16 @@ function utimes(path, atime, mtime, callback) {
  * @returns {void}
  */
 function utimesSync(path, atime, mtime) {
+  path = getValidatedPath(path);
+
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.utimesSync(path, atime, mtime);
+    if (result !== undefined) return;
+  }
+
   binding.utimes(
-    getValidatedPath(path),
+    path,
     toUnixTimestamp(atime),
     toUnixTimestamp(mtime),
   );
@@ -3460,6 +3557,21 @@ realpath.native = (path, options, callback) => {
  */
 function mkdtemp(prefix, options, callback) {
   callback = makeCallback(typeof options === 'function' ? options : callback);
+
+  const h = vfsState.handlers;
+  if (h !== null) {
+    try {
+      const result = h.mkdtempSync(prefix);
+      if (result !== undefined) {
+        process.nextTick(callback, null, result);
+        return;
+      }
+    } catch (err) {
+      process.nextTick(callback, err);
+      return;
+    }
+  }
+
   options = getOptions(options);
 
   prefix = getValidatedPath(prefix, 'prefix');
@@ -3477,6 +3589,12 @@ function mkdtemp(prefix, options, callback) {
  * @returns {string}
  */
 function mkdtempSync(prefix, options) {
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.mkdtempSync(prefix);
+    if (result !== undefined) return result;
+  }
+
   options = getOptions(options);
 
   prefix = getValidatedPath(prefix, 'prefix');

lib/internal/fs/cp/cp-sync.js

@@ -53,7 +53,25 @@ function cpSyncFn(src, dest, opts) {
     if (!shouldCopy) return;
   }
 
-  fsBinding.cpSyncCheckPaths(src, dest, opts.dereference, opts.recursive);
+  // Skip C++ path checks for VFS paths (C++ lstat can't see VFS files).
+  // The JS-level getStats() calls lstatSync which is VFS-intercepted.
+  const { vfsState } = require('internal/fs/utils');
+  if (vfsState.handlers === null || !vfsState.handlers.statSync(src)) {
+    fsBinding.cpSyncCheckPaths(src, dest, opts.dereference, opts.recursive);
+  } else {
+    // Minimal JS-level validation that mirrors what C++ does
+    const srcResolved = resolve(src);
+    const destResolved = resolve(dest);
+    if (isSrcSubdir(srcResolved, destResolved)) {
+      throw new ERR_FS_CP_EINVAL({
+        message: `cannot copy '${srcResolved}' to a subdirectory of itself, '${destResolved}'`,
+        path: destResolved,
+        syscall: 'cp',
+        errno: EINVAL,
+        code: 'EINVAL',
+      });
+    }
+  }
 
   return getStats(src, dest, opts);
 }
@@ -83,7 +101,13 @@ function onFile(srcStat, destStat, src, dest, opts) {
   if (!destStat) return copyFile(srcStat, src, dest, opts);
 
   if (opts.force) {
-    return fsBinding.cpSyncOverrideFile(src, dest, opts.mode, opts.preserveTimestamps);
+    // Skip C++ fast path for VFS paths (C++ can't see VFS files).
+    const { vfsState } = require('internal/fs/utils');
+    if (vfsState.handlers === null || !vfsState.handlers.statSync(src)) {
+      return fsBinding.cpSyncOverrideFile(src, dest, opts.mode, opts.preserveTimestamps);
+    }
+    unlinkSync(dest);
+    return copyFile(srcStat, src, dest, opts);
   }
 
   if (opts.errorOnExist) {
@@ -140,14 +164,18 @@ function onDir(srcStat, destStat, src, dest, opts) {
 function copyDir(src, dest, opts, mkDir, srcMode) {
   if (!opts.filter) {
     // The caller didn't provide a js filter function, in this case
-    // we can run the whole function faster in C++
-    // TODO(dario-piotrowicz): look into making cpSyncCopyDir also accept the potential filter function
-    return fsBinding.cpSyncCopyDir(src, dest,
-                                   opts.force,
-                                   opts.dereference,
-                                   opts.errorOnExist,
-                                   opts.verbatimSymlinks,
-                                   opts.preserveTimestamps);
+    // we can run the whole function faster in C++.
+    // Skip C++ fast path for VFS paths (C++ can't see VFS files).
+    const { vfsState } = require('internal/fs/utils');
+    if (vfsState.handlers === null || !vfsState.handlers.statSync(src)) {
+      // TODO(dario-piotrowicz): look into making cpSyncCopyDir also accept the potential filter function
+      return fsBinding.cpSyncCopyDir(src, dest,
+                                     opts.force,
+                                     opts.dereference,
+                                     opts.errorOnExist,
+                                     opts.verbatimSymlinks,
+                                     opts.preserveTimestamps);
+    }
   }
 
   if (mkDir) {
@@ -209,7 +237,14 @@ function onLink(destStat, src, dest, verbatimSymlinks) {
   if (!isAbsolute(resolvedDest)) {
     resolvedDest = resolve(dirname(dest), resolvedDest);
   }
-  const srcIsDir = fsBinding.internalModuleStat(src) === 1;
+  // internalModuleStat is a C++ call that can't see VFS files.
+  const { vfsState } = require('internal/fs/utils');
+  let srcIsDir;
+  if (vfsState.handlers !== null && vfsState.handlers.statSync(src)) {
+    srcIsDir = statSync(src).isDirectory();
+  } else {
+    srcIsDir = fsBinding.internalModuleStat(src) === 1;
+  }
 
   if (srcIsDir && isSrcSubdir(resolvedSrc, resolvedDest)) {
     throw new ERR_FS_CP_EINVAL({

lib/internal/fs/cp/cp.js

@@ -355,7 +355,14 @@ async function onLink(destStat, src, dest, opts) {
     resolvedDest = resolve(dirname(dest), resolvedDest);
   }
 
-  const srcIsDir = fsBinding.internalModuleStat(src) === 1;
+  // internalModuleStat is a C++ call that can't see VFS files.
+  const { vfsState } = require('internal/fs/utils');
+  let srcIsDir;
+  if (vfsState.handlers !== null && vfsState.handlers.statSync(src)) {
+    srcIsDir = (await stat(src)).isDirectory();
+  } else {
+    srcIsDir = fsBinding.internalModuleStat(src) === 1;
+  }
 
   if (srcIsDir && isSrcSubdir(resolvedSrc, resolvedDest)) {
     throw new ERR_FS_CP_EINVAL({

lib/internal/fs/dir.js

@@ -31,6 +31,7 @@ const {
   getDirent,
   getOptions,
   getValidatedPath,
+  vfsState,
 } = require('internal/fs/utils');
 const {
   validateFunction,
@@ -330,6 +331,20 @@ function opendir(path, options, callback) {
   callback = typeof options === 'function' ? options : callback;
   validateFunction(callback, 'callback');
 
+  const h = vfsState.handlers;
+  if (h !== null) {
+    try {
+      const result = h.opendirSync(path, options);
+      if (result !== undefined) {
+        process.nextTick(callback, null, result);
+        return;
+      }
+    } catch (err) {
+      process.nextTick(callback, err);
+      return;
+    }
+  }
+
   path = getValidatedPath(path);
   options = getOptions(options, {
     encoding: 'utf8',
@@ -354,6 +369,12 @@ function opendir(path, options, callback) {
 }
 
 function opendirSync(path, options) {
+  const h = vfsState.handlers;
+  if (h !== null) {
+    const result = h.opendirSync(path, options);
+    if (result !== undefined) return result;
+  }
+
   path = getValidatedPath(path);
   options = getOptions(options, { encoding: 'utf8' });