@dunx/http 2.2.0 → 2.3.0

package/dist/server/request-id.d.ts

@@ -0,0 +1,27 @@
+export declare const REQUEST_ID_HEADER = "x-request-id";
+/**
+ * The request id, and the only thing that decides a request has one.
+ *
+ * `RequestLoggingMiddleware` sets the header on a response it returns, and a
+ * failure is never one: `buildRoutes` and `buildFallback` catch outside the chain
+ * and build a fresh `Response` from the error mapper. So a guard's 401, a
+ * validation 400, a mapped 500 and every unmatched 404 went out with no id on
+ * them, which are the responses a caller most needs in order to find the log line
+ * the middleware just wrote.
+ *
+ * Recorded against the request rather than threaded through the mapper, because
+ * `ErrorMapper` is `(error, req) => Response` and an app writes its own.
+ * {@link stamp} then reads back whatever {@link assign} recorded, so an app that
+ * turned request logging off, or a path it told the middleware to ignore, is still
+ * answered without a header: nothing minted an id, so there is none to stamp.
+ */
+export declare class RequestIds {
+    /**
+     * Called by `RequestLoggingMiddleware` and by nothing else. Splitting minting
+     * from recording would let a second caller invent an id the log line does not
+     * carry.
+     */
+    static assign(req: Request): string;
+    /** The response, with this request's id on it if it was ever given one. */
+    static stamp(response: Response, req: Request): Response;
+}

package/dist/server/request-logging.d.ts

@@ -2,7 +2,6 @@ import { Logger, RequestContext } from '@dunx/core';
 import type { BunRequest } from 'bun';
 import type { RouteContext } from './context.js';
 import type { Middleware, Next } from './middleware.js';
-export declare const REQUEST_ID_HEADER = "x-request-id";
 export interface RequestLoggingOptions {
     /** Bodies past this many characters are logged as a size. Default 2048. `0` omits them. */
     readonly maxBodyLength?: number;

package/dist/ws/adapter.d.ts

@@ -25,6 +25,11 @@ export interface WebSocketRuntime {
      * "Consuming N job(s)" entry already set.
      */
     readonly gateways: readonly GatewaySummary[];
+    /**
+     * What `HttpFactory.create` logs at boot, the way the container logs its own
+     * scope warnings. Empty for a server that reports socket errors, or says it does.
+     */
+    readonly warnings: readonly string[];
 }
 export interface GatewaySummary {
     readonly name: string;

package/dist/ws/logging.d.ts

@@ -62,6 +62,8 @@ export declare class SocketLoggingMiddleware implements SocketMiddleware {
     #private;
     private readonly logger;
     private readonly context;
+    /** A throwing handler reaches the `Logger` here, at `errorLevel`. */
+    readonly reportsErrors = true;
     constructor(logger: Logger, context: RequestContext, options?: SocketLoggingOptions);
     handle(frame: SocketFrame, ctx: SocketContext, next: SocketNext): unknown;
 }

package/dist/ws/middleware.d.ts

@@ -59,6 +59,21 @@ export type SocketNext = () => unknown;
  * which is an HTTP request answered by the gateway's own route.
  */
 export interface SocketMiddleware {
+    /**
+     * That a failure passing through here is reported somewhere. Default
+     * **`false`**.
+     *
+     * `SocketOptions.onError`'s `console.error` fallback is not installed while any
+     * socket middleware exists, because a middleware wraps the handler and would
+     * report the same failure a second time. Whether it does is something only the
+     * middleware knows: one that ignores a throw turns error reporting off for the
+     * whole server, and nothing about the wiring says so.
+     *
+     * Setting it is how a middleware says it does report. Leaving it unset with no
+     * `websocket.onError` beside it is what `HttpFactory.create` warns about at
+     * boot.
+     */
+    readonly reportsErrors?: boolean;
     handle(frame: SocketFrame, ctx: SocketContext, next: SocketNext): unknown;
 }
 /** One slot's folded chain. The handler's own arguments ride in `run`. */

package/dist/ws/socket.d.ts

@@ -35,6 +35,11 @@ export type SocketOptions = Readonly<Pick<WebSocketHandler<SocketData>, 'backpre
      * The default is **not** installed when `socketMiddleware` is non-empty: a
      * middleware wraps the handler, so it already saw the failure and a second
      * report on the console would be a duplicate.
+     *
+     * Seeing a failure and reporting it are not the same thing, so a middleware that
+     * reports says so with `SocketMiddleware.reportsErrors`. Middleware that sets it
+     * nowhere, and no `onError` here, is a boot warning: the fallback is gone and
+     * nothing replaced it.
      */
     readonly onError?: SocketErrorHandler;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "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.2.0",
+    "@dunx/core": "^2.3.0",
     "@types/bun": ">=1.3.0"
   },
   "peerDependenciesMeta": {