@warlock.js/core 5.29.0 → 5.30.0

package/esm/http/ready-report.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ready-report.mjs","names":[],"sources":["../../../../../../../core/src/http/ready-report.ts"],"sourcesContent":["/**\n * What the HTTP connector learned at the moment it finished binding.\n *\n * ## Why this exists rather than another `log.*` call\n *\n * The facts a developer needs on a `warlock dev` boot — the URL, the port, the\n * mode, how many routes registered — are discovered by DIFFERENT components at\n * DIFFERENT times, and each one used to print the instant it knew. The result\n * was a ready \"screen\" assembled by whatever finished first:\n *\n *     ℹ info    [http] [routes] 14 route(s) registered\n *     ✓ success [http] [connection] Server ready at http://[::1]:2030\n *     …          Development Server is ready in 660ms\n *\n * Three lines, three formats, no single place stating where to point a browser.\n *\n * So the connector RECORDS instead of narrating, and one renderer prints one\n * block once boot has actually completed (`dev-server/ready-block.ts`). The\n * split matters: a component that prints cannot be composed, and a boot\n * sequence whose output order is its completion order cannot be read.\n *\n * ## What deliberately does NOT go through here\n *\n * Warnings. A status block is a summary of the healthy case, and folding a\n * warning into a summary is how a warning stops being read. Anything the\n * connector needs to WARN about is still logged the moment it is known, which\n * puts it above the block, where it survives being skimmed.\n *\n * Production is unchanged for the same reason it always was: `warlock start`\n * hands its stdout to a supervisor that greps for known lines, so the existing\n * per-fact log lines stay exactly as they are outside development.\n */\n\nexport type HttpReadyReport = {\n  /** Exactly what `listen()` returned — the bind, not its presentation. */\n  boundAddress?: string;\n  /** The address spelled for a human; safe to paste into a browser. */\n  url: string;\n  /** Whether the bind covers more than loopback. */\n  wildcardBind: boolean;\n  /** The port actually bound. */\n  port: number;\n  /** Routes on the app router at the moment the server started listening. */\n  routeCount: number;\n  /** `app.baseUrl`, when it is a deployment address rather than a local one. */\n  publicUrl?: string;\n};\n\nlet report: HttpReadyReport | undefined;\n\n/**\n * @internal Called by `HttpConnector.start()` right after a successful listen.\n */\nexport function setHttpReadyReport(next: HttpReadyReport): void {\n  report = next;\n}\n\n/**\n * The last recorded bind, or `undefined` for a process with no HTTP surface —\n * a queue worker still boots, and the ready block must render without an app\n * URL rather than invent one.\n */\nexport function getHttpReadyReport(): HttpReadyReport | undefined {\n  return report;\n}\n\n/** @internal Test seam — a module-level singleton needs a way back to empty. */\nexport function resetHttpReadyReport(): void {\n  report = undefined;\n}\n"],"mappings":";AAgDA,IAAI;;;;AAKJ,SAAgB,mBAAmB,MAA6B;CAC9D,SAAS;AACX;;;;;;AAOA,SAAgB,qBAAkD;CAChE,OAAO;AACT;;AAGA,SAAgB,uBAA6B;CAC3C,SAAS;AACX"}
+{"version":3,"file":"ready-report.mjs","names":[],"sources":["../../../../../../../../packages/core/src/http/ready-report.ts"],"sourcesContent":["/**\n * What the HTTP connector learned at the moment it finished binding.\n *\n * ## Why this exists rather than another `log.*` call\n *\n * The facts a developer needs on a `warlock dev` boot — the URL, the port, the\n * mode, how many routes registered — are discovered by DIFFERENT components at\n * DIFFERENT times, and each one used to print the instant it knew. The result\n * was a ready \"screen\" assembled by whatever finished first:\n *\n *     ℹ info    [http] [routes] 14 route(s) registered\n *     ✓ success [http] [connection] Server ready at http://[::1]:2030\n *     …          Development Server is ready in 660ms\n *\n * Three lines, three formats, no single place stating where to point a browser.\n *\n * So the connector RECORDS instead of narrating, and one renderer prints one\n * block once boot has actually completed (`dev-server/ready-block.ts`). The\n * split matters: a component that prints cannot be composed, and a boot\n * sequence whose output order is its completion order cannot be read.\n *\n * ## What deliberately does NOT go through here\n *\n * Warnings. A status block is a summary of the healthy case, and folding a\n * warning into a summary is how a warning stops being read. Anything the\n * connector needs to WARN about is still logged the moment it is known, which\n * puts it above the block, where it survives being skimmed.\n *\n * Production is unchanged for the same reason it always was: `warlock start`\n * hands its stdout to a supervisor that greps for known lines, so the existing\n * per-fact log lines stay exactly as they are outside development.\n */\n\nexport type HttpReadyReport = {\n  /** Exactly what `listen()` returned — the bind, not its presentation. */\n  boundAddress?: string;\n  /** The address spelled for a human; safe to paste into a browser. */\n  url: string;\n  /** Whether the bind covers more than loopback. */\n  wildcardBind: boolean;\n  /** The port actually bound. */\n  port: number;\n  /** Routes on the app router at the moment the server started listening. */\n  routeCount: number;\n  /** `app.baseUrl`, when it is a deployment address rather than a local one. */\n  publicUrl?: string;\n};\n\nlet report: HttpReadyReport | undefined;\n\n/**\n * @internal Called by `HttpConnector.start()` right after a successful listen.\n */\nexport function setHttpReadyReport(next: HttpReadyReport): void {\n  report = next;\n}\n\n/**\n * The last recorded bind, or `undefined` for a process with no HTTP surface —\n * a queue worker still boots, and the ready block must render without an app\n * URL rather than invent one.\n */\nexport function getHttpReadyReport(): HttpReadyReport | undefined {\n  return report;\n}\n\n/** @internal Test seam — a module-level singleton needs a way back to empty. */\nexport function resetHttpReadyReport(): void {\n  report = undefined;\n}\n"],"mappings":";AAgDA,IAAI;;;;AAKJ,SAAgB,mBAAmB,MAA6B;CAC9D,SAAS;AACX;;;;;;AAOA,SAAgB,qBAAkD;CAChE,OAAO;AACT;;AAGA,SAAgB,uBAA6B;CAC3C,SAAS;AACX"}

package/esm/http/request-controller.d.mts

@@ -3,7 +3,7 @@ import { Request } from "./request.mjs";
 import { ReturnedResponse } from "./types.mjs";
 import { RequestControllerContract } from "../router/types.mjs";
 
-//#region ../core/src/http/request-controller.d.ts
+//#region ../../packages/core/src/http/request-controller.d.ts
 declare abstract class RequestController implements RequestControllerContract {
   readonly request: Request;
   readonly response: Response;

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

@@ -1 +1 @@
-{"version":3,"file":"request-controller.d.mts","names":[],"sources":["../../../../../../../core/src/http/request-controller.ts"],"mappings":";;;;;;uBAKsB,iBAAA,YAA6B,yBAAA;EAAA,SAE/B,OAAA,EAAS,OAAA;EAAA,SACT,QAAA,EAAU,QAAA;cADV,OAAA,EAAS,OAAA,EACT,QAAA,EAAU,QAAA;EAAA,SAKZ,OAAA,IAAW,OAAA,CAAQ,gBAAA;AAAA"}
+{"version":3,"file":"request-controller.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/request-controller.ts"],"mappings":";;;;;;uBAKsB,iBAAA,YAA6B,yBAAA;EAAA,SAE/B,OAAA,EAAS,OAAA;EAAA,SACT,QAAA,EAAU,QAAA;cADV,OAAA,EAAS,OAAA,EACT,QAAA,EAAU,QAAA;EAAA,SAKZ,OAAA,IAAW,OAAA,CAAQ,gBAAA;AAAA"}

package/esm/http/request-controller.mjs

@@ -1,4 +1,4 @@
-//#region ../core/src/http/request-controller.ts
+//#region ../../packages/core/src/http/request-controller.ts
 var RequestController = class {
 	constructor(request, response) {
 		this.request = request;

package/esm/http/request-controller.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"request-controller.mjs","names":[],"sources":["../../../../../../../core/src/http/request-controller.ts"],"sourcesContent":["import type { RequestControllerContract } from \"./../router/types\";\nimport type { Request } from \"./request\";\nimport type { Response } from \"./response\";\nimport type { ReturnedResponse } from \"./types\";\n\nexport abstract class RequestController implements RequestControllerContract {\n  public constructor(\n    public readonly request: Request,\n    public readonly response: Response,\n  ) {\n    //\n  }\n\n  public abstract execute(): Promise<ReturnedResponse>;\n}\n"],"mappings":";AAKA,IAAsB,oBAAtB,MAA6E;CAC3E,AAAO,YACL,AAAgB,SAChB,AAAgB,UAChB;EAFgB;EACA;CAGlB;AAGF"}
+{"version":3,"file":"request-controller.mjs","names":[],"sources":["../../../../../../../../packages/core/src/http/request-controller.ts"],"sourcesContent":["import type { RequestControllerContract } from \"./../router/types\";\nimport type { Request } from \"./request\";\nimport type { Response } from \"./response\";\nimport type { ReturnedResponse } from \"./types\";\n\nexport abstract class RequestController implements RequestControllerContract {\n  public constructor(\n    public readonly request: Request,\n    public readonly response: Response,\n  ) {\n    //\n  }\n\n  public abstract execute(): Promise<ReturnedResponse>;\n}\n"],"mappings":";AAKA,IAAsB,oBAAtB,MAA6E;CAC3E,AAAO,YACL,AAAgB,SAChB,AAAgB,UAChB;EAFgB;EACA;CAGlB;AAGF"}

package/esm/http/request-log-snapshot.d.mts

@@ -0,0 +1,123 @@
+//#region ../../packages/core/src/http/request-log-snapshot.d.ts
+/**
+ * What a request's log entries carry of its input. Set globally under
+ * `http.logging` and per route with the route's `logging` option; the route
+ * wins key by key.
+ *
+ * @example
+ * // never log the body or the query string of this route, not even redacted
+ * router.post("/accounts/credentials", controller, {
+ *   logging: { body: false, query: false },
+ * });
+ */
+type RequestLoggingOptions = {
+  /**
+   * Include the request body in log entries.
+   *
+   * The body is logged as RECEIVED, before validation, so fields the schema
+   * later rejects are part of it. Turn it off on routes that accept secrets
+   * or arbitrary user text.
+   *
+   * @default true
+   */
+  body?: boolean;
+  /**
+   * Include the parsed query string in log entries. The logged URL keeps its
+   * path either way; with `query: false` its query string is dropped too.
+   *
+   * @default true
+   */
+  query?: boolean;
+};
+/**
+ * `http.logging`: the app-wide defaults for {@link RequestLoggingOptions},
+ * plus query parameter names whose values are masked in logged URLs.
+ */
+type HttpLoggingConfig = RequestLoggingOptions & {
+  /**
+   * Extra query parameter names to mask in logged URLs, on top of the
+   * logger's default secret-key denylist and {@link URL_CREDENTIAL_PARAMS}.
+   * Matched like the logger's keys: case, `-` and `_` are ignored.
+   */
+  redactQueryParams?: string[];
+};
+/**
+ * The bounded, plain-data view of a request that Core puts in log entries in
+ * place of the `Request`/`Response` instances, whose native request, reply
+ * and socket graphs reach every sink otherwise.
+ */
+type RequestLogSnapshot = {
+  id: string;
+  method: string; /** Path and query string, with credential-bearing parameter values masked. */
+  url: string; /** The matched route pattern, e.g. `/users/:id`. */
+  route?: string; /** The route name, when it has one. */
+  name?: string;
+  ip?: string;
+  userAgent?: string;
+  query?: Record<string, unknown>;
+  body?: Record<string, unknown>;
+};
+/**
+ * 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.
+ */
+declare const URL_CREDENTIAL_PARAMS: readonly string[];
+/**
+ * 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"
+ */
+declare function redactUrlCredentials(url: string, extraParams?: readonly string[]): string;
+/**
+ * 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" }
+ */
+declare function redactQueryCredentials(query: Record<string, unknown>, extraParams?: readonly string[]): Record<string, unknown>;
+/**
+ * The effective logging options for a request: `http.logging` overlaid by the
+ * route's own `logging` option.
+ */
+declare function resolveRequestLoggingOptions(routeOptions: RequestLoggingOptions | undefined): Required<RequestLoggingOptions> & {
+  redactQueryParams: string[];
+};
+/**
+ * The fields of a request the snapshot reads. Structural, so the snapshot can
+ * be built (and tested) without a live Fastify request.
+ */
+type RequestLogSource = {
+  id: string;
+  method: string;
+  url: string;
+  ip?: string;
+  userAgent?: string;
+  query?: Record<string, unknown>;
+  body?: Record<string, unknown>;
+  route?: {
+    path?: string;
+    name?: string;
+    logging?: RequestLoggingOptions;
+  };
+};
+/**
+ * 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.
+ */
+declare function buildRequestLogSnapshot(source: RequestLogSource): RequestLogSnapshot;
+//#endregion
+export { HttpLoggingConfig, RequestLogSnapshot, RequestLogSource, RequestLoggingOptions, URL_CREDENTIAL_PARAMS, buildRequestLogSnapshot, redactQueryCredentials, redactUrlCredentials, resolveRequestLoggingOptions };
+//# sourceMappingURL=request-log-snapshot.d.mts.map

package/esm/http/request-log-snapshot.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-log-snapshot.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/request-log-snapshot.ts"],"mappings":";;AAeA;;;;AAiBO;AAOP;;;;AAMmB;KA9BP,qBAAA;EAsCkB;;;;;;;;;EA5B5B,IAAA;EAuCA;;;;;AACa;EAjCb,KAAK;AAAA;;;AAkDN;AAmBD;KA9DY,iBAAA,GAAoB,qBAAqB;;;AA8DgC;AA4DrF;;EApHE,iBAAiB;AAAA;;;;;;KAQP,kBAAA;EACV,EAAA;EACA,MAAA;EAEA,GAAA,UAgJU;EA9IV,KAAA,WA8IS;EA5IT,IAAA;EACA,EAAA;EACA,SAAA;EACA,KAAA,GAAQ,MAAA;EACR,IAAA,GAAO,MAAM;AAAA;;AAwIyC;AAcxD;;;cA9Ia,qBAAA;;;;;;;;;;;;iBA4BG,oBAAA,CAAqB,GAAA,UAAa,WAAmC;;;;;;;;AA0HZ;iBA9DzD,sBAAA,CACd,KAAA,EAAO,MAAA,mBACP,WAAA,uBACC,MAAM;;;;;iBAmCO,4BAAA,CACd,YAAA,EAAc,qBAAA,eACb,QAAA,CAAS,qBAAA;EAA2B,iBAAA;AAAA;AAiC8C;;;;AAAA,KAnBzE,gBAAA;EACV,EAAA;EACA,MAAA;EACA,GAAA;EACA,EAAA;EACA,SAAA;EACA,KAAA,GAAQ,MAAA;EACR,IAAA,GAAO,MAAA;EACP,KAAA;IAAU,IAAA;IAAe,IAAA;IAAe,OAAA,GAAU,qBAAA;EAAA;AAAA;;;;;;;;;iBAWpC,uBAAA,CAAwB,MAAA,EAAQ,gBAAA,GAAmB,kBAAkB"}

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

@@ -0,0 +1,141 @@
+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.
+*/
+function resolveRequestLoggingOptions(routeOptions) {
+	const global = config.get("http.logging") ?? {};
+	return {
+		body: routeOptions?.body ?? global.body ?? true,
+		query: routeOptions?.query ?? global.query ?? true,
+		redactQueryParams: global.redactQueryParams ?? []
+	};
+}
+/**
+* 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);
+	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.\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/**\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};\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.\n */\nexport function resolveRequestLoggingOptions(\n  routeOptions: RequestLoggingOptions | undefined,\n): Required<RequestLoggingOptions> & { redactQueryParams: string[] } {\n  const global = (config.get(\"http.logging\") ?? {}) as HttpLoggingConfig;\n\n  return {\n    body: routeOptions?.body ?? global.body ?? true,\n    query: routeOptions?.query ?? global.query ?? true,\n    redactQueryParams: global.redactQueryParams ?? [],\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(source.route?.logging);\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":";;;;;;;;;;AAyEA,MAAa,wBAA2C;CACtD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,2BAAgD,IAAI,IACxD,sBAAsB,IAAI,kBAAkB,CAC9C;AAEA,MAAM,WAAW;;;;;;;;;;;;AAajB,SAAgB,qBAAqB,KAAa,cAAiC,CAAC,GAAW;CAC7F,MAAM,aAAa,IAAI,QAAQ,GAAG;CAElC,IAAI,eAAe,IAAI,OAAO;CAE9B,MAAM,YAAY,IAAI,QAAQ,KAAK,UAAU;CAC7C,MAAM,WAAW,cAAc,KAAK,IAAI,SAAS;CACjD,MAAM,eAAe,uBAAuB,WAAW;CAEvD,MAAM,QAAQ,IACX,MAAM,aAAa,GAAG,QAAQ,CAAC,CAC/B,MAAM,GAAG,CAAC,CACV,KAAK,SAAS;EACb,MAAM,YAAY,KAAK,QAAQ,GAAG;EAClC,MAAM,UAAU,cAAc,KAAK,OAAO,KAAK,MAAM,GAAG,SAAS;EAEjE,IAAI,OAAO;EAEX,IAAI;GACF,OAAO,mBAAmB,QAAQ,QAAQ,OAAO,GAAG,CAAC;EACvD,QAAQ,CAER;EAEA,IAAI,cAAc,MAAM,aAAa,IAAI,GACvC,OAAO,GAAG,QAAQ,GAAG;EAGvB,OAAO;CACT,CAAC,CAAC,CACD,KAAK,GAAG;CAIX,OAAO,GAAG,IAAI,MAAM,GAAG,UAAU,EAAE,GAAG;AACxC;;;;;;AAOA,SAAS,uBAAuB,aAA2D;CACzF,MAAM,QAAQ,IAAI,IAAI,YAAY,IAAI,kBAAkB,CAAC;CAEzD,QAAQ,SAAS;EACf,MAAM,MAAM,mBAAmB,IAAI;EAEnC,OAAO,uBAAuB,IAAI,GAAG,KAAK,yBAAyB,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG;CAC9F;AACF;;;;;;;;;AAUA,SAAgB,uBACd,OACA,cAAiC,CAAC,GACT;CACzB,OAAO,kBAAkB,OAAO,uBAAuB,WAAW,CAAC;AACrE;AAEA,SAAS,kBACP,OACA,cACyB;CACzB,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,KAAK,GAC9C,OAAO,QAAQ,aAAa,IAAI,IAAI,WAAW,iBAAiB,OAAO,YAAY;CAGrF,OAAO;AACT;AAEA,SAAS,iBAAiB,OAAgB,cAAkD;CAC1F,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,KAAK,SAAS,iBAAiB,MAAM,YAAY,CAAC;CAEzF,IACE,UAAU,QACV,OAAO,UAAU,YACjB,OAAO,eAAe,KAAK,MAAM,OAAO,WAExC,OAAO,kBAAkB,OAAkC,YAAY;CAGzE,OAAO;AACT;;;;;AAMA,SAAgB,6BACd,cACmE;CACnE,MAAM,SAAU,OAAO,IAAI,cAAc,KAAK,CAAC;CAE/C,OAAO;EACL,MAAM,cAAc,QAAQ,OAAO,QAAQ;EAC3C,OAAO,cAAc,SAAS,OAAO,SAAS;EAC9C,mBAAmB,OAAO,qBAAqB,CAAC;CAClD;AACF;;;;;;;;;AAyBA,SAAgB,wBAAwB,QAA8C;CACpF,MAAM,UAAU,6BAA6B,OAAO,OAAO,OAAO;CAClE,MAAM,MAAM,QAAQ,QAAQ,OAAO,MAAM,WAAW,OAAO,GAAG;CAE9D,MAAM,WAA+B;EACnC,IAAI,OAAO;EACX,QAAQ,OAAO;EACf,KAAK,qBAAqB,OAAO,IAAI,QAAQ,iBAAiB;CAChE;CAEA,IAAI,OAAO,OAAO,MAAM,SAAS,QAAQ,OAAO,MAAM;CACtD,IAAI,OAAO,OAAO,MAAM,SAAS,OAAO,OAAO,MAAM;CACrD,IAAI,OAAO,IAAI,SAAS,KAAK,OAAO;CACpC,IAAI,OAAO,WAAW,SAAS,YAAY,OAAO;CAElD,IAAI,QAAQ,SAAS,OAAO,SAAS,OAAO,KAAK,OAAO,KAAK,CAAC,CAAC,SAAS,GACtE,SAAS,QAAQ,uBAAuB,OAAO,OAAO,QAAQ,iBAAiB;CAGjF,IAAI,QAAQ,QAAQ,OAAO,QAAQ,OAAO,KAAK,OAAO,IAAI,CAAC,CAAC,SAAS,GACnE,SAAS,OAAO,eAAe,OAAO,IAAI;CAG5C,OAAO;AACT;AAEA,SAAS,WAAW,KAA6C;CAC/D,IAAI,CAAC,KAAK,OAAO;CAEjB,MAAM,aAAa,IAAI,QAAQ,GAAG;CAElC,OAAO,eAAe,KAAK,MAAM,IAAI,MAAM,GAAG,UAAU;AAC1D;AAEA,SAAS,eAAe,MAAwD;CAC9E,MAAM,SAAkC,CAAC;CAEzC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAAI,GAC5C,OAAO,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,IAAI,aAAa,IAAI,cAAc,KAAK;CAGrF,OAAO;AACT;AAEA,SAAS,cAAc,OAAyB;CAC9C,IAAI,EAAE,iBAAiB,eAAe,OAAO;CAE7C,OAAO;EAAE,MAAM,MAAM;EAAM,UAAU,MAAM;CAAS;AACtD"}

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
    */

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

@@ -8,6 +8,7 @@ import { createRequestStore } from "./middleware/inject-request-context.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";
@@ -17,7 +18,7 @@ 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 +31,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 +494,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
 		});
 	}
 	/**