node:fs: implement mkdtempDisposable / mkdtempDisposableSync

src/js/node/fs.promises.ts

@@ -161,6 +161,21 @@ const exports = {
   lstat: asyncWrap(fs.lstat, "lstat"),
   mkdir: asyncWrap(fs.mkdir, "mkdir"),
   mkdtemp: asyncWrap(fs.mkdtemp, "mkdtemp"),
+  mkdtempDisposable: async function mkdtempDisposable(prefix, options) {
+    // Capture cwd at creation time so process.chdir() between creation and
+    // disposal cannot misdirect the recursive rm.
+    const cwd = process.cwd();
+    const folder = await fs.mkdtemp(prefix, options);
+    const fullPath = require("node:path").resolve(cwd, folder);
+    const remove = () => fs.rm(fullPath, { recursive: true, force: true });
+    return {
+      path: folder,
+      remove,
+      async [Symbol.asyncDispose]() {
+        await remove();
+      },
+    };
+  },
   statfs: asyncWrap(fs.statfs, "statfs"),
   open: async (path, flags = "r", mode = 0o666) => {
     return new private_symbols.FileHandle(await fs.open(path, flags, mode), flags);

src/js/node/fs.ts

@@ -560,6 +560,22 @@ var access = function access(path, mode, callback) {
   lstatSync = fs.lstatSync.bind(fs) as unknown as typeof import("node:fs").lstatSync,
   mkdirSync = fs.mkdirSync.bind(fs) as unknown as typeof import("node:fs").mkdirSync,
   mkdtempSync = fs.mkdtempSync.bind(fs) as unknown as typeof import("node:fs").mkdtempSync,
+  mkdtempDisposableSync = function mkdtempDisposableSync(prefix, options) {
+    const folder = fs.mkdtempSync(prefix, options);
+    // Capture cwd at creation time so process.chdir() between creation and
+    // disposal cannot misdirect the recursive rm.
+    const fullPath = require("node:path").resolve(process.cwd(), folder);
+    const remove = () => {
+      rmSync(fullPath, { recursive: true, force: true });
+    };
+    return {
+      path: folder,
+      remove,
+      [Symbol.dispose]() {
+        remove();
+      },
+    };
+  },
   openSync = fs.openSync.bind(fs) as unknown as typeof import("node:fs").openSync,
   readSync = function readSync(fd, buffer, offsetOrOptions, length, position) {
     let offset = offsetOrOptions;
@@ -1199,6 +1215,7 @@ var exports = {
   mkdir,
   mkdirSync,
   mkdtemp,
+  mkdtempDisposableSync,
   mkdtempSync,
   open,
   openSync,
@@ -1349,6 +1366,7 @@ setName(lutimesSync, "lutimesSync");
 setName(mkdir, "mkdir");
 setName(mkdirSync, "mkdirSync");
 setName(mkdtemp, "mkdtemp");
+setName(mkdtempDisposableSync, "mkdtempDisposableSync");
 setName(mkdtempSync, "mkdtempSync");
 setName(open, "open");
 setName(openSync, "openSync");

test/js/node/fs/fs.test.ts

@@ -29,6 +29,7 @@ import fs, {
   lstatSync,
   mkdirSync,
   mkdtemp,
+  mkdtempDisposableSync,
   mkdtempSync,
   openAsBlob,
   openSync,
@@ -4043,3 +4044,101 @@ describe.skipIf(isWindows)("readFileSync on a FIFO larger than the stat size", (
     expect(exitCode).toBe(0);
   });
 });
+
+describe("mkdtempDisposableSync", () => {
+  it("creates a directory and removes it via Symbol.dispose", () => {
+    const result = mkdtempDisposableSync(join(tmpdirSync(), "disposable-"));
+    expect(typeof result.path).toBe("string");
+    expect(existsSync(result.path)).toBe(true);
+    result[Symbol.dispose]();
+    expect(existsSync(result.path)).toBe(false);
+  });
+
+  it("calling dispose twice is safe", () => {
+    const result = mkdtempDisposableSync(join(tmpdirSync(), "disposable-"));
+    result[Symbol.dispose]();
+    result[Symbol.dispose]();
+    expect(existsSync(result.path)).toBe(false);
+  });
+
+  it("remove() works as a manual alternative to dispose", () => {
+    const result = mkdtempDisposableSync(join(tmpdirSync(), "disposable-"));
+    result.remove();
+    expect(existsSync(result.path)).toBe(false);
+  });
+
+  it("works with `using` syntax", () => {
+    let savedPath: string;
+    {
+      using temp = mkdtempDisposableSync(join(tmpdirSync(), "disposable-"));
+      savedPath = temp.path;
+      expect(existsSync(temp.path)).toBe(true);
+    }
+    expect(existsSync(savedPath!)).toBe(false);
+  });
+
+  it("removes a non-empty directory recursively", () => {
+    const result = mkdtempDisposableSync(join(tmpdirSync(), "disposable-"));
+    writeFileSync(join(result.path, "nested.txt"), "hello");
+    mkdirSync(join(result.path, "sub"));
+    writeFileSync(join(result.path, "sub", "deep.txt"), "world");
+    result[Symbol.dispose]();
+    expect(existsSync(result.path)).toBe(false);
+  });
+
+  it("survives process.chdir between create and dispose", () => {
+    const originalCwd = process.cwd();
+    const base = tmpdirSync();
+    process.chdir(base);
+    try {
+      const result = mkdtempDisposableSync("./disposable-");
+      const absolute = path.resolve(base, result.path);
+      expect(existsSync(absolute)).toBe(true);
+      process.chdir(os.tmpdir());
+      result[Symbol.dispose]();
+      expect(existsSync(absolute)).toBe(false);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});
+
+describe("fs.promises.mkdtempDisposable", () => {
+  it("creates a directory and removes it via Symbol.asyncDispose", async () => {
+    const result = await _promises.mkdtempDisposable(join(tmpdirSync(), "disposable-"));
+    expect(typeof result.path).toBe("string");
+    expect(existsSync(result.path)).toBe(true);
+    await result[Symbol.asyncDispose]();
+    expect(existsSync(result.path)).toBe(false);
+  });
+
+  it("works with `await using` syntax", async () => {
+    let savedPath: string;
+    {
+      await using temp = await _promises.mkdtempDisposable(join(tmpdirSync(), "disposable-"));
+      savedPath = temp.path;
+      expect(existsSync(temp.path)).toBe(true);
+    }
+    expect(existsSync(savedPath!)).toBe(false);
+  });
+
+  it("calling asyncDispose twice is safe", async () => {
+    const result = await _promises.mkdtempDisposable(join(tmpdirSync(), "disposable-"));
+    await result[Symbol.asyncDispose]();
+    await result[Symbol.asyncDispose]();
+    expect(existsSync(result.path)).toBe(false);
+  });
+
+  it("remove() returns a Promise that resolves", async () => {
+    const result = await _promises.mkdtempDisposable(join(tmpdirSync(), "disposable-"));
+    await result.remove();
+    expect(existsSync(result.path)).toBe(false);
+  });
+
+  it("is also reachable via the node:fs `promises` namespace", async () => {
+    const result = await promises.mkdtempDisposable(join(tmpdirSync(), "disposable-"));
+    expect(existsSync(result.path)).toBe(true);
+    await result[Symbol.asyncDispose]();
+    expect(existsSync(result.path)).toBe(false);
+  });
+});