@dunx/http 2.5.0 → 3.0.1

package/dist/chunk-25g22350.js

@@ -0,0 +1,58 @@
+// @bun
+// src/server/trace-context.ts
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var HEX_32 = /^[0-9a-f]{32}$/;
+var HEX_16 = /^[0-9a-f]{16}$/;
+var HEX_2 = /^[0-9a-f]{2}$/;
+var ZERO_TRACE = "0".repeat(32);
+var ZERO_SPAN = "0".repeat(16);
+var SAMPLED = 1;
+var TRACE = Symbol.for("dunx.http.trace");
+var mintSpanId = () => Buffer.from(crypto.getRandomValues(new Uint8Array(8))).toString("hex");
+
+class TraceContext {
+  static adopt(req, requestId) {
+    const inbound = TraceContext.#parse(req.headers.get(TRACEPARENT_HEADER));
+    const state = req.headers.get(TRACESTATE_HEADER);
+    const trace = {
+      traceId: inbound?.traceId ?? requestId.replaceAll("-", ""),
+      spanId: mintSpanId(),
+      ...inbound === undefined ? {} : { parentSpanId: inbound.spanId },
+      flags: inbound?.flags ?? "01",
+      ...inbound !== undefined && state !== null ? { state } : {}
+    };
+    req[TRACE] = trace;
+    return trace;
+  }
+  static of(req) {
+    return req[TRACE];
+  }
+  static header(trace) {
+    return `00-${trace.traceId}-${trace.spanId}-${trace.flags}`;
+  }
+  static sampled(trace) {
+    return (Number.parseInt(trace.flags, 16) & SAMPLED) === SAMPLED;
+  }
+  static #parse(header) {
+    if (header === null)
+      return;
+    const parts = header.split("-");
+    if (parts.length < 4)
+      return;
+    const [version, traceId, spanId, flags] = parts;
+    if (!HEX_2.test(version) || version === "ff")
+      return;
+    if (version === "00" && parts.length !== 4)
+      return;
+    if (!HEX_32.test(traceId) || traceId === ZERO_TRACE)
+      return;
+    if (!HEX_16.test(spanId) || spanId === ZERO_SPAN)
+      return;
+    if (!HEX_2.test(flags))
+      return;
+    return { traceId, spanId, flags };
+  }
+}
+
+export { TRACEPARENT_HEADER, TRACESTATE_HEADER, TraceContext };

package/dist/chunk-b699cfes.js

@@ -0,0 +1,130 @@
+// @bun
+import {
+  HttpStatusCode
+} from "./chunk-sz4pvqxy.js";
+
+// src/client/errors.ts
+import { AppError } from "@dunx/core";
+
+class FetchError extends AppError {
+  status;
+  statusText;
+  body;
+  response;
+  name = "FetchError";
+  constructor(status, statusText, body, response) {
+    super(`HTTP ${status} ${statusText} from ${response.method} ${response.url}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.response = response;
+  }
+}
+Object.defineProperty(FetchError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "readonly status: number" }, { unresolved: "readonly statusText: string" }, { unresolved: "readonly body: unknown" }, { unresolved: `readonly response: {
+      readonly method: string;
+      readonly url: string;
+      readonly headers: Headers;
+    }` }] });
+
+class FetchTransportError extends AppError {
+  response;
+  aborted;
+  name = "FetchTransportError";
+  constructor(response, aborted, options) {
+    super(`${response.method} ${response.url} failed: ${aborted ? "aborted" : "transport error"}`, options);
+    this.response = response;
+    this.aborted = aborted;
+  }
+}
+Object.defineProperty(FetchTransportError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "readonly response: { readonly method: string; readonly url: string }" }, { unresolved: "readonly aborted: boolean" }, ErrorOptions] });
+
+// src/client/json.ts
+var safeStringify = (value) => {
+  const seen = new WeakSet;
+  return JSON.stringify(value, (_key, entry) => {
+    if (typeof entry === "object" && entry !== null) {
+      if (seen.has(entry))
+        return "[Circular]";
+      seen.add(entry);
+    }
+    return entry;
+  });
+};
+var isPlainObject = (value) => {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var isJsonBody = (payload) => {
+  if (payload === null || payload === undefined)
+    return false;
+  if (typeof payload !== "object")
+    return typeof payload !== "string";
+  return !(payload instanceof FormData || payload instanceof URLSearchParams || payload instanceof Blob || payload instanceof ArrayBuffer || payload instanceof ReadableStream || ArrayBuffer.isView(payload));
+};
+
+// src/client/retry.ts
+var uniform = () => {
+  const buffer = new Uint32Array(1);
+  crypto.getRandomValues(buffer);
+  return (buffer[0] ?? 0) / 2 ** 32;
+};
+var backoffDelay = (attempt, { baseMs, power = 2, jitterMs = 1000, maxMs = 30000 }) => Math.min(baseMs * power ** attempt + uniform() * jitterMs, maxMs);
+var retryAfterMs = (headers, now = Date.now()) => {
+  const header = headers.get("retry-after");
+  if (header === null)
+    return;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const at = Date.parse(header);
+  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
+};
+var isRetryableStatus = (status) => status >= HttpStatusCode.INTERNAL_SERVER_ERROR || status === HttpStatusCode.REQUEST_TIMEOUT || status === HttpStatusCode.TOO_MANY_REQUESTS;
+var decide = (error, attempt, options) => {
+  const {
+    retryDelayMs = 1000,
+    backoff,
+    shouldRetryOnStatus = isRetryableStatus,
+    respectRetryAfter = true
+  } = options;
+  const computed = backoffDelay(attempt, { baseMs: retryDelayMs, ...backoff });
+  if (error instanceof FetchTransportError) {
+    return { retry: !error.aborted, delayMs: computed };
+  }
+  if (error instanceof FetchError) {
+    if (!shouldRetryOnStatus(error.status))
+      return { retry: false, delayMs: 0 };
+    const asked = respectRetryAfter ? retryAfterMs(error.response.headers) : undefined;
+    const maxMs = backoff?.maxMs ?? 30000;
+    return {
+      retry: true,
+      delayMs: asked === undefined ? computed : Math.min(asked, maxMs)
+    };
+  }
+  return { retry: true, delayMs: computed };
+};
+var executeWithRetry = async (operation, options = {}) => {
+  const { maxRetries = 3, onAttempt, onError, onSuccess } = options;
+  let lastError;
+  for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
+    onAttempt?.(attempt + 1, attempt > 0);
+    try {
+      const result = await operation();
+      onSuccess?.(result, attempt + 1);
+      return result;
+    } catch (error) {
+      lastError = error;
+      const { retry, delayMs } = decide(error, attempt, options);
+      const willRetry = retry && attempt < maxRetries;
+      onError?.(error, attempt + 1, willRetry);
+      if (!willRetry)
+        throw error;
+      await Bun.sleep(delayMs);
+    }
+  }
+  throw lastError;
+};
+
+export { FetchError, FetchTransportError, safeStringify, isPlainObject, isJsonBody, backoffDelay, retryAfterMs, isRetryableStatus, executeWithRetry };