@jskit-ai/http-runtime 0.1.212 → 0.1.214

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/http-runtime",
-  "version": "0.1.212",
+  "version": "0.1.214",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -78,6 +78,6 @@
     }
   },
   "peerDependencies": {
-    "@jskit-ai/kernel": "0.1.214"
+    "@jskit-ai/kernel": "0.1.216"
   }
 }

package/src/client/transientRetryHttpClient.js

@@ -14,6 +14,9 @@ function sleep(delayMs) {
 }
 
 function shouldRetryTransientHttpFailure(error, method, attemptIndex) {
+  if (error?.name === "AbortError" || error?.name === "TimeoutError") {
+    return false;
+  }
   if (!SAFE_RETRY_METHODS.has(String(method || "GET").toUpperCase())) {
     return false;
   }
@@ -23,13 +26,15 @@ function shouldRetryTransientHttpFailure(error, method, attemptIndex) {
   return Number(attemptIndex) < MAX_TRANSIENT_HTTP_RETRIES;
 }
 
-async function requestWithTransientRetry(executor, method) {
+async function requestWithTransientRetry(executor, method, signal) {
   let attemptIndex = 0;
 
   while (true) {
+    signal?.throwIfAborted();
     try {
       return await executor();
     } catch (error) {
+      signal?.throwIfAborted();
       if (!shouldRetryTransientHttpFailure(error, method, attemptIndex)) {
         throw error;
       }
@@ -48,14 +53,16 @@ function createTransientRetryHttpClient(options = {}) {
       const method = String(requestOptions?.method || "GET").toUpperCase();
       return requestWithTransientRetry(
         () => baseHttpClient.request(url, requestOptions, state),
-        method
+        method,
+        requestOptions?.signal
       );
     },
     requestStream(url, requestOptions = {}, handlers = {}, state = null) {
       const method = String(requestOptions?.method || "GET").toUpperCase();
       return requestWithTransientRetry(
         () => baseHttpClient.requestStream(url, requestOptions, handlers, state),
-        method
+        method,
+        requestOptions?.signal
       );
     }
   });

package/src/shared/clientRuntime/client.js

@@ -13,6 +13,15 @@ import {
 
 const DEFAULT_UNSAFE_METHODS = Object.freeze(["POST", "PUT", "PATCH", "DELETE"]);
 const DEFAULT_NDJSON_CONTENT_TYPE = "application/x-ndjson";
+const DEFAULT_READ_TIMEOUT_MS = 30_000;
+
+function requestSignalWithDeadline(signal, timeoutMs) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
+    throw new TypeError("Request timeoutMs must be a positive finite integer.");
+  }
+  const deadline = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, deadline]) : deadline;
+}
 
 function normalizeMethod(method) {
   return String(method || "GET")
@@ -94,7 +103,7 @@ function appendRequestQueryToUrl(url, query = null, transport = null) {
   return appendQueryString(normalizedUrl, serializedQuery);
 }
 
-function parseJsonSafely(response) {
+function parseJsonSafely(response, signal) {
   const contentType = String(response?.headers?.get?.("content-type") || "");
   const isJson = isJsonContentType(contentType);
   if (!isJson) {
@@ -106,7 +115,13 @@ function parseJsonSafely(response) {
   }
 
   return Promise.resolve(response?.json?.())
-    .catch(() => ({}))
+    .catch((error) => {
+      signal?.throwIfAborted();
+      if (error?.name === "AbortError") {
+        throw error;
+      }
+      return {};
+    })
     .then((data) => ({
       contentType,
       isJson,
@@ -199,6 +214,7 @@ function createHttpClient(options = {}) {
 
   async function fetchSessionForCsrf() {
     const activeFetch = configuredFetchImpl || resolveFetch();
+    const signal = requestSignalWithDeadline(null, options.readTimeoutMs ?? DEFAULT_READ_TIMEOUT_MS);
     const requestUrl = await resolveRequestUrl(csrf.sessionPath, {
       originalUrl: csrf.sessionPath,
       method: "GET",
@@ -213,13 +229,16 @@ function createHttpClient(options = {}) {
     try {
       response = await activeFetch(requestUrl, {
         method: "GET",
-        credentials: String(options?.credentials || "same-origin")
+        credentials: String(options?.credentials || "same-origin"),
+        signal
       });
     } catch (cause) {
+      signal.throwIfAborted();
       throw createNetworkError(cause);
     }
 
-    const { data } = await parseJsonSafely(response);
+    const { data } = await parseJsonSafely(response, signal);
+    signal.throwIfAborted();
     updateCsrfTokenFromPayload(data);
 
     if (!response.ok) {
@@ -352,6 +371,7 @@ function createHttpClient(options = {}) {
       transport: _transport,
       query: requestQuery,
       csrf: requestCsrf,
+      timeoutMs: requestTimeoutMs,
       ...forwardedRequestOptions
     } = requestOptions && typeof requestOptions === "object" ? requestOptions : {};
     const csrfEnabled = csrf.enabled && requestCsrf !== false;
@@ -385,6 +405,13 @@ function createHttpClient(options = {}) {
       method,
       headers
     };
+    const ordinaryRead = !stream && ["GET", "HEAD"].includes(method);
+    const timeoutMs = requestTimeoutMs ?? (ordinaryRead
+      ? options.readTimeoutMs ?? DEFAULT_READ_TIMEOUT_MS
+      : undefined);
+    if (timeoutMs !== undefined) {
+      config.signal = requestSignalWithDeadline(config.signal, timeoutMs);
+    }
 
     if (transport) {
       setHeaderIfMissing(headers, "Accept", JSON_API_CONTENT_TYPE);
@@ -418,15 +445,18 @@ function createHttpClient(options = {}) {
   }
 
   async function executePreparedRequest(url, config, { method, state }, onNetworkFailure) {
+    config.signal?.throwIfAborted();
     let response;
     try {
       const activeFetch = configuredFetchImpl || resolveFetch();
       response = await activeFetch(url, config);
     } catch (cause) {
+      config.signal?.throwIfAborted();
       return onNetworkFailure(cause);
     }
 
-    const { contentType, isJson, data } = await parseJsonSafely(response);
+    const { contentType, isJson, data } = await parseJsonSafely(response, config.signal);
+    config.signal?.throwIfAborted();
     updateCsrfTokenFromPayload(data);
 
     return {
@@ -556,6 +586,9 @@ function createHttpClient(options = {}) {
       state,
       stream: false,
       async handleNetworkFailure({ cause, method, state: resolvedState }) {
+        if (cause?.name === "AbortError") {
+          throw cause;
+        }
         const error = createNetworkError(cause);
         await notifyFailure({
           url,

package/test/client.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { createServer } from "node:http";
 
 import { createHttpClient } from "../src/shared/clientRuntime/client.js";
 
@@ -21,6 +22,62 @@ function mockResponse({ status = 200, data = {}, contentType = "application/json
   };
 }
 
+test("ordinary reads get a finite default deadline while streams keep their explicit lifetime", async (t) => {
+  const deadlines = [];
+  const calls = [];
+  t.mock.method(AbortSignal, "timeout", (milliseconds) => {
+    deadlines.push(milliseconds);
+    return new AbortController().signal;
+  });
+  const client = createHttpClient({
+    fetchImpl: async (_url, options) => {
+      calls.push(options);
+      return mockResponse();
+    }
+  });
+  await client.request("/api/list");
+  await client.request("/api/report", { timeoutMs: 90_000 });
+  await client.requestStream("/api/events");
+  assert.deepEqual(deadlines, [30_000, 90_000]);
+  assert.ok(calls[0].signal instanceof AbortSignal);
+  assert.equal(calls[1].timeoutMs, undefined);
+  assert.equal(calls[2].signal, undefined);
+  for (const timeoutMs of [0, -1, Infinity, NaN]) {
+    await assert.rejects(client.request("/api/list", { timeoutMs }), /positive finite integer/u);
+  }
+});
+
+for (const phase of ["headers", "body", "CSRF session"]) {
+  test(`read deadline closes a real HTTP connection stalled during ${phase}`, async (t) => {
+    let received;
+    let closed;
+    const requestReceived = new Promise((resolve) => { received = resolve; });
+    const responseClosed = new Promise((resolve) => { closed = resolve; });
+    const server = createServer((_request, response) => {
+      response.on("close", closed);
+      if (phase !== "headers") {
+        response.writeHead(200, { "Content-Type": "application/json" });
+        response.write('{"pending":');
+      }
+      received();
+    });
+    t.after(() => {
+      server.closeAllConnections();
+      server.close();
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const origin = `http://127.0.0.1:${server.address().port}`;
+    const client = createHttpClient({ readTimeoutMs: 100, csrf: { sessionPath: `${origin}/session` } });
+    const pending = client.request(`${origin}/read`, phase === "CSRF session"
+      ? { method: "POST", body: { value: 1 } }
+      : {});
+    const rejected = assert.rejects(pending, (error) => error.name === "TimeoutError");
+    await requestReceived;
+    await rejected;
+    await responseClosed;
+  });
+}
+
 test("request retains standard and JSON:API write outcomes without retrying", async () => {
   for (const jsonapi of [false, true]) {
     for (const outcome of ["committed", "rolledBack", "unknown", "invalid"]) {

package/test/transientRetryHttpClient.test.js

@@ -165,3 +165,73 @@ test("createTransientRetryHttpClient retries transient GET stream failures", asy
     assert.equal(callCount, 2);
   });
 });
+
+for (const phase of ["before request", "waiting for headers", "reading body", "retry delay"]) {
+  test(`request cancellation during ${phase} rejects without starting another fetch`, async () => {
+    await withImmediateTimers(async () => {
+      const controller = new AbortController();
+      const reason = new DOMException("Read superseded", "AbortError");
+      let callCount = 0;
+      const client = createTransientRetryHttpClient({
+        fetchImpl: async (_url, { signal }) => {
+          callCount += 1;
+          if (phase === "before request") signal.throwIfAborted();
+          if (phase === "waiting for headers") {
+            controller.abort(reason);
+            signal.throwIfAborted();
+          }
+          if (phase === "reading body") {
+            return {
+              ...mockResponse(),
+              async json() {
+                controller.abort(reason);
+                signal.throwIfAborted();
+              }
+            };
+          }
+          return mockResponse({ status: 503 });
+        }
+      });
+      const immediateTimer = globalThis.setTimeout;
+      if (phase === "before request") controller.abort(reason);
+      if (phase === "retry delay") {
+        globalThis.setTimeout = (handler, delay, ...args) => {
+          controller.abort(reason);
+          return immediateTimer(handler, delay, ...args);
+        };
+      }
+      await assert.rejects(client.request("/api/cancellation", { signal: controller.signal }),
+        (error) => error === reason);
+      assert.equal(callCount, phase === "before request" ? 0 : 1);
+    });
+  });
+}
+
+for (const phase of ["headers", "body"]) {
+  test(`default read deadline during ${phase} rejects without a caller signal or another fetch`, async (t) => {
+    await withImmediateTimers(async () => {
+      const deadline = new AbortController();
+      const reason = new DOMException("Read timed out", "TimeoutError");
+      t.mock.method(AbortSignal, "timeout", () => deadline.signal);
+      let callCount = 0;
+      const client = createTransientRetryHttpClient({
+        fetchImpl: async () => {
+          callCount += 1;
+          if (phase === "headers") {
+            deadline.abort(reason);
+            throw reason;
+          }
+          return {
+            ...mockResponse(),
+            async json() {
+              deadline.abort(reason);
+              throw new DOMException("Body read aborted", "AbortError");
+            }
+          };
+        }
+      });
+      await assert.rejects(client.request("/api/forgotten-read"), (error) => error === reason);
+      assert.equal(callCount, 1);
+    });
+  });
+}