@zlink-systems/http-client 0.26.0 → 0.28.0

package/dist/browser/index.mjs

@@ -62,222 +62,24 @@ var ZLINK_PACKET_JSON_CONTRACTS = Symbol.for("@zlink-systems/framework:packet-js
 // packages/framework/src/contracts/Handlers/Attributes.ts
 var ZLINK_DECORATOR_METADATA = Symbol.for("@zlink-systems/framework:decorator");
 
-// packages/http-client/src/runtime/http-client-errors.ts
-function responseBodySizeExceeded(message = "HTTP response exceeded the maximum body size") {
-  return new ZLinkFrameworkException(4 /* Rejected */, message);
-}
-function redirectLimitExceeded(message = "HTTP request exceeded the redirect limit") {
-  return new ZLinkFrameworkException(8 /* ProtocolError */, message);
-}
-function redirectFormatError(message) {
-  return new ZLinkFrameworkException(8 /* ProtocolError */, message);
-}
-
-// packages/http-client/src/runtime/redirect-policy.ts
-var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-function isRedirectStatus(status) {
-  return REDIRECT_STATUSES.has(status);
-}
-function makeTarget(prefix, path) {
-  if (prefix.length === 0 || prefix === "/") {
-    return path;
-  }
-  return prefix.endsWith("/") ? prefix.slice(0, -1) + path : prefix + path;
-}
-function rewriteForRedirect(status, method, body) {
-  if (status === 303 || (status === 301 || status === 302) && method === "POST") {
-    return { method: "GET", body: void 0 };
-  }
-  return { method, body };
-}
-function resolveLocation(current, location) {
-  try {
-    if (location.startsWith("http://") || location.startsWith("https://")) {
-      return new URL(location);
-    }
-    if (location.startsWith("//")) {
-      return new URL(current.protocol + location);
-    }
-    if (location.startsWith("/")) {
-      return new URL(current.origin + location);
-    }
-  } catch {
-    throw redirectFormatError(`HTTP redirect location is malformed: ${location}`);
-  }
-  throw redirectFormatError(`HTTP redirect location is not supported: ${location}`);
-}
-
-// packages/http-client/src/runtime/retry-policy.ts
-function delayMsFor(attempt) {
-  const ceiling = Math.min(1e3, 50 << Math.min(attempt, 5));
-  return Math.floor(Math.random() * (ceiling + 1));
-}
-var RetryPolicy = class {
-  constructor(options) {
-    this.options = options;
-  }
-  async execute(spec, perform) {
-    const maxRetries = spec.sink !== void 0 || spec.bodyProvider !== void 0 ? 0 : this.options.retryAttempts;
-    const timeoutMs = spec.timeoutMs ?? this.options.timeoutMs;
-    for (let attempt = 0; ; attempt++) {
-      const controller = new AbortController();
-      const timer = setTimeout(() => {
-        controller.abort();
-      }, timeoutMs);
-      try {
-        return await perform(spec, controller.signal);
-      } catch (error) {
-        const failure = mapFailure(error, controller.signal.aborted);
-        if (isRetriableHttpFailure(failure) && attempt < maxRetries) {
-          await delay(delayMsFor(attempt));
-          continue;
-        }
-        throw failure;
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-  }
-};
-function mapFailure(error, aborted) {
-  if (error instanceof ZLinkFrameworkException) {
-    return error;
-  }
-  if (aborted || error instanceof Error && error.name === "AbortError") {
-    return new ZLinkFrameworkException(
-      6 /* DeadlineExceeded */,
-      "HTTP request exceeded timeout",
-      error
-    );
-  }
-  const message = error instanceof Error ? error.message : "HTTP transport failure";
-  return new ZLinkFrameworkException(5 /* Unavailable */, message, error);
-}
-function isRetriableHttpFailure(error) {
-  return error.kind === 5 /* Unavailable */ || error.kind === 6 /* DeadlineExceeded */;
-}
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-// packages/http-client/src/runtime/browser-runtime.ts
-var HttpClientRuntime = class {
-  constructor(options) {
-    this.options = options;
-    rejectUnsupportedTransportOptions(options);
-    this.retryPolicy = new RetryPolicy(options);
-  }
-  retryPolicy;
-  async executeAsync(spec) {
-    return await this.retryPolicy.execute(spec, (request, signal) => this.perform(request, signal));
-  }
-  async close() {
-  }
-  async perform(spec, signal) {
-    const baseUri = new URL(this.options.baseUrl);
-    const origin = baseUri.origin;
-    let current = new URL(origin + makeTarget(baseUri.pathname, spec.target));
-    let method = spec.method;
-    let body = spec.body;
-    let bodyProvider = spec.bodyProvider;
-    let redirectsLeft = this.options.followRedirects;
-    for (; ; ) {
-      const headers = this.buildHeaders(
-        spec,
-        current.origin === origin,
-        body !== void 0 || bodyProvider !== void 0
-      );
-      const response = await fetch(current, {
-        method,
-        headers,
-        body: body ?? bodyStream(bodyProvider),
-        credentials: this.options.cookies ? "include" : "same-origin",
-        redirect: "manual",
-        signal
-      });
-      const location = response.headers.get("location");
-      if (this.options.followRedirects > 0 && isRedirectStatus(response.status) && location !== null) {
-        if (redirectsLeft === 0) {
-          await response.body?.cancel();
-          throw redirectLimitExceeded();
-        }
-        redirectsLeft--;
-        ({ method, body } = rewriteForRedirect(response.status, method, body));
-        bodyProvider = void 0;
-        await response.body?.cancel();
-        current = resolveLocation(current, location);
-        continue;
-      }
-      const headersResult = collectHeaders(response.headers);
-      if (spec.sink !== void 0) {
-        await streamResponse(response, spec.sink, this.options.maxResponseBodySize);
-        return { status: response.status, headers: headersResult, body: "" };
-      }
-      const text = await response.text();
-      if (new TextEncoder().encode(text).length > this.options.maxResponseBodySize) {
-        throw responseBodySizeExceeded();
-      }
-      return { status: response.status, headers: headersResult, body: text };
-    }
-  }
-  buildHeaders(spec, keepAuthorization, hasBody) {
-    const headers = { accept: "application/json" };
-    applyHeaders(headers, this.options.headers, keepAuthorization);
-    applyHeaders(headers, spec.headers, keepAuthorization);
-    if (!hasBody) delete headers["content-type"];
-    return headers;
-  }
-};
-function rejectUnsupportedTransportOptions(options) {
-  if (options.trustCertificateFile !== void 0 || options.clientCertificate !== void 0 || options.proxy !== void 0) {
-    throw new ZLinkFrameworkException(
-      8 /* ProtocolError */,
-      "Browser HTTP clients cannot configure certificate files or a transport proxy."
-    );
-  }
-}
-function bodyStream(provider) {
-  if (provider === void 0) return void 0;
-  return new ReadableStream({
-    pull(controller) {
-      const chunk = provider();
-      if (chunk === null) controller.close();
-      else controller.enqueue(chunk);
-    }
-  });
-}
-async function streamResponse(response, sink, maximumSize) {
-  if (response.body === null) return;
-  const reader = response.body.getReader();
-  let total = 0;
-  for (; ; ) {
-    const result = await reader.read();
-    if (result.done) return;
-    total += result.value.length;
-    if (total > maximumSize) {
-      await reader.cancel();
-      throw responseBodySizeExceeded();
-    }
-    sink(result.value);
-  }
-}
-function collectHeaders(headers) {
-  const result = {};
-  headers.forEach((value, name) => {
-    result[name.toLowerCase()] = value;
-  });
-  return result;
-}
-function applyHeaders(target, source, keepAuthorization) {
-  for (const [name, value] of Object.entries(source)) {
-    const lower = name.toLowerCase();
-    if (keepAuthorization || lower !== "authorization") target[lower] = value;
-  }
-}
-
 // packages/http-client/src/runtime/text.ts
+var HttpHeaderName = Object.freeze({
+  Accept: "accept",
+  Authorization: "authorization",
+  ContentType: "content-type",
+  Location: "location",
+  SetCookie: "set-cookie",
+  UserAgent: "user-agent",
+  AcceptEncoding: "accept-encoding",
+  Cookie: "cookie",
+  ContentEncoding: "content-encoding",
+  ContentLength: "content-length"
+});
+var HttpContentType = Object.freeze({
+  Json: "application/json",
+  UrlEncoded: "application/x-www-form-urlencoded",
+  Multipart: "multipart/form-data"
+});
 function isBlank(value) {
   return value.length === 0 || /^[\s]*$/u.test(value);
 }
@@ -311,11 +113,14 @@ function percentEncode(value) {
 function basicAuthorization(user, password) {
   return "Basic " + Buffer.from(`${user}:${password}`, "utf8").toString("base64");
 }
+var MULTIPART_BOUNDARY_PREFIX = "zlink-boundary-";
+var MULTIPART_BOUNDARY_ENTROPY_CHARACTERS = 16;
 function makeMultipartBoundary() {
-  return "zlink-boundary-" + Math.random().toString(16).slice(2).padEnd(16, "0").slice(0, 16);
+  return MULTIPART_BOUNDARY_PREFIX + Math.random().toString(16).slice(2).padEnd(MULTIPART_BOUNDARY_ENTROPY_CHARACTERS, "0").slice(0, MULTIPART_BOUNDARY_ENTROPY_CHARACTERS);
 }
 
 // packages/http-client/src/request-builder.ts
+var HTTP_FAILURE_STATUS_MIN = 400;
 var ZLinkHttpRequestBuilder = class {
   constructor(client, method, path, clientFactory) {
     this.method = method;
@@ -364,10 +169,16 @@ var ZLinkHttpRequestBuilder = class {
     }
     return this.clientInstance;
   }
-  async closeIfOwned() {
-    if (this.ownsClient && this.clientInstance !== void 0) {
-      await this.clientInstance.close().catch(() => void 0);
+  async execute(client, operation) {
+    if (!this.ownsClient) return operation;
+    const [outcome] = await Promise.allSettled([operation]);
+    try {
+      await client.close();
+    } catch (closeError) {
+      if (outcome.status === "fulfilled") throw closeError;
     }
+    if (outcome.status === "rejected") throw outcome.reason;
+    return outcome.value;
   }
   header(name, value) {
     requireNonBlank(name, "HTTP request header name is required");
@@ -394,11 +205,11 @@ var ZLinkHttpRequestBuilder = class {
       }
       requireNonBlank(contentType, "HTTP request body content type is required");
       this.bodyValue = value;
-      this.headersValue["content-type"] = contentType;
+      this.headersValue[HttpHeaderName.ContentType] = contentType;
       return this;
     }
     this.bodyValue = JSON.stringify(value);
-    this.headersValue["content-type"] ??= "application/json";
+    this.headersValue[HttpHeaderName.ContentType] ??= HttpContentType.Json;
     return this;
   }
   /**
@@ -414,7 +225,7 @@ var ZLinkHttpRequestBuilder = class {
     }
     requireNonBlank(contentType, "HTTP request body content type is required");
     this.bodyProviderValue = provider;
-    this.headersValue["content-type"] = contentType;
+    this.headersValue[HttpHeaderName.ContentType] = contentType;
     return this;
   }
   form(name, value) {
@@ -438,11 +249,7 @@ var ZLinkHttpRequestBuilder = class {
   async submitRaw() {
     const request = this.makeRequest(void 0);
     const client = this.resolveClient();
-    try {
-      return await client.runtime.executeAsync(request);
-    } finally {
-      await this.closeIfOwned();
-    }
+    return this.execute(client, client.runtime.executeAsync(request));
   }
   /**
    * Streams the response body to `sink` chunk by chunk instead of buffering it; the returned
@@ -457,11 +264,7 @@ var ZLinkHttpRequestBuilder = class {
     }
     const request = this.makeRequest(sink);
     const client = this.resolveClient();
-    try {
-      return await client.runtime.executeAsync(request);
-    } finally {
-      await this.closeIfOwned();
-    }
+    return this.execute(client, client.runtime.executeAsync(request));
   }
   submit(callback) {
     const pending = this.executeTyped();
@@ -474,8 +277,13 @@ var ZLinkHttpRequestBuilder = class {
     );
   }
   async executeTyped() {
-    const raw = await this.submitRaw();
-    if (raw.status >= 400) {
+    const request = this.makeRequest(void 0);
+    const client = this.resolveClient();
+    return this.execute(client, this.decodeResponse(client.runtime.executeAsync(request)));
+  }
+  async decodeResponse(pending) {
+    const raw = await pending;
+    if (raw.status >= HTTP_FAILURE_STATUS_MIN) {
       throw new ZLinkFrameworkException(
         11 /* InternalFailure */,
         `HTTP request failed with status ${raw.status}`
@@ -544,12 +352,12 @@ var ZLinkHttpRequestBuilder = class {
       return { body: this.bodyValue, headers };
     }
     if (this.formValue.length > 0) {
-      headers["content-type"] = "application/x-www-form-urlencoded";
+      headers[HttpHeaderName.ContentType] = HttpContentType.UrlEncoded;
       return { body: this.encodeFormBody(), headers };
     }
     if (this.multipartValue.length > 0) {
       const boundary = makeMultipartBoundary();
-      headers["content-type"] = `multipart/form-data; boundary=${boundary}`;
+      headers[HttpHeaderName.ContentType] = `${HttpContentType.Multipart}; boundary=${boundary}`;
       return { body: this.encodeMultipartBody(boundary), headers };
     }
     return { body: void 0, headers };
@@ -608,6 +416,311 @@ function safeJsonReviver(key, value) {
   return value;
 }
 
+// packages/http-client/src/runtime/http-client-errors.ts
+function responseBodySizeExceeded(message = "HTTP response exceeded the maximum body size") {
+  return new ZLinkFrameworkException(4 /* Rejected */, message);
+}
+function redirectLimitExceeded(message = "HTTP request exceeded the redirect limit") {
+  return new ZLinkFrameworkException(8 /* ProtocolError */, message);
+}
+function redirectFormatError(message) {
+  return new ZLinkFrameworkException(8 /* ProtocolError */, message);
+}
+
+// packages/http-client/src/runtime/redirect-policy.ts
+var RedirectStatus = {
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308
+};
+var REDIRECT_STATUSES = new Set(Object.values(RedirectStatus));
+function isRedirectStatus(status) {
+  return REDIRECT_STATUSES.has(status);
+}
+function makeTarget(prefix, path) {
+  if (prefix.length === 0 || prefix === "/") {
+    return path;
+  }
+  return prefix.endsWith("/") ? prefix.slice(0, -1) + path : prefix + path;
+}
+function rewriteForRedirect(status, method, body) {
+  if (status === RedirectStatus.SeeOther || (status === RedirectStatus.MovedPermanently || status === RedirectStatus.Found) && method === "POST") {
+    return { method: "GET", body: void 0 };
+  }
+  return { method, body };
+}
+function resolveLocation(current, location) {
+  try {
+    if (location.startsWith("http://") || location.startsWith("https://")) {
+      return new URL(location);
+    }
+    if (location.startsWith("//")) {
+      return new URL(current.protocol + location);
+    }
+    if (location.startsWith("/")) {
+      return new URL(current.origin + location);
+    }
+  } catch {
+    throw redirectFormatError(`HTTP redirect location is malformed: ${location}`);
+  }
+  throw redirectFormatError(`HTTP redirect location is not supported: ${location}`);
+}
+
+// packages/http-client/src/runtime/retry-policy.ts
+var INITIAL_RETRY_DELAY_MS = 50;
+var MAX_RETRY_DELAY_MS = 1e3;
+var MAX_RETRY_DELAY_SHIFT = Math.ceil(Math.log2(MAX_RETRY_DELAY_MS / INITIAL_RETRY_DELAY_MS));
+function delayMsFor(attempt) {
+  const ceiling = Math.min(
+    MAX_RETRY_DELAY_MS,
+    INITIAL_RETRY_DELAY_MS << Math.min(attempt, MAX_RETRY_DELAY_SHIFT)
+  );
+  return Math.floor(Math.random() * (ceiling + 1));
+}
+var RetryPolicy = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async execute(spec, perform) {
+    const maxRetries = spec.sink !== void 0 || spec.bodyProvider !== void 0 ? 0 : this.options.retryAttempts;
+    const timeoutMs = spec.timeoutMs ?? this.options.timeoutMs;
+    for (let attempt = 0; ; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => {
+        controller.abort();
+      }, timeoutMs);
+      try {
+        return await perform(spec, controller);
+      } catch (error) {
+        const failure = mapFailure(error, controller.signal.aborted, 1 /* Application */);
+        if (isRetriableHttpFailure(failure) && attempt < maxRetries) {
+          await delay(delayMsFor(attempt));
+          continue;
+        }
+        throw failure;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  }
+};
+function mapFailure(error, aborted, stage) {
+  if (error instanceof ZLinkFrameworkException) {
+    return error;
+  }
+  if (stage === 0 /* Transport */ && aborted) {
+    const cause = new DOMException("HTTP request exceeded timeout", "TimeoutError");
+    return new ZLinkFrameworkException(
+      6 /* DeadlineExceeded */,
+      cause.message,
+      cause
+    );
+  }
+  const message = error instanceof Error ? error.message : "HTTP execution failure";
+  return new ZLinkFrameworkException(
+    stage === 0 /* Transport */ ? 5 /* Unavailable */ : 11 /* InternalFailure */,
+    message,
+    error
+  );
+}
+function isRetriableHttpFailure(error) {
+  return error.kind === 5 /* Unavailable */ || error.kind === 6 /* DeadlineExceeded */;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// packages/http-client/src/runtime/bounded-response-body.ts
+async function readResponseBody(stream, maximumSize, consume) {
+  let total = 0;
+  for await (const chunk of stream) {
+    total += chunk.length;
+    if (total > maximumSize) {
+      throw responseBodySizeExceeded();
+    }
+    consume(chunk);
+  }
+}
+
+// packages/http-client/src/runtime/browser-runtime.ts
+var HttpClientRuntime = class {
+  constructor(options) {
+    this.options = options;
+    rejectUnsupportedTransportOptions(options);
+    this.retryPolicy = new RetryPolicy(options);
+  }
+  retryPolicy;
+  async executeAsync(spec) {
+    return await this.retryPolicy.execute(
+      spec,
+      (request, controller) => this.perform(request, controller)
+    );
+  }
+  async close() {
+  }
+  async perform(spec, controller) {
+    const signal = controller.signal;
+    const baseUri = new URL(this.options.baseUrl);
+    const origin = baseUri.origin;
+    let current = new URL(origin + makeTarget(baseUri.pathname, spec.target));
+    let method = spec.method;
+    let body = spec.body;
+    let bodyProvider = spec.bodyProvider;
+    let redirectsLeft = this.options.followRedirects;
+    for (; ; ) {
+      const headers = this.buildHeaders(
+        spec,
+        current.origin === origin,
+        body !== void 0 || bodyProvider !== void 0
+      );
+      let response;
+      try {
+        const init = {
+          method,
+          headers,
+          body: body ?? bodyStream(bodyProvider, controller),
+          duplex: "half",
+          credentials: this.options.cookies ? "include" : "same-origin",
+          redirect: "manual",
+          signal
+        };
+        response = await fetch(current, init);
+      } catch (error) {
+        throw mapFailure(error, signal.aborted, 0 /* Transport */);
+      }
+      const location = response.headers.get(HttpHeaderName.Location);
+      if (this.options.followRedirects > 0 && isRedirectStatus(response.status) && location !== null) {
+        if (redirectsLeft === 0) {
+          try {
+            await response.body?.cancel();
+          } catch (error) {
+            throw mapFailure(error, signal.aborted, 0 /* Transport */);
+          }
+          throw redirectLimitExceeded();
+        }
+        redirectsLeft--;
+        ({ method, body } = rewriteForRedirect(response.status, method, body));
+        bodyProvider = void 0;
+        try {
+          await response.body?.cancel();
+        } catch (error) {
+          throw mapFailure(error, signal.aborted, 0 /* Transport */);
+        }
+        current = resolveLocation(current, location);
+        continue;
+      }
+      const headersResult = collectHeaders(response.headers);
+      if (spec.sink !== void 0) {
+        const sink = spec.sink;
+        await readResponseBody(
+          responseChunks(response, signal),
+          this.options.maxResponseBodySize,
+          (chunk) => {
+            try {
+              sink(chunk);
+            } catch (error) {
+              throw mapFailure(error, signal.aborted, 1 /* Application */);
+            }
+          }
+        );
+        return { status: response.status, headers: headersResult, body: "" };
+      }
+      const decoder = new TextDecoder();
+      const text = [];
+      await readResponseBody(
+        responseChunks(response, signal),
+        this.options.maxResponseBodySize,
+        (chunk) => {
+          text.push(decoder.decode(chunk, { stream: true }));
+        }
+      );
+      text.push(decoder.decode());
+      return { status: response.status, headers: headersResult, body: text.join("") };
+    }
+  }
+  buildHeaders(spec, keepAuthorization, hasBody) {
+    const headers = {
+      [HttpHeaderName.Accept]: HttpContentType.Json
+    };
+    applyHeaders(headers, this.options.headers, keepAuthorization);
+    applyHeaders(headers, spec.headers, keepAuthorization);
+    if (!hasBody) delete headers[HttpHeaderName.ContentType];
+    return headers;
+  }
+};
+function rejectUnsupportedTransportOptions(options) {
+  if (options.trustCertificateFile !== void 0 || options.clientCertificate !== void 0 || options.proxy !== void 0) {
+    throw new ZLinkFrameworkException(
+      8 /* ProtocolError */,
+      "Browser HTTP clients cannot configure certificate files or a transport proxy."
+    );
+  }
+}
+function bodyStream(provider, abortController) {
+  if (provider === void 0) return void 0;
+  return new ReadableStream({
+    pull(controller) {
+      let chunk;
+      try {
+        chunk = provider();
+      } catch (error) {
+        const failure = mapFailure(
+          error,
+          abortController.signal.aborted,
+          1 /* Application */
+        );
+        abortController.abort(failure);
+        throw failure;
+      }
+      if (chunk === null) controller.close();
+      else controller.enqueue(chunk);
+    }
+  });
+}
+async function* responseChunks(response, signal) {
+  if (response.body === null) return;
+  const reader = response.body.getReader();
+  try {
+    for (; ; ) {
+      let result;
+      try {
+        result = await reader.read();
+      } catch (error) {
+        throw mapFailure(error, signal.aborted, 0 /* Transport */);
+      }
+      if (result.done) return;
+      yield result.value;
+    }
+  } finally {
+    try {
+      try {
+        await reader.cancel();
+      } catch (error) {
+        throw mapFailure(error, signal.aborted, 0 /* Transport */);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}
+function collectHeaders(headers) {
+  const result = {};
+  headers.forEach((value, name) => {
+    result[name.toLowerCase()] = value;
+  });
+  return result;
+}
+function applyHeaders(target, source, keepAuthorization) {
+  for (const [name, value] of Object.entries(source)) {
+    const lower = name.toLowerCase();
+    if (keepAuthorization || lower !== HttpHeaderName.Authorization) target[lower] = value;
+  }
+}
+
 // packages/http-client/src/client.ts
 var ZLinkHttpClient = class {
   constructor(runtimeInstance, executionScheduler) {
@@ -648,10 +761,13 @@ var ZLinkHttpClient = class {
     await this.runtimeInstance.close();
   }
 };
+var DEFAULT_HTTP_CLIENT_TIMEOUT_MS = 3e3;
+var DEFAULT_HTTP_RESPONSE_BODY_SIZE = 16 * 1024 * 1024;
+var DEFAULT_HTTP_MAX_REDIRECTS = 5;
 var ZLinkHttpClientBuilder = class {
   baseUrlValue = "";
-  timeoutMsValue = 3e3;
-  maxResponseBodySizeValue = 16 * 1024 * 1024;
+  timeoutMsValue = DEFAULT_HTTP_CLIENT_TIMEOUT_MS;
+  maxResponseBodySizeValue = DEFAULT_HTTP_RESPONSE_BODY_SIZE;
   headersValue = {};
   trustCertificateFileValue;
   clientCertificateValue;
@@ -679,12 +795,12 @@ var ZLinkHttpClientBuilder = class {
   }
   basicAuth(user, password) {
     requireNonBlank(user, "HTTP client basic auth user is required");
-    this.headersValue["authorization"] = basicAuthorization(user, password);
+    this.headersValue[HttpHeaderName.Authorization] = basicAuthorization(user, password);
     return this;
   }
   bearerToken(token) {
     requireNonBlank(token, "HTTP client bearer token is required");
-    this.headersValue["authorization"] = `Bearer ${token}`;
+    this.headersValue[HttpHeaderName.Authorization] = `Bearer ${token}`;
     return this;
   }
   maxResponseBodySize(bytes) {
@@ -708,7 +824,7 @@ var ZLinkHttpClientBuilder = class {
     this.clientCertificateValue = { certificatePath, keyPath };
     return this;
   }
-  followRedirects(maxRedirects = 5) {
+  followRedirects(maxRedirects = DEFAULT_HTTP_MAX_REDIRECTS) {
     if (!(maxRedirects > 0)) {
       throw new ZLinkFrameworkException(
         8 /* ProtocolError */,