Port SocketConfig to bindings generator

src/bun.js/api/bun/socket.zig

@@ -574,8 +574,8 @@ pub fn NewSocket(comptime ssl: bool) type {
                     // clean onOpen callback so only called in the first handshake and not in every renegotiation
                     // on servers this would require a different approach but it's not needed because our servers will not call handshake multiple times
                     // servers don't support renegotiation
-                    this.handlers.?.onOpen.unprotect();
-                    this.handlers.?.onOpen = .zero;
+                    handlers.onOpen.unprotect();
+                    handlers.onOpen = .zero;
                 }
             } else {
                 // call handhsake callback with authorized and authorization error if has one
@@ -1349,14 +1349,10 @@ pub fn NewSocket(comptime ssl: bool) type {
                 return globalObject.throw("Expected \"socket\" option", .{});
             };
 
-            var prev_handlers = this.getHandlers();
-
-            const handlers = try Handlers.fromJS(globalObject, socket_obj, prev_handlers.is_server);
-
-            prev_handlers.unprotect();
-            this.handlers.?.* = handlers; // TODO: this is a memory leak
-            this.handlers.?.withAsyncContextIfNeeded(globalObject);
-            this.handlers.?.protect();
+            const this_handlers = this.getHandlers();
+            const handlers = try Handlers.fromJS(globalObject, socket_obj, this_handlers.is_server);
+            this_handlers.deinit();
+            this_handlers.* = handlers;
 
             return .js_undefined;
         }
@@ -1398,7 +1394,7 @@ pub fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
 
-            var handlers = try Handlers.fromJS(globalObject, socket_obj, this.isServer());
+            const handlers = try Handlers.fromJS(globalObject, socket_obj, this.isServer());
 
             if (globalObject.hasException()) {
                 return .zero;
@@ -1435,10 +1431,8 @@ pub fn NewSocket(comptime ssl: bool) type {
             const options = socket_config.asUSockets();
             const ext_size = @sizeOf(WrappedSocket);
 
-            var handlers_ptr = bun.handleOom(bun.default_allocator.create(Handlers));
-            handlers.withAsyncContextIfNeeded(globalObject);
+            const handlers_ptr = bun.handleOom(handlers.vm.allocator.create(Handlers));
             handlers_ptr.* = handlers;
-            handlers_ptr.protect();
             var tls = bun.new(TLSSocket, .{
                 .ref_count = .init(),
                 .handlers = handlers_ptr,
@@ -1489,7 +1483,7 @@ pub fn NewSocket(comptime ssl: bool) type {
 
                 tls.deref();
 
-                handlers_ptr.unprotect();
+                handlers_ptr.deinit();
                 bun.default_allocator.destroy(handlers_ptr);
 
                 // If BoringSSL gave us an error code, let's use it.
@@ -1514,29 +1508,10 @@ pub fn NewSocket(comptime ssl: bool) type {
             const new_context = new_socket.context().?;
             tls.socket_context = new_context; // owns the new tls context that have a ref from the old one
             tls.ref();
-            const vm = handlers.vm;
 
-            var raw_handlers_ptr = bun.handleOom(bun.default_allocator.create(Handlers));
-            raw_handlers_ptr.* = blk: {
-                const this_handlers = this.getHandlers();
-                break :blk .{
-                    .vm = vm,
-                    .globalObject = globalObject,
-                    .onOpen = this_handlers.onOpen,
-                    .onClose = this_handlers.onClose,
-                    .onData = this_handlers.onData,
-                    .onWritable = this_handlers.onWritable,
-                    .onTimeout = this_handlers.onTimeout,
-                    .onConnectError = this_handlers.onConnectError,
-                    .onEnd = this_handlers.onEnd,
-                    .onError = this_handlers.onError,
-                    .onHandshake = this_handlers.onHandshake,
-                    .binary_type = this_handlers.binary_type,
-                    .is_server = this_handlers.is_server,
-                };
-            };
-
-            raw_handlers_ptr.protect();
+            const this_handlers = this.getHandlers();
+            const raw_handlers_ptr = bun.handleOom(this_handlers.vm.allocator.create(Handlers));
+            raw_handlers_ptr.* = this_handlers.clone();
 
             const raw = bun.new(TLSSocket, .{
                 .ref_count = .init(),
@@ -1563,7 +1538,7 @@ pub fn NewSocket(comptime ssl: bool) type {
             tls.markActive();
 
             // we're unrefing the original instance and refing the TLS instance
-            tls.poll_ref.ref(this.getHandlers().vm);
+            tls.poll_ref.ref(this_handlers.vm);
 
             // mark both instances on socket data
             if (new_socket.ext(WrappedSocket)) |ctx| {
@@ -1933,7 +1908,8 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
         return globalObject.throw("Expected \"socket\" option", .{});
     };
 
-    var handlers = try Handlers.fromJS(globalObject, socket_obj, false);
+    const is_server = false; // A duplex socket is always handled as a client
+    const handlers = try Handlers.fromJS(globalObject, socket_obj, is_server);
 
     var ssl_opts: ?jsc.API.ServerConfig.SSLConfig = null;
     if (try opts.getTruthy(globalObject, "tls")) |tls| {
@@ -1953,13 +1929,8 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
         default_data.ensureStillAlive();
     }
 
-    const is_server = false; // A duplex socket is always handled as a client
-
-    var handlers_ptr = bun.handleOom(handlers.vm.allocator.create(Handlers));
+    const handlers_ptr = bun.handleOom(handlers.vm.allocator.create(Handlers));
     handlers_ptr.* = handlers;
-    handlers_ptr.is_server = is_server;
-    handlers_ptr.withAsyncContextIfNeeded(globalObject);
-    handlers_ptr.protect();
     var tls = bun.new(TLSSocket, .{
         .ref_count = .init(),
         .handlers = handlers_ptr,