feat(lambda-at-edge): no-op rewrite support (#759)

serverless-nextjs · Nov 3, 2020 · 2107ab1 · 2107ab1
1 parent dff1d46
commit 2107ab1
Show file tree

Hide file tree

Showing 5 changed files with 91 additions and 9 deletions.
diff --git a/packages/libs/lambda-at-edge/src/api-handler.ts b/packages/libs/lambda-at-edge/src/api-handler.ts
@@ -84,15 +84,21 @@ export const handler = async (
   let isNonDynamicRoute =
     buildManifest.apis.nonDynamic[normaliseUri(request.uri)];
 
+  let uri = normaliseUri(request.uri);
+
   if (!isNonDynamicRoute) {
-    const customRewrite = getRewritePath(request.uri, routesManifest);
+    const customRewrite = getRewritePath(
+      request.uri,
+      routesManifest,
+      router(manifest),
+      uri
+    );
     if (customRewrite) {
       request.uri = customRewrite;
+      uri = normaliseUri(request.uri);
     }
   }
 
-  const uri = normaliseUri(request.uri);
-
   const pagePath = router(manifest)(uri);
 
   if (!pagePath) {

diff --git a/packages/libs/lambda-at-edge/src/default-handler.ts b/packages/libs/lambda-at-edge/src/default-handler.ts
@@ -150,6 +150,10 @@ const router = (
       return ssr.nonDynamic[normalisedUri];
     }
 
+    if (html.nonDynamic[normalisedUri]) {
+      return html.nonDynamic[normalisedUri];
+    }
+
     for (const route in allDynamicRoutes) {
       const { file, regex } = allDynamicRoutes[route];
 
@@ -311,7 +315,12 @@ const handleOriginRequest = async ({
 
   // Handle custom rewrites, but don't rewrite non-dynamic pages, public files or data requests per Next.js docs: https://nextjs.org/docs/api-reference/next.config.js/rewrites
   if (!isNonDynamicRoute && !isDataReq) {
-    const customRewrite = getRewritePath(request.uri, routesManifest);
+    const customRewrite = getRewritePath(
+      request.uri,
+      routesManifest,
+      router(manifest),
+      uri
+    );
     if (customRewrite) {
       request.uri = customRewrite;
       uri = normaliseUri(request.uri);

diff --git a/packages/libs/lambda-at-edge/src/routing/rewriter.ts b/packages/libs/lambda-at-edge/src/routing/rewriter.ts
@@ -5,18 +5,33 @@ import { RewriteData, RoutesManifest } from "../../types";
  * Get the rewrite of the given path, if it exists. Otherwise return null.
  * @param path
  * @param routesManifest
+ * @param router
+ * @param normalisedPath
  */
 export function getRewritePath(
   path: string,
-  routesManifest: RoutesManifest
+  routesManifest: RoutesManifest,
+  router: (uri: string) => string | null,
+  normalisedPath: string
 ): string | null {
   const rewrites: RewriteData[] = routesManifest.rewrites;
 
   for (const rewrite of rewrites) {
     const match = matchPath(path, rewrite.source);
 
     if (match) {
-      return compileDestination(rewrite.destination, match.params);
+      const destination = compileDestination(rewrite.destination, match.params);
+
+      // No-op rewrite support: skip to next rewrite if path does not map to existing non-dynamic and dynamic routes
+      if (path === destination) {
+        const url = router(normalisedPath);
+
+        if (url === "pages/404.html" || url === "pages/_error.js") {
+          continue;
+        }
+      }
+
+      return destination;
     }
   }
 

diff --git a/packages/libs/lambda-at-edge/tests/routing/rewriter.test.ts b/packages/libs/lambda-at-edge/tests/routing/rewriter.test.ts
@@ -4,6 +4,7 @@ import { RoutesManifest } from "../../types";
 describe("Rewriter Tests", () => {
   describe("getRewritePath()", () => {
     let routesManifest: RoutesManifest;
+    let router: (path: string) => string | null;
 
     beforeAll(() => {
       routesManifest = {
@@ -32,7 +33,12 @@ describe("Rewriter Tests", () => {
             regex: "^/invalid-destination$"
           }
         ],
-        redirects: []
+        redirects: [],
+        headers: []
+      };
+
+      router = (path: string): string | null => {
+        return path;
       };
     });
 
@@ -46,9 +52,54 @@ describe("Rewriter Tests", () => {
       ${"/external"}            | ${"https://example.com"}
       ${"/invalid-destination"} | ${null}
     `(
-      "redirects path $path to $expectedRedirect",
+      "rewrites path $path to $expectedRewrite",
       ({ path, expectedRewrite }) => {
-        const rewrite = getRewritePath(path, routesManifest);
+        const rewrite = getRewritePath(path, routesManifest, router, path);
+
+        if (expectedRewrite) {
+          expect(rewrite).toEqual(expectedRewrite);
+        } else {
+          expect(rewrite).toBeNull();
+        }
+      }
+    );
+
+    it.each`
+      path    | expectedRewrite
+      ${"/a"} | ${"/a"}
+      ${"/b"} | ${"/another/b"}
+    `(
+      "no-op rewrite: rewrites $path to $expectedRewrite",
+      ({ path, expectedRewrite }) => {
+        routesManifest = {
+          basePath: "",
+          rewrites: [
+            {
+              source: "/:path*",
+              destination: "/:path*",
+              regex: "^(?:/((?:[^/]+?)(?:/(?:[^/]+?))*))?$"
+            },
+            {
+              source: "/:path*",
+              destination: "/another/:path*",
+              regex: "^/path(?:/([^/]+?))$"
+            }
+          ],
+          redirects: [],
+          headers: []
+        };
+
+        router = (path: string): string | null => {
+          if (path === "/a") {
+            return "pages/a.html";
+          } else if (path === "/b") {
+            return "pages/404.html";
+          } else {
+            return null;
+          }
+        };
+
+        const rewrite = getRewritePath(path, routesManifest, router, path);
 
         if (expectedRewrite) {
           expect(rewrite).toEqual(expectedRewrite);

diff --git a/packages/libs/lambda-at-edge/types.d.ts b/packages/libs/lambda-at-edge/types.d.ts
@@ -103,6 +103,7 @@ export type RedirectData = {
 export type RewriteData = {
   source: string;
   destination: string;
+  regex: string;
 };
 
 export type Header = {