fixup! fs: add support for async iterators to fs.writeFile

Fixes: #38075

Author: HiroyukiYagihashi

lib/fs.js

@@ -2045,21 +2045,16 @@ function lutimesSync(path, atime, mtime) {
 function writeAll(
   fd, isUserFd, buffer, offset, length, signal, encoding, callback) {
   if (signal?.aborted) {
-    const abortError = new AbortError();
-    if (isUserFd) {
-      callback(abortError);
-    } else {
-      fs.close(fd, (err) => {
-        callback(aggregateTwoErrors(err, abortError));
-      });
-    }
+    handleWriteAllErrorCallback(fd, isUserFd, new AbortError(), callback);
     return;
   }
 
   if (isCustomIterable(buffer)) {
     writeAllCustomIterable(
       fd, isUserFd, buffer, offset, length, signal, encoding, callback)
-      .catch((reason) => { throw reason; });
+      .catch((reason) => {
+        handleWriteAllErrorCallback(fd, isUserFd, reason, callback);
+      });
     return;
   }
   fs.write(fd, buffer, offset, length, null, (writeErr, written) => {
@@ -2082,20 +2077,29 @@ function writeAll(
 
 async function writeAllCustomIterable(
   fd, isUserFd, buffer, offset, length, signal, encoding, callback) {
+  if (signal?.aborted) {
+    handleWriteAllErrorCallback(fd, isUserFd, new AbortError(), callback);
+    return;
+  }
+
   const result = await buffer.next();
   if (result.done) {
-    fs.close(fd, callback);
+    if (isUserFd) {
+      callback(null);
+    } else {
+      fs.close(fd, callback);
+    }
     return;
   }
-  const resultValue = result.value.toString();
-  fs.write(fd, resultValue, undefined,
-           isArrayBufferView(buffer) ? resultValue.byteLength : encoding,
+  const resultValue = isArrayBufferView(result.value) ?
+    result.value : Buffer.from(String(result.value), encoding);
+  fs.write(fd, resultValue, offset, resultValue.byteLength,
            null, (writeErr, _) => {
              if (writeErr) {
                handleWriteAllErrorCallback(fd, isUserFd, writeErr, callback);
              } else {
-               writeAll(fd, isUserFd, buffer, offset,
-                        length, signal, encoding, callback);
+               writeAllCustomIterable(fd, isUserFd, buffer, offset, length,
+                                      signal, encoding, callback);
              }
            }
   );

test/parallel/test-fs-write-file-async-iterators.js

@@ -44,6 +44,26 @@ tmpdir.refresh();
   );
 }
 
+{
+  const filenameBufferIterableWithEncoding =
+    join(tmpdir.path, 'testBufferIterableWithEncoding.txt');
+  const bufferIterableWithEncoding = {
+    expected: 'ümlaut sechzig',
+    *[Symbol.iterator]() {
+      yield Buffer.from('ümlaut');
+      yield Buffer.from(' ');
+      yield Buffer.from('sechzig');
+    }
+  };
+
+  fs.writeFile(
+    filenameBufferIterableWithEncoding,
+    bufferIterableWithEncoding, common.mustSucceed(() => {
+      const data = fs.readFileSync(filenameBufferIterableWithEncoding, 'utf-8');
+      assert.strictEqual(bufferIterableWithEncoding.expected, data);
+    })
+  );
+}
 
 {
   const filenameAsyncIterable = join(tmpdir.path, 'testAsyncIterable.txt');
@@ -86,3 +106,47 @@ tmpdir.refresh();
     })
   );
 }
+
+{
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const filenameIterableAbort = join(tmpdir.path, 'testIterableAbort.txt');
+  const iterable = {
+    expected: 'abc',
+    *[Symbol.iterator]() {
+      yield 'a';
+      yield 'b';
+      yield 'c';
+    }
+  };
+
+
+  fs.writeFile(filenameIterableAbort,
+               iterable, { signal }, common.mustCall((err) => {
+                 assert.strictEqual(err.name, 'AbortError');
+               }));
+
+  controller.abort();
+}
+
+{
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const filenameAsyncIterableAbort =
+    join(tmpdir.path, 'testAsyncIterableAbort.txt');
+  const asyncIterable = {
+    expected: 'abc',
+    *[Symbol.asyncIterator]() {
+      yield 'a';
+      yield 'b';
+      yield 'c';
+    }
+  };
+
+  fs.writeFile(filenameAsyncIterableAbort,
+               asyncIterable, { signal }, common.mustCall((err) => {
+                 assert.strictEqual(err.name, 'AbortError');
+               }));
+
+  process.nextTick(() => controller.abort());
+}