nucleus-core-ts 0.9.925 → 0.9.926

package/dist/.build-ok

@@ -1 +1 @@
-0.9.925
+0.9.926

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

@@ -1,5 +1,6 @@
 import { evaluateAccess, ManifestCache, RoleClaimsCache, resolveClaimsFromRoles, verifyJwtHS256 } from './authz';
 import { createProxyLogger, matchPath, parseCookies, rewritePath } from './utils';
+import { canBufferForRetry, timeoutForBody } from './largeBody';
 async function fetchSuppressedClaims(url, cookieHeader, logger) {
     const empty = {
         suppressedClaims: [],
@@ -461,12 +462,33 @@ export function createHttpProxyHandler(config) {
             } else if (!accessToken && isAuthPath) {
                 logger.warn(`[Auth:proxy] NO TOKEN available for ${path} — request will likely fail with 401`);
             }
-            const timeout = target.timeout ?? 30000;
+            const baseTimeout = target.timeout ?? 30000;
+            /*
+       * A file needs minutes, not thirty seconds.
+       *
+       * The fixed timeout aborted a 200 MB video long before the last byte, and
+       * the browser had no way to tell that from a slow line — the bar simply
+       * stopped. The allowance now grows with the declared size.
+       */ const timeout = timeoutForBody(req.headers, baseTimeout);
             const followRedirects = target.followRedirects !== false;
             // Buffer body for potential retry (only if 401 retry is enabled)
             let bodyForRetry = null;
             let bodyToSend = req.body;
-            if (refreshEnabled && (refreshConfig.retryOn401 ?? true) && req.body) {
+            /*
+       * Only a body small enough to hold.
+       *
+       * Buffering exists so a 401 can be answered by refreshing the token and
+       * sending the same request again — worth it for a form post, fatal for a
+       * file. An 800 MB video was read into an ArrayBuffer inside a container
+       * limited to 256 MiB: the upload appeared to run, because the browser
+       * really was sending bytes, and then died with nothing to show for it.
+       *
+       * A large body streams straight through and gives up the retry. That is
+       * the right way round: an upload that is refused can be started again by
+       * the person who chose the file; an upload that never completes cannot be
+       * rescued by anybody.
+       */ const bufferable = canBufferForRetry(req.headers);
+            if (refreshEnabled && (refreshConfig.retryOn401 ?? true) && req.body && bufferable) {
                 try {
                     bodyForRetry = await req.arrayBuffer();
                     bodyToSend = bodyForRetry;

package/dist/src/Client/Proxy/largeBody.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Whether a request body is small enough to hold in memory for a retry.
+ *
+ * The proxy buffers the whole body so that a 401 can be answered by refreshing
+ * the token and sending the same request again. That is a good trade for a form
+ * post and a catastrophic one for a file: an eight-hundred-megabyte video was
+ * read into `ArrayBuffer` inside a container limited to 256 MiB, so the upload
+ * appeared to run — the browser really was sending bytes — and then died with
+ * nothing to show for it. Measured on the customer's install: the video module
+ * accepts up to 1 GB, the ingress passes 1 GB, and the proxy in between could
+ * never carry more than a fraction of it.
+ *
+ * A large body is streamed straight through instead. The cost is that it cannot
+ * be replayed after a token refresh, which is the right way round: an upload
+ * that is refused can be started again by the person who chose the file, while
+ * an upload that never completes cannot be rescued by anybody.
+ */
+export declare const RETRY_BUFFER_LIMIT_BYTES: number;
+/**
+ * `null` when the size is not declared.
+ *
+ * An undeclared length is treated as LARGE: a chunked upload announces nothing,
+ * and guessing "small" there is how the buffer gets filled by the one request
+ * that must not fill it.
+ */
+export declare function declaredBodySize(headers: Headers): number | null;
+export declare function canBufferForRetry(headers: Headers, limit?: number): boolean;
+/**
+ * How long to allow, given what is being carried.
+ *
+ * Thirty seconds is right for an API call and absurd for a file: a 200 MB video
+ * over an office line needs minutes, and the old fixed timeout aborted it long
+ * before the last byte. The allowance grows with the declared size — a minute
+ * per fifty megabytes — and is never shorter than the configured default.
+ */
+export declare function timeoutForBody(headers: Headers, baseTimeoutMs: number): number;

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

@@ -0,0 +1,48 @@
+/**
+ * Whether a request body is small enough to hold in memory for a retry.
+ *
+ * The proxy buffers the whole body so that a 401 can be answered by refreshing
+ * the token and sending the same request again. That is a good trade for a form
+ * post and a catastrophic one for a file: an eight-hundred-megabyte video was
+ * read into `ArrayBuffer` inside a container limited to 256 MiB, so the upload
+ * appeared to run — the browser really was sending bytes — and then died with
+ * nothing to show for it. Measured on the customer's install: the video module
+ * accepts up to 1 GB, the ingress passes 1 GB, and the proxy in between could
+ * never carry more than a fraction of it.
+ *
+ * A large body is streamed straight through instead. The cost is that it cannot
+ * be replayed after a token refresh, which is the right way round: an upload
+ * that is refused can be started again by the person who chose the file, while
+ * an upload that never completes cannot be rescued by anybody.
+ */ export const RETRY_BUFFER_LIMIT_BYTES = 2 * 1024 * 1024;
+/**
+ * `null` when the size is not declared.
+ *
+ * An undeclared length is treated as LARGE: a chunked upload announces nothing,
+ * and guessing "small" there is how the buffer gets filled by the one request
+ * that must not fill it.
+ */ export function declaredBodySize(headers) {
+    const raw = headers.get('content-length');
+    if (!raw) return null;
+    const size = Number(raw);
+    return Number.isFinite(size) && size >= 0 ? size : null;
+}
+export function canBufferForRetry(headers, limit = RETRY_BUFFER_LIMIT_BYTES) {
+    const size = declaredBodySize(headers);
+    if (size === null) return false;
+    return size <= limit;
+}
+/**
+ * How long to allow, given what is being carried.
+ *
+ * Thirty seconds is right for an API call and absurd for a file: a 200 MB video
+ * over an office line needs minutes, and the old fixed timeout aborted it long
+ * before the last byte. The allowance grows with the declared size — a minute
+ * per fifty megabytes — and is never shorter than the configured default.
+ */ export function timeoutForBody(headers, baseTimeoutMs) {
+    const size = declaredBodySize(headers);
+    if (size === null || size <= RETRY_BUFFER_LIMIT_BYTES) return baseTimeoutMs;
+    const perFiftyMb = 60000;
+    const allowance = Math.ceil(size / (50 * 1024 * 1024)) * perFiftyMb;
+    return Math.max(baseTimeoutMs, allowance);
+}

package/package.json

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