windows: fs/promises: fix when writing to file opened in append mode

src/bun.js/node/node_fs.zig

@@ -5458,6 +5458,10 @@ pub const NodeFS = struct {
         }
 
         if (Environment.isWindows) {
+            if (args.flag == .a) {
+                return Maybe(Return.WriteFile).success;
+            }
+
             const rc = std.os.windows.kernel32.SetEndOfFile(fd.cast());
             if (rc == 0) {
                 return .{

src/js/node/fs.promises.ts

@@ -19,6 +19,7 @@ const kTransfer = Symbol("kTransfer");
 const kTransferList = Symbol("kTransferList");
 const kDeserialize = Symbol("kDeserialize");
 const kEmptyObject = ObjectFreeze({ __proto__: null });
+const kFlag = Symbol("kFlag");
 
 function watch(
   filename: string | Buffer | URL,
@@ -175,7 +176,7 @@ const exports = {
   mkdir: fs.mkdir.bind(fs),
   mkdtemp: fs.mkdtemp.bind(fs),
   open: async (path, flags, mode) => {
-    return new FileHandle(await fs.open(path, flags, mode));
+    return new FileHandle(await fs.open(path, flags, mode), flags);
   },
   read: fs.read.bind(fs),
   write: fs.write.bind(fs),
@@ -240,11 +241,12 @@ export default exports;
   // These functions await the result so that errors propagate correctly with
   // async stack traces and so that the ref counting is correct.
   var FileHandle = (private_symbols.FileHandle = class FileHandle extends EventEmitter {
-    constructor(fd) {
+    constructor(fd, flag) {
       super();
       this[kFd] = fd ? fd : -1;
       this[kRefs] = 1;
       this[kClosePromise] = null;
+      this[kFlag] = flag;
     }
 
     getAsyncId() {
@@ -255,13 +257,23 @@ export default exports;
       return this[kFd];
     }
 
-    async appendFile(data, options) {
+    async appendFile(data, options: object | string | undefined) {
       const fd = this[kFd];
       throwEBADFIfNecessary(writeFile, fd);
+      let encoding = "utf8";
+      let flush = false;
+
+      if (options == null || typeof options === "function") {
+      } else if (typeof options === "string") {
+        encoding = options;
+      } else {
+        encoding = options?.encoding ?? encoding;
+        flush = options?.flush ?? flush;
+      }
 
       try {
         this[kRef]();
-        return await writeFile(fd, data, options);
+        return await writeFile(fd, data, { encoding, flush, flag: this[kFlag] });
       } finally {
         this[kUnref]();
       }
@@ -415,13 +427,21 @@ export default exports;
       }
     }
 
-    async writeFile(data, options) {
+    async writeFile(data: string, options: object | string | undefined = "utf8") {
       const fd = this[kFd];
       throwEBADFIfNecessary(writeFile, fd);
+      let encoding: string = "utf8";
+
+      if (options == null || typeof options === "function") {
+      } else if (typeof options === "string") {
+        encoding = options;
+      } else {
+        encoding = options?.encoding ?? encoding;
+      }
 
       try {
         this[kRef]();
-        return await writeFile(fd, data, options);
+        return await writeFile(fd, data, { encoding, flag: this[kFlag] });
       } finally {
         this[kUnref]();
       }

test/js/node/fs/promises.test.js

@@ -9,6 +9,7 @@ const open = fsPromises.open;
 const copyFile = fsPromises.copyFile;
 const statfs = fsPromises.statfs;
 const unlink = fsPromises.unlink;
+const readFile = fsPromises.readFile;
 
 //
 //
@@ -186,3 +187,18 @@ describe("more", () => {
     });
   });
 });
+
+test("writing to file in append mode works", async () => {
+  const tempFile = os.tmpdir() + "/" + Date.now() + ".txt";
+
+  const f = await open(tempFile, "a");
+
+  await f.writeFile("test\n");
+  await f.appendFile("test\n");
+  await f.write("test\n");
+  await f.datasync();
+
+  await f.close();
+
+  expect((await readFile(tempFile)).toString()).toEqual("test\ntest\ntest\n");
+});