@linebridge/engine-neo 1.2.2 → 1.3.0

package/lib/response.d.ts

@@ -43,6 +43,10 @@ export default class Response<TServer = Server<any>> implements BaseHttpResponse
     _status_code: number;
     /** Custom status message (overrides the default from STATUS_CODES). */
     _status_message: string | null;
+    /** Cached engine reference to avoid walking route.server on every response. */
+    _engine: EngineAdaptor | null;
+    /** Whether at least one header was queued. Avoids enumerating an empty object. */
+    _has_headers: boolean;
     /** Response headers (key → value or key → string[]). */
     _headers: Record<string, string | string[]>;
     /** Set-Cookie headers (name → serialized cookie string). */
@@ -141,11 +145,16 @@ export default class Response<TServer = Server<any>> implements BaseHttpResponse
      *   Must return `true` if the chunk was successfully written.
      */
     drain(handler: (offset: number) => boolean): void;
+    /**
+     * Marks the response as completed and fires the lifecycle listeners.
+     * Used by every path that finishes a response, including streaming.
+     */
+    _mark_completed(): void;
     /**
      * Sends the response body and marks the response as completed.
      *
-     * Supports corked (batched) and uncorked paths, streaming mode, and
-     * `endWithoutBody` when a custom `content-length` header is set.
+     * All uWS writes are wrapped in a single cork callback so status,
+     * headers and body are flushed atomically.
      *
      * Fires `finish` and `close` event listeners.
      */
@@ -178,7 +187,7 @@ export default class Response<TServer = Server<any>> implements BaseHttpResponse
     redirect(url: string): boolean;
     /**
      * Fast-path send used by the `_invokeHandler`.
-     * Skips cork/uncork logic and writes directly.
+     * Corks the writes so status, headers and body are flushed atomically.
      */
     _sendFast(body: any): void;
     /**

package/lib/response.js

@@ -46,6 +46,10 @@ export default class Response {
     _status_code;
     /** Custom status message (overrides the default from STATUS_CODES). */
     _status_message;
+    /** Cached engine reference to avoid walking route.server on every response. */
+    _engine;
+    /** Whether at least one header was queued. Avoids enumerating an empty object. */
+    _has_headers;
     /** Response headers (key → value or key → string[]). */
     _headers;
     /** Set-Cookie headers (name → serialized cookie string). */
@@ -79,26 +83,36 @@ export default class Response {
         const res = new Response();
         res._raw_response = raw_response;
         res.route = route;
+        res._engine = route.engine ?? null;
         res._wrapped_request = request;
         res._upgrade_socket = socket || null;
-        res._headers = {};
+        res._headers = Object.create(null);
+        res._has_headers = false;
+        res._cookies = null;
+        res._events = null;
+        res._streaming = false;
+        res._cork = false;
+        res._corked = false;
+        res._drain_handler = null;
         res._status_code = 200;
+        res._status_message = null;
         res._middleware_cursor = -1;
         // handle uWS abort (client disconnects before response is sent)
         raw_response.onAborted(() => {
             if (res.completed)
                 return;
             res.completed = true;
-            res.route?.server.engine._resolve_pending_request();
+            res._engine?._resolve_pending_request();
             //res._wrapped_request.pause()
-            if (res._events?.abort) {
-                for (let i = 0; i < res._events.abort.length; i++) {
-                    res._events.abort[i](res._wrapped_request, res);
+            const events = res._events;
+            if (events?.abort) {
+                for (let i = 0; i < events.abort.length; i++) {
+                    events.abort[i](res._wrapped_request, res);
                 }
             }
-            if (res._events?.close) {
-                for (let i = 0; i < res._events.close.length; i++) {
-                    res._events.close[i](res._wrapped_request, res);
+            if (events?.close) {
+                for (let i = 0; i < events.close.length; i++) {
+                    events.close[i](res._wrapped_request, res);
                 }
             }
         });
@@ -187,6 +201,7 @@ export default class Response {
         }
         this._headers["content-type"] =
             mime_types.contentType(mime_type) || "text/plain";
+        this._has_headers = true;
         return this;
     }
     /**
@@ -197,6 +212,7 @@ export default class Response {
         name = name.toLowerCase();
         if (overwrite || this._headers[name] === undefined) {
             this._headers[name] = value;
+            this._has_headers = true;
             return this;
         }
         const existing = this._headers[name];
@@ -269,7 +285,7 @@ export default class Response {
         // perform the uWS upgrade with the stored socket handle
         this._raw_response.upgrade({ context }, headers["sec-websocket-key"], headers["sec-websocket-protocol"], headers["sec-websocket-extensions"], this._upgrade_socket);
         this.completed = true;
-        this.engine?._resolve_pending_request();
+        this._engine?._resolve_pending_request();
     }
     /**
      * Writes the status line and all accumulated headers to the uWS response.
@@ -281,31 +297,34 @@ export default class Response {
             return false;
         this.initiated = true;
         const raw = this._raw_response;
-        if (this._status_message) {
-            raw.writeStatus(`${this._status_code} ${this._status_message}`);
-        }
-        else {
-            raw.writeStatus(STATUS_CACHE[this._status_code] || `${this._status_code} OK`);
-        }
-        const headerKeys = Object.keys(this._headers);
-        for (let i = 0; i < headerKeys.length; i++) {
-            const name = headerKeys[i];
-            if (name === "content-length")
-                continue;
-            const values = this._headers[name];
-            if (Array.isArray(values)) {
-                for (let j = 0; j < values.length; j++) {
-                    raw.writeHeader(name, values[j]);
+        const status_code = this._status_code;
+        const status_message = this._status_message;
+        if (status_message) {
+            raw.writeStatus(`${status_code} ${status_message}`);
+        }
+        else if (status_code !== 200) {
+            raw.writeStatus(STATUS_CACHE[status_code] || `${status_code} OK`);
+        }
+        if (this._has_headers) {
+            const headers = this._headers;
+            for (const name in headers) {
+                if (name === "content-length")
+                    continue;
+                const values = headers[name];
+                if (Array.isArray(values)) {
+                    for (let j = 0; j < values.length; j++) {
+                        raw.writeHeader(name, values[j]);
+                    }
+                }
+                else {
+                    raw.writeHeader(name, values);
                 }
-            }
-            else {
-                raw.writeHeader(name, values);
             }
         }
         if (this._cookies) {
-            const cookieKeys = Object.keys(this._cookies);
-            for (let i = 0; i < cookieKeys.length; i++) {
-                raw.writeHeader("set-cookie", this._cookies[cookieKeys[i]]);
+            const cookies = this._cookies;
+            for (const name in cookies) {
+                raw.writeHeader("set-cookie", cookies[name]);
             }
         }
         return true;
@@ -329,71 +348,64 @@ export default class Response {
             });
         }
     }
+    /**
+     * Marks the response as completed and fires the lifecycle listeners.
+     * Used by every path that finishes a response, including streaming.
+     */
+    _mark_completed() {
+        if (this.completed)
+            return;
+        const events = this._events;
+        if (!events) {
+            this.completed = true;
+            this._engine?._resolve_pending_request();
+            return;
+        }
+        const finish = events.finish;
+        if (!this._streaming && finish) {
+            for (let i = 0; i < finish.length; i++) {
+                finish[i](this._wrapped_request, this);
+            }
+        }
+        this.completed = true;
+        this._engine?._resolve_pending_request();
+        const close = events.close;
+        if (close) {
+            for (let i = 0; i < close.length; i++) {
+                close[i](this._wrapped_request, this);
+            }
+        }
+    }
     /**
      * Sends the response body and marks the response as completed.
      *
-     * Supports corked (batched) and uncorked paths, streaming mode, and
-     * `endWithoutBody` when a custom `content-length` header is set.
+     * All uWS writes are wrapped in a single cork callback so status,
+     * headers and body are flushed atomically.
      *
      * Fires `finish` and `close` event listeners.
      */
     send(body, close_connection) {
         if (this.completed)
             return this;
-        if (this._cork && !this._corked) {
-            this._corked = true;
-            this._raw_response.cork(() => {
-                this._initiate_response();
-                if (body !== undefined || this._streaming) {
-                    this._raw_response.end(body, close_connection);
-                }
-                else {
-                    const custom_length = this._headers["content-length"];
-                    if (custom_length) {
-                        const content_length = typeof custom_length === "string"
-                            ? custom_length
-                            : custom_length[custom_length.length - 1];
-                        this._raw_response.endWithoutBody(content_length, close_connection);
-                    }
-                    else {
-                        this._raw_response.end(body, close_connection);
-                    }
-                }
-            });
-        }
-        else {
+        const raw = this._raw_response;
+        raw.cork(() => {
             this._initiate_response();
-            const raw = this._raw_response;
             if (body !== undefined || this._streaming) {
                 raw.end(body, close_connection);
+                return;
             }
-            else {
-                const custom_length = this._headers["content-length"];
-                if (custom_length) {
-                    const content_length = typeof custom_length === "string"
-                        ? custom_length
-                        : custom_length[custom_length.length - 1];
-                    raw.endWithoutBody(content_length, close_connection);
-                }
-                else {
-                    raw.end(body, close_connection);
-                }
-            }
-        }
-        if (!this._streaming && this.listenerCount("finish") > 0) {
-            const handlers = this._events.finish;
-            for (let i = 0; i < handlers.length; i++) {
-                handlers[i](this._wrapped_request, this);
-            }
-        }
-        this.completed = true;
-        this.engine?._resolve_pending_request();
-        if (this.listenerCount("close") > 0) {
-            const handlers = this._events.close;
-            for (let i = 0; i < handlers.length; i++) {
-                handlers[i](this._wrapped_request, this);
+            const custom_length = this._headers["content-length"];
+            if (!custom_length) {
+                raw.end(body, close_connection);
+                return;
             }
-        }
+            const content_length = typeof custom_length === "string"
+                ? custom_length
+                : custom_length[custom_length.length - 1];
+            raw.endWithoutBody(content_length, close_connection);
+        });
+        this._corked = true;
+        this._mark_completed();
         return this;
     }
     _uws_write_chunk(chunk, total_size) {
@@ -407,17 +419,16 @@ export default class Response {
      * Initiates headers if not yet sent. Returns false under backpressure.
      */
     write(chunk) {
-        if (this._cork && !this._corked) {
-            this._corked = true;
-            let ok = false;
-            this._raw_response.cork(() => {
-                this._initiate_response();
-                ok = this._raw_response.write(chunk);
-            });
-            return ok;
-        }
-        this._initiate_response();
-        return this._raw_response.write(chunk);
+        if (this.completed)
+            return false;
+        const raw = this._raw_response;
+        let ok = false;
+        raw.cork(() => {
+            this._initiate_response();
+            ok = raw.write(chunk);
+        });
+        this._corked = true;
+        return ok;
     }
     /**
      * Streams a single chunk with backpressure support.
@@ -427,30 +438,44 @@ export default class Response {
         if (this.completed)
             return Promise.resolve();
         return new Promise((resolve) => {
-            if (this._cork && !this._corked) {
-                this._corked = true;
-                this._raw_response.cork(() => this._initiate_response());
-            }
-            else {
+            const raw = this._raw_response;
+            let sent = false;
+            let responded = false;
+            let write_offset = 0;
+            raw.cork(() => {
                 this._initiate_response();
-            }
-            if (this.completed)
+                write_offset = raw.getWriteOffset();
+                [sent, responded] = this._uws_write_chunk(chunk, total_size);
+                if (sent || responded)
+                    return;
+                this.drain((offset) => {
+                    if (this.completed || !total_size) {
+                        resolve();
+                        return true;
+                    }
+                    const remaining = chunk.slice(offset - write_offset);
+                    let flushed = false;
+                    let has_responded = false;
+                    raw.cork(() => {
+                        ;
+                        [flushed, has_responded] = this._uws_write_chunk(remaining, total_size);
+                    });
+                    if (has_responded) {
+                        this._mark_completed();
+                        resolve();
+                        return true;
+                    }
+                    if (flushed)
+                        resolve();
+                    return flushed;
+                });
+            });
+            if (responded) {
+                this._mark_completed();
                 return resolve();
-            const write_offset = this._raw_response.getWriteOffset();
-            const [sent] = this._uws_write_chunk(chunk, total_size);
+            }
             if (sent)
-                return resolve();
-            this.drain((offset) => {
-                if (this.completed || !total_size) {
-                    resolve();
-                    return true;
-                }
-                const remaining = chunk.slice(offset - write_offset);
-                const [flushed] = this._uws_write_chunk(remaining, total_size);
-                if (flushed)
-                    resolve();
-                return flushed;
-            });
+                resolve();
         });
     }
     /**
@@ -483,7 +508,7 @@ export default class Response {
         }
         if (!this.completed) {
             if (total_size)
-                this.engine?._resolve_pending_request();
+                this._engine?._resolve_pending_request();
             else
                 this.send();
         }
@@ -495,7 +520,7 @@ export default class Response {
         if (this.completed)
             return;
         this.completed = true;
-        this.engine?._resolve_pending_request();
+        this._engine?._resolve_pending_request();
         //this._wrapped_request.pause()
         this._raw_response.close();
     }
@@ -509,24 +534,18 @@ export default class Response {
     }
     /**
      * Fast-path send used by the `_invokeHandler`.
-     * Skips cork/uncork logic and writes directly.
+     * Corks the writes so status, headers and body are flushed atomically.
      */
     _sendFast(body) {
+        if (this.completed)
+            return;
+        const raw = this._raw_response;
+        raw.cork(() => {
+            this._initiate_response();
+            raw.end(body);
+        });
         this._corked = true;
-        this._initiate_response();
-        this._raw_response.end(body);
-        this.completed = true;
-        this.engine?._resolve_pending_request();
-        if (this._events?.finish) {
-            for (let i = 0; i < this._events.finish.length; i++) {
-                this._events.finish[i](this._wrapped_request, this);
-            }
-        }
-        if (this._events?.close) {
-            for (let i = 0; i < this._events.close.length; i++) {
-                this._events.close[i](this._wrapped_request, this);
-            }
-        }
+        this._mark_completed();
     }
     /**
      * Sends a JSON response. Sets `Content-Type: application/json` and
@@ -534,6 +553,7 @@ export default class Response {
      */
     json(body) {
         this._headers["content-type"] = "application/json";
+        this._has_headers = true;
         return this.send(stringify(body));
     }
     /**
@@ -541,6 +561,7 @@ export default class Response {
      */
     html(body) {
         this._headers["content-type"] = "text/html";
+        this._has_headers = true;
         return this.send(body);
     }
     /**
@@ -711,6 +732,7 @@ export default class Response {
      */
     location(path) {
         this._headers["location"] = path;
+        this._has_headers = true;
         return this;
     }
     /**
@@ -737,6 +759,7 @@ export default class Response {
      */
     vary(name) {
         this._headers["vary"] = name;
+        this._has_headers = true;
         return this;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linebridge/engine-neo",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "publishConfig": {
     "access": "public"
   },