@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/src/context/http/HttpContext.js

@@ -0,0 +1,309 @@
+import HttpError from "../../errors/httpError.js";
+import Cookie from "../../cookies/cookie.js";
+import Context from "../Context.js";
+import { sanitizeRequestId } from "../requestId.js";
+import HttpRequest from "./Request.js";
+import HttpResponse from "./Response.js";
+import Http2Request from "../http2/Request.js";
+import Http2Response from "../http2/Response.js";
+import { extend, typeOf } from "nodefony";
+import url, { URL } from "node:url";
+//#region nodefony/src/context/http/HttpContext.ts
+const socketActiveContext = /* @__PURE__ */ new WeakMap();
+const socketTimeoutArmed = /* @__PURE__ */ new WeakSet();
+const PERF_PROBE_SUB = process.env.NF_PERF_PROBE === "1";
+var HttpContext = class extends Context {
+	proxy = null;
+	isRedirect = false;
+	sended = false;
+	request;
+	response;
+	uploadService;
+	csrf;
+	constructor(container, request, response, type) {
+		super(container, type);
+		this.uploadService = this.get("upload");
+		const perfSub = PERF_PROBE_SUB ? globalThis.__nfPerfProbe : void 0;
+		if (perfSub && perfSub.t0 !== 0n) perfSub.uploadNs += Number(process.hrtime.bigint() - perfSub.t0);
+		if (this.type === "http2") {
+			this.request = new Http2Request(request, this);
+			this.response = new Http2Response(response, this);
+		} else {
+			this.request = new HttpRequest(request, this);
+			this.response = new HttpResponse(response, this);
+		}
+		if (perfSub && perfSub.t0 !== 0n) perfSub.reqResNs += Number(process.hrtime.bigint() - perfSub.t0);
+		this.url = this.request.href;
+		this.scheme = this.setScheme();
+		this.method = this.request.getMethod();
+		this.remoteAddress = this.request.remoteAddress;
+		this.proxy = null;
+		const fwd = this.request.forwarded;
+		if (fwd) {
+			this.proxy = {
+				proxyServer: request.headers["x-forwarded-server"] || "unknown",
+				proxyProto: fwd.proto ?? request.headers["x-forwarded-proto"],
+				proxyScheme: request.headers["x-forwarded-scheme"],
+				proxyPort: request.headers["x-forwarded-port"],
+				proxyFor: fwd.forwardedFor ?? request.headers["x-forwarded-for"],
+				proxyHost: fwd.host ?? request.headers["x-forwarded-host"],
+				proxyUri: request.headers["x-original-uri"],
+				proxyRealIp: request.headers["x-real-ip"],
+				proxyVia: request.headers.via || "unknown"
+			};
+			this.log(`PROXY REQUEST ${fwd.fromStandard ? "Forwarded (RFC 7239)" : "x-forwarded"} VIA : ${this.proxy.proxyVia}`, "DEBUG");
+		}
+		const incomingId = sanitizeRequestId(request.headers["x-request-id"]);
+		if (incomingId) this.requestId = incomingId;
+		this.domain = this.getHostName();
+		this.validDomain = this.isValidDomain();
+		this.parseCookies();
+		this.cookieSession = this.getCookieSession(this.getSessionCookieName());
+	}
+	/**
+	* URL d'origine effective, construite À LA DEMANDE (1ʳᵉ lecture, puis
+	* mémoïsée). `Origin` invalide ou `null` (RFC 6454) → repli sur l'URL de la
+	* requête, comme le WS — jamais de throw.
+	*/
+	get originUrl() {
+		if (this._originUrl === null) try {
+			this._originUrl = new URL(this.request.origin || this.url);
+		} catch {
+			this._originUrl = new URL(this.url);
+		}
+		return this._originUrl;
+	}
+	set originUrl(value) {
+		this._originUrl = value;
+	}
+	/**
+	* Chemin timeout direct — appelé par les handlers socket/stream de
+	* `setTimeout()`. T4 : remplace l'ancien `once("onTimeout")` posé au ctor
+	* (1 onceWrapper node + 1 closure alloués à CHAQUE requête pour un event
+	* qui ne fire presque jamais). L'event `onTimeout` reste émis pour
+	* d'éventuels listeners externes — guard 0-listener : 0 alloc sinon.
+	*/
+	_onTimeout() {
+		if (this.listenerCount("onTimeout")) this.fire("onTimeout", this);
+		this._abortIfPending("Request timeout");
+		let error = null;
+		if (this.response.stream) error = new HttpError("Gateway Timeout", 504, this);
+		else error = new HttpError("Request Timeout", 408, this);
+		this.httpKernel?.onError(error, this);
+	}
+	setScheme() {
+		const req = this.request;
+		if (req.hasParsedUrl) return req.url.protocol.replace(":", "");
+		return req.scheme;
+	}
+	async handle() {
+		this.setTimeout();
+		if (this.isRedirect) {
+			await this.send();
+			return this;
+		}
+		this.fire("onRequest", this);
+		this.kernel?.fire("onRequest", this);
+		if (!this.resolver && this.router) this.resolver = this.router.resolve(this);
+		if (this.resolver && this.resolver.resolve) {
+			this.setMetaData();
+			return await this.resolver.callController();
+		}
+		throw new HttpError("", 404, this);
+	}
+	setTimeout() {
+		const res = this.response.response;
+		if (!res) return;
+		if (this.response.stream) {
+			res.setTimeout(this.response.timeout, () => {
+				if (!this.response?.response?.writableEnded) this._onTimeout();
+			});
+			return;
+		}
+		const socket = res.socket;
+		if (!socket) return;
+		socketActiveContext.set(socket, this);
+		const ms = this.response.timeout;
+		if (socket.timeout !== ms) socket.setTimeout(ms);
+		if (!socketTimeoutArmed.has(socket)) {
+			socketTimeoutArmed.add(socket);
+			socket.on("timeout", () => {
+				const ctx = socketActiveContext.get(socket);
+				if (ctx && !ctx.response?.response?.writableEnded) ctx._onTimeout();
+			});
+		}
+	}
+	async render(chunk, encoding, status, headers) {
+		let data = chunk;
+		switch (true) {
+			case this.isJson:
+				data = JSON.stringify(chunk);
+				break;
+			case this.isHtml:
+			default: switch (typeOf(chunk)) {
+				case "object":
+					this.setContextJson();
+					data = JSON.stringify(chunk);
+					break;
+				case "string":
+					if (this.response.contentType === "application/octet-stream") this.setContextHtml();
+					break;
+				default: if (this.response.contentType === "application/octet-stream") this.response.setContentType("text");
+			}
+		}
+		if (headers) this.response.setHeaders(headers);
+		if (status) this.response.setStatusCode(status);
+		return this.send(data, encoding);
+	}
+	async end() {
+		return this.saveSession().then(async (_session) => {
+			return this.close().catch((e) => {
+				throw e;
+			});
+		});
+	}
+	async send(chunk, encoding) {
+		if (this.finished && !this.sended) {
+			this.log("send() on finished context — client disconnected", "DEBUG");
+			return this.response;
+		}
+		if (this.sended || this.finished || this.response.isHeaderSent()) return new Promise((_resolve, reject) => {
+			return reject(/* @__PURE__ */ new Error("Response Already sended"));
+		});
+		if (!this.timingEnabled) return this.#doSend(chunk, encoding);
+		this.phaseStart("send");
+		try {
+			return await this.#doSend(chunk, encoding);
+		} finally {
+			this.phaseEnd("send");
+		}
+	}
+	async #doSend(chunk, encoding) {
+		try {
+			if (this.session != null) await this.saveSession();
+			if (chunk) this.response?.setBody(chunk);
+			if (this.listenerCount("onSend") > 0) await this.fireAsync("onSend", this.response, this);
+			try {
+				this.writeHead();
+			} catch (e) {
+				this.log(e, "WARNING");
+			}
+			if (this.isRedirect) return await this.close();
+			return await this.write(chunk, encoding);
+		} catch (error) {
+			this.log(error, "ERROR");
+			throw error;
+		}
+	}
+	writeHead(statusCode, headers) {
+		if (this.response) {
+			if (this.csrfToken) this.setCookie(new Cookie("csrf-token", this.csrfToken, {
+				httpOnly: false,
+				sameSite: "Strict",
+				secure: this.scheme === "https",
+				path: "/"
+			}));
+			this.response.setCookies();
+			this.response.writeHead(statusCode, headers);
+		}
+	}
+	async write(chunk, encoding, _flush = false) {
+		await this.response.send(chunk, encoding || this.response.encoding).then(() => {
+			this.sended = true;
+		}).catch((e) => {
+			throw e;
+		});
+		return this.close().catch((e) => {
+			throw e;
+		});
+	}
+	flush(chunk, encoding) {
+		return this.response.flush(chunk, encoding);
+	}
+	async close() {
+		if (this.listenerCount("onClose") > 0) await this.fireAsync("onClose", this);
+		return this.response.end().then(() => this.response).catch((e) => {
+			throw e;
+		});
+	}
+	redirect(Url, status, headers) {
+		if (typeof Url === "object") return this.response.redirect(url.format(Url), status, headers);
+		return this.response.redirect(Url, status, headers);
+	}
+	redirectHttps(status, headers) {
+		if (this.session) {}
+		let urlExtend = null;
+		if (this.proxy) urlExtend = {
+			protocol: "https",
+			href: "",
+			host: ""
+		};
+		else urlExtend = {
+			protocol: "https",
+			port: this.httpKernel?.httpsPort || 443,
+			href: "",
+			host: ""
+		};
+		const urlChange = extend({}, this.request.url, urlExtend);
+		const newUrl = url.format(urlChange);
+		return this.redirect(newUrl, status, headers);
+	}
+	redirectHttp(status, headers) {
+		if (this.session) {}
+		let urlExtend = null;
+		if (this.proxy) urlExtend = {
+			protocol: "http",
+			href: "",
+			host: ""
+		};
+		else urlExtend = {
+			protocol: "http",
+			port: this.httpKernel?.httpPort || 80,
+			href: "",
+			host: ""
+		};
+		const urlChange = extend({}, this.request.url, urlExtend);
+		const newUrl = url.format(urlChange);
+		return this.redirect(newUrl, status, headers);
+	}
+	getHostName() {
+		return this.request?.getHostName();
+	}
+	getRemoteAddress() {
+		return this.request?.getRemoteAddress();
+	}
+	getHost() {
+		return this.request?.getHost();
+	}
+	getUserAgent() {
+		return this.request?.getUserAgent();
+	}
+	getMethod() {
+		return this.request?.getMethod();
+	}
+	setContentType(type, encoding) {
+		return this.response.setContentType(type, encoding);
+	}
+	resolveIsHtml() {
+		return this.request?.acceptHtml ?? false;
+	}
+	setDefaultContentType() {
+		if (this.isHtml) this.response.setContentType("html", "utf-8");
+		else if (this.request.accepts("json")) {
+			this.isJson = true;
+			this.response.setContentType("json", "utf-8");
+		}
+	}
+	setContextJson(encoding = "utf-8") {
+		this.isJson = true;
+		this.isHtml = false;
+		this.response.setContentType("json", encoding);
+	}
+	setContextHtml(encoding = "utf-8") {
+		this.isHtml = true;
+		this.isJson = false;
+		this.response.setContentType("html", encoding);
+	}
+};
+//#endregion
+export { HttpContext as default };