@dooboostore/simple-boot-http-server 1.0.33 → 1.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dooboostore/simple-boot-http-server",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "license": "MIT",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -55,16 +55,18 @@
     "SeoDH <adonis_84@naver.com> (https://github.com/SeoDH)",
     "tkyung (https://github.com/tkyungDev)",
     "Hoil-Gang (https://github.com/khl1154)",
-    "hwangsero (https://github.com/hwangsero)"
+    "hwangsero (https://github.com/hwangsero)",
+    "visualkhh <visualkhh@gmail.com> (https://github.com/visualkhh)"
   ],
-  "homepage": "https://github.com/dooboostore-develop/packages",
+  "homepage": "https://dooboostore-develop.github.io/package/simple-boot-http-server",
   "bugs": {
-    "url": "https://github.com/dooboostore-develop/packages",
+    "url": "https://github.com/dooboostore-develop/packages/issues",
     "email": "dooboostore@gmail.com"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dooboostore-develop/packages"
+    "url": "git+https://github.com/dooboostore-develop/packages.git",
+    "directory": "packages/@dooboostore/simple-boot-http-server"
   },
   "peerDependencies": {
     "reflect-metadata": "^0.2.2"
@@ -98,11 +100,11 @@
     "mime-types": "^2.1.34",
     "node-gzip": "^1.1.2",
     "ws": "^8.18.3",
-    "@dooboostore/core": "1.0.33",
-    "@dooboostore/dom-render": "1.0.115",
     "@dooboostore/core-node": "1.0.14",
-    "@dooboostore/core-web": "1.0.14",
-    "@dooboostore/simple-boot": "1.0.60"
+    "@dooboostore/dom-render": "1.0.115",
+    "@dooboostore/core": "1.0.33",
+    "@dooboostore/simple-boot": "1.0.60",
+    "@dooboostore/core-web": "1.0.14"
   },
   "scripts": {
     "clean": "rm -rf dist",

package/src/SimpleBootHttpServer.ts

@@ -44,6 +44,27 @@ export class SimpleBootHttpServer extends SimpleApplication {
     this.sessionManager = new SessionManager(this.option);
   }
 
+  /**
+   * Final response flush that can never escape as an unhandled rejection.
+   * When the response is already gone (sent, closed, or destroyed mid-write),
+   * there is nobody left to send to, so gone-response write errors
+   * (ERR_HTTP_HEADERS_SENT, ERR_STREAM_ALREADY_FINISHED,
+   * ERR_STREAM_DESTROYED, ECONNRESET) are swallowed; anything else still throws.
+   */
+  private async safeResEnd(rr: RequestResponse): Promise<void> {
+    if (rr.resIsDone()) {
+      return;
+    }
+    try {
+      await rr.resEnd();
+    } catch (e: any) {
+      const code = e && (e.code || '');
+      if (code !== 'ERR_HTTP_HEADERS_SENT' && code !== 'ERR_STREAM_ALREADY_FINISHED' && code !== 'ERR_STREAM_DESTROYED' && code !== 'ECONNRESET') {
+        throw e;
+      }
+    }
+  }
+
 
   public run(otherInstanceSim?: Map<ConstructorType<any> | Function | SimConfig | symbol, any>) {
     otherInstanceSim ??= new Map<ConstructorType<any> | Function | SimConfig | symbol, any>();
@@ -95,7 +116,7 @@ export class SimpleBootHttpServer extends SimpleApplication {
         }
 
         if (!rr.resIsDone()) {
-          rr.resEnd();
+          await this.safeResEnd(rr);
         }
       });
       res.on('error', async () => {
@@ -113,7 +134,7 @@ export class SimpleBootHttpServer extends SimpleApplication {
         }
 
         if (!rr.resIsDone()) {
-          rr.resEnd();
+          await this.safeResEnd(rr);
         }
       });
 
@@ -351,14 +372,18 @@ export class SimpleBootHttpServer extends SimpleApplication {
                   headers[HttpHeaders.ContentType] = contentType;
                 }
                 rr.resSetHeaders(headers);
-                rr.resSetStatusCode(resConfig?.status ?? HttpStatus.Ok);
+                if (resConfig?.status !== undefined) {
+                  // Explicit decorator status wins. The Node default (200) is left
+                  // alone otherwise so a handler-set status (e.g. via resEnd(Response))
+                  // is not clobbered back to 200.
+                  rr.resSetStatusCode(resConfig.status);
+                }
                 await rr.resStream(data, { compress: stream?.compress });
               } else {
                 if (it.config?.resolver) {
                   const execute = typeof it.config.resolver === 'function' ? this.simstanceManager.getOrNewSim({target: it.config.resolver}) : it.config.resolver;
                   data = await execute?.resolve?.(data, rr, resConfig);
                 }
-                const status = resConfig?.status ?? HttpStatus.Ok;
                 const headers = resConfig?.header ?? {};
                 if (resConfig?.contentType) {
                   headers[HttpHeaders.ContentType] = resConfig.contentType;
@@ -369,7 +394,12 @@ export class SimpleBootHttpServer extends SimpleApplication {
                   data = JSON.stringify(data);
                 }
                 rr.resSetHeaders(headers)
-                rr.resSetStatusCode(status);
+                if (resConfig?.status !== undefined) {
+                  // An explicit decorator status wins. Otherwise leave the status
+                  // alone (Node defaults to 200) so a handler-set status is not
+                  // clobbered back to 200.
+                  rr.resSetStatusCode(resConfig.status);
+                }
                 rr.resWrite(data);
               }
             }
@@ -419,7 +449,7 @@ export class SimpleBootHttpServer extends SimpleApplication {
       }
 
       if (!rr.resIsDone()) {
-        rr.resEnd();
+        await this.safeResEnd(rr);
       }
     });
 

package/src/models/RequestResponse.ts

@@ -18,6 +18,14 @@ import { Blob } from 'node:buffer';
 import * as fs from 'fs';
 import * as os from 'os';
 import { RandomUtils } from '@dooboostore/core';
+
+/**
+ * Responses with a send already in flight. Keyed by the underlying
+ * ServerResponse (shared by RequestResponse and its chains), so concurrent
+ * resEnd() calls for one response serialize instead of racing each other
+ * through gzip/setHeader into ERR_HTTP_HEADERS_SENT.
+ */
+const resEndingSet = new WeakSet<object>();
 import { FileUtils } from '@dooboostore/core-node';
 import { ConvertUtils as CoreConvertUtils } from '@dooboostore/core';
 import { ConvertUtils } from '@dooboostore/core-node';
@@ -491,6 +499,12 @@ export class RequestResponse {
   }
 
   resWrite(chunk: string | Buffer | any, encoding: BufferEncoding = 'utf8') {
+    if (chunk === undefined) {
+      // A handler that already wrote via rr.resEnd()/resWrite() and returns
+      // undefined must not have its buffered body clobbered by the pipeline's
+      // return-value write (express#7510-class probe caught this).
+      return this.createRequestResponseChain(this.resWriteChunk);
+    }
     this.resWriteChunk = chunk;
     return this.createRequestResponseChain(this.resWriteChunk);
   }
@@ -532,32 +546,52 @@ export class RequestResponse {
   }
 
   async resEnd(chunk?: string | Buffer | Blob | ArrayBuffer | Response) {
-    if (chunk instanceof Response) {
-      chunk.headers.forEach((value, key) => {
-        this.res.setHeader(`ORIGIN-${key}`, value);
-      });
-      if (!this.resHeader(HttpHeaders.ContentType)) {
-        const contentType = chunk.headers.get(HttpHeaders.ContentType);
-        if (contentType) this.res.setHeader(HttpHeaders.ContentType, contentType);
-      }
-      this.res.statusCode = chunk.status;
-      this.resWriteChunk = Buffer.from(await chunk.arrayBuffer());
-    } else if (chunk instanceof Blob) {
-      this.resWriteChunk = Buffer.from(await chunk.arrayBuffer());
-      if (!this.resHeader(HttpHeaders.ContentType)) {
-        this.res.setHeader(HttpHeaders.ContentType, chunk.type);
-      }
-    } else if (chunk instanceof ArrayBuffer) {
-      this.resWriteChunk = Buffer.from(chunk);
-    } else {
-      this.resWriteChunk = chunk ?? this.resWriteChunk;
+    if (resEndingSet.has(this.res) || this.resIsDone()) {
+      // A send is already in flight (or finished): concurrent resEnd() calls
+      // — e.g. a handler-sent body followed by the pipeline's final flush —
+      // must not start a second send. Without this guard the two sends race
+      // through gzip/setHeader and the loser throws ERR_HTTP_HEADERS_SENT.
+      // The set is keyed by the underlying response (shared by chains).
+      return;
     }
+    resEndingSet.add(this.res);
+    try {
+      if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(chunk) && !Buffer.isBuffer(chunk)) {
+        // Typed-array views (incl. DataView, which Node's res.end() rejects outright)
+        // are normalized to their exact byte range. Native res.end() already honors
+        // byteOffset for typed arrays, but DataView throws ERR_INVALID_ARG_TYPE,
+        // so every non-Buffer view goes through here (expressjs/express#7510 class).
+        const view = chunk as unknown as { buffer: ArrayBuffer; byteOffset: number; byteLength: number };
+        this.resWriteChunk = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+      } else if (chunk instanceof Response) {
+        chunk.headers.forEach((value, key) => {
+          this.res.setHeader(`ORIGIN-${key}`, value);
+        });
+        if (!this.resHeader(HttpHeaders.ContentType)) {
+          const contentType = chunk.headers.get(HttpHeaders.ContentType);
+          if (contentType) this.res.setHeader(HttpHeaders.ContentType, contentType);
+        }
+        this.res.statusCode = chunk.status;
+        this.resWriteChunk = Buffer.from(await chunk.arrayBuffer());
+      } else if (chunk instanceof Blob) {
+        this.resWriteChunk = Buffer.from(await chunk.arrayBuffer());
+        if (!this.resHeader(HttpHeaders.ContentType)) {
+          this.res.setHeader(HttpHeaders.ContentType, chunk.type);
+        }
+      } else if (chunk instanceof ArrayBuffer) {
+        this.resWriteChunk = Buffer.from(chunk);
+      } else {
+        this.resWriteChunk = chunk ?? this.resWriteChunk;
+      }
 
-    if (this.req.readable) {
-      await this.reqBodyData();
-      await this.resEndChunk();
-    } else {
-      await this.resEndChunk();
+      if (this.req.readable) {
+        await this.reqBodyData();
+        await this.resEndChunk();
+      } else {
+        await this.resEndChunk();
+      }
+    } finally {
+      resEndingSet.delete(this.res);
     }
   }