vfs: normalize RealFSProvider mkdir return paths

RealFSProvider.mkdirSync()/mkdir() forwarded the raw fs.mkdirSync()
result, which for { recursive: true } is the absolute backing-directory
path of the first created directory. VirtualFileSystem#toMountedPath()
then joined the mount point with it, producing <mount>/<root>/a instead
of <mount>/a, so the returned path failed fs.existsSync().

Reuse the existing #resolvedToVfsPath() helper (as realpath does) to
translate the result back to a provider-relative VFS path, matching
MemoryProvider.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: opencode

Author: trivikr

lib/internal/vfs/providers/real.js

@@ -458,12 +458,16 @@ class RealFSProvider extends VirtualProvider {
 
   mkdirSync(vfsPath, options) {
     const realPath = this.#resolvePath(vfsPath);
-    return fs.mkdirSync(realPath, options);
+    const created = fs.mkdirSync(realPath, options);
+    if (created === undefined) return undefined;
+    return this.#resolvedToVfsPath(created, vfsPath, 'mkdir');
   }
 
   async mkdir(vfsPath, options) {
     const realPath = this.#resolvePath(vfsPath);
-    return fs.promises.mkdir(realPath, options);
+    const created = await fs.promises.mkdir(realPath, options);
+    if (created === undefined) return undefined;
+    return this.#resolvedToVfsPath(created, vfsPath, 'mkdir');
   }
 
   rmdirSync(vfsPath) {

test/parallel/test-vfs-real-provider-promises.js

@@ -35,6 +35,19 @@ const myVfs = vfs.create(new vfs.RealFSProvider(root));
   assert.deepStrictEqual(entries.sort(), ['sub']);
   await myVfs.promises.rmdir('/d/sub');
 
+  // Recursive mkdir returns the first directory created, as a VFS-relative
+  // path (never the backing-directory path), matching MemoryProvider.
+  const createdSub = await myVfs.promises.mkdir('/d/sub', { recursive: true });
+  assert.strictEqual(createdSub, '/d/sub');
+  assert.strictEqual(await myVfs.promises.mkdir('/d/sub', { recursive: true }),
+                     undefined);
+  const created = await myVfs.promises.mkdir('/d/deep/nested', { recursive: true });
+  assert.strictEqual(created, '/d/deep');
+  assert.strictEqual(myVfs.existsSync(created), true);
+  await myVfs.promises.rmdir('/d/sub');
+  await myVfs.promises.rmdir('/d/deep/nested');
+  await myVfs.promises.rmdir('/d/deep');
+
   // rename
   await myVfs.promises.writeFile('/old.txt', 'x');
   await myVfs.promises.rename('/old.txt', '/new.txt');

test/parallel/test-vfs-real-provider.js

@@ -106,6 +106,37 @@ fs.mkdirSync(testDir, { recursive: true });
   fs.rmdirSync(path.join(testDir, 'deep/nested/dir'));
   fs.rmdirSync(path.join(testDir, 'deep/nested'));
   fs.rmdirSync(path.join(testDir, 'deep'));
+
+  // Recursive mkdir returns the first directory created, as a VFS-relative
+  // path (never the backing-directory path), matching MemoryProvider.
+  const created = realVfs.mkdirSync('/returned/nested/dir', { recursive: true });
+  assert.strictEqual(created, '/returned');
+  assert.strictEqual(realVfs.existsSync(created), true);
+  assert.strictEqual(
+    realVfs.mkdirSync('/returned/nested/dir', { recursive: true }),
+    undefined,
+  );
+  assert.strictEqual(realVfs.mkdirSync('/returned/new-dir'),
+                     undefined);
+  fs.rmdirSync(path.join(testDir, 'returned/nested/dir'));
+  fs.rmdirSync(path.join(testDir, 'returned/nested'));
+  fs.rmdirSync(path.join(testDir, 'returned/new-dir'));
+  fs.rmdirSync(path.join(testDir, 'returned'));
+}
+
+// Mounted recursive mkdir returns a path that exists on the real filesystem.
+{
+  const realVfs = vfs.create(new vfs.RealFSProvider(testDir));
+  const mountPoint = realVfs.mount();
+  try {
+    const created = realVfs.mkdirSync(path.join(mountPoint, 'm/nested/dir'),
+                                      { recursive: true });
+    assert.strictEqual(created, path.join(mountPoint, 'm'));
+    assert.strictEqual(fs.existsSync(created), true);
+  } finally {
+    realVfs.unmount();
+    fs.rmSync(path.join(testDir, 'm'), { recursive: true, force: true });
+  }
 }
 
 // unlink