@qwik.dev/router 2.0.0-beta.39 → 2.0.0-beta.40

package/lib/middleware/node/index.mjs

@@ -1,373 +1,313 @@
-import { isDev } from '@qwik.dev/core';
-import { setServerPlatform } from '@qwik.dev/core/server';
-import { isStaticPath, requestHandler } from '@qwik.dev/router/middleware/request-handler';
-import { createReadStream } from 'node:fs';
-import { join, basename, extname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { n as normalizeRequestUrl, M as MIME_TYPES } from '../../chunks/url.mjs';
-import { d as devPreloadedRouteLoaders } from '../../chunks/dev-preloaded-route-loader.mjs';
-import { Http2ServerRequest } from 'node:http2';
-import { D as DEFAULT_REQUEST_BODY_LIMIT, v as validateRequestBodyLimit, R as RequestBodyLimitError } from '../../chunks/request-body-limit.mjs';
-
+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 { 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";
+import { Http2ServerRequest } from "node:http2";
 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 computeOrigin(req, opts) {
-  return opts?.getOrigin?.(req) ?? opts?.origin ?? process.env.ORIGIN ?? fallbackOrigin(req);
+	return opts?.getOrigin?.(req) ?? opts?.origin ?? process.env.ORIGIN ?? fallbackOrigin(req);
 }
 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;
+	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;
 }
-const invalidHeadersPattern = /^:(method|scheme|authority|path)$/i;
+var invalidHeadersPattern = /^:(method|scheme|authority|path)$/i;
 function normalizeUrl(url, base) {
-  return normalizeRequestUrl(url, base);
+	return normalizeRequestUrl(url, base);
 }
 function getUrl(req, origin) {
-  return normalizeUrl(req.originalUrl || req.url || "/", 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
-  };
+	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, 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);
-  const serverRequestEv = {
-    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
-  };
-  return serverRequestEv;
+	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
+	};
 }
-
-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);
-    }
-  };
-  const notFound = async (_req, _res, next) => next();
-  const staticFile = async (req, res, next) => {
-    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 (!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
-  };
+/** @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
+	};
 }
-const createQwikCity = createQwikRouter;
-
+/**
+* @deprecated Use `createQwikRouter` instead. Will be removed in V3
+* @public
+*/ var createQwikCity = createQwikRouter;
 export { createQwikCity, createQwikRouter };