@warlock.js/core 5.29.0 → 5.31.0

package/esm/http/request-log-snapshot.mjs

@@ -0,0 +1,220 @@
+import { UploadedFile } from "./uploaded-file.mjs";
+import config from "@mongez/config";
+import { DEFAULT_REDACT_KEY_SET, normalizeRedactKey } from "@warlock.js/logger";
+
+//#region ../../packages/core/src/http/request-log-snapshot.ts
+/**
+* Query parameters that carry a credential in a URL even though their names
+* are too generic for the logger's key denylist: signed-URL signatures,
+* pre-signed cloud credentials and OAuth authorization codes.
+*/
+const URL_CREDENTIAL_PARAMS = [
+	"signature",
+	"sig",
+	"code",
+	"x-amz-signature",
+	"x-amz-credential",
+	"x-amz-security-token",
+	"x-goog-signature",
+	"x-goog-credential"
+];
+const URL_CREDENTIAL_PARAM_SET = new Set(URL_CREDENTIAL_PARAMS.map(normalizeRedactKey));
+const REDACTED = "[REDACTED]";
+/**
+* Mask the values of credential-bearing query parameters in a URL (absolute,
+* or a path with a query string). A parameter is credential-bearing when its
+* normalized name is in the logger's default secret-key denylist (`secret`,
+* `token`, `apiKey`, …), in {@link URL_CREDENTIAL_PARAMS}, or in `extraParams`.
+*
+* The path and the other parameters are kept as written.
+*
+* @example
+* redactUrlCredentials("/hooks?secret=abc&page=2") // "/hooks?secret=[REDACTED]&page=2"
+*/
+function redactUrlCredentials(url, extraParams = []) {
+	const queryStart = url.indexOf("?");
+	if (queryStart === -1) return url;
+	const hashStart = url.indexOf("#", queryStart);
+	const queryEnd = hashStart === -1 ? url.length : hashStart;
+	const isCredential = credentialParamMatcher(extraParams);
+	const query = url.slice(queryStart + 1, queryEnd).split("&").map((pair) => {
+		const separator = pair.indexOf("=");
+		const rawName = separator === -1 ? pair : pair.slice(0, separator);
+		let name = rawName;
+		try {
+			name = decodeURIComponent(rawName.replace(/\+/g, " "));
+		} catch {}
+		if (separator !== -1 && isCredential(name)) return `${rawName}=${REDACTED}`;
+		return pair;
+	}).join("&");
+	return `${url.slice(0, queryStart)}?${query}`;
+}
+/**
+* A predicate telling whether a query parameter name carries a credential:
+* its normalized name is in the logger's default secret-key denylist, in
+* {@link URL_CREDENTIAL_PARAMS}, or in `extraParams`.
+*/
+function credentialParamMatcher(extraParams) {
+	const extra = new Set(extraParams.map(normalizeRedactKey));
+	return (name) => {
+		const key = normalizeRedactKey(name);
+		return DEFAULT_REDACT_KEY_SET.has(key) || URL_CREDENTIAL_PARAM_SET.has(key) || extra.has(key);
+	};
+}
+/**
+* Mask the values of credential-bearing parameters in a parsed query object,
+* with the same names {@link redactUrlCredentials} masks in the URL. Nested
+* objects and arrays (`a[b]=…` parsing) are walked; the input is not mutated.
+*
+* @example
+* redactQueryCredentials({ code: "abc", page: "2" }) // { code: "[REDACTED]", page: "2" }
+*/
+function redactQueryCredentials(query, extraParams = []) {
+	return redactQueryObject(query, credentialParamMatcher(extraParams));
+}
+function redactQueryObject(query, isCredential) {
+	const output = {};
+	for (const [name, value] of Object.entries(query)) output[name] = isCredential(name) ? REDACTED : redactQueryValue(value, isCredential);
+	return output;
+}
+function redactQueryValue(value, isCredential) {
+	if (Array.isArray(value)) return value.map((item) => redactQueryValue(item, isCredential));
+	if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) return redactQueryObject(value, isCredential);
+	return value;
+}
+/**
+* The effective logging options for a request: `http.logging` overlaid by the
+* route's own `logging` option, then restricted by matching private URL policies.
+*/
+function resolveRequestLoggingOptions(routeOptions, url, routePath) {
+	const global = config.get("http.logging") ?? {};
+	const options = {
+		body: routeOptions?.body ?? global.body ?? true,
+		query: routeOptions?.query ?? global.query ?? true,
+		redactQueryParams: global.redactQueryParams ?? []
+	};
+	if (!global.private?.length || url === void 0) return options;
+	const candidates = loggingPathCandidates(url);
+	if (candidates === void 0) return {
+		...options,
+		body: false,
+		query: false
+	};
+	if (routePath) {
+		const routeCandidates = loggingPathCandidates(routePath);
+		if (!routeCandidates) return {
+			...options,
+			body: false,
+			query: false
+		};
+		candidates.push(...routeCandidates);
+	}
+	for (const rule of compiledPrivateRules(global.private)) {
+		let matches;
+		if (rule.type === "regex") {
+			const { regex, needsClone } = rule;
+			matches = candidates.some((candidate) => (needsClone ? new RegExp(regex.source, regex.flags) : regex).test(candidate));
+		} else {
+			const { prefixes } = rule;
+			matches = prefixes === void 0 || prefixes.some((prefix) => candidates.some((candidate) => prefix === "/" || candidate === prefix || candidate.startsWith(`${prefix}/`)));
+		}
+		if (!matches) continue;
+		if (rule.body === false) options.body = false;
+		if (rule.query === false) options.query = false;
+	}
+	return options;
+}
+/**
+* Compiled rules per configured `http.logging.private` array. Snapshots are
+* built several times per request, so each array's prefixes are normalised
+* once; replacing the array (a new config value) compiles the new one.
+*/
+const compiledRulesCache = /* @__PURE__ */ new WeakMap();
+function compiledPrivateRules(rules) {
+	let compiled = compiledRulesCache.get(rules);
+	if (compiled) return compiled;
+	compiled = rules.map((rule) => {
+		const { path, body, query } = rule;
+		if (path instanceof RegExp) return {
+			type: "regex",
+			regex: path,
+			needsClone: path.global || path.sticky,
+			body,
+			query
+		};
+		return {
+			type: "prefix",
+			prefixes: loggingPathCandidates(path),
+			body,
+			query
+		};
+	});
+	compiledRulesCache.set(rules, compiled);
+	return compiled;
+}
+/** Backslashes to slashes, repeated slashes collapsed, no trailing slash. */
+function collapseLoggingPath(path) {
+	return path.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function loggingPathCandidates(url) {
+	try {
+		const pathname = url.replace(/^[a-z][a-z\d+.-]*:\/\/[^/?#]*/i, "").split(/[?#]/u)[0] || "/";
+		const raw = collapseLoggingPath(pathname);
+		const decoded = collapseLoggingPath(decodeURIComponent(pathname));
+		const segments = [];
+		for (const segment of decoded.split("/")) if (segment === "..") segments.pop();
+		else if (segment && segment !== ".") segments.push(segment);
+		return [...new Set([
+			raw,
+			decoded,
+			`/${segments.join("/")}`
+		])];
+	} catch {
+		return;
+	}
+}
+/**
+* Build the {@link RequestLogSnapshot} for a request, applying the route's
+* logging policy BEFORE anything reaches a log entry: an omitted body or
+* query is never copied, so no sink, channel or redaction setting can expose it.
+* Credential-bearing query parameters are masked in both `url` and `query`.
+*
+* Uploaded files are summarised (`{ file, mimeType }`) rather than walked.
+*/
+function buildRequestLogSnapshot(source) {
+	const options = resolveRequestLoggingOptions(source.route?.logging, source.url, source.route?.path);
+	const url = options.query ? source.url : stripQuery(source.url);
+	const snapshot = {
+		id: source.id,
+		method: source.method,
+		url: redactUrlCredentials(url ?? "", options.redactQueryParams)
+	};
+	if (source.route?.path) snapshot.route = source.route.path;
+	if (source.route?.name) snapshot.name = source.route.name;
+	if (source.ip) snapshot.ip = source.ip;
+	if (source.userAgent) snapshot.userAgent = source.userAgent;
+	if (options.query && source.query && Object.keys(source.query).length > 0) snapshot.query = redactQueryCredentials(source.query, options.redactQueryParams);
+	if (options.body && source.body && Object.keys(source.body).length > 0) snapshot.body = summariseFiles(source.body);
+	return snapshot;
+}
+function stripQuery(url) {
+	if (!url) return url;
+	const queryStart = url.indexOf("?");
+	return queryStart === -1 ? url : url.slice(0, queryStart);
+}
+function summariseFiles(body) {
+	const output = {};
+	for (const [key, value] of Object.entries(body)) output[key] = Array.isArray(value) ? value.map(summariseFile) : summariseFile(value);
+	return output;
+}
+function summariseFile(value) {
+	if (!(value instanceof UploadedFile)) return value;
+	return {
+		file: value.name,
+		mimeType: value.mimeType
+	};
+}
+
+//#endregion
+export { URL_CREDENTIAL_PARAMS, buildRequestLogSnapshot, redactQueryCredentials, redactUrlCredentials, resolveRequestLoggingOptions };
+//# sourceMappingURL=request-log-snapshot.mjs.map

package/esm/http/request-log-snapshot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-log-snapshot.mjs","names":[],"sources":["../../../../../../../../packages/core/src/http/request-log-snapshot.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { DEFAULT_REDACT_KEY_SET, normalizeRedactKey } from \"@warlock.js/logger\";\nimport { UploadedFile } from \"./uploaded-file\";\n\n/**\n * What a request's log entries carry of its input. Set globally under\n * `http.logging` and per route with the route's `logging` option; the route\n * wins key by key, unless a private URL policy suppresses that field.\n *\n * @example\n * // never log the body or the query string of this route, not even redacted\n * router.post(\"/accounts/credentials\", controller, {\n *   logging: { body: false, query: false },\n * });\n */\nexport type RequestLoggingOptions = {\n  /**\n   * Include the request body in log entries.\n   *\n   * The body is logged as RECEIVED, before validation, so fields the schema\n   * later rejects are part of it. Turn it off on routes that accept secrets\n   * or arbitrary user text.\n   *\n   * @default true\n   */\n  body?: boolean;\n  /**\n   * Include the parsed query string in log entries. The logged URL keeps its\n   * path either way; with `query: false` its query string is dropped too.\n   *\n   * @default true\n   */\n  query?: boolean;\n};\n\n/** A URL policy that can only remove input from snapshots, even on unmatched requests. */\nexport type PrivateRequestLoggingRule = {\n  /** Path prefix at a segment boundary, or a regular expression over the normalized path. */\n  path: string | RegExp;\n  body?: false;\n  query?: false;\n};\n\n/**\n * `http.logging`: the app-wide defaults for {@link RequestLoggingOptions},\n * plus query parameter names whose values are masked in logged URLs.\n */\nexport type HttpLoggingConfig = RequestLoggingOptions & {\n  /**\n   * Extra query parameter names to mask in logged URLs, on top of the\n   * logger's default secret-key denylist and {@link URL_CREDENTIAL_PARAMS}.\n   * Matched like the logger's keys: case, `-` and `_` are ignored.\n   */\n  redactQueryParams?: string[];\n  /** URL policies applied before route logging; matching rules cannot be overridden by a route. */\n  private?: PrivateRequestLoggingRule[];\n};\n\n/**\n * The bounded, plain-data view of a request that Core puts in log entries in\n * place of the `Request`/`Response` instances, whose native request, reply\n * and socket graphs reach every sink otherwise.\n */\nexport type RequestLogSnapshot = {\n  id: string;\n  method: string;\n  /** Path and query string, with credential-bearing parameter values masked. */\n  url: string;\n  /** The matched route pattern, e.g. `/users/:id`. */\n  route?: string;\n  /** The route name, when it has one. */\n  name?: string;\n  ip?: string;\n  userAgent?: string;\n  query?: Record<string, unknown>;\n  body?: Record<string, unknown>;\n};\n\n/**\n * Query parameters that carry a credential in a URL even though their names\n * are too generic for the logger's key denylist: signed-URL signatures,\n * pre-signed cloud credentials and OAuth authorization codes.\n */\nexport const URL_CREDENTIAL_PARAMS: readonly string[] = [\n  \"signature\",\n  \"sig\",\n  \"code\",\n  \"x-amz-signature\",\n  \"x-amz-credential\",\n  \"x-amz-security-token\",\n  \"x-goog-signature\",\n  \"x-goog-credential\",\n];\n\nconst URL_CREDENTIAL_PARAM_SET: ReadonlySet<string> = new Set(\n  URL_CREDENTIAL_PARAMS.map(normalizeRedactKey),\n);\n\nconst REDACTED = \"[REDACTED]\";\n\n/**\n * Mask the values of credential-bearing query parameters in a URL (absolute,\n * or a path with a query string). A parameter is credential-bearing when its\n * normalized name is in the logger's default secret-key denylist (`secret`,\n * `token`, `apiKey`, …), in {@link URL_CREDENTIAL_PARAMS}, or in `extraParams`.\n *\n * The path and the other parameters are kept as written.\n *\n * @example\n * redactUrlCredentials(\"/hooks?secret=abc&page=2\") // \"/hooks?secret=[REDACTED]&page=2\"\n */\nexport function redactUrlCredentials(url: string, extraParams: readonly string[] = []): string {\n  const queryStart = url.indexOf(\"?\");\n\n  if (queryStart === -1) return url;\n\n  const hashStart = url.indexOf(\"#\", queryStart);\n  const queryEnd = hashStart === -1 ? url.length : hashStart;\n  const isCredential = credentialParamMatcher(extraParams);\n\n  const query = url\n    .slice(queryStart + 1, queryEnd)\n    .split(\"&\")\n    .map((pair) => {\n      const separator = pair.indexOf(\"=\");\n      const rawName = separator === -1 ? pair : pair.slice(0, separator);\n\n      let name = rawName;\n\n      try {\n        name = decodeURIComponent(rawName.replace(/\\+/g, \" \"));\n      } catch {\n        // A malformed escape is logged under its raw name.\n      }\n\n      if (separator !== -1 && isCredential(name)) {\n        return `${rawName}=${REDACTED}`;\n      }\n\n      return pair;\n    })\n    .join(\"&\");\n\n  // A fragment never reaches the server, but a URL handed in by app code may\n  // carry one; it is dropped rather than risk logging a token in it.\n  return `${url.slice(0, queryStart)}?${query}`;\n}\n\n/**\n * A predicate telling whether a query parameter name carries a credential:\n * its normalized name is in the logger's default secret-key denylist, in\n * {@link URL_CREDENTIAL_PARAMS}, or in `extraParams`.\n */\nfunction credentialParamMatcher(extraParams: readonly string[]): (name: string) => boolean {\n  const extra = new Set(extraParams.map(normalizeRedactKey));\n\n  return (name) => {\n    const key = normalizeRedactKey(name);\n\n    return DEFAULT_REDACT_KEY_SET.has(key) || URL_CREDENTIAL_PARAM_SET.has(key) || extra.has(key);\n  };\n}\n\n/**\n * Mask the values of credential-bearing parameters in a parsed query object,\n * with the same names {@link redactUrlCredentials} masks in the URL. Nested\n * objects and arrays (`a[b]=…` parsing) are walked; the input is not mutated.\n *\n * @example\n * redactQueryCredentials({ code: \"abc\", page: \"2\" }) // { code: \"[REDACTED]\", page: \"2\" }\n */\nexport function redactQueryCredentials(\n  query: Record<string, unknown>,\n  extraParams: readonly string[] = [],\n): Record<string, unknown> {\n  return redactQueryObject(query, credentialParamMatcher(extraParams));\n}\n\nfunction redactQueryObject(\n  query: Record<string, unknown>,\n  isCredential: (name: string) => boolean,\n): Record<string, unknown> {\n  const output: Record<string, unknown> = {};\n\n  for (const [name, value] of Object.entries(query)) {\n    output[name] = isCredential(name) ? REDACTED : redactQueryValue(value, isCredential);\n  }\n\n  return output;\n}\n\nfunction redactQueryValue(value: unknown, isCredential: (name: string) => boolean): unknown {\n  if (Array.isArray(value)) return value.map((item) => redactQueryValue(item, isCredential));\n\n  if (\n    value !== null &&\n    typeof value === \"object\" &&\n    Object.getPrototypeOf(value) === Object.prototype\n  ) {\n    return redactQueryObject(value as Record<string, unknown>, isCredential);\n  }\n\n  return value;\n}\n\n/**\n * The effective logging options for a request: `http.logging` overlaid by the\n * route's own `logging` option, then restricted by matching private URL policies.\n */\nexport function resolveRequestLoggingOptions(\n  routeOptions: RequestLoggingOptions | undefined,\n  url?: string,\n  routePath?: string,\n): Required<RequestLoggingOptions> & { redactQueryParams: string[] } {\n  const global = (config.get(\"http.logging\") ?? {}) as HttpLoggingConfig;\n\n  const options = {\n    body: routeOptions?.body ?? global.body ?? true,\n    query: routeOptions?.query ?? global.query ?? true,\n    redactQueryParams: global.redactQueryParams ?? [],\n  };\n  if (!global.private?.length || url === undefined) return options;\n  const candidates = loggingPathCandidates(url);\n  if (candidates === undefined) return { ...options, body: false, query: false };\n  if (routePath) {\n    const routeCandidates = loggingPathCandidates(routePath);\n    if (!routeCandidates) return { ...options, body: false, query: false };\n    candidates.push(...routeCandidates);\n  }\n\n  for (const rule of compiledPrivateRules(global.private)) {\n    let matches: boolean;\n    if (rule.type === \"regex\") {\n      const { regex, needsClone } = rule;\n      matches = candidates.some((candidate) =>\n        (needsClone ? new RegExp(regex.source, regex.flags) : regex).test(candidate),\n      );\n    } else {\n      const { prefixes } = rule;\n      // A malformed configured prefix must never silently disable privacy.\n      matches =\n        prefixes === undefined ||\n        prefixes.some((prefix) =>\n          candidates.some(\n            (candidate) =>\n              prefix === \"/\" || candidate === prefix || candidate.startsWith(`${prefix}/`),\n          ),\n        );\n    }\n    if (!matches) continue;\n    if (rule.body === false) options.body = false;\n    if (rule.query === false) options.query = false;\n  }\n  return options;\n}\n\n/** A private rule with its path matcher prepared once. */\ntype CompiledPrivateRule = Pick<PrivateRequestLoggingRule, \"body\" | \"query\"> &\n  (\n    | { type: \"regex\"; regex: RegExp; needsClone: boolean }\n    // `undefined` prefixes: the configured path does not decode, so it matches every request.\n    | { type: \"prefix\"; prefixes: string[] | undefined }\n  );\n\n/**\n * Compiled rules per configured `http.logging.private` array. Snapshots are\n * built several times per request, so each array's prefixes are normalised\n * once; replacing the array (a new config value) compiles the new one.\n */\nconst compiledRulesCache = new WeakMap<\n  readonly PrivateRequestLoggingRule[],\n  CompiledPrivateRule[]\n>();\n\nfunction compiledPrivateRules(rules: readonly PrivateRequestLoggingRule[]): CompiledPrivateRule[] {\n  let compiled = compiledRulesCache.get(rules);\n  if (compiled) return compiled;\n  compiled = rules.map((rule): CompiledPrivateRule => {\n    const { path, body, query } = rule;\n    if (path instanceof RegExp) {\n      // A global or sticky regex keeps `lastIndex` between tests; use a fresh copy.\n      return { type: \"regex\", regex: path, needsClone: path.global || path.sticky, body, query };\n    }\n    return { type: \"prefix\", prefixes: loggingPathCandidates(path), body, query };\n  });\n  compiledRulesCache.set(rules, compiled);\n  return compiled;\n}\n\n/** Backslashes to slashes, repeated slashes collapsed, no trailing slash. */\nfunction collapseLoggingPath(path: string): string {\n  return path.replace(/\\\\/g, \"/\").replace(/\\/+/g, \"/\").replace(/\\/$/, \"\") || \"/\";\n}\n\nfunction loggingPathCandidates(url: string): string[] | undefined {\n  try {\n    // Preserve raw dot segments in absolute-form requests; URL() would erase them.\n    const pathname = url.replace(/^[a-z][a-z\\d+.-]*:\\/\\/[^/?#]*/i, \"\").split(/[?#]/u)[0] || \"/\";\n    const raw = collapseLoggingPath(pathname);\n    const decoded = collapseLoggingPath(decodeURIComponent(pathname));\n    const segments: string[] = [];\n    for (const segment of decoded.split(\"/\")) {\n      if (segment === \"..\") segments.pop();\n      else if (segment && segment !== \".\") segments.push(segment);\n    }\n    return [...new Set([raw, decoded, `/${segments.join(\"/\")}`])];\n  } catch {\n    // With a private-path policy, undecodable input is withheld rather than guessed.\n    return undefined;\n  }\n}\n\n/**\n * The fields of a request the snapshot reads. Structural, so the snapshot can\n * be built (and tested) without a live Fastify request.\n */\nexport type RequestLogSource = {\n  id: string;\n  method: string;\n  url: string;\n  ip?: string;\n  userAgent?: string;\n  query?: Record<string, unknown>;\n  body?: Record<string, unknown>;\n  route?: { path?: string; name?: string; logging?: RequestLoggingOptions };\n};\n\n/**\n * Build the {@link RequestLogSnapshot} for a request, applying the route's\n * logging policy BEFORE anything reaches a log entry: an omitted body or\n * query is never copied, so no sink, channel or redaction setting can expose it.\n * Credential-bearing query parameters are masked in both `url` and `query`.\n *\n * Uploaded files are summarised (`{ file, mimeType }`) rather than walked.\n */\nexport function buildRequestLogSnapshot(source: RequestLogSource): RequestLogSnapshot {\n  const options = resolveRequestLoggingOptions(\n    source.route?.logging,\n    source.url,\n    source.route?.path,\n  );\n  const url = options.query ? source.url : stripQuery(source.url);\n\n  const snapshot: RequestLogSnapshot = {\n    id: source.id,\n    method: source.method,\n    url: redactUrlCredentials(url ?? \"\", options.redactQueryParams),\n  };\n\n  if (source.route?.path) snapshot.route = source.route.path;\n  if (source.route?.name) snapshot.name = source.route.name;\n  if (source.ip) snapshot.ip = source.ip;\n  if (source.userAgent) snapshot.userAgent = source.userAgent;\n\n  if (options.query && source.query && Object.keys(source.query).length > 0) {\n    snapshot.query = redactQueryCredentials(source.query, options.redactQueryParams);\n  }\n\n  if (options.body && source.body && Object.keys(source.body).length > 0) {\n    snapshot.body = summariseFiles(source.body);\n  }\n\n  return snapshot;\n}\n\nfunction stripQuery(url: string | undefined): string | undefined {\n  if (!url) return url;\n\n  const queryStart = url.indexOf(\"?\");\n\n  return queryStart === -1 ? url : url.slice(0, queryStart);\n}\n\nfunction summariseFiles(body: Record<string, unknown>): Record<string, unknown> {\n  const output: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(body)) {\n    output[key] = Array.isArray(value) ? value.map(summariseFile) : summariseFile(value);\n  }\n\n  return output;\n}\n\nfunction summariseFile(value: unknown): unknown {\n  if (!(value instanceof UploadedFile)) return value;\n\n  return { file: value.name, mimeType: value.mimeType };\n}\n"],"mappings":"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"}

package/esm/http/request.d.mts

@@ -1,3 +1,4 @@
+import { RequestLogSnapshot } from "./request-log-snapshot.mjs";
 import { Response } from "./response.mjs";
 import { UploadedFile } from "./uploaded-file.mjs";
 import { DecodedAccessToken, RequestEvent, RequestLocals } from "./types.mjs";
@@ -7,7 +8,7 @@ import { LogLevel } from "@warlock.js/logger";
 import { FastifyRequest } from "fastify";
 import { IncomingHttpHeaders } from "node:http2";
 
-//#region ../core/src/http/request.d.ts
+//#region ../../packages/core/src/http/request.d.ts
 type StandardHeaders = { [K in keyof IncomingHttpHeaders as string extends K ? never : number extends K ? never : K]: IncomingHttpHeaders[K] };
 type HeaderKeys = keyof StandardHeaders;
 /** A request-bound translator: keyword in, translated string out. */
@@ -38,6 +39,31 @@ declare class Request<RequestValidation = any> {
    * Route Object
    */
   route: Route;
+  /**
+   * Backing controller for `signal` — created on first access, so requests
+   * that never ask for it attach no listeners.
+   */
+  private disconnectController?;
+  /**
+   * An `AbortSignal` that aborts when the client disconnects before the
+   * response has finished. Pass it to long-running work (`fetch`, database
+   * cursors, child processes) so that work stops when nobody is waiting:
+   *
+   * ```ts
+   * const report = await buildReport({ signal: request.signal });
+   * ```
+   *
+   * It follows the RESPONSE, not the request stream: reading the request body
+   * to the end does not abort it, and a response that finishes normally never
+   * aborts it. The abort reason is a `DOMException` named `"AbortError"`.
+   * The listener is attached on first access and removed when the response
+   * closes. Combine with a deadline via
+   * `AbortSignal.any([request.signal, AbortSignal.timeout(ms)])`.
+   *
+   * A request with no bound response (a hand-built `Request` in a test) gets
+   * a signal that never aborts.
+   */
+  get signal(): AbortSignal;
   /**
    * Parsed Request Payload
    */
@@ -222,7 +248,7 @@ declare class Request<RequestValidation = any> {
   /**
    * Validate the given validation schema
    */
-  validate(validation: BaseValidator, selectedInputs?: string[]): Promise<import("@warlock.js/seal").ValidationResult>;
+  validate(validation: BaseValidator, selectedInputs?: string[]): Promise<import("@warlock.js/seal").TypedValidationResult<any>>;
   /**
    * Get value of the given header
    */
@@ -338,6 +364,19 @@ declare class Request<RequestValidation = any> {
    * Make a log message
    */
   log(message: any, level?: LogLevel): void;
+  /**
+   * The bounded, plain-data view of this request that log entries carry:
+   * id, method, URL (credential-bearing query values masked), route, client
+   * IP, user agent, and the query and body unless `http.logging` or the
+   * route's `logging` option omits them. Never the native request, reply or
+   * socket.
+   *
+   * Use it in your own log calls instead of passing the request itself.
+   *
+   * @example
+   * log.warn("billing", "charge", "declined", { request: request.toLogSnapshot() });
+   */
+  toLogSnapshot(): RequestLogSnapshot;
   /**
    * Get current request path
    */
@@ -385,14 +424,14 @@ declare class Request<RequestValidation = any> {
    * @internal Framework orchestration — do not call from app code. Wired
    * from the Fastify route handler in `router.scan()`.
    */
-  execute(): Promise<any[] | Record<string, any> | Response>;
+  execute(): Promise<any[] | Response | Record<string, any>>;
   /**
    * Iterate the collected middlewares in order; return the first short-circuit
    * value or `undefined` when every middleware passes through.
    *
    * @internal Framework orchestration — do not call from app code.
    */
-  protected executeMiddleware(): Promise<any[] | Record<string, any> | Response | undefined>;
+  protected executeMiddleware(): Promise<any[] | Response | Record<string, any> | undefined>;
   /**
    * Gather the middleware list for the current route — today just the
    * route-level array; future extraction may merge group + app-wide layers.

package/esm/http/request.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"request.d.mts","names":[],"sources":["../../../../../../../core/src/http/request.ts"],"mappings":"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"}
+{"version":3,"file":"request.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/request.ts"],"mappings":"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"}

package/esm/http/request.mjs

@@ -5,19 +5,21 @@ import { deriveTraceId } from "./tracing/trace-id.mjs";
 import { buildTracingContext, dispatchPhase, isTracingEnabled } from "./tracing/tracing-dispatcher.mjs";
 import "./tracing/index.mjs";
 import { createRequestStore } from "./middleware/inject-request-context.mjs";
+import { resolveRouteValidation } from "../router/resolve-route-validation.mjs";
 import { Response } from "./response.mjs";
 import { validateAll } from "../validation/validateAll.mjs";
 import { UploadedFile } from "./uploaded-file.mjs";
+import { buildRequestLogSnapshot } from "./request-log-snapshot.mjs";
 import { v } from "@warlock.js/seal";
 import { trans, transFrom } from "@mongez/localization";
 import { log } from "@warlock.js/logger";
+import { randomBytes } from "node:crypto";
 import { isEmpty } from "@mongez/supportive-is";
 import { Random, except, get, only, rtrim, set, unset } from "@mongez/reinforcements";
 import { colors } from "@mongez/copper";
 import events from "@mongez/events";
-import { randomBytes } from "node:crypto";
 
-//#region ../core/src/http/request.ts
+//#region ../../packages/core/src/http/request.ts
 var Request = class Request {
 	constructor() {
 		this.payload = {};
@@ -30,6 +32,43 @@ var Request = class Request {
 		this.startTime = Date.now();
 	}
 	/**
+	* An `AbortSignal` that aborts when the client disconnects before the
+	* response has finished. Pass it to long-running work (`fetch`, database
+	* cursors, child processes) so that work stops when nobody is waiting:
+	*
+	* ```ts
+	* const report = await buildReport({ signal: request.signal });
+	* ```
+	*
+	* It follows the RESPONSE, not the request stream: reading the request body
+	* to the end does not abort it, and a response that finishes normally never
+	* aborts it. The abort reason is a `DOMException` named `"AbortError"`.
+	* The listener is attached on first access and removed when the response
+	* closes. Combine with a deadline via
+	* `AbortSignal.any([request.signal, AbortSignal.timeout(ms)])`.
+	*
+	* A request with no bound response (a hand-built `Request` in a test) gets
+	* a signal that never aborts.
+	*/
+	get signal() {
+		if (this.disconnectController) return this.disconnectController.signal;
+		const controller = new AbortController();
+		this.disconnectController = controller;
+		const raw = this.response?.baseResponse?.raw;
+		if (!raw || typeof raw.once !== "function") return controller.signal;
+		const abortUnlessFinished = () => {
+			if (raw.writableFinished) return;
+			controller.abort(new DOMException("The client disconnected before the response finished", "AbortError"));
+		};
+		if (raw.writableFinished) return controller.signal;
+		if (raw.destroyed) {
+			abortUnlessFinished();
+			return controller.signal;
+		}
+		raw.once("close", abortUnlessFinished);
+		return controller.signal;
+	}
+	/**
 	* Decoded access token payload (set by auth middleware).
 	*
 	* A prototype accessor, not a plain field, so assignment can mark the
@@ -456,7 +495,32 @@ var Request = class Request {
 			action: this.route.method + " " + this.route.path.replace("/*", "") + `:${this.id}`,
 			message,
 			type: level,
-			context: { request: this }
+			context: { request: this.toLogSnapshot() }
+		});
+	}
+	/**
+	* The bounded, plain-data view of this request that log entries carry:
+	* id, method, URL (credential-bearing query values masked), route, client
+	* IP, user agent, and the query and body unless `http.logging` or the
+	* route's `logging` option omits them. Never the native request, reply or
+	* socket.
+	*
+	* Use it in your own log calls instead of passing the request itself.
+	*
+	* @example
+	* log.warn("billing", "charge", "declined", { request: request.toLogSnapshot() });
+	*/
+	toLogSnapshot() {
+		const baseRequest = this.baseRequest;
+		return buildRequestLogSnapshot({
+			id: this.id,
+			method: baseRequest?.method ?? this.route?.method ?? "",
+			url: baseRequest?.url ?? "",
+			ip: baseRequest ? this.detectIp() : void 0,
+			userAgent: baseRequest?.headers?.["user-agent"],
+			query: this.payload?.query,
+			body: this.payload?.body,
+			route: this.route
 		});
 	}
 	/**
@@ -491,11 +555,11 @@ var Request = class Request {
 			if (middlewareOutput instanceof Response) return middlewareOutput;
 			return this.response.send(middlewareOutput);
 		}
-		const handler = this.route.handler;
-		if (!handler.validation) return;
+		const validation = resolveRouteValidation(this.route);
+		if (!validation) return;
 		const tracingEnabled = isTracingEnabled();
 		const validationStartedAt = tracingEnabled ? performance.now() : 0;
-		const validationOutput = await validateAll(handler.validation, this, this.response);
+		const validationOutput = await validateAll(validation, this, this.response);
 		if (tracingEnabled) dispatchPhase(buildTracingContext(this), {
 			name: "validation",
 			durationMs: performance.now() - validationStartedAt