lib: normalize . and .. in path before rm/rmSync

When fs.rm, fs.rmSync, or fs.promises.rm receive a path containing '.'
or '..' components (e.g. 'a/b/../.'), the sync and async implementations
behaved differently:

- rmSync (C++ binding): std::filesystem::remove_all deleted the
  directory's children, but when trying to remove the top-level entry
  the path became invalid (the '..' referred to a now-deleted directory),
  causing the parent directory to be left behind.

- promises.rm / rm (JS rimraf): rmdir(2) on a path ending in '.'
  returns EINVAL on POSIX, so the operation failed immediately without
  removing anything.

Fix by calling path.normalize() on string paths immediately after
getValidatedPath(), before the path is passed to either rimraf or the
C++ binding. This resolves '.' and '..' lexically (e.g. 'a/b/../.'
becomes 'a'), giving both code paths a clean, unambiguous path to
operate on.

Fixes: #61958

Author: RajeshKumar11

lib/fs.js

@@ -1179,6 +1179,7 @@ function rm(path, options, callback) {
     options = undefined;
   }
   path = getValidatedPath(path);
+  if (typeof path === 'string') path = pathModule.normalize(path);
 
   validateRmOptions(path, options, false, (err, options) => {
     if (err) {
@@ -1202,8 +1203,10 @@ function rm(path, options, callback) {
  * @returns {void}
  */
 function rmSync(path, options) {
+  path = getValidatedPath(path);
+  if (typeof path === 'string') path = pathModule.normalize(path);
   const opts = validateRmOptionsSync(path, options, false);
-  return binding.rmSync(getValidatedPath(path), opts.maxRetries, opts.recursive, opts.retryDelay);
+  return binding.rmSync(path, opts.maxRetries, opts.recursive, opts.retryDelay);
 }
 
 /**

lib/internal/fs/promises.js

@@ -802,6 +802,7 @@ async function ftruncate(handle, len = 0) {
 
 async function rm(path, options) {
   path = getValidatedPath(path);
+  if (typeof path === 'string') path = pathModule.normalize(path);
   options = await validateRmOptionsPromise(path, options, false);
   return lazyRimRaf()(path, options);
 }

test/parallel/test-fs-rm.js

@@ -569,3 +569,42 @@ if (isGitPresent) {
     }
   }
 }
+
+// Test that rm/rmSync normalize '.' and '..' in paths before processing.
+// Regression test for https://github.com/nodejs/node/issues/61958
+//
+// Each variant gets its own base directory to avoid async/sync races.
+// The weird path is constructed by joining components with path.sep so that
+// the '..' and '.' are preserved and not pre-normalized by path.join.
+{
+  // --- rmSync: <base>/a/b/../. should remove <base>/a entirely ---
+  const base = nextDirPath('dotdot-sync');
+  fs.mkdirSync(path.join(base, 'a', 'b', 'c', 'd'), { recursive: true });
+  const weirdPath = [base, 'a', 'b', '..', '.'].join(path.sep);
+  fs.rmSync(weirdPath, { recursive: true });
+  assert.strictEqual(fs.existsSync(path.join(base, 'a')), false,
+    'rmSync should completely remove the normalized target directory');
+}
+
+{
+  // --- fs.rm (callback): same path construction ---
+  const base = nextDirPath('dotdot-cb');
+  fs.mkdirSync(path.join(base, 'a', 'b', 'c', 'd'), { recursive: true });
+  const weirdPath = [base, 'a', 'b', '..', '.'].join(path.sep);
+  fs.rm(weirdPath, { recursive: true }, common.mustCall((err) => {
+    assert.ifError(err);
+    assert.strictEqual(fs.existsSync(path.join(base, 'a')), false,
+      'fs.rm callback should completely remove the normalized target directory');
+  }));
+}
+
+{
+  // --- fs.promises.rm: same path construction ---
+  const base = nextDirPath('dotdot-prom');
+  fs.mkdirSync(path.join(base, 'a', 'b', 'c', 'd'), { recursive: true });
+  const weirdPath = [base, 'a', 'b', '..', '.'].join(path.sep);
+  fs.promises.rm(weirdPath, { recursive: true }).then(common.mustCall(() => {
+    assert.strictEqual(fs.existsSync(path.join(base, 'a')), false,
+      'fs.promises.rm should completely remove the normalized target directory');
+  }));
+}