nucleus-core-ts 0.9.966 → 0.9.967

package/dist/.build-ok

@@ -1 +1 @@
-0.9.966
+0.9.967

package/dist/src/Client/Proxy/httpProxy.js

@@ -1,6 +1,6 @@
 import { evaluateAccess, ManifestCache, RoleClaimsCache, resolveClaimsFromRoles, verifyJwtHS256 } from './authz';
-import { createProxyLogger, matchPath, parseCookies, rewritePath } from './utils';
 import { canBufferForRetry, timeoutForBody } from './largeBody';
+import { createProxyLogger, matchPath, parseCookies, rewritePath } from './utils';
 async function fetchSuppressedClaims(url, cookieHeader, logger) {
     const empty = {
         suppressedClaims: [],
@@ -368,9 +368,58 @@ export function createHttpProxyHandler(config) {
     function injectToken(headers, token, headerName) {
         headers.set(headerName, `Bearer ${token}`);
     }
-    async function forwardRequest(finalUrl, method, headers, body, timeout, followRedirects) {
+    /**
+   * Forward one request upstream, bounded by BOTH clocks that can end it.
+   *
+   * The timeout below only bounds time-to-first-headers: it is cleared the
+   * moment headers arrive, because a streamed body (SSE, a long download, a
+   * model's token stream) legitimately takes as long as it takes. That is
+   * correct — but on its own it left a streamed request with NO way to end.
+   *
+   * So when the person closed the tab, the browser's connection went away and
+   * ours did not. The upstream request stayed open, holding one of the
+   * runtime's outgoing connection slots, forever.
+   *
+   * That is not a slow leak. Measured on Bun 1.3.14: 256 clients that connect
+   * and hang up leave 256 upstream requests open (0 cancelled), and the process
+   * can then make no outgoing request at all — every later fetch times out.
+   * A single tab reconnecting an EventSource 256 times does it alone.
+   *
+   * Cancelling the body we hand back (`body.cancel()`) does NOT release the
+   * slot; only aborting the upstream fetch does. Measured both ways.
+   *
+   * Hence `clientSignal`: the client's hangup is wired to the same controller
+   * the timeout uses, so whichever ends first ends the upstream request. The
+   * listener is left attached deliberately — it belongs to this one request and
+   * is collected with it, and aborting an already-finished fetch is a no-op.
+   */ async function forwardRequest(finalUrl, method, headers, body, timeout, followRedirects, clientSignal) {
         const controller = new AbortController();
         const timeoutId = setTimeout(()=>controller.abort(), timeout);
+        // Tracked so the catch below can tell "the user left" from "upstream was
+        // too slow". Both surface as AbortError; only one is a fault worth a 504.
+        let clientGone = false;
+        if (clientSignal) {
+            if (clientSignal.aborted) {
+                clientGone = true;
+                controller.abort();
+            } else {
+                clientSignal.addEventListener('abort', ()=>{
+                    clientGone = true;
+                    clearTimeout(timeoutId);
+                    controller.abort();
+                    /*
+             * Logged HERE, not in the catch below, because the common case
+             * never reaches the catch: once headers have arrived this function
+             * has already returned, and the hangup happens while the body is
+             * still streaming. That is exactly the case that used to leak, so
+             * it is exactly the case that has to be visible — a cancellation
+             * nobody can see is how this went unnoticed for months.
+             */ logger.info(`Client disconnected, upstream cancelled: ${finalUrl}`);
+                }, {
+                    once: true
+                });
+            }
+        }
         try {
             const response = await fetch(finalUrl, {
                 method,
@@ -383,6 +432,13 @@ export function createHttpProxyHandler(config) {
             return response;
         } catch (error) {
             clearTimeout(timeoutId);
+            if (clientGone && error instanceof Error && error.name === 'AbortError') {
+                // Re-labelled so an operator reading the log is not sent hunting for a
+                // slow upstream that was never slow.
+                const gone = new Error('Client disconnected before the response arrived');
+                gone.name = 'ClientGoneError';
+                throw gone;
+            }
             throw error;
         }
     }
@@ -497,7 +553,7 @@ export function createHttpProxyHandler(config) {
                 }
             }
             try {
-                const response = await forwardRequest(finalUrl, req.method, headers, bodyToSend, timeout, followRedirects);
+                const response = await forwardRequest(finalUrl, req.method, headers, bodyToSend, timeout, followRedirects, req.signal);
                 // --- REACTIVE REFRESH: API returned 401, try refresh + retry ---
                 if (response.status === 401 && refreshEnabled && (refreshConfig.retryOn401 ?? true) && refreshToken && refreshSetCookies.length === 0) {
                     logger.info(`[TokenRefresh] Got 401, attempting reactive refresh for ${path}`);
@@ -513,7 +569,7 @@ export function createHttpProxyHandler(config) {
                         const retryHeaders = buildHeaders(req, target, clientIp);
                         injectToken(retryHeaders, refreshResult.accessToken, tokenHeaderName);
                         logger.info(`[TokenRefresh] Retrying ${req.method} ${path} with new token`);
-                        const retryResponse = await forwardRequest(finalUrl, req.method, retryHeaders, bodyForRetry ? new Response(bodyForRetry).body : null, timeout, followRedirects);
+                        const retryResponse = await forwardRequest(finalUrl, req.method, retryHeaders, bodyForRetry ? new Response(bodyForRetry).body : null, timeout, followRedirects, req.signal);
                         const retryDuration = performance.now() - startTime;
                         logger.info(`Response (after refresh): ${retryResponse.status} (${retryDuration.toFixed(0)}ms)`);
                         config.onResponse?.(path, retryResponse.status, retryDuration);
@@ -560,6 +616,20 @@ export function createHttpProxyHandler(config) {
             } catch (error) {
                 const duration = performance.now() - startTime;
                 const err = error instanceof Error ? error : new Error(String(error));
+                /*
+         * The person closed the tab. Nothing failed, and there is nobody left
+         * to send a status to — so this is not an error, and calling it one
+         * sends whoever reads the log hunting a timeout that never happened.
+         *
+         * Reported with the elapsed time, because on a streaming path "the
+         * client left after 4 minutes" is genuinely useful and "Gateway
+         * Timeout" is genuinely misleading.
+         */ if (err.name === 'ClientGoneError') {
+                    logger.info(`Client disconnected after ${duration.toFixed(0)}ms, upstream cancelled: ${path}`);
+                    return new Response(null, {
+                        status: 499
+                    });
+                }
                 if (isStreamingPath) {
                     logger.error(`[SSE:proxy] FETCH ERROR for ${path} after ${duration.toFixed(0)}ms: ${err.name} - ${err.message}`);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.966",
+	"version": "0.9.967",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",