@znight/http 0.1.4 → 0.2.0

package/README.md

@@ -1506,8 +1506,11 @@ A stream-lifetime hook is not provided.
 When CORS is off, routes (other than `@All`) without guards, interceptors, `@Sse`, `@Res()` or
 `@Header` take a fast lane: the plugin decides at boot what the pipeline would do for them, runs a
 synchronous handler without creating a promise and builds the headers of a JSON reply from a
-template. The replies are the same as through the full pipeline (a thrown error, an `HttpResponse`
-or anything unusual continues there, in the same request scope; a promise is awaited first). The
+template. A plain object or array result is served there, and so is an `HttpResponse` whose body is
+one, with no cookie and no header other than a lower-case `content-type` (`HttpResponse.ok(body)`,
+an explicit status, a custom JSON media type), except on `@Head` routes. The replies are the same as
+through the full pipeline (a thrown error, another `HttpResponse` or anything unusual continues
+there, in the same request scope; a promise is awaited first). The
 lane runs the `http:request` hooks too: listeners keep it synchronous, and wrappers (such as those of
 `@znight/observability`) see the same event, in the same request scope and async context, as with
 the full pipeline; a reply whose wrappers added response headers or cookies is completed like any

package/dist/index.mjs

@@ -3884,7 +3884,8 @@ var Pipeline = class {
 			},
 			method: definition.method,
 			jsonStatus: definition.method === "HEAD" || isBodylessStatus(json) ? void 0 : json,
-			emptyStatus: definition.status ?? (post ? 201 : 204)
+			emptyStatus: definition.status ?? (post ? 201 : 204),
+			responses: definition.method !== "HEAD"
 		};
 	}
 	/**
@@ -4021,28 +4022,38 @@ var Pipeline = class {
 		x.answer(reply);
 	}
 	/**
-	* The reply of a plain JSON value (see {@link isPlainJson}) or of `undefined`: what
-	* `serializeResult` and {@link #complete} produce for it, the headers in their final order.
-	* `undefined` when the result or the context needs the general pipeline. Throws like
-	* `JSON.stringify`.
+	* The reply of a plain JSON value (see {@link isPlainJson}), of an `HttpResponse` carrying one
+	* (see {@link fastResponseType}) or of `undefined`: what `serializeResult` and {@link #complete}
+	* produce for it, the headers in their final order. `undefined` when the result or the context
+	* needs the general pipeline. Throws like `JSON.stringify`.
 	*/
 	#fastReply(route, ctx, result) {
-		const status = result === void 0 ? route.emptyStatus : route.jsonStatus;
+		let payload = result;
+		let status = result === void 0 ? route.emptyStatus : route.jsonStatus;
+		let type = null;
+		if (route.responses && result instanceof HttpResponse) {
+			const own = fastResponseType(result);
+			if (own === void 0) return void 0;
+			type = own;
+			payload = result.body;
+			if (route.plan.definition.status === void 0 && result.status !== void 0) status = isBodylessStatus(result.status) ? void 0 : result.status;
+			if (payload === void 0) return void 0;
+		}
 		if (status === void 0 || ctx.hasResponseHeaders || ctx.hasCookies || this.draining) return void 0;
 		const requestId = ctx.requestId;
 		if (!this.#validIds && !isHeaderValue(requestId)) return void 0;
-		if (result === void 0) return this.#templateReply(status, null, void 0, requestId);
-		if (!isPlainJson(result)) return void 0;
-		const json = JSON.stringify(result);
-		if (json === void 0) throw new TypeError(`Cannot serialise a ${typeof result} as a response body`);
-		return this.#templateReply(status, utf8(json), json, requestId);
+		if (payload === void 0) return this.#templateReply(status, null, void 0, requestId, null);
+		if (!isPlainJson(payload)) return void 0;
+		const json = JSON.stringify(payload);
+		if (json === void 0) throw new TypeError(`Cannot serialise a ${typeof payload} as a response body`);
+		return this.#templateReply(status, utf8(json), json, requestId, type);
 	}
 	/**
 	* The reply of a JSON body (`text` set) or of no body, its headers copied from the template of
 	* the fast lane (see {@link #jsonHeaders}), completed with the length and the request id (one that
-	* can be sent).
+	* can be sent). `type` replaces the JSON content type in place (the `HttpResponse`'s own).
 	*/
-	#templateReply(status, body, text, requestId) {
+	#templateReply(status, body, text, requestId, type) {
 		if (text === void 0) {
 			const headers = { ...this.#emptyHeaders };
 			const idHeader = this.#emptyIdHeader;
@@ -4054,6 +4065,7 @@ var Pipeline = class {
 			};
 		}
 		const headers = { ...this.#jsonHeaders };
+		if (type !== null) headers["content-type"] = type;
 		headers["content-length"] = String(body.byteLength);
 		const idHeader = this.#jsonIdHeader;
 		if (idHeader !== void 0) headers[idHeader] = requestId;
@@ -4169,7 +4181,7 @@ var Pipeline = class {
 		if (outcome === void 0) return this.#fastUnhandled(x, failed ? hookError : NOT_CALLED);
 		if (failed) this.#wrapperFailed(x, hookError);
 		else if (x.fast && outcome !== RAW && !hasOwnKeys(x.event.responseHeaders) && !ctx.hasCookies && !this.draining && (this.#validIds || isHeaderValue(x.requestId))) {
-			const reply = this.#templateReply(outcome.status, outcome.body, outcome.text, x.requestId);
+			const reply = this.#templateReply(outcome.status, outcome.body, outcome.text, x.requestId, null);
 			ctx.commit();
 			ctx.releaseBody();
 			x.answer(reply);
@@ -4974,6 +4986,22 @@ function isPlainJson(value) {
 	} else if (prototype !== Array.prototype || ctor !== Array) return false;
 	return typeof value.pipe !== "function";
 }
+/**
+* The content type of an `HttpResponse` the fast lane can serve: `null` without headers, its
+* `content-type` when that is its only header (lower-case name, a value every adapter can send);
+* `undefined` when it needs the general pipeline (other headers, cookies).
+*/
+function fastResponseType(response) {
+	if (response.cookies.length > 0) return void 0;
+	const headers = response.headers;
+	let type = null;
+	for (const name of Object.keys(headers)) {
+		const value = headers[name];
+		if (name !== "content-type" || typeof value !== "string" || !isHeaderValue(value)) return void 0;
+		type = value;
+	}
+	return type;
+}
 const ENCODER = new TextEncoder();
 /** UTF-8 encoding of a text body, like the serialiser (a pooled `Buffer` on Node.js, `TextEncoder` on Bun). */
 const utf8 = isBun() ? (text) => ENCODER.encode(text) : (text) => Buffer$1.from(text, "utf8");