opennextjs · conico974 · Jun 29, 2023 · Jul 3, 2023 · Jul 6, 2023 · Jul 11, 2023
diff --git a/packages/open-next/package.json b/packages/open-next/package.json
@@ -41,6 +41,7 @@
     "@node-minify/terser": "^8.0.6",
     "@tsconfig/node18": "^1.0.1",
     "esbuild": "^0.15.18",
+    "path-to-regexp": "^6.2.1",
     "promise.series": "^0.2.0"
   },
   "devDependencies": {

diff --git a/packages/open-next/src/adapters/event-mapper.ts b/packages/open-next/src/adapters/event-mapper.ts
@@ -10,13 +10,15 @@ import type {
 
 import { debug } from "./logger.js";
 
-type InternalEvent = {
+export type InternalEvent = {
   readonly type: "v1" | "v2" | "cf";
   readonly method: string;
   readonly rawPath: string;
   readonly url: string;
   readonly body: Buffer;
   readonly headers: Record<string, string>;
+  readonly query: Record<string, string | string[]>;
+  readonly cookies: Record<string, string>;
   readonly remoteAddress: string;
 };
 
@@ -72,6 +74,18 @@ export function convertTo(
   throw new Error("Unsupported event type");
 }
 
+function removeUndefinedFromQuery(
+  query: Record<string, string | string[] | undefined>,
+) {
+  const newQuery: Record<string, string | string[]> = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined) {
+      newQuery[key] = value;
+    }
+  }
+  return newQuery;
+}
+
 function convertFromAPIGatewayProxyEvent(
   event: APIGatewayProxyEvent,
 ): InternalEvent {
@@ -84,6 +98,14 @@ function convertFromAPIGatewayProxyEvent(
     body: Buffer.from(body ?? "", isBase64Encoded ? "base64" : "utf8"),
     headers: normalizeAPIGatewayProxyEventHeaders(event),
     remoteAddress: requestContext.identity.sourceIp,
+    query: removeUndefinedFromQuery(
+      event.multiValueQueryStringParameters ?? {},
+    ),
+    cookies:
+      event.multiValueHeaders?.cookie?.reduce((acc, cur) => {
+        const [key, value] = cur.split("=");
+        return { ...acc, [key]: value };
+      }, {}) ?? {},
   };
 }
 
@@ -99,6 +121,12 @@ function convertFromAPIGatewayProxyEventV2(
     body: normalizeAPIGatewayProxyEventV2Body(event),
     headers: normalizeAPIGatewayProxyEventV2Headers(event),
     remoteAddress: requestContext.http.sourceIp,
+    query: removeUndefinedFromQuery(event.queryStringParameters ?? {}),
+    cookies:
+      event.cookies?.reduce((acc, cur) => {
+        const [key, value] = cur.split("=");
+        return { ...acc, [key]: value };
+      }, {}) ?? {},
   };
 }
 
@@ -118,6 +146,17 @@ function convertFromCloudFrontRequestEvent(
     ),
     headers: normalizeCloudFrontRequestEventHeaders(headers),
     remoteAddress: clientIp,
+    query: querystring.split("&").reduce(
+      (acc, cur) => ({
+        ...acc,
+        [cur.split("=")[0]]: cur.split("=")[1],
+      }),
+      {},
+    ),
+    cookies: headers.cookie.reduce((acc, cur) => {
+      const { key, value } = cur;
+      return { ...acc, [key ?? ""]: value };
+    }, {}),
   };
 }
 

diff --git a/packages/open-next/src/adapters/next-types.ts b/packages/open-next/src/adapters/next-types.ts
@@ -41,7 +41,38 @@ export interface RouteDefinition {
   regex: string;
 }
 
+export interface DataRouteDefinition {
+  page: string;
+  dataRouteRegex: string;
+  routeKeys?: string;
+}
+
+export interface RewriteMatcher {
+  type: "header" | "cookie" | "query" | "host";
+  key: string;
+  value?: string;
+}
+export interface RewriteDefinition {
+  source: string;
+  destination: string;
+  has?: RewriteMatcher[];
+  missing?: RewriteMatcher[];
+  regex: string;
+}
+
+export interface RedirectDefinition extends RewriteDefinition {
+  internal?: boolean;
+  statusCode?: number;
+}
+
 export interface RoutesManifest {
   dynamicRoutes: RouteDefinition[];
   staticRoutes: RouteDefinition[];
+  dataRoutes: DataRouteDefinition[];
+  rewrites: {
+    beforeFiles: RewriteDefinition[];
+    afterFiles: RewriteDefinition[];
+    fallback: RewriteDefinition[];
+  };
+  redirects: RedirectDefinition[];
 }
diff --git a/packages/open-next/src/adapters/routing.ts b/packages/open-next/src/adapters/routing.ts
@@ -0,0 +1,177 @@
+import { compile, match } from "path-to-regexp";
+
+import { InternalEvent } from "./event-mapper.js";
+import { debug } from "./logger.js";
+import {
+  RedirectDefinition,
+  RewriteDefinition,
+  RewriteMatcher,
+} from "./next-types.js";
+import { IncomingMessage } from "./request.js";
+import { ServerResponse } from "./response.js";
+import { escapeRegex, unescapeRegex } from "./util.js";
+
+const redirectMatcher =
+  (
+    headers: Record<string, string>,
+    cookies: Record<string, string>,
+    query: Record<string, string | string[]>,
+  ) =>
+  (redirect: RewriteMatcher) => {
+    switch (redirect.type) {
+      case "header":
+        return (
+          headers?.[redirect.key.toLowerCase()] &&
+          new RegExp(redirect.value ?? "").test(
+            headers[redirect.key.toLowerCase()] ?? "",
+          )
+        );
+      case "cookie":
+        return (
+          cookies?.[redirect.key] &&
+          new RegExp(redirect.value ?? "").test(cookies[redirect.key] ?? "")
+        );
+      case "query":
+        return query[redirect.key] && Array.isArray(redirect.value)
+          ? redirect.value.reduce(
+              (prev, current) =>
+                prev || new RegExp(current).test(query[redirect.key] as string),
+              false,
+            )
+          : new RegExp(redirect.value ?? "").test(
+              (query[redirect.key] as string | undefined) ?? "",
+            );
+      case "host":
+        return (
+          headers?.host && new RegExp(redirect.value ?? "").test(headers.host)
+        );
+      default:
+        return false;
+    }
+  };
+
+function isExternal(url?: string) {
+  if (!url) return false;
+  const pattern = /^https?:\/\//;
+  return pattern.test(url);
+}
+
+function getUrlParts(url: string, isExternal: boolean) {
+  if (!isExternal) {
+    return {
+      hostname: "",
+      pathname: url,
+      protocol: "",
+    };
+  }
+  const { hostname, pathname, protocol } = new URL(url);
+  return {
+    hostname,
+    pathname,
+    protocol,
+  };
+}
+
+export function handleRewrites<T extends RewriteDefinition>(
+  internalEvent: InternalEvent,
+  rewrites: T[],
+) {
+  const { rawPath, headers, query, cookies } = internalEvent;
+  const matcher = redirectMatcher(headers, cookies, query);
+  const rewrite = rewrites.find(
+    (route) =>
+      new RegExp(route.regex).test(rawPath) &&
+      (route.has
+        ? route.has.reduce((acc, cur) => {
+            if (acc === false) return false;
+            return matcher(cur);
+          }, true)
+        : true) &&
+      (route.missing
+        ? route.missing.reduce((acc, cur) => {
+            if (acc === false) return false;
+            return !matcher(cur);
+          }, true)
+        : true),
+  );
+
+  const urlQueryString = new URLSearchParams(query).toString();
+  let rewrittenUrl = rawPath;
+  const isExternalRewrite = isExternal(rewrite?.destination);
+  debug("isExternalRewrite", isExternalRewrite);
+  if (rewrite) {
+    const { pathname, protocol, hostname } = getUrlParts(
+      rewrite.destination,
+      isExternalRewrite,
+    );
+    const toDestination = compile(escapeRegex(pathname ?? "") ?? "");
+    const fromSource = match(escapeRegex(rewrite?.source) ?? "");
+    const _match = fromSource(rawPath);
+    if (_match) {
+      const { params } = _match;
+      const isUsingParams = Object.keys(params).length > 0;
+      if (isUsingParams) {
+        const rewrittenPath = unescapeRegex(toDestination(params));
+        rewrittenUrl = isExternalRewrite
+          ? `${protocol}//${hostname}${rewrittenPath}`
+          : `/${rewrittenPath}`;
+      } else {
+        rewrittenUrl = rewrite.destination;
+      }
+      debug("rewrittenUrl", rewrittenUrl);
+    }
+  }
+
+  return {
+    internalEvent: {
+      ...internalEvent,
+      rawPath: rewrittenUrl,
+      url: `${rewrittenUrl}${urlQueryString ? `?${urlQueryString}` : ""}`,
+    },
+    __rewrite: rewrite,
+    isExternalRewrite,
+  };
+}
+
+export function handleRedirects(
+  internalEvent: InternalEvent,
+  redirects: RedirectDefinition[],
+) {
+  const { internalEvent: _internalEvent, __rewrite } = handleRewrites(
+    internalEvent,
+    redirects,
+  );
+  if (__rewrite && !__rewrite.internal) {
+    return {
+      statusCode: __rewrite.statusCode ?? 308,
+      headers: {
+        Location: _internalEvent.url,
+      },
+    };
+  }
+}
+
+export async function proxyRequest(req: IncomingMessage, res: ServerResponse) {
+  const HttpProxy = require("next/dist/compiled/http-proxy") as any;
+
+  const proxy = new HttpProxy({
+    changeOrigin: true,
+    ignorePath: true,
+    xfwd: true,
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    proxy.on("proxyRes", () => {
+      resolve();
+    });
+
+    proxy.on("error", (err: any) => {
+      reject(err);
+    });
+
+    proxy.web(req, res, {
+      target: req.url,
+      headers: req.headers,
+    });
+  });
+}