@dunx/http 3.2.0 → 3.2.1

package/dist/chunk-3j2n1n11.js

@@ -0,0 +1,71 @@
+// @bun
+// src/server/trace-context.ts
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var TRACERESPONSE_HEADER = "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 TraceContext {
+  static adopt(req, expose = true) {
+    const inbound = TraceContext.#parse(req.headers.get(TRACEPARENT_HEADER));
+    const state = req.headers.get(TRACESTATE_HEADER);
+    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_HEADER, TraceContext.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_HEADER, TRACESTATE_HEADER, TRACERESPONSE_HEADER, TraceContext };

package/dist/chunk-3nbj06q8.js

@@ -0,0 +1,174 @@
+// @bun
+import {
+  HttpStatusCode
+} from "./chunk-sz4pvqxy.js";
+
+// src/route/marker.ts
+var ROUTE = Symbol.for("dunx.route");
+var CONTROLLER = Symbol.for("dunx.controller");
+var defaultStatusFor = (method) => method === "POST" ? HttpStatusCode.CREATED : HttpStatusCode.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 metaKey = (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 meta = (key, value) => (target) => {
+  write(target, key, value);
+  return target;
+};
+var ROLES = metaKey("roles");
+var PUBLIC = metaKey("public");
+var HIDDEN = metaKey("hidden");
+var UNMATCHED = metaKey("unmatched");
+var Roles = (...roles) => meta(ROLES, roles);
+var Public = () => meta(PUBLIC, true);
+var ApiHidden = () => meta(HIDDEN, true);
+var UseGuards = (...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 metaOf = (target) => target[META];
+var mergeMeta = (...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 joinPath = (prefix, path) => {
+  const joined = `/${prefix}/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
+};
+var discoverRoutes = (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: meta2, value: marked }) => ({
+    method: meta2.method,
+    path: joinPath(prefix, resolvePath(meta2.path)),
+    controller: klass.name,
+    handlerName: name,
+    handler: members[name].bind(instance),
+    options: meta2.options,
+    meta: mergeMeta(klass, marked),
+    classMeta: metaOf(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, meta2) => {
+  Object.defineProperty(target, HANDLER, { value: meta2, 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 isGateway = (target) => target[GATEWAY] !== undefined;
+
+// src/server/context.ts
+var EMPTY = new Map;
+var buildContext = (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: meta2 }) => ({
+      kind: meta2.kind,
+      event: meta2.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 (isGateway(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 { defaultStatusFor, markRoute, markController, metaKey, meta, ROLES, PUBLIC, HIDDEN, UNMATCHED, Roles, Public, ApiHidden, UseGuards, metaOf, mergeMeta, joinPath, discoverRoutes, HandlerKind, markHandler, markGateway, isGateway, discoverGateway, discoverGateways, buildContext };

package/dist/{chunk-9x3evk19.js → chunk-sz4pvqxy.js}

@@ -105,73 +105,4 @@ var HttpStatusCode = Object.freeze({
   GATEWAY_TIMEOUT: 504
 });
 
-// src/server/trace-context.ts
-var TRACEPARENT_HEADER = "traceparent";
-var TRACESTATE_HEADER = "tracestate";
-var TRACERESPONSE_HEADER = "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 TraceContext {
-  static adopt(req, expose = true) {
-    const inbound = TraceContext.#parse(req.headers.get(TRACEPARENT_HEADER));
-    const state = req.headers.get(TRACESTATE_HEADER);
-    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_HEADER, TraceContext.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 { __privateGet, __privateAdd, __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, HttpStatusCode, TRACEPARENT_HEADER, TRACESTATE_HEADER, TRACERESPONSE_HEADER, TraceContext };
+export { __privateGet, __privateAdd, __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, HttpStatusCode };

package/dist/client.js

@@ -1,16 +1,47 @@
 // @bun
-import {
-  FetchError,
-  FetchTransportError,
-  executeWithRetry,
-  isJsonBody,
-  safeStringify
-} from "./chunk-e8a9c6j2.js";
 import {
   TRACEPARENT_HEADER,
   TRACESTATE_HEADER,
   TraceContext
-} from "./chunk-9x3evk19.js";
+} from "./chunk-3j2n1n11.js";
+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: "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 >= 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;
+};
+
+// src/client/service.ts
 class HttpService extends UrlHelper {
   options;
   logger;