@dunx/http 0.1.0

package/dist/index.js

@@ -0,0 +1,1427 @@
+// @bun
+// src/route/marker.ts
+var ROUTE = Symbol.for("dunx.route");
+var CONTROLLER = Symbol.for("dunx.controller");
+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/decorators.ts
+var Controller = (prefix = "") => (target) => {
+  markController(target, prefix);
+  return target;
+};
+var verb = (method) => (path = "/", options) => (value, _context) => {
+  markRoute(value, { method, path, options });
+  return value;
+};
+var Get = verb("GET");
+var Post = verb("POST");
+var Put = verb("PUT");
+var Patch = verb("PATCH");
+var Delete = verb("DELETE");
+// 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 Roles = (...roles) => meta(ROLES, roles);
+var Public = () => meta(PUBLIC, 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
+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;
+  const routes = [];
+  const seen = new Set;
+  for (let proto = Object.getPrototypeOf(instance);proto !== null && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+      if (name === "constructor" || seen.has(name))
+        continue;
+      const meta2 = routeMetaOf(descriptor.value);
+      if (!meta2)
+        continue;
+      seen.add(name);
+      const marked = descriptor.value;
+      routes.push({
+        method: meta2.method,
+        path: joinPath(prefix, meta2.path),
+        controller: klass.name,
+        handlerName: name,
+        handler: members[name].bind(instance),
+        options: meta2.options,
+        meta: mergeMeta(klass, marked),
+        guards: [...classGuards, ...guardsOf(marked)]
+      });
+    }
+  }
+  return routes;
+};
+// src/server/client-address.ts
+import { AppError } from "@dunx/core";
+var sources = new WeakMap;
+
+class ClientAddress {
+  of(req) {
+    const source = sources.get(this);
+    if (!source) {
+      throw new AppError("ClientAddress has no server yet. The address comes from the live Bun " + "server, so it is only available once listen() has run.");
+    }
+    if (source.trustProxy) {
+      const forwarded = req.headers.get("x-forwarded-for")?.split(",")[0]?.trim();
+      if (forwarded)
+        return forwarded;
+    }
+    return source.server.requestIP(req)?.address;
+  }
+}
+var attachAddressSource = (target, source) => {
+  sources.set(target, source);
+};
+// 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,
+    get: (key) => record.get(key.id)
+  });
+};
+// src/server/status.ts
+var HttpStatusCode = 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
+});
+
+// src/server/cors.ts
+var ORIGIN = "access-control-allow-origin";
+var allowedOrigin = (options, requested) => {
+  const origin = options.origin ?? "*";
+  if (typeof origin === "string") {
+    if (origin !== "*")
+      return origin === requested ? origin : undefined;
+    if (!options.credentials)
+      return "*";
+    return requested ?? undefined;
+  }
+  if (requested === null)
+    return;
+  const allowed = typeof origin === "function" ? origin(requested) : origin.includes(requested);
+  return allowed ? requested : undefined;
+};
+var applyCors = (options, req, response) => {
+  const origin = allowedOrigin(options, req.headers.get("origin"));
+  if (origin === undefined)
+    return response;
+  response.headers.set(ORIGIN, origin);
+  if (origin !== "*")
+    response.headers.append("vary", "Origin");
+  if (options.credentials) {
+    response.headers.set("access-control-allow-credentials", "true");
+  }
+  if (options.exposedHeaders?.length) {
+    response.headers.set("access-control-expose-headers", options.exposedHeaders.join(", "));
+  }
+  return response;
+};
+var withCors = (options, handler) => {
+  return async (req) => applyCors(options, req, await handler(req));
+};
+var preflight = (options, methods) => {
+  const allowMethods = (options.methods ?? methods).join(", ");
+  return async (req) => {
+    const response = applyCors(options, req, new Response(null, { status: HttpStatusCode.NO_CONTENT }));
+    if (!response.headers.has(ORIGIN))
+      return response;
+    response.headers.set("access-control-allow-methods", allowMethods);
+    const allowHeaders = options.allowedHeaders ?? (req.headers.get("access-control-request-headers") ?? "").split(",").map((header) => header.trim()).filter((header) => header.length > 0);
+    if (allowHeaders.length > 0) {
+      response.headers.set("access-control-allow-headers", allowHeaders.join(", "));
+    }
+    if (options.maxAge !== undefined) {
+      response.headers.set("access-control-max-age", String(options.maxAge));
+    }
+    return response;
+  };
+};
+// src/server/errors.ts
+import { AppError as AppError2 } from "@dunx/core";
+class HttpError extends AppError2 {
+  status;
+  name = "HttpError";
+  constructor(status, message, options) {
+    super(message, options);
+    this.status = status;
+  }
+}
+Object.defineProperty(HttpError, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "readonly status: number" }, { unresolved: "message: string" }, ErrorOptions]
+});
+
+class ValidationError extends HttpError {
+  source;
+  issues;
+  name = "ValidationError";
+  constructor(source, issues) {
+    super(HttpStatusCode.BAD_REQUEST, `Invalid ${source}`);
+    this.source = source;
+    this.issues = issues;
+  }
+}
+Object.defineProperty(ValidationError, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "readonly source: InputSource" }, { unresolved: "readonly issues: readonly ValidationIssue[]" }]
+});
+var defaultErrorMapper = (error) => {
+  if (error instanceof ValidationError) {
+    return Response.json({ error: error.message, status: error.status, issues: error.issues }, { status: error.status });
+  }
+  if (error instanceof HttpError) {
+    return Response.json({ error: error.message, status: error.status }, { status: error.status });
+  }
+  console.error(error);
+  return Response.json({
+    error: "Internal Server Error",
+    status: HttpStatusCode.INTERNAL_SERVER_ERROR
+  }, { status: HttpStatusCode.INTERNAL_SERVER_ERROR });
+};
+// src/server/factory.ts
+import {
+  collectModules,
+  AppError as AppError8,
+  AppFactory,
+  Logger as Logger3,
+  provide,
+  readControllers,
+  RequestContext as RequestContext2
+} from "@dunx/core";
+
+// src/ws/envelope.ts
+var encode = (event, data) => JSON.stringify({ event, data });
+var decode = (message) => {
+  if (typeof message !== "string")
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return;
+  const { event, data } = parsed;
+  return typeof event === "string" ? { event, data } : undefined;
+};
+
+// src/ws/runtime.ts
+import { AppError as AppError3 } from "@dunx/core";
+
+// 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/ws/runtime.ts
+var slotOf = (handler) => handler.kind === HandlerKind.MESSAGE && handler.event !== undefined ? `message ${JSON.stringify(handler.event)}` : handler.kind;
+var buildRuntime = (gateway) => {
+  if (gateway.handlers.length === 0) {
+    throw new AppError3(`${gateway.name} is registered as a gateway but declares no handlers. ` + "Add an @OnMessage/@OnOpen/... method, or drop the @Gateway decorator.");
+  }
+  const owners = new Map;
+  const events = new Map;
+  for (const handler of gateway.handlers) {
+    const slot = slotOf(handler);
+    const existing = owners.get(slot);
+    if (existing) {
+      throw new AppError3(`Handler collision in ${gateway.name}: ${slot} is claimed by ` + `${existing.method}() and by ${handler.method}(). One handler per event.`);
+    }
+    owners.set(slot, handler);
+    if (handler.kind === HandlerKind.MESSAGE && handler.event !== undefined) {
+      events.set(handler.event, handler.invoke);
+    }
+  }
+  const at = (slot) => owners.get(slot)?.invoke;
+  return {
+    name: gateway.name,
+    path: gateway.path,
+    upgrade: at(HandlerKind.UPGRADE),
+    open: at(HandlerKind.OPEN),
+    close: at(HandlerKind.CLOSE),
+    drain: at(HandlerKind.DRAIN),
+    ping: at(HandlerKind.PING),
+    pong: at(HandlerKind.PONG),
+    raw: at(HandlerKind.MESSAGE),
+    events
+  };
+};
+var buildGateways = (discovered) => {
+  const byPath = new Map;
+  for (const gateway of discovered) {
+    const existing = byPath.get(gateway.path);
+    if (existing) {
+      throw new AppError3(`Gateway path collision: ${gateway.path} is served by ${existing.name} ` + `and by ${gateway.name}. One gateway per path.`);
+    }
+    byPath.set(gateway.path, buildRuntime(gateway));
+  }
+  return byPath;
+};
+var someHandler = (gateways, pick) => {
+  for (const gateway of gateways)
+    if (pick(gateway) !== undefined)
+      return true;
+  return false;
+};
+
+// src/ws/adapter.ts
+var RUNTIME = Symbol.for("dunx.ws.runtime");
+var defaultOnError = (error, socket) => {
+  console.error(`[dunx/http] ${socket.data.path} handler failed:`, error);
+};
+var runtimeOf = (socket) => socket.data[RUNTIME];
+var isBinary = (value) => value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+var replyRaw = (socket, value) => {
+  if (value === undefined)
+    return;
+  socket.send(typeof value === "string" || isBinary(value) ? value : JSON.stringify(value));
+};
+var settle = (result, socket, onError, then) => {
+  if (result instanceof Promise) {
+    result.then((value) => {
+      if (!then)
+        return;
+      try {
+        then(value);
+      } catch (error) {
+        onError(error, socket);
+      }
+    }, (error) => onError(error, socket));
+    return;
+  }
+  if (then)
+    then(result);
+};
+var buildWebSocket = (discovered, options = {}) => {
+  const byPath = buildGateways(discovered);
+  const gateways = [...byPath.values()];
+  const onError = options.onError ?? defaultOnError;
+  const { onError: _onError, ...socketOptions } = options;
+  const run = (invoke, args, ws, then) => {
+    try {
+      settle(invoke(...args), ws, onError, then);
+    } catch (error) {
+      onError(error, ws);
+    }
+  };
+  const websocket = {
+    ...socketOptions,
+    message(ws, message) {
+      const gateway = runtimeOf(ws);
+      if (gateway.events.size > 0) {
+        const envelope = decode(message);
+        const handler = envelope && gateway.events.get(envelope.event);
+        if (envelope && handler) {
+          run(handler, [envelope.data, ws], ws, (value) => {
+            if (value !== undefined)
+              ws.send(encode(envelope.event, value));
+          });
+          return;
+        }
+      }
+      if (gateway.raw) {
+        run(gateway.raw, [message, ws], ws, (value) => replyRaw(ws, value));
+      }
+    },
+    ...someHandler(gateways, (g) => g.open) && {
+      open(ws) {
+        const { open } = runtimeOf(ws);
+        if (open)
+          run(open, [ws], ws, undefined);
+      }
+    },
+    ...someHandler(gateways, (g) => g.close) && {
+      close(ws, code, reason) {
+        const { close } = runtimeOf(ws);
+        if (close)
+          run(close, [ws, code, reason], ws, undefined);
+      }
+    },
+    ...someHandler(gateways, (g) => g.drain) && {
+      drain(ws) {
+        const { drain } = runtimeOf(ws);
+        if (drain)
+          run(drain, [ws], ws, undefined);
+      }
+    },
+    ...someHandler(gateways, (g) => g.ping) && {
+      ping(ws, data) {
+        const { ping } = runtimeOf(ws);
+        if (ping)
+          run(ping, [data, ws], ws, undefined);
+      }
+    },
+    ...someHandler(gateways, (g) => g.pong) && {
+      pong(ws, data) {
+        const { pong } = runtimeOf(ws);
+        if (pong)
+          run(pong, [data, ws], ws, undefined);
+      }
+    }
+  };
+  const accept = (req, server, gateway, context) => {
+    const data = { path: gateway.path, context, [RUNTIME]: gateway };
+    return server.upgrade(req, { data }) ? undefined : new Response("Expected a WebSocket upgrade", { status: 426 });
+  };
+  const upgradeHandler = (gateway) => (req, server) => {
+    if (!gateway.upgrade)
+      return accept(req, server, gateway, undefined);
+    const result = gateway.upgrade(req);
+    if (result instanceof Promise) {
+      return result.then((value) => value instanceof Response ? value : accept(req, server, gateway, value));
+    }
+    return result instanceof Response ? result : accept(req, server, gateway, result);
+  };
+  return {
+    websocket,
+    routes: new Map(gateways.map((gateway) => [gateway.path, upgradeHandler(gateway)])),
+    paths: [...byPath.keys()]
+  };
+};
+
+// src/ws/discover.ts
+import {
+  AppError as AppError4
+} from "@dunx/core";
+var normalizePath = (path) => {
+  const joined = `/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
+};
+var eachHandler = (start) => {
+  const found = [];
+  const seen = new Set;
+  for (let proto = start;proto !== null && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+      if (name === "constructor" || seen.has(name))
+        continue;
+      const meta2 = handlerMetaOf(descriptor.value);
+      if (!meta2)
+        continue;
+      seen.add(name);
+      found.push([name, meta2]);
+    }
+  }
+  return found;
+};
+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, meta2]) => ({
+      kind: meta2.kind,
+      event: meta2.event,
+      method: name,
+      invoke: members[name].bind(instance)
+    }))
+  };
+};
+var findHandlerMethod = (ctor) => eachHandler(ctor.prototype)[0]?.[0];
+var classOf = (entry) => {
+  if (typeof entry === "function")
+    return { token: entry, ctor: entry };
+  return entry.provider.kind === "class" ? { token: entry.token, ctor: entry.provider.ctor } : undefined;
+};
+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 AppError4(`${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;
+};
+
+// src/ws/pubsub.ts
+import { AppError as AppError5 } from "@dunx/core";
+
+// src/ws/relay.ts
+var DEFAULT_RELAY_CHANNEL = "dunx:ws";
+var defaultRelayError = (error, phase) => {
+  console.warn(`[dunx/http] the websocket relay could not ${phase}. Fan-out is local to ` + "this process until it recovers:", error);
+};
+var toBytes = (data) => ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
+var encodeRelay = (origin, topic, data) => typeof data === "string" ? JSON.stringify({ o: origin, t: topic, d: data }) : JSON.stringify({
+  o: origin,
+  t: topic,
+  d: Buffer.from(toBytes(data)).toString("base64"),
+  b: 1
+});
+var decodeRelay = (message) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return;
+  const { o, t, d, b } = parsed;
+  if (typeof o !== "string" || typeof t !== "string" || typeof d !== "string") {
+    return;
+  }
+  return { origin: o, topic: t, data: b ? Buffer.from(d, "base64") : d };
+};
+
+// src/ws/pubsub.ts
+class PubSub {
+  #origin = Bun.randomUUIDv7();
+  #server;
+  #relay;
+  #channel = DEFAULT_RELAY_CHANNEL;
+  #onRelayError = defaultRelayError;
+  #relayFailing = false;
+  #resubscribeTimer;
+  #resubscribeLeft = 0;
+  #resubscribeDelay = 0;
+  attach(server) {
+    this.#server = server;
+  }
+  get attached() {
+    return this.#server !== undefined;
+  }
+  get origin() {
+    return this.#origin;
+  }
+  get relaying() {
+    return this.#relay !== undefined;
+  }
+  async relayThrough(relay, options = {}) {
+    if (this.#relay) {
+      throw new AppError5("PubSub already relays. Two subscriptions on one channel would deliver " + "every relayed message twice \u2014 pass HttpOptions.relay or call " + "relayThrough(), not both.");
+    }
+    this.#relay = relay;
+    this.#channel = options.channel ?? DEFAULT_RELAY_CHANNEL;
+    this.#onRelayError = options.onError ?? defaultRelayError;
+    this.#resubscribeLeft = options.resubscribe?.attempts ?? 5;
+    this.#resubscribeDelay = options.resubscribe?.delayMs ?? 500;
+    await this.#trySubscribe();
+  }
+  async#trySubscribe() {
+    const relay = this.#relay;
+    if (!relay)
+      return;
+    try {
+      await relay.subscribe(this.#channel, (message) => {
+        this.#inbound(message);
+      });
+      this.#relayFailing = false;
+      this.#resubscribeLeft = 0;
+    } catch (error) {
+      this.#degrade(error, "subscribe");
+      this.#scheduleResubscribe();
+    }
+  }
+  #scheduleResubscribe() {
+    if (this.#resubscribeLeft <= 0 || this.#relay === undefined)
+      return;
+    this.#resubscribeLeft -= 1;
+    const delay = this.#resubscribeDelay;
+    this.#resubscribeDelay = Math.min(delay * 2, 30000);
+    this.#resubscribeTimer = setTimeout(() => {
+      this.#trySubscribe();
+    }, delay);
+    this.#resubscribeTimer.unref?.();
+  }
+  publish(topic, data, compress) {
+    const sent = this.#live().publish(topic, data, compress);
+    this.#outbound(topic, data);
+    return sent;
+  }
+  publishEvent(topic, event, data) {
+    return this.publish(topic, encode(event, data));
+  }
+  subscriberCount(topic) {
+    return this.#live().subscriberCount(topic);
+  }
+  async close() {
+    const relay = this.#relay;
+    this.#relay = undefined;
+    this.#resubscribeLeft = 0;
+    if (this.#resubscribeTimer !== undefined) {
+      clearTimeout(this.#resubscribeTimer);
+      this.#resubscribeTimer = undefined;
+    }
+    this.#server = undefined;
+    if (!relay?.close)
+      return;
+    try {
+      await relay.close();
+    } catch (error) {
+      this.#degrade(error, "close");
+    }
+  }
+  #outbound(topic, data) {
+    const relay = this.#relay;
+    if (!relay)
+      return;
+    try {
+      const result = relay.publish(this.#channel, encodeRelay(this.#origin, topic, data));
+      if (result instanceof Promise) {
+        result.then(() => {
+          this.#relayFailing = false;
+        }, (error) => {
+          this.#degrade(error, "publish");
+        });
+        return;
+      }
+      this.#relayFailing = false;
+    } catch (error) {
+      this.#degrade(error, "publish");
+    }
+  }
+  #inbound(message) {
+    const frame = decodeRelay(message);
+    if (!frame || frame.origin === this.#origin)
+      return;
+    this.#server?.publish(frame.topic, frame.data);
+  }
+  #degrade(error, phase) {
+    if (this.#relayFailing)
+      return;
+    this.#relayFailing = true;
+    this.#onRelayError(error, phase);
+  }
+  #live() {
+    if (!this.#server) {
+      throw new AppError5("PubSub has no server yet. Publish once the server is listening: " + "HttpApp.listen() is what attaches it.");
+    }
+    return this.#server;
+  }
+}
+
+// src/server/application.ts
+import {
+  AppError as AppError7,
+  Logger as Logger2
+} from "@dunx/core";
+
+// src/server/request-logging.ts
+import { Logger, RequestContext } from "@dunx/core";
+var REQUEST_ID_HEADER = "x-request-id";
+var parse = (text, limit) => {
+  if (limit === 0)
+    return;
+  if (text.length === 0)
+    return;
+  if (text.length > limit)
+    return `[${text.length} bytes]`;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var elapsedMs = (started) => Math.round((Bun.nanoseconds() - started) / 1e6);
+
+class RequestLoggingMiddleware {
+  logger;
+  context;
+  #limit;
+  #requestBody;
+  #responseBody;
+  #ignore;
+  constructor(logger, context, options = {}) {
+    this.logger = logger;
+    this.context = context;
+    this.#limit = options.maxBodyLength ?? 2048;
+    this.#requestBody = options.requestBody ?? false;
+    this.#responseBody = options.responseBody ?? false;
+    this.#ignore = new Set(options.ignore ?? []);
+  }
+  handle(req, ctx, next) {
+    const url = req.url;
+    const from = url.indexOf("/", url.indexOf("://") + 3);
+    const mark = from === -1 ? -1 : url.indexOf("?", from);
+    const path = from === -1 ? "/" : mark === -1 ? url.slice(from) : url.slice(from, mark);
+    if (this.#ignore.size > 0 && this.#ignore.has(path))
+      return next();
+    const started = Bun.nanoseconds();
+    const requestId = req.headers.get(REQUEST_ID_HEADER) ?? crypto.randomUUID();
+    return this.context.runWithContext({
+      requestId,
+      method: ctx.method,
+      event: path,
+      flow: "http",
+      context: `${ctx.controller}.${ctx.handler}`
+    }, () => {
+      const request = {};
+      if (mark !== -1) {
+        request["query"] = Object.fromEntries(new URLSearchParams(url.slice(mark + 1)));
+      }
+      const body = this.#body(req);
+      if (body === undefined) {
+        request["userAgent"] = req.headers.get("user-agent");
+        return this.#dispatch(req, path, requestId, started, request, next);
+      }
+      return body.then((value) => {
+        if (value !== undefined)
+          request["body"] = value;
+        request["userAgent"] = req.headers.get("user-agent");
+        return this.#dispatch(req, path, requestId, started, request, next);
+      });
+    });
+  }
+  #dispatch(req, path, requestId, started, request, next) {
+    let settled;
+    try {
+      settled = next();
+    } catch (error) {
+      this.#failed(req, path, started, request, error);
+      throw error;
+    }
+    return settled.then((response) => this.#succeeded(req, path, requestId, started, request, response), (error) => {
+      this.#failed(req, path, started, request, error);
+      throw error;
+    });
+  }
+  #failed(req, path, started, request, error) {
+    const status = error instanceof HttpError ? error.status : HttpStatusCode.INTERNAL_SERVER_ERROR;
+    const entry = {
+      request,
+      err: error,
+      statusCode: status,
+      elapsedMs: elapsedMs(started)
+    };
+    const line = `${req.method} ${path} ${status}`;
+    if (status < HttpStatusCode.INTERNAL_SERVER_ERROR) {
+      this.logger.warn(line, entry);
+    } else {
+      this.logger.error(line, entry);
+    }
+  }
+  #succeeded(req, path, requestId, started, request, response) {
+    const body = this.#responseFields(response);
+    if (body === undefined) {
+      this.logger.info(`${req.method} ${path} ${response.status}`, {
+        request,
+        statusCode: response.status,
+        elapsedMs: elapsedMs(started)
+      });
+      response.headers.set(REQUEST_ID_HEADER, requestId);
+      return response;
+    }
+    return body.then((value) => {
+      this.logger.info(`${req.method} ${path} ${response.status}`, {
+        request,
+        statusCode: response.status,
+        ...value === undefined ? {} : { responseBody: value },
+        elapsedMs: elapsedMs(started)
+      });
+      response.headers.set(REQUEST_ID_HEADER, requestId);
+      return response;
+    });
+  }
+  #body(req) {
+    if (!this.#requestBody)
+      return;
+    if (req.method === "GET" || req.method === "HEAD")
+      return;
+    if (!(req.headers.get("content-type") ?? "").includes("application/json")) {
+      return;
+    }
+    return req.clone().text().then((text) => parse(text, this.#limit));
+  }
+  #responseFields(response) {
+    if (!this.#responseBody)
+      return;
+    if (!(response.headers.get("content-type") ?? "").includes("application/json")) {
+      return;
+    }
+    return response.clone().text().then((text) => parse(text, this.#limit));
+  }
+}
+Object.defineProperty(RequestLoggingMiddleware, Symbol.for("dunx.deps"), {
+  value: () => [Logger, RequestContext, { unresolved: "options: RequestLoggingOptions = {}" }]
+});
+
+// src/server/routes.ts
+import { AppError as AppError6 } from "@dunx/core";
+
+// src/server/input.ts
+var grouped = (entries) => {
+  const collected = {};
+  entries.forEach((value, key) => {
+    const existing = collected[key];
+    if (existing === undefined)
+      collected[key] = value;
+    else if (Array.isArray(existing))
+      existing.push(value);
+    else
+      collected[key] = [existing, value];
+  });
+  return collected;
+};
+var asJson = (req) => req.json();
+var asUrlEncoded = async (req) => grouped(new URLSearchParams(await req.text()));
+var asMultipart = async (req) => grouped(await req.formData());
+var asText = (req) => req.text();
+var parserFor = (media) => {
+  if (media === "application/json" || media.endsWith("+json"))
+    return asJson;
+  if (media === "application/x-www-form-urlencoded")
+    return asUrlEncoded;
+  if (media === "multipart/form-data")
+    return asMultipart;
+  if (media.startsWith("text/"))
+    return asText;
+  return;
+};
+var JSON_MEDIA = "application/json";
+var mediaTypeOf = (req) => {
+  const header = req.headers.get("content-type");
+  if (header === JSON_MEDIA || header === null)
+    return JSON_MEDIA;
+  const end = header.indexOf(";");
+  const media = (end === -1 ? header : header.slice(0, end)).trim();
+  return media === "" ? JSON_MEDIA : media.toLowerCase();
+};
+var flatten = (issue) => {
+  const path = issue.path?.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+  return path === undefined || path === "" ? { message: issue.message } : { message: issue.message, path };
+};
+var accept = (source, result) => {
+  if (result.issues !== undefined) {
+    throw new ValidationError(source, result.issues.map(flatten));
+  }
+  return result.value;
+};
+var fillWith = (draft, source, schema, value) => {
+  const result = schema["~standard"].validate(value);
+  if (result instanceof Promise) {
+    return result.then((settled) => {
+      draft[source] = accept(source, settled);
+      return draft;
+    });
+  }
+  draft[source] = accept(source, result);
+  return draft;
+};
+var bodyFill = (schema) => (draft) => {
+  const media = mediaTypeOf(draft.req);
+  const parse2 = parserFor(media);
+  if (parse2 === undefined) {
+    throw new HttpError(HttpStatusCode.UNSUPPORTED_MEDIA_TYPE, `Unsupported content type "${media}". Declared bodies accept ` + "application/json, application/x-www-form-urlencoded, multipart/form-data or text/*.");
+  }
+  return parse2(draft.req).then((value) => fillWith(draft, "body", schema, value), (error) => {
+    throw new HttpError(HttpStatusCode.BAD_REQUEST, `Malformed ${media} body`, { cause: error });
+  });
+};
+var searchOf = (url) => {
+  const start = url.indexOf("?");
+  if (start === -1)
+    return "";
+  const end = url.indexOf("#", start + 1);
+  return end === -1 ? url.slice(start + 1) : url.slice(start + 1, end);
+};
+var queryFill = (schema) => (draft) => {
+  const params = new URLSearchParams(searchOf(draft.req.url));
+  return fillWith(draft, "query", schema, grouped(params));
+};
+var paramsFill = (schema) => (draft) => fillWith(draft, "params", schema, draft.req.params);
+var then = (first, second) => (draft) => {
+  const started = first(draft);
+  return started instanceof Promise ? started.then(second) : second(started);
+};
+var buildInputReader = (options) => {
+  const fills = [];
+  if (options?.body !== undefined)
+    fills.push(bodyFill(options.body));
+  if (options?.query !== undefined)
+    fills.push(queryFill(options.query));
+  if (options?.params !== undefined)
+    fills.push(paramsFill(options.params));
+  if (fills.length === 0)
+    return (req) => ({ req });
+  const fill = fills.reduce(then);
+  return (req) => fill({ req });
+};
+
+// src/server/middleware.ts
+var compose = (middleware, ctx, handler) => middleware.reduceRight((next, current) => (req) => current.handle(req, ctx, () => next(req)), handler);
+
+// src/server/routes.ts
+var construct = (guard) => new guard;
+var toResponse = (value, status) => {
+  if (value instanceof Response)
+    return value;
+  if (value === undefined || value === null) {
+    return new Response(null, { status: HttpStatusCode.NO_CONTENT });
+  }
+  return Response.json(value, { status });
+};
+var statusFor = (route) => route.options?.status ?? (route.method === "POST" ? HttpStatusCode.CREATED : HttpStatusCode.OK);
+var assertNoCollisions = (discovered) => {
+  const owners = new Map;
+  for (const route of discovered) {
+    const key = `${route.method} ${route.path}`;
+    const owner = `${route.controller}.${route.handlerName}`;
+    const existing = owners.get(key);
+    if (existing !== undefined) {
+      throw new AppError6(`Route collision: ${key} is declared by ${existing} and by ${owner}. ` + "Bun would keep only one of them.");
+    }
+    owners.set(key, owner);
+  }
+};
+var assertNoGatewayCollisions = (discovered, gatewayPaths) => {
+  const gateways = new Set(gatewayPaths);
+  for (const route of discovered) {
+    if (gateways.has(route.path)) {
+      throw new AppError6(`Gateway path collision: ${route.path} is served by a gateway and by ` + `${route.controller}.${route.handlerName}(). The upgrade is a route too, ` + "so one of them would be dropped.");
+    }
+  }
+};
+var withUpgradeRoutes = (routes, gateways) => {
+  const merged = { ...routes };
+  for (const [path, upgrade] of gateways)
+    merged[path] = { GET: upgrade };
+  return merged;
+};
+var unmatchedContext = (req) => Object.freeze({
+  controller: "(unmatched)",
+  handler: "(none)",
+  method: req.method,
+  path: new URL(req.url).pathname,
+  get: () => {
+    return;
+  }
+});
+var buildFallback = (middleware = [], onError = defaultErrorMapper, cors) => {
+  const miss = () => {
+    throw new HttpError(HttpStatusCode.NOT_FOUND, "NOT_FOUND");
+  };
+  const run = async (req) => {
+    try {
+      return await compose(middleware, unmatchedContext(req), miss)(req);
+    } catch (error) {
+      return onError(error, req);
+    }
+  };
+  return cors ? withCors(cors, run) : run;
+};
+var directOr = (guarded, route, read, status, onError, noMiddleware) => {
+  if (!noMiddleware)
+    return guarded;
+  const settle2 = (value, req) => {
+    try {
+      return toResponse(value, status);
+    } catch (error) {
+      return onError(error, req);
+    }
+  };
+  const invoke = (input, req) => {
+    try {
+      const value = route.handler(input);
+      return value instanceof Promise ? value.then((resolved) => settle2(resolved, req), (error) => onError(error, req)) : settle2(value, req);
+    } catch (error) {
+      return onError(error, req);
+    }
+  };
+  return (req) => {
+    try {
+      const input = read(req);
+      return input instanceof Promise ? input.then((resolved) => invoke(resolved, req), (error) => onError(error, req)) : invoke(input, req);
+    } catch (error) {
+      return onError(error, req);
+    }
+  };
+};
+var buildRoutes = (discovered, middleware = [], onError = defaultErrorMapper, cors, resolve = construct) => {
+  assertNoCollisions(discovered);
+  const routes = {};
+  const instances = new Map;
+  const guardOf = (guard) => {
+    const existing = instances.get(guard);
+    if (existing)
+      return existing;
+    const created = resolve(guard);
+    instances.set(guard, created);
+    return created;
+  };
+  for (const route of discovered) {
+    const read = buildInputReader(route.options);
+    const status = statusFor(route);
+    const chain = [...middleware, ...(route.guards ?? []).map(guardOf)];
+    const chained = compose(chain, buildContext(route), async (req) => toResponse(await route.handler(await read(req)), status));
+    const guarded = async (req) => {
+      try {
+        return await chained(req);
+      } catch (error) {
+        return onError(error, req);
+      }
+    };
+    const byMethod = routes[route.path] ??= {};
+    byMethod[route.method] = cors ? withCors(cors, guarded) : directOr(guarded, route, read, status, onError, chain.length === 0);
+  }
+  if (cors) {
+    for (const byMethod of Object.values(routes)) {
+      byMethod.OPTIONS = preflight(cors, Object.keys(byMethod));
+    }
+  }
+  return routes;
+};
+
+// src/server/settings.ts
+var defaultSettings = () => ({ "trust proxy": false });
+
+// src/server/application.ts
+class HttpApplication {
+  closed;
+  gatewayPaths;
+  #app;
+  #discovered;
+  #middleware;
+  #settings = defaultSettings();
+  #onError;
+  #port;
+  #websocket;
+  #relay;
+  #relayChannel;
+  #globalPrefix = "";
+  #cors;
+  #started = false;
+  #server;
+  #resolveClosed;
+  #shuttingDown;
+  #hooked = false;
+  constructor(app, discovered, options, websocket) {
+    this.#app = app;
+    this.#discovered = discovered;
+    this.#middleware = [
+      ...options.requestLogging === false ? [] : [RequestLoggingMiddleware],
+      ...options.middleware ?? []
+    ];
+    this.#onError = options.onError ?? defaultErrorMapper;
+    this.#port = options.port ?? 3000;
+    this.#websocket = websocket;
+    this.#relay = options.relay;
+    this.#relayChannel = options.relayChannel;
+    this.gatewayPaths = websocket?.paths ?? [];
+    this.closed = new Promise((resolve) => {
+      this.#resolveClosed = resolve;
+    });
+  }
+  get(token) {
+    return this.#app.get(token);
+  }
+  setGlobalPrefix(prefix) {
+    this.#assertNotStarted("setGlobalPrefix()");
+    this.#globalPrefix = prefix;
+    return this;
+  }
+  use(...middleware) {
+    this.#assertNotStarted("use()");
+    this.#middleware.push(...middleware);
+    return this;
+  }
+  set(key, value) {
+    this.#assertNotStarted("set()");
+    this.#settings[key] = value;
+    return this;
+  }
+  setting(key) {
+    return this.#settings[key];
+  }
+  enableCors(options = {}) {
+    this.#assertNotStarted("enableCors()");
+    this.#cors = options;
+    return this;
+  }
+  clientIp(req) {
+    return this.#app.get(ClientAddress).of(req);
+  }
+  async listen(port = this.#port) {
+    this.#assertNotStarted("listen()");
+    this.#started = true;
+    const middleware = this.#middleware.map((entry) => this.#app.get(entry));
+    const prefixed = this.#prefixed();
+    const routes = buildRoutes(prefixed, middleware, this.#onError, this.#cors, (guard) => this.#app.get(guard));
+    const ws = this.#websocket;
+    if (ws)
+      assertNoGatewayCollisions(prefixed, ws.paths);
+    const fetch = buildFallback(middleware, this.#onError, this.#cors);
+    const options = ws ? {
+      port,
+      fetch,
+      routes: withUpgradeRoutes(routes, ws.routes),
+      websocket: ws.websocket
+    } : { port, fetch, routes };
+    this.#server = Bun.serve(options);
+    attachAddressSource(this.#app.get(ClientAddress), {
+      server: this.#server,
+      trustProxy: this.#settings["trust proxy"]
+    });
+    const pubsub = this.#app.get(PubSub);
+    pubsub.attach(this.#server);
+    if (this.#relay) {
+      const logger = this.#app.get(Logger2);
+      await pubsub.relayThrough(this.#relay, {
+        ...this.#relayChannel !== undefined && {
+          channel: this.#relayChannel
+        },
+        onError: (error, phase) => {
+          logger.warn(`the websocket relay could not ${phase}. Fan-out is local to this ` + "process until it recovers.", { error });
+        }
+      });
+    }
+    return this.#server.url.href;
+  }
+  async shutdown() {
+    this.#shuttingDown ??= (async () => {
+      await this.#server?.stop(this.#websocket !== undefined);
+      this.#server = undefined;
+      await this.#app.get(PubSub).close();
+      await this.#app.shutdown();
+      this.#resolveClosed?.();
+    })();
+    return this.#shuttingDown;
+  }
+  enableShutdownHooks(signals = ["SIGTERM", "SIGINT"]) {
+    if (this.#hooked)
+      return this;
+    this.#hooked = true;
+    for (const signal of signals) {
+      process.once(signal, () => void this.shutdown());
+    }
+    return this;
+  }
+  #prefixed() {
+    if (this.#globalPrefix === "")
+      return this.#discovered;
+    return this.#discovered.map((route) => ({
+      ...route,
+      path: joinPath(this.#globalPrefix, route.path)
+    }));
+  }
+  #assertNotStarted(hook) {
+    if (!this.#started)
+      return;
+    throw new AppError7(`${hook} must be called before listen(). The route table and the middleware ` + "chain are folded into one closure per route when the server binds, so " + "this call could not take effect.");
+  }
+}
+Object.defineProperty(HttpApplication, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "app: App" }, { unresolved: "discovered: readonly DiscoveredRoute[]" }, { unresolved: "options: HttpOptions" }, { unresolved: "websocket?: WebSocketRuntime" }]
+});
+
+// src/server/factory.ts
+class HttpModule {
+}
+
+class HttpFactory {
+  static async create(root, options = {}) {
+    const logging = provide(RequestLoggingMiddleware, {
+      useFactory: (logger, context) => new RequestLoggingMiddleware(logger, context, typeof options.requestLogging === "object" ? options.requestLogging : {}),
+      inject: [Logger3, RequestContext2]
+    });
+    const scope = {
+      module: HttpModule,
+      imports: [root],
+      providers: options.requestLogging === false ? [PubSub] : [PubSub, logging]
+    };
+    const app = await AppFactory.create(scope, options.overrides ? { overrides: options.overrides } : {});
+    const modules = collectModules(scope);
+    const discovered = [];
+    for (const module of modules) {
+      for (const controller of readControllers(module)) {
+        const routes = discoverRoutes(app.get(controller));
+        if (routes.length === 0) {
+          throw new AppError8(`${controller.name} is registered as a controller but declares no routes. ` + "Add a @Get/@Post/... method, or move it to providers.");
+        }
+        discovered.push(...routes);
+      }
+    }
+    assertNoCollisions(discovered);
+    const gateways = discoverGateways(modules, (token) => app.get(token));
+    const websocket = gateways.length > 0 ? buildWebSocket(gateways, options.websocket) : undefined;
+    return new HttpApplication(app, discovered, options, websocket);
+  }
+}
+// src/ws/decorators.ts
+var Gateway = (path = "/") => (target) => {
+  markGateway(target, path);
+  return target;
+};
+var lifecycle = (kind) => () => (value) => {
+  markHandler(value, { kind, event: undefined });
+  return value;
+};
+var OnUpgrade = lifecycle(HandlerKind.UPGRADE);
+var OnOpen = lifecycle(HandlerKind.OPEN);
+var OnClose = lifecycle(HandlerKind.CLOSE);
+var OnDrain = lifecycle(HandlerKind.DRAIN);
+var OnPing = lifecycle(HandlerKind.PING);
+var OnPong = lifecycle(HandlerKind.PONG);
+var OnMessage = (event) => (value) => {
+  markHandler(value, { kind: HandlerKind.MESSAGE, event });
+  return value;
+};
+// src/ws/redis-relay.ts
+import { AppError as AppError9 } from "@dunx/core";
+var PROTOCOLS = [
+  "redis:",
+  "rediss:",
+  "valkey:",
+  "valkeys:",
+  "redis+tls:",
+  "redis+unix:",
+  "redis+tls+unix:"
+];
+var defaultRelayUrl = () => process.env["VALKEY_URL"] ?? process.env["REDIS_URL"] ?? "redis://localhost:6379";
+var assertUrl = (url) => {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new AppError9(`${JSON.stringify(url)} is not a valid URL for the websocket relay. ` + "Expected something like redis://localhost:6379.");
+  }
+  if (!PROTOCOLS.includes(parsed.protocol)) {
+    throw new AppError9(`Unsupported protocol ${JSON.stringify(parsed.protocol)} in ` + `${JSON.stringify(url)}. Expected one of ${PROTOCOLS.join(", ")}.`);
+  }
+  return url;
+};
+
+class RedisRelay {
+  #url;
+  #options;
+  #pub;
+  #sub;
+  #channel;
+  constructor(options = {}) {
+    this.#url = assertUrl(options.url ?? defaultRelayUrl());
+    this.#options = {
+      maxRetries: options.maxRetries ?? 0,
+      ...options.connectionTimeout !== undefined && {
+        connectionTimeout: options.connectionTimeout
+      },
+      ...options.tls !== undefined && { tls: options.tls }
+    };
+  }
+  get url() {
+    const parsed = new URL(this.#url);
+    if (parsed.password)
+      parsed.password = "***";
+    return parsed.toString();
+  }
+  async publish(channel, message) {
+    const client = this.#pub ??= new Bun.RedisClient(this.#url, this.#options);
+    try {
+      return await client.publish(channel, message);
+    } catch (error) {
+      if (this.#pub === client) {
+        this.#pub = undefined;
+        client.close();
+      }
+      throw error;
+    }
+  }
+  async subscribe(channel, listener) {
+    const client = this.#sub ??= new Bun.RedisClient(this.#url, this.#options);
+    try {
+      await client.connect();
+      await client.subscribe(channel, listener);
+      this.#channel = channel;
+    } catch (error) {
+      if (this.#sub === client) {
+        this.#sub = undefined;
+        client.close();
+      }
+      throw error;
+    }
+  }
+  async close() {
+    const sub = this.#sub;
+    const channel = this.#channel;
+    this.#pub?.close();
+    this.#pub = undefined;
+    this.#sub = undefined;
+    this.#channel = undefined;
+    if (!sub)
+      return;
+    if (channel !== undefined) {
+      try {
+        await sub.unsubscribe(channel);
+      } catch {}
+    }
+    sub.close();
+  }
+}
+Object.defineProperty(RedisRelay, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "options: RedisRelayOptions = {}" }]
+});
+export {
+  withUpgradeRoutes,
+  withCors,
+  preflight,
+  normalizePath,
+  metaOf,
+  metaKey,
+  meta,
+  mergeMeta,
+  joinPath,
+  guardsOf,
+  encodeRelay,
+  encode,
+  discoverRoutes,
+  discoverGateways,
+  discoverGateway,
+  defaultRelayUrl,
+  defaultErrorMapper,
+  decodeRelay,
+  decode,
+  compose,
+  buildWebSocket,
+  buildRuntime,
+  buildRoutes,
+  buildGateways,
+  buildContext,
+  assertNoGatewayCollisions,
+  assertNoCollisions,
+  ValidationError,
+  UseGuards,
+  Roles,
+  RequestLoggingMiddleware,
+  RedisRelay,
+  ROLES,
+  REQUEST_ID_HEADER,
+  Put,
+  Public,
+  PubSub,
+  Post,
+  Patch,
+  PUBLIC,
+  OnUpgrade,
+  OnPong,
+  OnPing,
+  OnOpen,
+  OnMessage,
+  OnDrain,
+  OnClose,
+  HttpStatusCode,
+  HttpFactory,
+  HttpError,
+  HandlerKind,
+  Get,
+  Gateway,
+  Delete,
+  DEFAULT_RELAY_CHANNEL,
+  Controller,
+  ClientAddress
+};
+
+//# debugId=B2F007DAD14DC76D64756E2164756E21
+//# sourceMappingURL=index.js.map