@qwik.dev/router 2.0.0-beta.4 → 2.0.0-beta.41

package/lib/middleware/node/index.mjs

@@ -1,287 +1,313 @@
-// packages/qwik-router/src/middleware/node/index.ts
-import { getNotFound } from "@qwik-router-not-found-paths";
-import { isStaticPath } from "@qwik-router-static-paths";
-import { _deserialize, _serialize, _verifySerializable } from "@qwik.dev/core/internal";
+import { n as MIME_TYPES, t as normalizeRequestUrl } from "../../chunks/url.mjs";
+import { i as validateRequestBodyLimit, n as RequestBodyLimitError, t as DEFAULT_REQUEST_BODY_LIMIT } from "../../chunks/request-body-limit.mjs";
+import { t as devPreloadedRouteLoaders } from "../../chunks/dev-preloaded-route-loader.mjs";
+import { isDev } from "@qwik.dev/core";
 import { setServerPlatform } from "@qwik.dev/core/server";
-import { requestHandler } from "../request-handler/index.mjs";
 import { createReadStream } from "node:fs";
 import { basename, extname, join } from "node:path";
+import { isStaticPath, requestHandler } from "@qwik.dev/router/middleware/request-handler";
 import { fileURLToPath } from "node:url";
-
-// packages/qwik-router/src/middleware/request-handler/mime-types.ts
-var MIME_TYPES = {
-  "3gp": "video/3gpp",
-  "3gpp": "video/3gpp",
-  asf: "video/x-ms-asf",
-  asx: "video/x-ms-asf",
-  avi: "video/x-msvideo",
-  avif: "image/avif",
-  bmp: "image/x-ms-bmp",
-  css: "text/css",
-  flv: "video/x-flv",
-  gif: "image/gif",
-  htm: "text/html",
-  html: "text/html",
-  ico: "image/x-icon",
-  jng: "image/x-jng",
-  jpeg: "image/jpeg",
-  jpg: "image/jpeg",
-  js: "application/javascript",
-  json: "application/json",
-  kar: "audio/midi",
-  m4a: "audio/x-m4a",
-  m4v: "video/x-m4v",
-  mid: "audio/midi",
-  midi: "audio/midi",
-  mng: "video/x-mng",
-  mov: "video/quicktime",
-  mp3: "audio/mpeg",
-  mp4: "video/mp4",
-  mpeg: "video/mpeg",
-  mpg: "video/mpeg",
-  ogg: "audio/ogg",
-  pdf: "application/pdf",
-  png: "image/png",
-  rar: "application/x-rar-compressed",
-  shtml: "text/html",
-  svg: "image/svg+xml",
-  svgz: "image/svg+xml",
-  tif: "image/tiff",
-  tiff: "image/tiff",
-  ts: "video/mp2t",
-  txt: "text/plain",
-  wbmp: "image/vnd.wap.wbmp",
-  webm: "video/webm",
-  webp: "image/webp",
-  wmv: "video/x-ms-wmv",
-  woff: "font/woff",
-  woff2: "font/woff2",
-  xml: "text/xml",
-  zip: "application/zip"
-};
-
-// packages/qwik-router/src/middleware/node/http.ts
 import { Http2ServerRequest } from "node:http2";
-function computeOrigin(req, opts) {
-  var _a;
-  return ((_a = opts == null ? void 0 : opts.getOrigin) == null ? void 0 : _a.call(opts, req)) ?? (opts == null ? void 0 : opts.origin) ?? process.env.ORIGIN ?? fallbackOrigin(req);
-}
 function fallbackOrigin(req) {
-  const { PROTOCOL_HEADER, HOST_HEADER } = process.env;
-  const headers = req.headers;
-  const protocol = PROTOCOL_HEADER && headers[PROTOCOL_HEADER] || (req.socket.encrypted || req.connection.encrypted ? "https" : "http");
-  const hostHeader = HOST_HEADER ?? (req instanceof Http2ServerRequest ? ":authority" : "host");
-  const host = headers[hostHeader];
-  return `${protocol}://${host}`;
+	const { PROTOCOL_HEADER, HOST_HEADER } = process.env;
+	const headers = req.headers;
+	return `${PROTOCOL_HEADER && headers[PROTOCOL_HEADER] || (req.socket.encrypted || req.connection.encrypted ? "https" : "http")}://${headers[HOST_HEADER ?? (req instanceof Http2ServerRequest ? ":authority" : "host")]}`;
 }
-function getUrl(req, origin) {
-  return normalizeUrl(req.originalUrl || req.url || "/", origin);
+function computeOrigin(req, opts) {
+	return opts?.getOrigin?.(req) ?? opts?.origin ?? process.env.ORIGIN ?? fallbackOrigin(req);
 }
-function isIgnoredError(message = "") {
-  const ignoredErrors = ["The stream has been destroyed", "write after end"];
-  return ignoredErrors.some((ignored) => message.includes(ignored));
+function isClientAbortWriteError(error) {
+	if (!(error instanceof Error)) return false;
+	const code = error.code;
+	if (code === "EPIPE" || code === "ECONNRESET" || code === "ERR_STREAM_DESTROYED" || code === "ERR_STREAM_WRITE_AFTER_END") return true;
+	return false;
 }
 var invalidHeadersPattern = /^:(method|scheme|authority|path)$/i;
 function normalizeUrl(url, base) {
-  const DOUBLE_SLASH_REG = /\/\/|\\\\/g;
-  return new URL(url.replace(DOUBLE_SLASH_REG, "/"), base);
+	return normalizeRequestUrl(url, base);
+}
+function getUrl(req, origin) {
+	return normalizeUrl(req.originalUrl || req.url || "/", origin);
+}
+function createNodeResponseSink(res) {
+	let closed = res.closed || res.destroyed;
+	let responseError;
+	let resolveClosed;
+	const closedPromise = closed ? Promise.resolve() : new Promise((resolve) => {
+		resolveClosed = resolve;
+		res.once("close", () => {
+			closed = true;
+			resolve();
+		});
+	});
+	res.on("error", (error) => {
+		if (responseError === void 0) responseError = error;
+		if (!closed) {
+			closed = true;
+			resolveClosed();
+		}
+	});
+	const shouldPropagateResponseError = () => responseError !== void 0 && !isClientAbortWriteError(responseError);
+	const write = (chunk) => {
+		if (closed || res.closed || res.destroyed) {
+			if (shouldPropagateResponseError()) return Promise.reject(responseError);
+			return;
+		}
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let onDrain;
+			const cleanupDrain = () => {
+				if (onDrain) {
+					res.off("drain", onDrain);
+					onDrain = void 0;
+				}
+			};
+			const finish = () => {
+				if (settled) return;
+				settled = true;
+				cleanupDrain();
+				setImmediate(resolve);
+			};
+			const finishClosed = () => {
+				closed = true;
+				finish();
+			};
+			const fail = (error) => {
+				if (settled) return;
+				settled = true;
+				closed = true;
+				cleanupDrain();
+				reject(error);
+			};
+			closedPromise.then(() => {
+				if (shouldPropagateResponseError()) {
+					fail(responseError);
+					return;
+				}
+				finish();
+			});
+			let ok;
+			try {
+				ok = res.write(chunk, (error) => {
+					if (error) {
+						if (isClientAbortWriteError(error)) {
+							finishClosed();
+							return;
+						}
+						fail(error);
+						return;
+					}
+					finish();
+				});
+			} catch (error) {
+				if (isClientAbortWriteError(error)) {
+					finishClosed();
+					return;
+				}
+				fail(error);
+				return;
+			}
+			if (settled) return;
+			if (ok) finish();
+			else {
+				onDrain = () => {
+					onDrain = void 0;
+					finish();
+				};
+				res.once("drain", onDrain);
+			}
+		});
+	};
+	const close = () => {
+		if (closed || res.closed || res.destroyed) {
+			if (shouldPropagateResponseError()) return Promise.reject(responseError);
+			return;
+		}
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			const finish = () => {
+				if (settled) return;
+				settled = true;
+				closed = true;
+				resolve();
+			};
+			const fail = (error) => {
+				if (settled) return;
+				settled = true;
+				closed = true;
+				reject(error);
+			};
+			closedPromise.then(() => {
+				if (shouldPropagateResponseError()) {
+					fail(responseError);
+					return;
+				}
+				finish();
+			});
+			res.once("finish", finish);
+			try {
+				res.end();
+			} catch (error) {
+				if (isClientAbortWriteError(error)) {
+					finish();
+					return;
+				}
+				fail(error);
+			}
+		});
+	};
+	return {
+		write,
+		close
+	};
 }
-async function fromNodeHttp(url, req, res, mode, getClientConn) {
-  const requestHeaders = new Headers();
-  const nodeRequestHeaders = req.headers;
-  try {
-    for (const [key, value] of Object.entries(nodeRequestHeaders)) {
-      if (invalidHeadersPattern.test(key)) {
-        continue;
-      }
-      if (typeof value === "string") {
-        requestHeaders.set(key, value);
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          requestHeaders.append(key, v);
-        }
-      }
-    }
-  } catch (err) {
-    console.error(err);
-  }
-  const getRequestBody = async function* () {
-    for await (const chunk of req) {
-      yield chunk;
-    }
-  };
-  const body = req.method === "HEAD" || req.method === "GET" ? void 0 : getRequestBody();
-  const controller = new AbortController();
-  const options = {
-    method: req.method,
-    headers: requestHeaders,
-    body,
-    signal: controller.signal,
-    duplex: "half"
-  };
-  res.on("close", () => {
-    controller.abort();
-  });
-  const serverRequestEv = {
-    mode,
-    url,
-    request: new Request(url.href, options),
-    env: {
-      get(key) {
-        return process.env[key];
-      }
-    },
-    getWritableStream: (status, headers, cookies) => {
-      res.statusCode = status;
-      try {
-        for (const [key, value] of headers) {
-          if (invalidHeadersPattern.test(key)) {
-            continue;
-          }
-          res.setHeader(key, value);
-        }
-        const cookieHeaders = cookies.headers();
-        if (cookieHeaders.length > 0) {
-          res.setHeader("Set-Cookie", cookieHeaders);
-        }
-      } catch (err) {
-        console.error(err);
-      }
-      return new WritableStream({
-        write(chunk) {
-          if (res.closed || res.destroyed) {
-            return;
-          }
-          res.write(chunk, (error) => {
-            if (error && !isIgnoredError(error.message)) {
-              console.error(error);
-            }
-          });
-        },
-        close() {
-          res.end();
-        }
-      });
-    },
-    getClientConn: () => {
-      return getClientConn ? getClientConn(req) : {
-        ip: req.socket.remoteAddress
-      };
-    },
-    platform: {
-      ssr: true,
-      incomingMessage: req,
-      node: process.versions.node
-      // Weirdly needed to make typecheck of insights happy
-    },
-    locale: void 0
-  };
-  return serverRequestEv;
+async function fromNodeHttp(url, req, res, mode, getClientConn, requestBodyLimit = DEFAULT_REQUEST_BODY_LIMIT) {
+	validateRequestBodyLimit(requestBodyLimit);
+	const requestHeaders = new Headers();
+	const nodeRequestHeaders = req.headers;
+	try {
+		for (const [key, value] of Object.entries(nodeRequestHeaders)) {
+			if (invalidHeadersPattern.test(key)) continue;
+			if (typeof value === "string") requestHeaders.set(key, value);
+			else if (Array.isArray(value)) for (const v of value) requestHeaders.append(key, v);
+		}
+	} catch (err) {
+		console.error(err);
+	}
+	const getRequestBody = async function* () {
+		let received = 0;
+		for await (const chunk of req) {
+			const byteLength = typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.byteLength;
+			if (byteLength > requestBodyLimit - received) {
+				req.resume();
+				throw new RequestBodyLimitError(requestBodyLimit);
+			}
+			received += byteLength;
+			yield chunk;
+		}
+	};
+	const body = req.method === "HEAD" || req.method === "GET" ? void 0 : getRequestBody();
+	const controller = new AbortController();
+	const abort = () => {
+		controller.abort();
+	};
+	const options = {
+		method: req.method,
+		headers: requestHeaders,
+		body,
+		signal: controller.signal,
+		duplex: "half"
+	};
+	req.on("aborted", abort);
+	req.on("error", abort);
+	res.on("close", abort);
+	res.on("error", abort);
+	return {
+		mode,
+		url,
+		request: new Request(url.href, options),
+		env: { get(key) {
+			return process.env[key];
+		} },
+		getWritableStream: (status, headers, cookies, resolve) => {
+			res.statusCode = status;
+			const sink = createNodeResponseSink(res);
+			try {
+				for (const [key, value] of headers) {
+					if (invalidHeadersPattern.test(key)) continue;
+					res.setHeader(key, value);
+				}
+				const cookieHeaders = cookies.headers();
+				if (cookieHeaders.length > 0) res.setHeader("Set-Cookie", cookieHeaders);
+			} catch (err) {
+				console.error(err);
+			}
+			resolve(true);
+			return new WritableStream({
+				write(chunk) {
+					return sink.write(chunk);
+				},
+				close() {
+					return sink.close();
+				}
+			});
+		},
+		getClientConn: () => {
+			return getClientConn ? getClientConn(req) : { ip: req.socket.remoteAddress };
+		},
+		platform: {
+			ssr: true,
+			incomingMessage: req,
+			node: process.versions.node
+		},
+		locale: void 0
+	};
 }
-
-// packages/qwik-router/src/middleware/node/index.ts
-function createQwikRouter(opts) {
-  var _a;
-  if (opts.qwikCityPlan && !opts.qwikRouterConfig) {
-    console.warn("qwikCityPlan is deprecated. Use qwikRouterConfig instead.");
-    opts.qwikRouterConfig = opts.qwikCityPlan;
-  } else if (!opts.qwikRouterConfig) {
-    throw new Error("qwikRouterConfig is required.");
-  }
-  const qwikSerializer = {
-    _deserialize,
-    _serialize,
-    _verifySerializable
-  };
-  if (opts.manifest) {
-    setServerPlatform(opts.manifest);
-  }
-  const staticFolder = ((_a = opts.static) == null ? void 0 : _a.root) ?? join(fileURLToPath(import.meta.url), "..", "..", "dist");
-  const router = async (req, res, next) => {
-    try {
-      const origin = computeOrigin(req, opts);
-      const serverRequestEv = await fromNodeHttp(
-        getUrl(req, origin),
-        req,
-        res,
-        "server",
-        opts.getClientConn
-      );
-      const handled = await requestHandler(serverRequestEv, opts, qwikSerializer);
-      if (handled) {
-        const err = await handled.completion;
-        if (err) {
-          throw err;
-        }
-        if (handled.requestEv.headersSent) {
-          return;
-        }
-      }
-      next();
-    } catch (e) {
-      console.error(e);
-      next(e);
-    }
-  };
-  const notFound = async (req, res, next) => {
-    try {
-      if (!res.headersSent) {
-        const origin = computeOrigin(req, opts);
-        const url = getUrl(req, origin);
-        const notFoundHtml = isStaticPath(req.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
-        res.writeHead(404, {
-          "Content-Type": "text/html; charset=utf-8",
-          "X-Not-Found": url.pathname
-        });
-        res.end(notFoundHtml);
-      }
-    } catch (e) {
-      console.error(e);
-      next(e);
-    }
-  };
-  const staticFile = async (req, res, next) => {
-    var _a2;
-    try {
-      const origin = computeOrigin(req, opts);
-      const url = getUrl(req, origin);
-      if (isStaticPath(req.method || "GET", url)) {
-        const pathname = url.pathname;
-        let filePath;
-        if (basename(pathname).includes(".")) {
-          filePath = join(staticFolder, pathname);
-        } else if (opts.qwikRouterConfig.trailingSlash) {
-          filePath = join(staticFolder, pathname + "index.html");
-        } else {
-          filePath = join(staticFolder, pathname, "index.html");
-        }
-        const ext = extname(filePath).replace(/^\./, "");
-        const stream = createReadStream(filePath);
-        stream.on("error", next);
-        const contentType = MIME_TYPES[ext];
-        if (contentType) {
-          res.setHeader("Content-Type", contentType);
-        }
-        if ((_a2 = opts.static) == null ? void 0 : _a2.cacheControl) {
-          res.setHeader("Cache-Control", opts.static.cacheControl);
-        }
-        stream.pipe(res);
-        return;
-      }
-      return next();
-    } catch (e) {
-      console.error(e);
-      next(e);
-    }
-  };
-  return {
-    router,
-    notFound,
-    staticFile
-  };
+/** @public */ function createQwikRouter(opts) {
+	if (opts.manifest) setServerPlatform(opts.manifest);
+	const staticFolder = opts.static?.root ?? join(fileURLToPath(import.meta.url), "..", "..", "dist");
+	const router = async (req, res, next, limits = {}) => {
+		try {
+			const origin = computeOrigin(req, opts);
+			let requestBodyLimit = opts.requestBodyLimit;
+			if (limits?.bodyLimit !== void 0) {
+				if (requestBodyLimit === void 0) requestBodyLimit = limits.bodyLimit;
+				else requestBodyLimit = Math.min(requestBodyLimit, limits.bodyLimit);
+			}
+			const serverRequestEv = await fromNodeHttp(getUrl(req, origin), req, res, "server", opts.getClientConn, requestBodyLimit);
+			if (isDev && opts.platform) Object.assign(serverRequestEv.platform, opts.platform);
+			if (isDev) {
+				const loader = devPreloadedRouteLoaders.get(req);
+				if (loader) {
+					devPreloadedRouteLoaders.set(serverRequestEv.request, loader);
+					devPreloadedRouteLoaders.delete(req);
+				}
+			}
+			const handled = await requestHandler(serverRequestEv, opts);
+			if (handled) {
+				const err = await handled.completion;
+				if (handled.requestEv.headersSent) return;
+				if (err) throw err;
+			}
+			next();
+		} catch (e) {
+			console.error(e);
+			next(e);
+		}
+	};
+	/** @deprecated `router` handles 404 responses. Will be removed in V3. */ const notFound = async (_req, _res, next) => next();
+	const staticFile = async (req, res, next) => {
+		try {
+			const url = getUrl(req, computeOrigin(req, opts));
+			if (isStaticPath(req.method || "GET", url)) {
+				const pathname = url.pathname;
+				let filePath;
+				if (basename(pathname).includes(".")) filePath = join(staticFolder, pathname);
+				else if (!globalThis.__NO_TRAILING_SLASH__) filePath = join(staticFolder, pathname + "index.html");
+				else filePath = join(staticFolder, pathname, "index.html");
+				const ext = extname(filePath).replace(/^\./, "");
+				const stream = createReadStream(filePath);
+				stream.on("error", next);
+				const contentType = MIME_TYPES[ext];
+				if (contentType) res.setHeader("Content-Type", contentType);
+				if (opts.static?.cacheControl) res.setHeader("Cache-Control", opts.static.cacheControl);
+				stream.pipe(res);
+				return;
+			}
+			return next();
+		} catch (e) {
+			console.error(e);
+			next(e);
+		}
+	};
+	return {
+		router,
+		notFound,
+		staticFile
+	};
 }
-var createQwikCity = createQwikRouter;
-export {
-  createQwikCity,
-  createQwikRouter
-};
+/**
+* @deprecated Use `createQwikRouter` instead. Will be removed in V3
+* @public
+*/ var createQwikCity = createQwikRouter;
+export { createQwikCity, createQwikRouter };