react-native-nitro-net 0.5.1 → 0.5.3

package/lib/net.js

@@ -81,6 +81,10 @@ function initWithConfig(config) {
     if (config.debug !== undefined) {
         setVerbose(config.debug);
     }
+    // Inject dispatcher for async events to avoid thread starvation/deadlocks
+    if (Driver.installDispatcher) {
+        Driver.installDispatcher();
+    }
     Driver.initWithConfig(config);
 }
 export class SocketAddress {
@@ -262,6 +266,7 @@ export class Socket extends Duplex {
         this.autoSelectFamilyAttemptedAddresses = [];
         this._autoSelectFamily = false;
         this._timeout = 0;
+        this._nativeWriteCallbacks = [];
         if (options?.socketDriver) {
             // Wrapping existing socket (from Server)
             this._driver = options.socketDriver;
@@ -269,9 +274,8 @@ export class Socket extends Duplex {
             this._setupEvents();
             // Enable noDelay by default
             this._driver.setNoDelay(true);
-            // Resume the socket since it starts paused on server-accept
-            this.resume();
-            // Emit connect for server-side socket? No, it's already connected.
+            // For accepted server sockets, defer resume until after the server
+            // emits 'connection' so user handlers can attach first.
         }
         else {
             // New client socket
@@ -290,8 +294,8 @@ export class Socket extends Duplex {
             return this;
         }
         const ret = super.on(event, listener);
-        if (event === 'data' && !this.isPaused() && this.readableFlowing !== true) {
-            debugLog(`Socket on('data'), flowing: ${this.readableFlowing}`);
+        if (event === 'data' && this.readableFlowing !== true) {
+            debugLog(`Socket on('data'), flowing: ${this.readableFlowing}, paused: ${this.isPaused()}`);
             this.resume();
         }
         return ret;
@@ -327,8 +331,10 @@ export class Socket extends Duplex {
                     if (data && data.byteLength > 0) {
                         const buffer = Buffer.from(data);
                         this.bytesRead += buffer.length;
-                        if (!this.push(buffer)) {
-                            this.pause();
+                        this.push(buffer);
+                        if (this.listenerCount('data') > 0 && this.readableFlowing !== true) {
+                            debugLog(`Socket onEvent(DATA) restoring flowing mode for attached 'data' listeners`);
+                            this.resume();
                         }
                     }
                     break;
@@ -355,6 +361,11 @@ export class Socket extends Duplex {
                     this._connected = false;
                     this.connecting = false;
                     this.push(null); // EOF
+                    if (!this.allowHalfOpen && !this.writableEnded && !this.destroyed) {
+                        // Match Node's default behavior: half-close the writable side
+                        // when the peer finishes and allowHalfOpen is false.
+                        this.end();
+                    }
                     this.emit('close', this._hadError);
                     break;
                 case NetSocketEvent.DRAIN:
@@ -506,22 +517,39 @@ export class Socket extends Duplex {
         return this;
     }
     end(chunk, encoding, cb) {
-        debugLog(`Socket (localPort: ${this.localPort}) .end() called`);
         if (typeof chunk === 'function') {
-            super.end(chunk);
+            cb = chunk;
+            chunk = null;
+            encoding = null;
         }
-        else if (chunk == null) {
-            super.end(cb);
+        else if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = null;
         }
-        else {
-            super.end(chunk, encoding, cb);
+        debugLog(`Socket (localPort: ${this.localPort}) .end() called`);
+        if (chunk != null) {
+            this.write(chunk, encoding);
         }
+        super.end(cb);
         return this;
     }
     _write(chunk, encoding, callback) {
         if (!this._driver) {
             return callback(new Error('Socket not connected'));
         }
+        if (!this._connected && this.connecting) {
+            const onConnect = () => {
+                this.removeListener('error', onError);
+                this._write(chunk, encoding, callback);
+            };
+            const onError = (err) => {
+                this.removeListener('connect', onConnect);
+                callback(err);
+            };
+            this.once('connect', onConnect);
+            this.once('error', onError);
+            return;
+        }
         try {
             const buffer = (chunk instanceof Buffer) ? chunk : Buffer.from(chunk, encoding);
             this.bytesWritten += buffer.length;
@@ -539,9 +567,24 @@ export class Socket extends Duplex {
             this._driver.resume();
     }
     _final(callback) {
-        if (this._driver) {
-            this._driver.shutdown();
+        if (!this._driver) {
+            return callback(null);
+        }
+        if (!this._connected && this.connecting) {
+            const onConnect = () => {
+                this.removeListener('error', onError);
+                this._final(callback);
+            };
+            const onError = () => {
+                this.removeListener('connect', onConnect);
+                callback(null); // Already destroyed/errored
+            };
+            this.once('connect', onConnect);
+            this.once('error', onError);
+            return;
         }
+        debugLog(`Socket (localPort: ${this.localPort}) ._final() called, shutting down driver`);
+        this._driver.shutdown();
         callback(null);
     }
     destroy(reason) {
@@ -724,6 +767,9 @@ export class Server extends EventEmitter {
                                 this._sockets.delete(socket);
                             });
                             this.emit('connection', socket);
+                            // Start reading only after 'connection' handlers ran.
+                            // This prevents dropping data when listeners are attached in the callback.
+                            socket.resume();
                         }
                     }
                     break;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "react-native-nitro-net",
     "description": "Ultra-high-performance networking to React Native by combining a memory-safe Rust core with the zero-overhead Nitro Modules JSI bridge. Provides Node.js-compatible net, tls, http(s) API.",
-    "version": "0.5.1",
+    "version": "0.5.3",
     "type": "module",
     "main": "./lib/index.js",
     "module": "./lib/index.js",
@@ -18,6 +18,7 @@
     ],
     "author": "iwater <iwater@gmail.com>",
     "license": "ISC",
+    "homepage": "https://github.com/iwater/react-native-nitro-net",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/iwater/react-native-nitro-net.git"

package/react-native-nitro-net.podspec

@@ -6,12 +6,12 @@ Pod::Spec.new do |s|
   s.name         = "react-native-nitro-net"
   s.version      = package["version"]
   s.summary      = package["description"]
-  s.homepage     = "https://github.com/iwater/react-native-nitro-net"
+  s.homepage     = package["homepage"]
   s.license      = package["license"]
   s.authors      = package["author"]
   
   s.platform     = :ios, "13.0"
-  s.source       = { :git => "https://github.com/iwater/react-native-nitro-net.git", :tag => "v#{s.version}" }
+  s.source       = { :git => package["repository"]["url"].gsub("git+", ""), :tag => "v#{s.version}" }
   
   # Module Name must match iosModuleName in nitro.json
   s.module_name  = "RustCNet"

package/src/http.ts

@@ -105,7 +105,14 @@ export class IncomingMessage extends Readable {
     }
 
     _read() {
-        this.socket.resume();
+        // Server-side: socket is kept flowing by _setupHttpConnection.
+        // Calling socket.resume() here is the correct Node.js backpressure pattern
+        // but only when socket is the actual data source (client-side IncomingMessage).
+        // For server-side req, body bytes come via parser→push(), not socket directly.
+        // Still call resume() to unblock if paused by backpressure, but guard it.
+        if (this.socket && !(this.socket as any)._destroyed) {
+            this.socket.resume();
+        }
     }
 
     public setTimeout(msecs: number, callback?: () => void): this {
@@ -289,8 +296,16 @@ export class OutgoingMessage extends Writable {
     }
 
     end(chunk?: any, encoding?: any, callback?: any): this {
-        debugLog(`OutgoingMessage.end() called, already ending: ${(this as any)._writableState?.ending}, chunk: ${!!chunk}`);
-        if (chunk) {
+        if (typeof chunk === 'function') {
+            callback = chunk;
+            chunk = null;
+            encoding = null;
+        } else if (typeof encoding === 'function') {
+            callback = encoding;
+            encoding = null;
+        }
+
+        if (chunk != null) {
             this.write(chunk, encoding);
         }
         super.end(callback);
@@ -362,24 +377,31 @@ export class ServerResponse extends OutgoingMessage {
     }
 
     end(chunk?: any, encoding?: any, callback?: any): this {
+        if (typeof chunk === 'function') {
+            callback = chunk;
+            chunk = null;
+            encoding = null;
+        } else if (typeof encoding === 'function') {
+            callback = encoding;
+            encoding = null;
+        }
+
         if (!this.headersSent) {
             // If we have a single chunk and no headers sent yet, we can add Content-Length
             // to avoid chunked encoding for simple responses.
-            if (chunk) {
-                const len = typeof chunk === 'string' ? Buffer.byteLength(chunk, encoding) : chunk.length;
+            if (chunk != null) {
+                const len = typeof chunk === 'string' ? Buffer.byteLength(chunk, (encoding as string) || undefined) : chunk.length;
                 this.setHeader('Content-Length', len);
-            } else {
+            } else if (!this.hasHeader('Transfer-Encoding')) {
                 this.setHeader('Content-Length', 0);
             }
             this._sendResponseHeaders();
         }
-        if (typeof chunk === 'function') {
-            super.end(chunk);
-        } else if (chunk == null) {
-            super.end(callback);
-        } else {
-            super.end(chunk, encoding, callback);
+
+        if (chunk != null) {
+            this.write(chunk, encoding);
         }
+        super.end(callback);
         return this;
     }
 }
@@ -558,16 +580,51 @@ export class Server extends EventEmitter {
                     }
                 }
 
-                if (req && parsed.body && parsed.body.length > 0) {
-                    req.push(Buffer.from(parsed.body));
-                }
-
-                if (req && parsed.complete) {
-                    req.complete = true;
-                    if (parsed.trailers) {
-                        req.trailers = parsed.trailers;
+                // Push body/EOF into IncomingMessage.
+                // CRITICAL: When headers and body arrive in the same TCP packet
+                // (parsed.is_headers && body present), the user's 'request' handler
+                // has just been called synchronously above. The readable-stream
+                // library schedules its internal resume/flow via process.nextTick.
+                // If we push() synchronously here, the data lands in the buffer
+                // *before* the Readable enters flowing mode, and since no further
+                // socket data events will arrive, the flow() loop never drains it.
+                // Solution: always defer body/EOF push via process.nextTick so the
+                // Readable has a chance to enter flowing mode first.
+                const _bodyToPush = req && parsed.body && parsed.body.length > 0
+                    ? Buffer.from(parsed.body) : null;
+                const _isComplete = !!(req && parsed.complete);
+                const _trailers = parsed.trailers;
+                const _reqRef = req;
+
+                // Diagnostic: log body delivery state (requires debug mode)
+                debugLog(`[Server] handleParsedResult: is_headers=${parsed.is_headers}, ` +
+                    `bodyLen=${_bodyToPush?.length ?? 0}, complete=${_isComplete}, ` +
+                    `req.readableFlowing=${(_reqRef as any)?._readableState?.flowing}`);
+
+                if (_bodyToPush !== null || _isComplete) {
+                    if (parsed.is_headers) {
+                        // Same-packet case: defer to give Readable time to enter flowing mode
+                        debugLog(`[Server] Deferring body/EOF push via setImmediate (same-packet)`);
+                        setImmediate(() => {
+                            if (!_reqRef) return;
+                            debugLog(`[Server] setImmediate: pushing body=${_bodyToPush?.length ?? 0}, EOF=${_isComplete}`);
+                            if (_bodyToPush) _reqRef.push(_bodyToPush);
+                            if (_isComplete) {
+                                _reqRef.complete = true;
+                                if (_trailers) _reqRef.trailers = _trailers;
+                                _reqRef.push(null);
+                            }
+                        });
+                    } else {
+                        // Subsequent-packet case: push immediately
+                        debugLog(`[Server] Pushing body/EOF immediately (subsequent-packet)`);
+                        if (_bodyToPush) _reqRef!.push(_bodyToPush);
+                        if (_isComplete) {
+                            _reqRef!.complete = true;
+                            if (_trailers) _reqRef!.trailers = _trailers;
+                            _reqRef!.push(null);
+                        }
                     }
-                    req.push(null);
                 }
 
                 // For Keep-Alive, try to parse remaining buffer in case of pipelining
@@ -954,6 +1011,25 @@ export class ClientRequest extends OutgoingMessage {
     private _expectContinue: boolean = false;
     private _continueReceived: boolean = false;
 
+    private _getChunkByteLength(chunk: any, encoding?: string | null): number {
+        if (chunk == null) return 0;
+        const normalizedEncoding = typeof encoding === 'string' ? encoding : undefined;
+        if (typeof chunk === 'string') {
+            return Buffer.byteLength(chunk, normalizedEncoding as BufferEncoding | undefined);
+        }
+        if (typeof chunk.length === 'number') {
+            return chunk.length;
+        }
+        const buffer = Buffer.from(chunk, normalizedEncoding as BufferEncoding | undefined);
+        return buffer.length;
+    }
+
+    private _getPendingBodyLength(): number {
+        return this._pendingWrites.reduce((total, pending) => {
+            return total + this._getChunkByteLength(pending.chunk, pending.encoding);
+        }, 0);
+    }
+
     constructor(options: RequestOptions, callback?: (res: IncomingMessage) => void) {
         super();
         this._options = options;
@@ -1000,9 +1076,10 @@ export class ClientRequest extends OutgoingMessage {
             this.socket = socket;
             this._connected = true;
             this.emit('socket', this.socket);
-            // DO NOT call _sendRequest() here. Headers should only be sent once write() or end() is called.
-            this._flushPendingWrites();
+            // IMPORTANT: attach response listeners BEFORE flushing writes.
+            // If we flush first, the server may respond before we have a data listener.
             this._attachSocketListeners();
+            this._flushPendingWrites();
         } else {
             this._connect();
         }
@@ -1017,15 +1094,18 @@ export class ClientRequest extends OutgoingMessage {
                 this.emit('error', err);
                 return;
             }
-            debugLog(`ClientRequest._connect: Socket connected! socket=${!!socket}, socket._driver=${!!(socket as any)._driver}`);
-            debugLog(`[HTTP] _connect: Socket connected!`);
+            debugLog(`ClientRequest._connect: Socket connected!`);
             this.socket = socket;
             this._connected = true;
             this.emit('socket', this.socket);
-            debugLog(`ClientRequest._connect: Calling _sendRequest`);
-            this._sendRequest();
-            this._flushPendingWrites();
+            // IMPORTANT: attach response listeners BEFORE flushing writes.
+            // If we flush first, the server may respond before we have a data listener.
             this._attachSocketListeners();
+            // _flushPendingWrites() internally calls _sendRequest() if headers not sent yet.
+            // Do NOT call _sendRequest() separately here — _flushPendingWrites() needs to
+            // inspect headersSent and _pendingWrites together so it can set Content-Length
+            // before sending headers (to avoid chunked encoding when body is already known).
+            this._flushPendingWrites();
         };
 
         this.socket = agent.createConnection(this._options, connectCallback);
@@ -1171,28 +1251,64 @@ export class ClientRequest extends OutgoingMessage {
         this.emit('close');
     }
 
+    private _isFlushing = false;
     private _flushPendingWrites() {
-        if (!this.socket) return;
-        if (!this.headersSent) this._sendRequest();
+        if (!this.socket || this._isFlushing) return;
 
-        // If we are waiting for 100-continue, don't flush yet
-        if (this._expectContinue && !this._continueReceived) {
-            return;
-        }
+        this._isFlushing = true;
+        try {
+            if (!this.headersSent) {
+                // KEY FIX: When all body data is already queued AND the request is ending,
+                // we can calculate the exact Content-Length and avoid chunked encoding.
+                //
+                // Why this matters: without Content-Length, the request is sent with
+                // Transfer-Encoding: chunked. The Rust HTTP parser on the server side
+                // stores chunked body bytes in its internal buffer after parsing headers,
+                // but calling parser.feed(empty_buffer) to drain those bytes does NOT work
+                // — the drain call returns empty metadata and the body is permanently lost.
+                //
+                // By setting Content-Length here (when we have all the data), the body is
+                // sent as raw bytes. The server parser simply reads N bytes and marks the
+                // request complete — no chunked framing, no drain issues.
+                if (this._ended
+                    && !this.hasHeader('Content-Length')
+                    && !this.hasHeader('Transfer-Encoding')
+                    && this._pendingWrites.length > 0) {
+                    const totalLen = this._getPendingBodyLength();
+                    this.setHeader('Content-Length', totalLen);
+                }
+                this._sendRequest();
+            }
 
-        const writes = this._pendingWrites;
-        this._pendingWrites = [];
-        for (const pending of writes) {
-            this._write(pending.chunk, pending.encoding, pending.callback);
-        }
-        if (this._ended) {
-            this._finishRequest();
+            // If we are waiting for 100-continue, don't flush yet
+            if (this._expectContinue && !this._continueReceived) {
+                return;
+            }
+
+            // Keep draining the queue as long as it has items
+            // This handles writes that might happen while we are flushing (e.g. from callbacks)
+            while (this._pendingWrites.length > 0) {
+                const writes = this._pendingWrites;
+                this._pendingWrites = [];
+                for (const pending of writes) {
+                    // Call super._write (OutgoingMessage._write) directly
+                    super._write(pending.chunk, pending.encoding, pending.callback);
+                }
+            }
+
+            if (this._ended) {
+                super.end();
+            }
+        } finally {
+            this._isFlushing = false;
         }
     }
 
+    // Simplified _finishRequest - not needed as much if we call super.end() directly
     private _finishRequest() {
-        if (!this._ended) return;
-        super.end();
+        if (this._connected && this._pendingWrites.length === 0) {
+            super.end();
+        }
     }
 
     private _sendRequest() {
@@ -1210,7 +1326,7 @@ export class ClientRequest extends OutgoingMessage {
 
     _write(chunk: any, encoding: string, callback: (error?: Error | null) => void) {
         this._hasBody = true;
-        if (!this._connected) {
+        if (!this._connected || this._isFlushing) {
             this._pendingWrites.push({ chunk, encoding, callback });
             return;
         }
@@ -1220,39 +1336,47 @@ export class ClientRequest extends OutgoingMessage {
 
     write(chunk: any, encoding?: any, callback?: any): boolean {
         this._hasBody = true;
-        if (!this._connected) {
+        // If not connected OR currently flushing, enqueue to preserve order
+        if (!this._connected || this._isFlushing) {
             this._pendingWrites.push({ chunk, encoding, callback });
             return true;
         }
-        if (!this.headersSent) this._sendRequest();
         return super.write(chunk, encoding, callback);
     }
 
     end(chunk?: any, encoding?: any, callback?: any): this {
-        debugLog(`ClientRequest.end() called, connected=${this._connected}, headersSent=${this.headersSent}`);
-        if (chunk) {
+        if (typeof chunk === 'function') {
+            callback = chunk;
+            chunk = null;
+            encoding = null;
+        } else if (typeof encoding === 'function') {
+            callback = encoding;
+            encoding = null;
+        }
+
+        debugLog(`ClientRequest.end() called, connected=${this._connected}, chunk=${!!chunk}`);
+
+        if (chunk != null) {
             this._hasBody = true;
             if (!this.headersSent && !this.hasHeader('Content-Length')) {
-                const len = typeof chunk === 'string' ? Buffer.byteLength(chunk, encoding as any) : chunk.length;
+                const len = this._getPendingBodyLength() + this._getChunkByteLength(chunk, encoding as string | undefined);
                 this.setHeader('Content-Length', len);
             }
+            // Use this.write to handle pending queue if not connected
             this.write(chunk, encoding);
         }
+
         this._ended = true;
 
-        // If connected, we can send request and end immediately
         if (this._connected) {
-            if (!this.headersSent) {
-                this._sendRequest();
-            }
-            // Call super.end only when connected
-            super.end(callback);
-        } else {
-            // Socket not connected yet - _flushPendingWrites will handle ending
-            // Store callback if provided
-            if (callback) {
+            // Only end if the queue is empty. _flushPendingWrites will handle it otherwise.
+            if (this._pendingWrites.length === 0) {
+                super.end(callback);
+            } else if (callback) {
                 this.once('finish', callback);
             }
+        } else {
+            if (callback) this.once('finish', callback);
         }
         return this;
     }