Core refactor part 2

packages/libs/core/package.json

@@ -31,9 +31,12 @@
   "homepage": "https://github.com/serverless-nextjs/serverless-next.js#readme",
   "dependencies": {
     "@hapi/accept": "^5.0.1",
+    "jsonwebtoken": "^8.5.1",
     "regex-parser": "^2.2.10"
   },
   "devDependencies": {
+    "@types/cookie": "^0.4.0",
+    "@types/jsonwebtoken": "^8.5.0",
     "typescript": "^3.9.6"
   }
 }

packages/libs/core/src/api.ts

@@ -0,0 +1,50 @@
+import { normalise } from "./basepath";
+import { matchDynamic } from "./match";
+import { getRewritePath, isExternalRewrite } from "./rewrite";
+import { ApiManifest, ApiRoute, ExternalRoute, RoutesManifest } from "./types";
+
+export const handleApiReq = (
+  uri: string,
+  manifest: ApiManifest,
+  routesManifest: RoutesManifest,
+  isRewrite?: boolean
+): ExternalRoute | ApiRoute | undefined => {
+  const { apis } = manifest;
+  const normalisedUri = normalise(uri, routesManifest);
+
+  const nonDynamic = apis.nonDynamic[normalisedUri];
+  if (nonDynamic) {
+    return {
+      isApi: true,
+      page: nonDynamic
+    };
+  }
+
+  const rewrite = !isRewrite && getRewritePath(uri, routesManifest);
+  if (rewrite) {
+    const [path, querystring] = rewrite.split("?");
+    if (isExternalRewrite(path)) {
+      return {
+        isExternal: true,
+        path,
+        querystring
+      };
+    }
+    const route = handleApiReq(path, manifest, routesManifest, true);
+    if (route) {
+      return {
+        ...route,
+        querystring
+      };
+    }
+    return route;
+  }
+
+  const dynamic = matchDynamic(normalisedUri, Object.values(apis.dynamic));
+  if (dynamic) {
+    return {
+      isApi: true,
+      page: dynamic
+    };
+  }
+};

packages/libs/core/src/basepath.ts

@@ -0,0 +1,28 @@
+import { RoutesManifest } from "./types";
+
+export const normalise = (
+  uri: string,
+  routesManifest: RoutesManifest
+): string => {
+  const { basePath, i18n } = routesManifest;
+  if (basePath) {
+    if (uri.startsWith(basePath)) {
+      uri = uri.slice(basePath.length);
+    } else {
+      // basePath set but URI does not start with basePath, return 404
+      if (i18n?.defaultLocale) {
+        return `/${i18n.defaultLocale}/404`;
+      } else {
+        return "/404";
+      }
+    }
+  }
+
+  // Remove trailing slash for all paths
+  if (uri.endsWith("/")) {
+    uri = uri.slice(0, -1);
+  }
+
+  // Empty path should be normalised to "/" as there is no Next.js route for ""
+  return uri === "" ? "/" : uri;
+};

packages/libs/core/src/data.ts

@@ -0,0 +1,104 @@
+import { matchDynamic, matchDynamicSSG } from "./match";
+import { DataRoute, PageManifest, StaticRoute } from "./types";
+
+/*
+ * Get page name from data route
+ */
+const normaliseDataUri = (uri: string, buildId: string) => {
+  const prefix = `/_next/data/${buildId}`;
+  if (!uri.startsWith(prefix)) {
+    return uri;
+  }
+  return uri
+    .slice(prefix.length)
+    .replace(/\.json$/, "")
+    .replace(/^(\/index)?$/, "/");
+};
+
+/*
+ * Get full data route uri from page name
+ */
+const fullDataUri = (uri: string, buildId: string) => {
+  const prefix = `/_next/data/${buildId}`;
+  if (uri === "/") {
+    return `${prefix}/index.js`;
+  }
+  return `${prefix}${uri}.json`;
+};
+
+/*
+ * Handles a data route
+ */
+export const handleDataReq = (
+  uri: string,
+  manifest: PageManifest,
+  isPreview: boolean
+): DataRoute | StaticRoute => {
+  const { buildId, pages } = manifest;
+  const normalisedUri = normaliseDataUri(uri, buildId);
+  if (pages.ssg.nonDynamic[normalisedUri] && !isPreview) {
+    return {
+      isData: true,
+      isStatic: true,
+      file: uri
+    };
+  }
+  if (
+    pages.ssr.nonDynamic[normalisedUri] ||
+    pages.ssg.nonDynamic[normalisedUri]
+  ) {
+    return {
+      isData: true,
+      isRender: true,
+      page: pages.ssr.nonDynamic[normalisedUri]
+    };
+  }
+  // TODO: this order reproduces default-handler logic,
+  // should sort all dynamic routes together in build
+  const dynamicSSG = matchDynamicSSG(
+    fullDataUri(normalisedUri, buildId),
+    pages.ssg.dynamic,
+    true
+  );
+  if (dynamicSSG) {
+    return {
+      isData: true,
+      isStatic: true,
+      file: fullDataUri(normalisedUri, buildId)
+    };
+  }
+  const dynamicSSR = matchDynamic(
+    normalisedUri,
+    Object.values(pages.ssr.dynamic)
+  );
+  if (dynamicSSR) {
+    return {
+      isData: true,
+      isRender: true,
+      page: dynamicSSR
+    };
+  }
+  const catchAll = matchDynamic(
+    normalisedUri,
+    Object.values(pages.ssr.catchAll)
+  );
+  if (catchAll) {
+    return {
+      isData: true,
+      isRender: true,
+      page: catchAll
+    };
+  }
+  if (pages.html.nonDynamic["/404"]) {
+    return {
+      isData: false,
+      isStatic: true,
+      file: "pages/404.html"
+    };
+  }
+  return {
+    isData: true,
+    isRender: true,
+    page: "pages/_error.js"
+  };
+};

packages/libs/core/src/index.ts

@@ -1,4 +1,9 @@
+import { handleApiReq } from "./api";
 import { getUnauthenticatedResponse } from "./auth";
+import { normalise } from "./basepath";
+import { handleDataReq } from "./data";
+import { handlePageReq } from "./page";
+import { isValidPreviewRequest } from "./preview";
 import {
   createRedirectResponse,
   getDomainRedirectPath,
@@ -7,12 +12,17 @@ import {
   getTrailingSlashPath
 } from "./redirect";
 import {
-  UnauthorizedRoute,
+  ApiManifest,
+  ApiRoute,
+  ExternalRoute,
   Manifest,
+  PageManifest,
+  PrerenderManifest,
   RedirectRoute,
   Request,
   Route,
-  RoutesManifest
+  RoutesManifest,
+  UnauthorizedRoute
 } from "./types";
 
 export const handleAuth = (
@@ -26,7 +36,7 @@ export const handleAuth = (
   );
 };
 
-export const handleCustomRedirects = (
+const handleCustomRedirects = (
   req: Request,
   routesManifest: RoutesManifest
 ): RedirectRoute | undefined => {
@@ -47,7 +57,7 @@ export const handleDomainRedirects = (
   }
 };
 
-export const handleLanguageRedirect = async (
+const handleLanguageRedirect = async (
   req: Request,
   manifest: Manifest,
   routesManifest: RoutesManifest
@@ -72,12 +82,12 @@ const handlePublicFiles = (
   if (isPublicFile) {
     return {
       isPublicFile: true,
-      file: decodedUri
+      file: uri
     };
   }
 };
 
-export const handleTrailingSlash = (
+const handleTrailingSlash = (
   req: Request,
   manifest: Manifest,
   isFile: boolean
@@ -88,41 +98,48 @@ export const handleTrailingSlash = (
   }
 };
 
-const normalise = (uri: string, routesManifest: RoutesManifest): string => {
-  const { basePath, i18n } = routesManifest;
-  if (basePath) {
-    if (uri.startsWith(basePath)) {
-      uri = uri.slice(basePath.length);
-    } else {
-      // basePath set but URI does not start with basePath, return 404
-      if (i18n?.defaultLocale) {
-        return `/${i18n.defaultLocale}/404`;
-      } else {
-        return "/404";
-      }
-    }
+/*
+ * Routes:
+ * - auth
+ * - redirects
+ * - api routes
+ * - rewrites (external and api)
+ */
+export const routeApi = (
+  req: Request,
+  manifest: ApiManifest,
+  routesManifest: RoutesManifest
+): ApiRoute | ExternalRoute | RedirectRoute | UnauthorizedRoute | undefined => {
+  const auth = handleAuth(req, manifest);
+  if (auth) {
+    return auth;
   }
 
-  // Remove trailing slash for all paths
-  if (uri.endsWith("/")) {
-    uri = uri.slice(0, -1);
+  const redirect =
+    handleDomainRedirects(req, manifest) ||
+    handleCustomRedirects(req, routesManifest);
+  if (redirect) {
+    return redirect;
   }
 
-  // Empty path should be normalised to "/" as there is no Next.js route for ""
-  return uri === "" ? "/" : uri;
+  return handleApiReq(req.uri, manifest, routesManifest);
 };
 
 /*
  * Routes:
  * - auth
  * - redirects
  * - public files
+ * - data routes
+ * - pages
+ * - rewrites (external and page)
  */
 export const routeDefault = async (
   req: Request,
-  manifest: Manifest,
+  manifest: PageManifest,
+  prerenderManifest: PrerenderManifest,
   routesManifest: RoutesManifest
-): Promise<Route | undefined> => {
+): Promise<Route> => {
   const auth = handleAuth(req, manifest);
   if (auth) {
     return auth;
@@ -145,11 +162,27 @@ export const routeDefault = async (
     return trailingSlash;
   }
 
-  return (
-    publicFile ||
+  if (publicFile) {
+    return publicFile;
+  }
+
+  const otherRedirect =
     handleCustomRedirects(req, routesManifest) ||
-    (await handleLanguageRedirect(req, manifest, routesManifest))
+    (await handleLanguageRedirect(req, manifest, routesManifest));
+  if (otherRedirect) {
+    return otherRedirect;
+  }
+
+  const isPreview = await isValidPreviewRequest(
+    req.headers.cookie,
+    prerenderManifest.preview.previewModeSigningKey
   );
+
+  if (isDataReq) {
+    return handleDataReq(uri, manifest, isPreview);
+  } else {
+    return handlePageReq(req.uri, manifest, routesManifest, isPreview);
+  }
 };
 
 export * from "./types";

packages/libs/core/src/match.ts

@@ -3,6 +3,7 @@
  */
 
 import { compile, Match, match } from "path-to-regexp";
+import { Dynamic, DynamicSSG } from "./types";
 
 /**
  * Match the given path against a source path.
@@ -55,3 +56,29 @@ export function compileDestination(
     return null;
   }
 }
+
+export const matchDynamic = (
+  uri: string,
+  routes: Dynamic[]
+): string | undefined => {
+  for (const { file, regex } of routes) {
+    const re = new RegExp(regex, "i");
+    if (re.test(uri)) {
+      return file;
+    }
+  }
+};
+
+export const matchDynamicSSG = (
+  uri: string,
+  routes: { [key: string]: DynamicSSG },
+  isData: boolean
+): string | undefined => {
+  for (const [key, route] of Object.entries(routes)) {
+    const regex = isData ? route.dataRouteRegex : route.routeRegex;
+    const re = new RegExp(regex, "i");
+    if (re.test(uri)) {
+      return key;
+    }
+  }
+};