[breaking] Add `binaryType` option to Bun.connect & Bun.listen

This is a breaking change because the default is `Buffer`, but previously the default was `Uint8Array`. While `Buffer` is a subclass of `Uint8Array`, it still technically is a breaking change because `slice` in `Uint8Array` is not semantically identical to `slice` in `Buffer`

cc @colinhacks, the .d.ts changes I made here aren't great.

1 files changed, 128 insertions, 3 deletions

diff --git a/test/bun.js/tcp-server.test.ts b/test/bun.js/tcp-server.test.ts
index 77af3c378..6ddacd662 100644
--- a/test/bun.js/tcp-server.test.ts
+++ b/test/bun.js/tcp-server.test.ts
@@ -1,5 +1,11 @@
-import { listen, connect, TCPSocketListener } from "bun";
-import { expect, it } from "bun:test";
+import {
+  listen,
+  connect,
+  TCPSocketListener,
+  TCPSocketOptions,
+  SocketHandler,
+} from "bun";
+import { describe, expect, it } from "bun:test";
 import * as JSC from "bun:jsc";
 
 var decoder = new TextDecoder();
@@ -74,12 +80,13 @@ it("echo server 1 on 1", async () => {
       drain(socket) {
         reject(new Error("Unexpected backpressure"));
       },
-    };
+    } as SocketHandler<any>;
 
     var server: TCPSocketListener<any> | undefined = listen({
       socket: handlers,
       hostname: "localhost",
       port: 8084,
+
       data: {
         isServer: true,
         counter: 0,
@@ -99,6 +106,124 @@ it("echo server 1 on 1", async () => {
   })();
 });
 
+describe("tcp socket binaryType", () => {
+  var port = 8085;
+  const binaryType = ["arraybuffer", "uint8array", "buffer"] as const;
+  for (const type of binaryType) {
+    it(type, async () => {
+      // wrap it in a separate closure so the GC knows to clean it up
+      // the sockets & listener don't escape the closure
+      await (async function () {
+        var resolve, reject, serverResolve, serverReject;
+        var prom = new Promise((resolve1, reject1) => {
+          resolve = resolve1;
+          reject = reject1;
+        });
+        var serverProm = new Promise((resolve1, reject1) => {
+          serverResolve = resolve1;
+          serverReject = reject1;
+        });
+
+        var serverData, clientData;
+        const handlers = {
+          open(socket) {
+            socket.data.counter = 1;
+            if (!socket.data?.isServer) {
+              clientData = socket.data;
+              clientData.sendQueue = ["client: Hello World! " + 0];
+              if (!socket.write("client: Hello World! " + 0)) {
+                socket.data = { pending: "server: Hello World! " + 0 };
+              }
+            } else {
+              serverData = socket.data;
+              serverData.sendQueue = ["server: Hello World! " + 0];
+            }
+
+            if (clientData) clientData.other = serverData;
+            if (serverData) serverData.other = clientData;
+            if (clientData) clientData.other = serverData;
+            if (serverData) serverData.other = clientData;
+          },
+          data(socket, buffer) {
+            expect(
+              buffer instanceof
+                (type === "arraybuffer"
+                  ? ArrayBuffer
+                  : type === "uint8array"
+                  ? Uint8Array
+                  : type === "buffer"
+                  ? Buffer
+                  : Error),
+            ).toBe(true);
+            const msg = `${
+              socket.data.isServer ? "server:" : "client:"
+            } Hello World! ${socket.data.counter++}`;
+            socket.data.sendQueue.push(msg);
+
+            expect(decoder.decode(buffer)).toBe(
+              socket.data.other.sendQueue.pop(),
+            );
+
+            if (socket.data.counter > 10) {
+              if (!socket.data.finished) {
+                socket.data.finished = true;
+                if (socket.data.isServer) {
+                  setTimeout(() => {
+                    serverResolve();
+                    socket.end();
+                  }, 1);
+                } else {
+                  setTimeout(() => {
+                    resolve();
+                    socket.end();
+                  }, 1);
+                }
+              }
+            }
+
+            if (!socket.write(msg)) {
+              socket.data.pending = msg;
+              return;
+            }
+          },
+          error(socket, error) {
+            reject(error);
+          },
+          drain(socket) {
+            reject(new Error("Unexpected backpressure"));
+          },
+
+          binaryType: type,
+        } as SocketHandler<any>;
+
+        var server: TCPSocketListener<any> | undefined = listen({
+          socket: handlers,
+          hostname: "localhost",
+          port,
+          data: {
+            isServer: true,
+            counter: 0,
+          },
+        });
+
+        const clientProm = connect({
+          socket: handlers,
+          hostname: "localhost",
+          port,
+          data: {
+            counter: 0,
+          },
+        });
+        port++;
+
+        await Promise.all([prom, clientProm, serverProm]);
+        server.stop(true);
+        server = serverData = clientData = undefined;
+      })();
+    });
+  }
+});
+
 it("should not leak memory", () => {
   // Tell the garbage collector for sure that we're done with the sockets
   Bun.gc(true);