@dunx/http 2.0.1 → 2.1.1

package/dist/route/discover.d.ts

@@ -1,4 +1,4 @@
-import type { Ctor, ModuleRef } from '@dunx/core';
+import { type Ctor, type ModuleRef } from '@dunx/core';
 import type { Middleware } from '../server/middleware.js';
 import { type HttpMethod } from './marker.js';
 import { type MetaRecord } from './metadata.js';

package/dist/server/application.d.ts

@@ -132,6 +132,12 @@ export declare class HttpApplication implements HttpApp {
      * matches an upgrade, and no `fetch` handler is needed at all.
      */
     listen(port?: number): Promise<string>;
+    /**
+     * Delegated unchanged: the drain is the container's phase, and `shutdown()`
+     * runs it. Public so an operator can start draining without committing to a
+     * shutdown, which is what a readiness probe wants during a rolling deploy.
+     */
+    drain(): Promise<void>;
     shutdown(): Promise<void>;
     enableShutdownHooks(signals?: readonly ShutdownSignal[], options?: ShutdownHookOptions): this;
 }

package/dist/server/client-address.d.ts

@@ -1,11 +1,17 @@
 import type { BunRequest, Server } from 'bun';
 export interface AddressSource {
     readonly server: Server<unknown>;
-    readonly trustProxy: boolean;
+    readonly trustProxy: boolean | number;
 }
 /**
  * The client's address, honouring the `'trust proxy'` setting.
  *
+ * With the setting on, the address is read from `X-Forwarded-For` counting from
+ * the right by the number of trusted hops, never from the left. A client can put
+ * anything in the header it sends; only the entries a proxy appended carry any
+ * weight, and there are exactly as many of those as there are proxies in front of
+ * this server.
+ *
  * Bound and exported by `HttpFactory`'s global wrapper module, so injecting it in a
  * middleware or controller needs no registration and `app.clientIp(req)` is the same
  * instance. That binding is not optional under module scoping: an unbound class

package/dist/server/settings.d.ts

@@ -5,10 +5,15 @@
  */
 export interface AppSettings {
     /**
-     * Resolve the client address from `X-Forwarded-For` rather than the socket. Only
-     * turn it on behind a proxy that rewrites the header: a direct client can send
-     * whatever it likes.
+     * Resolve the client address from `X-Forwarded-For` rather than the socket.
+     *
+     * The value is how many proxies sit in front of this server: `true` means one,
+     * a number means that many, `false` means read the socket. The address is taken
+     * that many entries from the **right**, because a direct client can send
+     * whatever it likes in the header and only a proxy under your control appends
+     * to it. Setting a count higher than the number of proxies you actually run
+     * hands the caller its own choice of address.
      */
-    'trust proxy': boolean;
+    'trust proxy': boolean | number;
 }
 export declare const defaultSettings: () => AppSettings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -58,7 +58,7 @@
     "@dunx/core": "workspace:*"
   },
   "peerDependencies": {
-    "@dunx/core": "^2.0.1",
+    "@dunx/core": "^2.1.1",
     "@types/bun": ">=1.3.0"
   },
   "peerDependenciesMeta": {