@dunx/http 2.0.0 → 2.1.0

package/dist/index.js

@@ -4,8 +4,10 @@ import {
   __decorateElement,
   __decoratorMetadata,
   __decoratorStart,
+  __privateAdd,
+  __privateGet,
   __runInitializers
-} from "./chunk-5z96f3gr.js";
+} from "./chunk-sz4pvqxy.js";
 
 // src/route/marker.ts
 var ROUTE = Symbol.for("dunx.route");
@@ -37,6 +39,9 @@ var Post = verb("POST");
 var Put = verb("PUT");
 var Patch = verb("PATCH");
 var Delete = verb("DELETE");
+// src/route/discover.ts
+import { markedMethods } from "@dunx/core";
+
 // src/route/metadata.ts
 var META = Symbol.for("dunx.meta");
 var GUARDS = Symbol.for("dunx.guards");
@@ -92,31 +97,17 @@ var discoverRoutes = (instance) => {
   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, 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)]
-      });
-    }
-  }
-  return routes;
+  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/inspect.ts
 import {
@@ -127,7 +118,9 @@ import {
 
 // src/ws/discover.ts
 import {
-  AppError
+  AppError,
+  classOf,
+  markedMethods as markedMethods2
 } from "@dunx/core";
 
 // src/ws/marker.ts
@@ -157,29 +150,14 @@ 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 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, meta2]) => ({
+    handlers: eachHandler(Object.getPrototypeOf(instance)).map(({ name, meta: meta2 }) => ({
       kind: meta2.kind,
       event: meta2.event,
       method: name,
@@ -187,12 +165,7 @@ var discoverGateway = (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 findHandlerMethod = (ctor) => eachHandler(ctor.prototype)[0]?.name;
 var discoverGateways = (modules, resolve) => {
   const discovered = [];
   for (const module of modules) {
@@ -271,6 +244,13 @@ var classOf2 = (entry) => {
 var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map(classOf2).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
 // src/server/client-address.ts
 import { AppError as AppError2 } from "@dunx/core";
+var trustedHops = (setting) => {
+  if (setting === true)
+    return 1;
+  if (setting === false)
+    return 0;
+  return Number.isFinite(setting) ? Math.max(0, Math.trunc(setting)) : 0;
+};
 var sources = new WeakMap;
 
 class ClientAddress {
@@ -279,10 +259,12 @@ class ClientAddress {
     if (!source) {
       throw new AppError2("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;
+    const hops = trustedHops(source.trustProxy);
+    if (hops > 0) {
+      const entries = (req.headers.get("x-forwarded-for") ?? "").split(",").map((entry2) => entry2.trim()).filter((entry2) => entry2.length > 0);
+      const entry = entries[Math.max(0, entries.length - hops)];
+      if (entry)
+        return entry;
     }
     return source.server.requestIP(req)?.address;
   }
@@ -761,6 +743,7 @@ class PubSub {
 import {
   AppError as AppError7,
   Logger as Logger2,
+  runtimeInfo,
   ShutdownHooks
 } from "@dunx/core";
 
@@ -1305,6 +1288,7 @@ class HttpApplication {
       ...gateways.length === 0 ? [] : [`${gateways.length} gateway(s)`]
     ].join(" and ");
     this.#app.get(Logger2).info(`Serving ${subject}`, {
+      ...runtimeInfo(),
       routes: routes.map((route) => `${route.method} ${route.path}`),
       ...gateways.length === 0 ? {} : {
         gateways: gateways.map((gateway) => ({
@@ -1315,8 +1299,12 @@ class HttpApplication {
       }
     });
   }
+  drain() {
+    return this.#app.drain();
+  }
   async shutdown() {
     this.#shuttingDown ??= (async () => {
+      await this.#app.drain();
       await this.#server?.stop(this.#websocket !== undefined);
       this.#server = undefined;
       await this.#app.get(PubSub).close();
@@ -1626,6 +1614,355 @@ class RedisRelay {
 Object.defineProperty(RedisRelay, Symbol.for("dunx.deps"), {
   value: () => [{ unresolved: "options: RedisRelayOptions = {}" }]
 });
+// src/health/contracts.ts
+class HealthIndicator {
+  critical = true;
+}
+
+class PingProbe {
+}
+
+class QueryProbe {
+}
+// src/health/controller.ts
+import { inject } from "@dunx/core";
+
+// src/health/registry.ts
+var bounded = async (indicator, timeoutMs) => {
+  let timer;
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2({ state: "unknown", detail: `no answer in ${timeoutMs} ms` }), timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => indicator.check()).catch((error) => ({
+        state: "down",
+        detail: error instanceof Error ? error.message : String(error)
+      })),
+      timeout
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+};
+var worst = (checks) => {
+  const critical = checks.filter((check) => check.critical);
+  if (critical.some((check) => check.state === "down"))
+    return "down";
+  if (critical.some((check) => check.state === "unknown"))
+    return "unknown";
+  return "up";
+};
+
+class HealthOptions {
+  liveness;
+  readiness;
+  timeoutMs;
+  routes;
+  drainDelayMs;
+  constructor(init = {}) {
+    this.liveness = init.liveness ?? [];
+    this.readiness = init.readiness ?? [];
+    this.timeoutMs = init.timeoutMs ?? 2000;
+    this.routes = init.routes ?? true;
+    this.drainDelayMs = Math.max(0, init.drainDelayMs ?? 0);
+  }
+}
+Object.defineProperty(HealthOptions, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "init: HealthOptionsInit = {}" }]
+});
+
+class HealthRegistry {
+  options;
+  readiness_;
+  #startedAt = Date.now();
+  constructor(options, readiness_) {
+    this.options = options;
+    this.readiness_ = readiness_;
+  }
+  async report(indicators) {
+    const checks = await Promise.all(indicators.map(async (indicator) => {
+      const started = performance.now();
+      const result = await bounded(indicator, this.options.timeoutMs);
+      return {
+        name: indicator.name,
+        state: result.state,
+        critical: indicator.critical,
+        ms: Math.round(performance.now() - started),
+        ...result.detail === undefined ? {} : { detail: result.detail }
+      };
+    }));
+    return {
+      status: worst(checks),
+      draining: this.readiness_.draining,
+      uptimeMs: Date.now() - this.#startedAt,
+      checks
+    };
+  }
+  liveness() {
+    return this.report(this.options.liveness);
+  }
+  async readiness() {
+    const report = await this.report(this.options.readiness);
+    if (!this.readiness_.draining)
+      return report;
+    return {
+      ...report,
+      status: "down",
+      checks: [
+        {
+          name: "readiness",
+          state: "down",
+          critical: true,
+          ms: 0,
+          detail: this.readiness_.reason ?? "not accepting traffic"
+        },
+        ...report.checks
+      ]
+    };
+  }
+}
+Object.defineProperty(HealthRegistry, Symbol.for("dunx.deps"), {
+  value: () => [HealthOptions, { unresolved: "private readonly readiness_: Readiness", typeOnly: "Readiness" }]
+});
+
+// src/health/controller.ts
+var answer = (report) => Response.json(report, { status: report.status === "up" ? 200 : 503 });
+var _dec = [
+  Controller("health"),
+  ApiHidden()
+];
+var _dec2 = [
+  Public(),
+  Get("/live")
+];
+var _dec3 = [
+  Public(),
+  Get("/ready")
+];
+var _health = new WeakMap;
+var _init = __decoratorStart(undefined);
+
+class HealthController {
+  constructor() {
+    __privateAdd(this, _health, inject(HealthRegistry));
+    __runInitializers(_init, 5, this);
+  }
+  async live() {
+    return answer(await __privateGet(this, _health).liveness());
+  }
+  async ready() {
+    return answer(await __privateGet(this, _health).readiness());
+  }
+}
+__decorateElement(_init, 1, "live", _dec2, HealthController);
+__decorateElement(_init, 1, "ready", _dec3, HealthController);
+HealthController = __decorateElement(_init, 0, "HealthController", _dec, HealthController);
+__runInitializers(_init, 1, HealthController);
+__decoratorMetadata(_init, HealthController);
+let _HealthController = HealthController;
+// src/health/indicators.ts
+import { statfs } from "fs/promises";
+var ms = (started) => Math.round(performance.now() - started);
+
+class RedisIndicator extends HealthIndicator {
+  redis;
+  name = "redis";
+  constructor(redis) {
+    super();
+    this.redis = redis;
+  }
+  async check() {
+    const started = performance.now();
+    await this.redis.ping();
+    return { state: "up", detail: `${ms(started)} ms` };
+  }
+}
+Object.defineProperty(RedisIndicator, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "private readonly redis: PingProbe", typeOnly: "PingProbe" }]
+});
+
+class DatabaseIndicator extends HealthIndicator {
+  db;
+  name = "database";
+  constructor(db) {
+    super();
+    this.db = db;
+  }
+  async check() {
+    const started = performance.now();
+    await this.db.ping();
+    return { state: "up", detail: `${ms(started)} ms` };
+  }
+}
+Object.defineProperty(DatabaseIndicator, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "private readonly db: QueryProbe", typeOnly: "QueryProbe" }]
+});
+
+class MemoryOptions {
+  maxRssBytes;
+  constructor(init) {
+    this.maxRssBytes = init.maxRssBytes;
+  }
+}
+Object.defineProperty(MemoryOptions, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "init: MemoryOptionsInit" }]
+});
+var MIB = 1024 * 1024;
+var mib = (bytes) => `${Math.round(bytes / MIB)} MiB`;
+
+class MemoryIndicator extends HealthIndicator {
+  options;
+  name = "memory";
+  critical = false;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  check() {
+    const { rss } = process.memoryUsage();
+    const detail = `${mib(rss)} of ${mib(this.options.maxRssBytes)}`;
+    return rss > this.options.maxRssBytes ? { state: "down", detail } : { state: "up", detail };
+  }
+}
+Object.defineProperty(MemoryIndicator, Symbol.for("dunx.deps"), {
+  value: () => [MemoryOptions]
+});
+
+class DiskOptions {
+  path;
+  maxUsedFraction;
+  constructor(init) {
+    this.path = init.path;
+    this.maxUsedFraction = init.maxUsedFraction;
+  }
+}
+Object.defineProperty(DiskOptions, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "init: DiskOptionsInit" }]
+});
+
+class DiskIndicator extends HealthIndicator {
+  options;
+  name = "disk";
+  critical = false;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  async check() {
+    const stats = await statfs(this.options.path);
+    const total = Number(stats.blocks) * Number(stats.bsize);
+    const free = Number(stats.bavail) * Number(stats.bsize);
+    if (total <= 0)
+      return { state: "unknown", detail: "no size reported" };
+    const used = (total - free) / total;
+    const detail = `${Math.round(used * 100)}% of ${mib(total)} used`;
+    return used > this.options.maxUsedFraction ? { state: "down", detail } : { state: "up", detail };
+  }
+}
+Object.defineProperty(DiskIndicator, Symbol.for("dunx.deps"), {
+  value: () => [DiskOptions]
+});
+// src/health/module.ts
+import {
+  Module as Module2,
+  provide as provide3
+} from "@dunx/core";
+
+// src/health/readiness.ts
+class ReadinessOptions {
+  drainDelayMs;
+  constructor(init = {}) {
+    this.drainDelayMs = Math.max(0, init.drainDelayMs ?? 0);
+  }
+}
+Object.defineProperty(ReadinessOptions, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "init: ReadinessOptionsInit = {}" }]
+});
+
+class Readiness {
+  options;
+  #reason;
+  #draining = false;
+  constructor(options) {
+    this.options = options;
+  }
+  get draining() {
+    return this.#draining || this.#reason !== undefined;
+  }
+  get reason() {
+    return this.#draining ? this.#reason ?? "shutting down" : this.#reason;
+  }
+  hold(reason) {
+    this.#reason = reason;
+  }
+  release() {
+    this.#reason = undefined;
+  }
+  async onDrain() {
+    this.#draining = true;
+    if (this.options.drainDelayMs > 0) {
+      await Bun.sleep(this.options.drainDelayMs);
+    }
+  }
+}
+Object.defineProperty(Readiness, Symbol.for("dunx.deps"), {
+  value: () => [ReadinessOptions]
+});
+
+// src/health/module.ts
+var wiring = (options) => [
+  ...options,
+  provide3(ReadinessOptions, {
+    useFactory: (opts) => new ReadinessOptions({ drainDelayMs: opts.drainDelayMs }),
+    inject: [HealthOptions]
+  }),
+  provide3(Readiness, {
+    useFactory: (opts) => new Readiness(opts),
+    inject: [ReadinessOptions]
+  }),
+  provide3(HealthRegistry, {
+    useFactory: (opts, readiness) => new HealthRegistry(opts, readiness),
+    inject: [HealthOptions, Readiness]
+  })
+];
+var surface = [HealthOptions, HealthRegistry, Readiness];
+var _dec = [
+  Module2({})
+];
+var _init = __decoratorStart(undefined);
+
+class HealthModule {
+  static forRoot(init = {}) {
+    const options = new HealthOptions(init);
+    return {
+      module: HealthModule,
+      ...options.routes ? { controllers: [HealthController] } : {},
+      exports: surface,
+      providers: wiring([provide3(HealthOptions, { useValue: options })])
+    };
+  }
+  static forRootAsync(config) {
+    return {
+      module: HealthModule,
+      ...config.imports ? { imports: config.imports } : {},
+      ...config.routes ?? true ? { controllers: [HealthController] } : {},
+      exports: surface,
+      providers: wiring([
+        provide3(HealthOptions, {
+          useFactory: async (...deps) => new HealthOptions(await config.useFactory(...deps)),
+          inject: config.inject ?? []
+        })
+      ])
+    };
+  }
+}
+HealthModule = __decorateElement(_init, 0, "HealthModule", _dec, HealthModule);
+__runInitializers(_init, 1, HealthModule);
+__decoratorMetadata(_init, HealthModule);
+let _HealthModule = HealthModule;
 export {
   withUpgradeRoutes,
   withCors,
@@ -1670,12 +2007,17 @@ export {
   Roles,
   RequestLoggingMiddleware,
   RedisRelay,
+  RedisIndicator,
+  ReadinessOptions,
+  Readiness,
   ROLES,
   REQUEST_ID_HEADER,
+  QueryProbe,
   Put,
   Public,
   PubSub,
   Post,
+  PingProbe,
   Patch,
   PUBLIC,
   OnUpgrade,
@@ -1685,20 +2027,30 @@ export {
   OnMessage,
   OnDrain,
   OnClose,
+  MemoryOptions,
+  MemoryIndicator,
   HttpStatusCode,
   HttpFactory,
   HttpError,
+  HealthRegistry,
+  HealthOptions,
+  HealthModule,
+  HealthIndicator,
+  HealthController,
   HandlerKind,
   HIDDEN,
   Get,
   Gateway,
   ErrorFilter,
+  DiskOptions,
+  DiskIndicator,
   Delete,
+  DatabaseIndicator,
   DEFAULT_RELAY_CHANNEL,
   Controller,
   ClientAddress,
   ApiHidden
 };
 
-//# debugId=BA2C19D6241E4DE564756E2164756E21
+//# debugId=4FEC45E6E771085064756E2164756E21
 //# sourceMappingURL=index.js.map