@qwik.dev/router 2.0.0-alpha.9 → 2.0.0-beta.10

package/lib/middleware/node/index.mjs

@@ -1,15 +1,10 @@
-// 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 { 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 { fileURLToPath } from "node:url";
-
-// packages/qwik-router/src/middleware/request-handler/mime-types.ts
-var MIME_TYPES = {
+import { setServerPlatform as R } from "@qwik.dev/core/server";
+import { requestHandler as b, isStaticPath as x, getNotFound as C } from "@qwik.dev/router/middleware/request-handler";
+import { createReadStream as k } from "node:fs";
+import { join as v, basename as S, extname as T } from "node:path";
+import { fileURLToPath as j } from "node:url";
+import { Http2ServerRequest as O } from "node:http2";
+const _ = {
   "3gp": "video/3gpp",
   "3gpp": "video/3gpp",
   asf: "video/x-ms-asf",
@@ -59,229 +54,152 @@ var MIME_TYPES = {
   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 w(e, t) {
+  return t?.getOrigin?.(e) ?? t?.origin ?? process.env.ORIGIN ?? A(e);
 }
-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}`;
+function A(e) {
+  const { PROTOCOL_HEADER: t, HOST_HEADER: n } = process.env, u = e.headers, h = t && u[t] || (e.socket.encrypted || e.connection.encrypted ? "https" : "http"), o = n ?? (e instanceof O ? ":authority" : "host"), r = u[o];
+  return `${h}://${r}`;
 }
-function getUrl(req, origin) {
-  return normalizeUrl(req.originalUrl || req.url || "/", origin);
+function y(e, t) {
+  return F(e.originalUrl || e.url || "/", t);
 }
-function isIgnoredError(message = "") {
-  const ignoredErrors = ["The stream has been destroyed", "write after end"];
-  return ignoredErrors.some((ignored) => message.includes(ignored));
+function P(e = "") {
+  return ["The stream has been destroyed", "write after end"].some((n) => e.includes(n));
 }
-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);
+const H = /^:(method|scheme|authority|path)$/i;
+function F(e, t) {
+  const n = /\/\/|\\\\/g;
+  return new URL(e.replace(n, "/"), t);
 }
-async function fromNodeHttp(url, req, res, mode, getClientConn) {
-  const requestHeaders = new Headers();
-  const nodeRequestHeaders = req.headers;
+async function L(e, t, n, u, h) {
+  const o = new Headers(), r = t.headers;
   try {
-    for (const [key, value] of Object.entries(nodeRequestHeaders)) {
-      if (invalidHeadersPattern.test(key)) {
-        continue;
+    for (const [a, l] of Object.entries(r))
+      if (!H.test(a)) {
+        if (typeof l == "string")
+          o.set(a, l);
+        else if (Array.isArray(l))
+          for (const f of l)
+            o.append(a, f);
       }
-      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);
+  } catch (a) {
+    console.error(a);
   }
-  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,
+  const m = async function* () {
+    for await (const a of t)
+      yield a;
+  }, i = t.method === "HEAD" || t.method === "GET" ? void 0 : m(), c = new AbortController(), s = {
+    method: t.method,
+    headers: o,
+    body: i,
+    signal: c.signal,
     duplex: "half"
   };
-  res.on("close", () => {
-    controller.abort();
-  });
-  const serverRequestEv = {
-    mode,
-    url,
-    request: new Request(url.href, options),
+  return n.on("close", () => {
+    c.abort();
+  }), {
+    mode: u,
+    url: e,
+    request: new Request(e.href, s),
     env: {
-      get(key) {
-        return process.env[key];
+      get(a) {
+        return process.env[a];
       }
     },
-    getWritableStream: (status, headers, cookies) => {
-      res.statusCode = status;
+    getWritableStream: (a, l, f) => {
+      n.statusCode = a;
       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);
+        for (const [g, E] of l)
+          H.test(g) || n.setHeader(g, E);
+        const p = f.headers();
+        p.length > 0 && n.setHeader("Set-Cookie", p);
+      } catch (p) {
+        console.error(p);
       }
       return new WritableStream({
-        write(chunk) {
-          if (res.closed || res.destroyed) {
-            return;
-          }
-          res.write(chunk, (error) => {
-            if (error && !isIgnoredError(error.message)) {
-              console.error(error);
-            }
+        write(p) {
+          n.closed || n.destroyed || n.write(p, (g) => {
+            g && !P(g.message) && console.error(g);
           });
         },
         close() {
-          res.end();
+          n.end();
         }
       });
     },
-    getClientConn: () => {
-      return getClientConn ? getClientConn(req) : {
-        ip: req.socket.remoteAddress
-      };
+    getClientConn: () => h ? h(t) : {
+      ip: t.socket.remoteAddress
     },
     platform: {
-      ssr: true,
-      incomingMessage: req,
+      ssr: !0,
+      incomingMessage: t,
       node: process.versions.node
       // Weirdly needed to make typecheck of insights happy
     },
     locale: void 0
   };
-  return serverRequestEv;
 }
-
-// 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;
+function N(e) {
+  e.qwikCityPlan && !e.qwikRouterConfig && (console.warn("qwikCityPlan is deprecated. Simply remove it."), e.qwikRouterConfig = e.qwikCityPlan), e.manifest && R(e.manifest);
+  const t = e.static?.root ?? v(j(import.meta.url), "..", "..", "dist");
+  return {
+    router: async (o, r, m) => {
+      try {
+        const i = w(o, e), c = await L(
+          y(o, i),
+          o,
+          r,
+          "server",
+          e.getClientConn
+        ), s = await b(c, e);
+        if (s) {
+          const d = await s.completion;
+          if (d)
+            throw d;
+          if (s.requestEv.headersSent)
+            return;
         }
+        m();
+      } catch (i) {
+        console.error(i), m(i);
       }
-      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);
+    },
+    notFound: async (o, r, m) => {
+      try {
+        if (!r.headersSent) {
+          const i = w(o, e), c = y(o, i), s = !o.headers.accept?.includes("text/html") || x(o.method || "GET", c) ? "Not Found" : C(c.pathname);
+          r.writeHead(404, {
+            "Content-Type": "text/html; charset=utf-8",
+            "X-Not-Found": c.pathname
+          }), r.end(s);
         }
-        if ((_a2 = opts.static) == null ? void 0 : _a2.cacheControl) {
-          res.setHeader("Cache-Control", opts.static.cacheControl);
+      } catch (i) {
+        console.error(i), m(i);
+      }
+    },
+    staticFile: async (o, r, m) => {
+      try {
+        const i = w(o, e), c = y(o, i);
+        if (x(o.method || "GET", c)) {
+          const s = c.pathname;
+          let d;
+          S(s).includes(".") ? d = v(t, s) : globalThis.__NO_TRAILING_SLASH__ ? d = v(t, s, "index.html") : d = v(t, s + "index.html");
+          const a = T(d).replace(/^\./, ""), l = k(d);
+          l.on("error", m);
+          const f = _[a];
+          f && r.setHeader("Content-Type", f), e.static?.cacheControl && r.setHeader("Cache-Control", e.static.cacheControl), l.pipe(r);
+          return;
         }
-        stream.pipe(res);
-        return;
+        return m();
+      } catch (i) {
+        console.error(i), m(i);
       }
-      return next();
-    } catch (e) {
-      console.error(e);
-      next(e);
     }
   };
-  return {
-    router,
-    notFound,
-    staticFile
-  };
 }
-var createQwikCity = createQwikRouter;
+const $ = N;
 export {
-  createQwikCity,
-  createQwikRouter
+  $ as createQwikCity,
+  N as createQwikRouter
 };