@qwik.dev/router 2.0.0-beta.36 → 2.0.0-beta.38

package/lib/middleware/aws-lambda/index.mjs

@@ -1,4 +1,5 @@
 import { createQwikRouter as createQwikRouter$1 } from '@qwik.dev/router/middleware/node';
+import { e as ensureSlash } from '../../chunks/pathname.mjs';
 
 function createQwikRouter(opts) {
   try {
@@ -22,7 +23,7 @@ function createQwikRouter(opts) {
           return pathT;
         }
         if (!url.pathname.endsWith("/")) {
-          return url.pathname + "/" + url.search;
+          return ensureSlash(url.pathname) + url.search;
         }
       }
       return pathT;

package/lib/middleware/azure-swa/index.mjs

@@ -1,5 +1,5 @@
 import { setServerPlatform } from '@qwik.dev/core/server';
-import { requestHandler, isStaticPath, getNotFound } from '@qwik.dev/router/middleware/request-handler';
+import { requestHandler, isStaticPath, getErrorHtml } from '@qwik.dev/router/middleware/request-handler';
 import { parseString } from 'set-cookie-parser';
 
 function createQwikRouter(opts) {
@@ -26,23 +26,27 @@ function createQwikRouter(opts) {
         },
         request: new Request(url, options),
         getWritableStream: (status, headers, cookies, resolve) => {
+          const chunks = [];
+          let bodyLength = 0;
           const response = {
             status,
-            body: new Uint8Array(),
             headers: {},
             cookies: cookies.headers().map((header) => parseString(header))
           };
           headers.forEach((value, key) => response.headers[key] = value);
           return new WritableStream({
             write(chunk) {
-              if (response.body instanceof Uint8Array) {
-                const newBuffer = new Uint8Array(response.body.length + chunk.length);
-                newBuffer.set(response.body);
-                newBuffer.set(chunk, response.body.length);
-                response.body = newBuffer;
-              }
+              chunks.push(chunk.slice());
+              bodyLength += chunk.length;
             },
             close() {
+              const body = new Uint8Array(bodyLength);
+              let offset = 0;
+              for (const chunk of chunks) {
+                body.set(chunk, offset);
+                offset += chunk.length;
+              }
+              response.body = body;
               resolve(response);
             }
           });
@@ -66,7 +70,7 @@ function createQwikRouter(opts) {
           return response;
         }
       }
-      const notFoundHtml = !req.headers.accept?.includes("text/html") || isStaticPath(req.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
+      const notFoundHtml = !req.headers.accept?.includes("text/html") || isStaticPath(req.method || "GET", url) ? "Not Found" : getErrorHtml(404, "Not Found");
       return {
         status: 404,
         headers: {

package/lib/middleware/cloudflare-pages/index.mjs

@@ -1,5 +1,5 @@
 import { setServerPlatform } from '@qwik.dev/core/server';
-import { _TextEncoderStream_polyfill, isStaticPath, mergeHeadersCookies, requestHandler, getNotFound } from '@qwik.dev/router/middleware/request-handler';
+import { _TextEncoderStream_polyfill, isStaticPath, mergeHeadersCookies, requestHandler, getErrorHtml } from '@qwik.dev/router/middleware/request-handler';
 import { isDev } from '@qwik.dev/core/build';
 
 function createQwikRouter(opts) {
@@ -72,7 +72,7 @@ function createQwikRouter(opts) {
           return response;
         }
       }
-      const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
+      const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getErrorHtml(404, "Not Found");
       return new Response(notFoundHtml, {
         status: 404,
         headers: {

package/lib/middleware/deno/index.d.ts

@@ -33,6 +33,8 @@ export declare interface QwikRouterDenoMiddleware {
 
 /** @public */
 export declare interface QwikRouterDenoOptions extends ServerRenderOptions {
+    /** Maximum request body size in bytes. Defaults to 10 MiB. */
+    requestBodyLimit?: number;
     /** Options for serving static files */
     static?: {
         /** The root folder for statics files. Defaults to /dist */

package/lib/middleware/deno/index.mjs

@@ -1,6 +1,7 @@
 import { setServerPlatform } from '@qwik.dev/core/server';
 import { isStaticPath, mergeHeadersCookies, requestHandler } from '@qwik.dev/router/middleware/request-handler';
 import { M as MIME_TYPES, n as normalizeRequestUrl } from '../../chunks/url.mjs';
+import { l as limitRequestBody } from '../../chunks/request-body-limit.mjs';
 import { join, fromFileUrl, extname } from 'https://deno.land/std/path/mod.ts';
 import { isDev } from '@qwik.dev/core/build';
 
@@ -26,7 +27,7 @@ function createQwikRouter(opts) {
         url,
         // @ts-ignore
         env: Deno.env,
-        request,
+        request: limitRequestBody(request, opts.requestBodyLimit),
         getWritableStream: (status, headers, cookies, resolve) => {
           const { readable, writable } = new TransformStream();
           const response = new Response(readable, {

package/lib/middleware/netlify-edge/index.mjs

@@ -1,5 +1,5 @@
 import { setServerPlatform } from '@qwik.dev/core/server';
-import { isStaticPath, mergeHeadersCookies, requestHandler, getNotFound } from '@qwik.dev/router/middleware/request-handler';
+import { isStaticPath, mergeHeadersCookies, requestHandler, getErrorHtml } from '@qwik.dev/router/middleware/request-handler';
 import { isDev } from '@qwik.dev/core/build';
 
 function createQwikRouter(opts) {
@@ -47,7 +47,7 @@ function createQwikRouter(opts) {
           return response;
         }
       }
-      const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getNotFound(url.pathname);
+      const notFoundHtml = !request.headers.get("accept")?.includes("text/html") || isStaticPath(request.method || "GET", url) ? "Not Found" : getErrorHtml(404, "Not Found");
       return new Response(notFoundHtml, {
         status: 404,
         headers: {

package/lib/middleware/node/index.d.ts

@@ -33,14 +33,22 @@ export declare type QwikCityNodeRequestOptions = QwikRouterNodeRequestOptions;
 
 /** @public */
 export declare interface QwikRouterNodeMiddleware {
-    router: (req: IncomingMessage | Http2ServerRequest, res: ServerResponse, next: NodeRequestNextFunction) => Promise<void>;
+    router: (req: IncomingMessage | Http2ServerRequest, res: ServerResponse, next: NodeRequestNextFunction, limits?: QwikRouterNodeRequestLimits) => Promise<void>;
     /** @deprecated `router` handles 404 responses. Will be removed in V3. */
     notFound: (req: IncomingMessage | Http2ServerRequest, res: ServerResponse, next: (e: any) => void) => Promise<void>;
     staticFile: (req: IncomingMessage | Http2ServerRequest, res: ServerResponse, next: (e?: any) => void) => Promise<void>;
 }
 
+/** @public */
+export declare interface QwikRouterNodeRequestLimits {
+    /** Maximum request body size in bytes imposed by the host. */
+    bodyLimit?: number;
+}
+
 /** @public */
 export declare interface QwikRouterNodeRequestOptions extends ServerRenderOptions {
+    /** Maximum request body size in bytes. Defaults to 10 MiB. */
+    requestBodyLimit?: number;
     /** Options for serving static files */
     static?: {
         /** The root folder for statics files. Defaults to /dist */

package/lib/middleware/node/index.mjs

@@ -5,7 +5,9 @@ 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';
 
 function fallbackOrigin(req) {
   const { PROTOCOL_HEADER, HOST_HEADER } = process.env;
@@ -184,7 +186,8 @@ function createNodeResponseSink(res) {
     close
   };
 }
-async function fromNodeHttp(url, req, res, mode, getClientConn) {
+async function fromNodeHttp(url, req, res, mode, getClientConn, requestBodyLimit = DEFAULT_REQUEST_BODY_LIMIT) {
+  validateRequestBodyLimit(requestBodyLimit);
   const requestHeaders = new Headers();
   const nodeRequestHeaders = req.headers;
   try {
@@ -204,7 +207,14 @@ async function fromNodeHttp(url, req, res, mode, getClientConn) {
     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;
     }
   };
@@ -280,13 +290,28 @@ function createQwikRouter(opts) {
     setServerPlatform(opts.manifest);
   }
   const staticFolder = opts.static?.root ?? join(fileURLToPath(import.meta.url), "..", "..", "dist");
-  const router = async (req, res, next) => {
+  const router = async (req, res, next, limits = {}) => {
     try {
       const origin = computeOrigin(req, opts);
-      const serverRequestEv = await fromNodeHttp(getUrl(req, origin), req, res, "server", opts.getClientConn);
+      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;

package/lib/middleware/request-handler/index.d.ts

@@ -10,11 +10,12 @@ import type { RenderOptions } from '@qwik.dev/core/server';
 import { RequestEvent as RequestEvent_2 } from '@qwik.dev/router/middleware/request-handler';
 import type { RequestHandler as RequestHandler_2 } from '@qwik.dev/router/middleware/request-handler';
 import type { ResolveSyncValue as ResolveSyncValue_2 } from '@qwik.dev/router/middleware/request-handler';
-import { SerializationStrategy } from '@qwik.dev/core/internal';
 import type { ValueOrPromise } from '@qwik.dev/core';
 
 /** @public */
 export declare class AbortMessage {
+    /** Type-only brand so `Exclude<>` can drop control-flow signals from resolved loader/action data. */
+    readonly __controlFlow: true;
 }
 
 /** @internal */
@@ -92,15 +93,35 @@ declare interface CacheControlOptions {
 declare type CacheControlTarget = 'Cache-Control' | 'CDN-Cache-Control' | 'Cloudflare-CDN-Cache-Control' | 'Vercel-CDN-Cache-Control' | '~ANY-OTHER-STRING' | (string & {});
 
 /**
- * The cacheKey export type. When exported from a page module alongside eTag, enables in-memory SSR
- * caching.
+ * Cache key function. Used by `routeConfig.cacheKey` (SSR HTML cache) and by `routeLoader$`'s
+ * `cacheKey` option (per-loader JSON cache).
  *
- * - `true`: use the default cache key `status|eTag|pathname`
- * - Function: receives status, eTag, and pathname; returns a cache key string or null (no cache)
+ * - `true`: use the surface's default key.
+ *
+ *   - SSR default: `${status}|${eTag}|${pathname}` when an eTag is set, otherwise
+ *       `${status}|${pathname}`.
+ *   - Loader default: `${pathname}|${filteredSearch}|${loaderId}|${eTag}` when an eTag is set,
+ *       otherwise `${pathname}|${filteredSearch}|${loaderId}`.
+ * - Function: receives the request event and the normalized, unquoted eTag (or an empty string when
+ *   none was provided). Return the cache key string, or `null` or `''` to skip caching for this
+ *   request. Loader callbacks receive the loader-scoped request event, with `url`, `query`, and
+ *   `request.url` filtered by the loader's `search` allowlist.
+ *
+ * Note: valid cacheKeys are non-empty strings.
+ *
+ * @public
+ */
+declare type CacheKeyFn = true | ((requestEv: RequestEvent_2, eTag: string) => string | null);
+
+/**
+ * Clear the in-memory loader cache. Call after deployments or data changes.
+ *
+ * When `cacheKey` is provided, only that single entry is removed; otherwise the entire cache is
+ * cleared.
  *
  * @public
  */
-declare type CacheKeyFn = true | ((status: number, eTag: string, pathname: string) => string | null);
+export declare function clearLoaderCache(cacheKey?: string): void;
 
 /**
  * Clear the in-memory SSR cache. Call after deployments or data changes.
@@ -141,7 +162,18 @@ declare interface ContentMenu {
 declare type ContentModule = PageModule | LayoutModule;
 
 /**
- * The eTag export type: a static string or a function receiving DocumentHeadProps.
+ * The eTag export type for routeConfig.
+ *
+ * - `string` — static ETag value.
+ * - `(props: DocumentHeadProps) => string | null` — compute the ETag from route context (params, URL,
+ *   loaded data via `resolveValue`, etc.). Return `null` to skip eTag for this request.
+ *
+ * Qwik normalizes eTag values by stripping weak-form `W/` prefixes, quotes, and forbidden chars,
+ * then sends a strong `ETag` header. Values that normalize to an empty string are treated as
+ * absent.
+ *
+ * When set (and a value is produced), the server includes an `ETag` header and returns `304` if
+ * `If-None-Match` matches.
  *
  * @public
  */
@@ -309,6 +341,8 @@ declare type DocumentStyle = Readonly<((Omit<QwikIntrinsicElements['style'], 'da
     style?: never;
 })>;
 
+declare type EndpointModuleLoader = () => ValueOrPromise<RouteModule>;
+
 /** @public */
 export declare interface EnvGetter {
     get(key: string): string | undefined;
@@ -319,19 +353,19 @@ declare type ErrorCodes = ClientErrorCode | ServerErrorCode;
 /** @public */
 export declare function getErrorHtml(status: number, e: any): string;
 
-/**
- * Return the HTML for a 404 page.
- *
- * @internal
- */
-export declare function getNotFound(prefix: string): string;
-
 /**
  * HTTP Informational Status Codes Status codes in the 1xx range indicate that the server has
  * received and is processing the request, but no response is available yet.
  */
 declare type InformationalCode = 100 | 101 | 102 | 103;
 
+/**
+ * Internal JSON request kind handled by Qwik Router, or `false` for normal page requests.
+ *
+ * @public
+ */
+export declare type InternalRequest = false | 'loader' | 'action';
+
 /**
  * Decide whether a given request path is a static path, for optimizing file access.
  *
@@ -359,13 +393,19 @@ declare interface LoadedRoute {
     $routeBundleNames$?: string[] | undefined;
     /** Whether this route is a not-found (404) route */
     $notFound$?: boolean;
-    /** The error module loader (nearest _E ancestor), for rendering ServerErrors */
-    $errorLoader$?: ContentModuleLoader;
+    /** The nearest _E (error.tsx) boundary's chain to render on a thrown ServerError (in its layouts). */
+    $errorLoader$?: ModuleLoader[];
+    /** Merged array of routeLoader$ hashes from all matched nodes (layouts + page) */
+    $loaders$?: string[];
+    /** Runtime-only mapping of routeLoader$ hashes to the matched pathname used for q-loader fetches */
+    $loaderPaths$?: Record<string, string>;
 }
 
 /** @public */
 export declare const mergeHeadersCookies: (headers: Headers, cookies: Cookie) => Headers;
 
+declare type ModuleLoader = ContentModuleLoader | EndpointModuleLoader;
+
 /** @public */
 declare type PageModule = RouteModule & {
     readonly default: (props: Record<string, never>) => JSXOutput;
@@ -464,6 +504,14 @@ export declare interface RequestEventBase<PLATFORM = QwikRouterPlatform> {
     readonly query: URLSearchParams;
     /** HTTP request URL. */
     readonly url: URL;
+    /**
+     * Identifies Qwik Router internal JSON requests, such as route loader fetches and fetch-based
+     * action submissions. Returns `false` for normal page requests.
+     *
+     * Check this before applying broad rewrite rules so internal JSON requests keep their routing
+     * behavior.
+     */
+    readonly internalRequest: InternalRequest;
     /**
      * The original HTTP request URL.
      *
@@ -582,8 +630,6 @@ export declare interface RequestEventCommon<PLATFORM = QwikRouterPlatform> exten
 }
 
 declare interface RequestEventInternal extends Readonly<RequestEvent>, Readonly<RequestEventLoader> {
-    readonly [RequestEvLoaders]: Record<string, ValueOrPromise<unknown> | undefined>;
-    readonly [RequestEvLoaderSerializationStrategyMap]: Map<string, SerializationStrategy>;
     readonly [RequestEvMode]: ServerRequestMode;
     readonly [RequestEvRoute]: LoadedRoute;
     /**
@@ -608,19 +654,12 @@ export declare interface RequestEventLoader<PLATFORM = QwikRouterPlatform> exten
     defer: <T>(returnData: Promise<T> | (() => Promise<T>)) => DeferReturn<T>;
 }
 
-declare const RequestEvLoaders: unique symbol;
-
-declare const RequestEvLoaderSerializationStrategyMap: unique symbol;
-
 declare const RequestEvMode: unique symbol;
 
 declare const RequestEvRoute: unique symbol;
 
-/** @internal */
-export declare const RequestEvShareQData = "qData";
-
 /** @public */
-export declare type RequestHandler<PLATFORM = QwikRouterPlatform> = (ev: RequestEvent<PLATFORM>) => Promise<void> | void;
+export declare type RequestHandler<PLATFORM = QwikRouterPlatform> = (ev: RequestEvent<PLATFORM>) => Promise<void | AbortMessage | ServerError> | void | AbortMessage | ServerError;
 
 /**
  * The request handler for QwikRouter. Called by every adapter.