feat(net.createServer) and adds socket.connect IPC support (#2337)

* added net.Server

* fix fmt

* fix cast and move test

* fix node-net.tests.ts but breaks server data receive

* fix end and close only emitting when data or pipe was added

* fix socket starting paused

* add echo test

* fix fmt

* fix fmt

* on close if the socket is paused, keep paused until the user resumes it to match node behavior

* resume on connect

* fix getConnections, error on close, make _Handler private and create symbols for SocketServerHandlers

* add path support (IPC)

* fix unix domains support, add connect unix tests

* fix unix socket tests

* emit listening and listening error on next tick

* fix connection flask test

* try fix connect error on macos test

* merge connection and drop tests

* added exclusive option

* fix socket.zig fmt

* fix validation for options and add test for it

* pass prettier fmt

1 files changed, 95 insertions, 18 deletions

diff --git a/test/js/node/net/node-net.test.ts b/test/js/node/net/node-net.test.ts
index e6c17d931..fae1a50f7 100644
--- a/test/js/node/net/node-net.test.ts
+++ b/test/js/node/net/node-net.test.ts
@@ -1,5 +1,10 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
 import { connect, isIP, isIPv4, isIPv6, Socket } from "net";
+import { realpathSync, mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+const socket_domain = mkdtempSync(join(realpathSync(tmpdir()), "node-net"));
 
 it("should support net.isIP()", () => {
   expect(isIP("::1")).toBe(6);
@@ -27,12 +32,13 @@ it("should support net.isIPv6()", () => {
 
 describe("net.Socket read", () => {
   var port = 12345;
+  var unix_servers = 0;
   for (let [message, label] of [
     // ["Hello World!".repeat(1024), "long message"],
     ["Hello!", "short message"],
   ]) {
     describe(label, () => {
-      function runWithServer(cb) {
+      function runWithServer(cb, unix_domain_path) {
         return done => {
           function drain(socket) {
             const message = socket.data.message;
@@ -44,23 +50,42 @@ describe("net.Socket read", () => {
             }
           }
 
-          var server = Bun.listen({
-            hostname: "localhost",
-            port: port++,
-            socket: {
-              open(socket) {
-                socket.data.message = message;
-                drain(socket);
-              },
-              drain,
-              error(socket, err) {
-                done(err);
-              },
-            },
-            data: {
-              message: "",
-            },
-          });
+          var server = Bun.listen(
+            unix_domain_path
+              ? {
+                  unix: join(unix_domain_path, `${unix_servers++}.sock`),
+                  socket: {
+                    open(socket) {
+                      socket.data.message = message;
+                      drain(socket);
+                    },
+                    drain,
+                    error(socket, err) {
+                      done(err);
+                    },
+                  },
+                  data: {
+                    message: "",
+                  },
+                }
+              : {
+                  hostname: "localhost",
+                  port: port++,
+                  socket: {
+                    open(socket) {
+                      socket.data.message = message;
+                      drain(socket);
+                    },
+                    drain,
+                    error(socket, err) {
+                      done(err);
+                    },
+                  },
+                  data: {
+                    message: "",
+                  },
+                },
+          );
 
           function onDone(err) {
             server.stop();
@@ -152,6 +177,58 @@ describe("net.Socket read", () => {
             .on("error", done);
         }),
       );
+
+      it(
+        "should work with .connect(path)",
+        runWithServer((server, drain, done) => {
+          var data = "";
+          const socket = new Socket()
+            .connect(server.unix)
+            .on("connect", () => {
+              expect(socket).toBeDefined();
+              expect(socket.connecting).toBe(false);
+            })
+            .setEncoding("utf8")
+            .on("data", chunk => {
+              data += chunk;
+            })
+            .on("end", () => {
+              try {
+                expect(data).toBe(message);
+                done();
+              } catch (e) {
+                server.stop();
+                done(e);
+              }
+            })
+            .on("error", done);
+        }, socket_domain),
+      );
+
+      it(
+        "should work with .connect(path, listener)",
+        runWithServer((server, drain, done) => {
+          var data = "";
+          const socket = new Socket()
+            .connect(server.unix, () => {
+              expect(socket).toBeDefined();
+              expect(socket.connecting).toBe(false);
+            })
+            .setEncoding("utf8")
+            .on("data", chunk => {
+              data += chunk;
+            })
+            .on("end", () => {
+              try {
+                expect(data).toBe(message);
+                done();
+              } catch (e) {
+                done(e);
+              }
+            })
+            .on("error", done);
+        }, socket_domain),
+      );
     });
   }
 });