@dunx/http 3.2.0 → 3.3.0

package/dist/chunk-8939brh2.js

@@ -0,0 +1,174 @@
+// @bun
+import {
+  HttpStatusCode2
+} from "./chunk-bg0dr54z.js";
+
+// src/route/marker.ts
+var ROUTE = Symbol.for("dunx.route");
+var CONTROLLER = Symbol.for("dunx.controller");
+var defaultStatusFor2 = (method) => method === "POST" ? HttpStatusCode2.CREATED : HttpStatusCode2.OK;
+var resolvePath = (path) => typeof path === "function" ? path() : path;
+var markRoute = (target, meta) => {
+  Object.defineProperty(target, ROUTE, { value: meta, configurable: true });
+};
+var routeMetaOf = (value) => typeof value === "function" ? value[ROUTE] : undefined;
+var markController = (target, prefix) => {
+  Object.defineProperty(target, CONTROLLER, {
+    value: prefix,
+    configurable: true
+  });
+};
+var prefixOf = (target) => target[CONTROLLER] ?? "";
+
+// src/route/metadata.ts
+var META = Symbol.for("dunx.meta");
+var GUARDS = Symbol.for("dunx.guards");
+var metaKey2 = (name) => ({
+  name,
+  id: Symbol(name)
+});
+var write = (target, key, value) => {
+  const record = new Map(target[META]);
+  record.set(key.id, value);
+  Object.defineProperty(target, META, { value: record, configurable: true });
+};
+var meta2 = (key, value) => (target) => {
+  write(target, key, value);
+  return target;
+};
+var ROLES2 = metaKey2("roles");
+var PUBLIC2 = metaKey2("public");
+var HIDDEN2 = metaKey2("hidden");
+var UNMATCHED2 = metaKey2("unmatched");
+var Roles2 = (...roles) => meta2(ROLES2, roles);
+var Public2 = () => meta2(PUBLIC2, true);
+var ApiHidden2 = () => meta2(HIDDEN2, true);
+var UseGuards2 = (...guards) => (target) => {
+  const existing = target[GUARDS] ?? [];
+  const merged = Object.hasOwn(target, GUARDS) ? [...guards, ...existing] : [...existing, ...guards];
+  Object.defineProperty(target, GUARDS, {
+    value: merged,
+    configurable: true
+  });
+  return target;
+};
+var guardsOf = (target) => target[GUARDS] ?? [];
+var metaOf2 = (target) => target[META];
+var mergeMeta2 = (...targets) => {
+  const merged = new Map;
+  for (const target of targets) {
+    const record = target[META];
+    if (record)
+      for (const [id, value] of record)
+        merged.set(id, value);
+  }
+  return merged;
+};
+
+// src/route/discover.ts
+import { markedMethods } from "@dunx/core";
+var joinPath2 = (prefix, path) => {
+  const joined = `/${prefix}/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
+};
+var discoverRoutes2 = (instance) => {
+  const klass = instance.constructor;
+  const prefix = prefixOf(klass);
+  const classGuards = guardsOf(klass);
+  const members = instance;
+  return markedMethods(Object.getPrototypeOf(instance), routeMetaOf).map(({ name, meta, value: marked }) => ({
+    method: meta.method,
+    path: joinPath2(prefix, resolvePath(meta.path)),
+    controller: klass.name,
+    handlerName: name,
+    handler: members[name].bind(instance),
+    options: meta.options,
+    meta: mergeMeta2(klass, marked),
+    classMeta: metaOf2(klass),
+    guards: [...classGuards, ...guardsOf(marked)]
+  }));
+};
+
+// src/ws/marker.ts
+var HANDLER = Symbol.for("dunx.ws.handler");
+var GATEWAY = Symbol.for("dunx.ws.gateway");
+var HandlerKind = Object.freeze({
+  UPGRADE: "upgrade",
+  OPEN: "open",
+  MESSAGE: "message",
+  CLOSE: "close",
+  DRAIN: "drain",
+  PING: "ping",
+  PONG: "pong"
+});
+var markHandler = (target, meta) => {
+  Object.defineProperty(target, HANDLER, { value: meta, configurable: true });
+};
+var handlerMetaOf = (value) => typeof value === "function" ? value[HANDLER] : undefined;
+var markGateway = (target, path) => {
+  Object.defineProperty(target, GATEWAY, { value: path, configurable: true });
+};
+var gatewayPathOf = (target) => target[GATEWAY] ?? "/";
+var isGateway2 = (target) => target[GATEWAY] !== undefined;
+
+// src/server/context.ts
+var EMPTY = new Map;
+var buildContext2 = (route) => {
+  const record = route.meta ?? EMPTY;
+  return Object.freeze({
+    controller: route.controller,
+    handler: route.handlerName,
+    method: route.method,
+    path: route.path,
+    parsesBody: route.options?.body !== undefined,
+    get: (key) => record.get(key.id)
+  });
+};
+
+// src/ws/discover.ts
+import {
+  AppError,
+  classOf,
+  markedMethods as markedMethods2
+} from "@dunx/core";
+var normalizePath = (path) => {
+  const joined = `/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
+};
+var eachHandler = (start) => markedMethods2(start, handlerMetaOf);
+var discoverGateway = (instance) => {
+  const klass = instance.constructor;
+  const members = instance;
+  return {
+    name: klass.name,
+    path: normalizePath(gatewayPathOf(klass)),
+    handlers: eachHandler(Object.getPrototypeOf(instance)).map(({ name, meta }) => ({
+      kind: meta.kind,
+      event: meta.event,
+      method: name,
+      invoke: members[name].bind(instance)
+    }))
+  };
+};
+var findHandlerMethod = (ctor) => eachHandler(ctor.prototype)[0]?.name;
+var discoverGateways = (modules, resolve) => {
+  const discovered = [];
+  for (const module of modules) {
+    for (const entry of module.options.providers ?? []) {
+      const candidate = classOf(entry);
+      if (!candidate)
+        continue;
+      if (isGateway2(candidate.ctor)) {
+        discovered.push(discoverGateway(resolve(candidate.token)));
+        continue;
+      }
+      const orphan = findHandlerMethod(candidate.ctor);
+      if (orphan !== undefined) {
+        throw new AppError(`${candidate.ctor.name}.${orphan}() is a websocket handler, but ` + `${candidate.ctor.name} is not a gateway. Decorate the class with ` + "@Gateway(path), or drop the handler decorator.");
+      }
+    }
+  }
+  return discovered;
+};
+
+export { defaultStatusFor2, markRoute, markController, metaKey2, meta2, ROLES2, PUBLIC2, HIDDEN2, UNMATCHED2, Roles2, Public2, ApiHidden2, UseGuards2, metaOf2, mergeMeta2, joinPath2, discoverRoutes2, HandlerKind, markHandler, markGateway, isGateway2, discoverGateway, discoverGateways, buildContext2 };

package/dist/chunk-bg0dr54z.js

@@ -0,0 +1,37 @@
+// @bun
+// src/server/status.ts
+var HttpStatusCode2 = Object.freeze({
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  IM_A_TEAPOT: 418,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+});
+
+export { HttpStatusCode2 };

package/dist/chunk-gmtwad7f.js

@@ -0,0 +1,71 @@
+// @bun
+// src/server/trace-context.ts
+var TRACEPARENT_HEADER2 = "traceparent";
+var TRACESTATE_HEADER2 = "tracestate";
+var TRACERESPONSE_HEADER2 = "traceresponse";
+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 DEFAULT_FLAGS = "01";
+var TRACE = Symbol.for("dunx.http.trace");
+var EXPOSE = Symbol.for("dunx.http.trace.expose");
+var mint = (bytes) => crypto.getRandomValues(new Uint8Array(bytes)).toHex();
+
+class TraceContext2 {
+  static adopt(req, expose = true) {
+    const inbound = TraceContext2.#parse(req.headers.get(TRACEPARENT_HEADER2));
+    const state = req.headers.get(TRACESTATE_HEADER2);
+    const trace = inbound === undefined ? { traceId: mint(16), spanId: mint(8), flags: DEFAULT_FLAGS } : {
+      traceId: inbound.traceId,
+      spanId: mint(8),
+      parentSpanId: inbound.spanId,
+      flags: inbound.flags,
+      ...state === null ? {} : { state }
+    };
+    req[TRACE] = trace;
+    if (expose)
+      req[EXPOSE] = true;
+    return trace;
+  }
+  static of(req) {
+    return req[TRACE];
+  }
+  static header(trace) {
+    return `00-${trace.traceId}-${trace.spanId}-${trace.flags}`;
+  }
+  static stamp(response, req) {
+    const traced = req;
+    const trace = traced[TRACE];
+    if (trace !== undefined && traced[EXPOSE] === true) {
+      response.headers.set(TRACERESPONSE_HEADER2, TraceContext2.header(trace));
+    }
+    return response;
+  }
+  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_HEADER2, TRACESTATE_HEADER2, TRACERESPONSE_HEADER2, TraceContext2 };

package/dist/client.js

@@ -1,16 +1,47 @@
 // @bun
 import {
-  FetchError,
-  FetchTransportError,
-  executeWithRetry,
-  isJsonBody,
-  safeStringify
-} from "./chunk-e8a9c6j2.js";
+  TRACEPARENT_HEADER2,
+  TRACESTATE_HEADER2,
+  TraceContext2
+} from "./chunk-gmtwad7f.js";
 import {
-  TRACEPARENT_HEADER,
-  TRACESTATE_HEADER,
-  TraceContext
-} from "./chunk-9x3evk19.js";
+  HttpStatusCode2
+} from "./chunk-bg0dr54z.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: "override 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/options.ts
 class HttpClientOptions {
   baseUrl;
@@ -51,6 +82,91 @@ import {
 // src/client/service.ts
 import { Logger, RequestContext } from "@dunx/core";
 import { UrlHelper } from "@arkv/shared";
+
+// 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 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 >= HttpStatusCode2.INTERNAL_SERVER_ERROR || status === HttpStatusCode2.REQUEST_TIMEOUT || status === HttpStatusCode2.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;
+};
+
+// src/client/service.ts
 class HttpService extends UrlHelper {
   options;
   logger;
@@ -214,12 +330,12 @@ class HttpService extends UrlHelper {
       ...serialised === "" ? {} : { "content-type": "application/json" },
       ...this.options.headers,
       ...typeof trace?.traceId === "string" && typeof trace.spanId === "string" ? {
-        [TRACEPARENT_HEADER]: TraceContext.header({
+        [TRACEPARENT_HEADER2]: TraceContext2.header({
           traceId: trace.traceId,
           spanId: trace.spanId,
           flags: typeof trace.traceFlags === "string" ? trace.traceFlags : "01"
         }),
-        ...typeof trace.traceState === "string" ? { [TRACESTATE_HEADER]: trace.traceState } : {}
+        ...typeof trace.traceState === "string" ? { [TRACESTATE_HEADER2]: trace.traceState } : {}
       } : {},
       ...config.headerFactory?.({
         timestamp: Math.floor(Date.now() / 1000),