feat: add support for next15 geolocation

Next15 moves the geolocation information from a geo property on the request to `x-vercel-ip` headers.
`@vercel/functions` has a `geolocation` helper function to access those.

Author: vicb

.changeset/friendly-kangaroos-give.md

@@ -0,0 +1,5 @@
+---
+"@opennextjs/aws": patch
+---
+
+feat: add support for Next15 geolocation

packages/open-next/src/core/routing/middleware.ts

@@ -46,38 +46,45 @@ export async function handleMiddleware(
   internalEvent: InternalEvent,
   middlewareLoader: MiddlewareLoader = defaultMiddlewareLoader,
 ): Promise<MiddlewareOutputEvent | InternalResult> {
-  const { query } = internalEvent;
+  // We bypass the middleware if the request is internal
+  if (internalEvent.headers["x-isr"]) return internalEvent;
+
   const normalizedPath = localizePath(internalEvent);
   // We only need the normalizedPath to check if the middleware should run
   const hasMatch = middleMatch.some((r) => r.test(normalizedPath));
   if (!hasMatch) return internalEvent;
-  // We bypass the middleware if the request is internal
-  if (internalEvent.headers["x-isr"]) return internalEvent;
 
   // Retrieve the protocol:
   // - In lambda, the url only contains the rawPath and the query - default to https
   // - In cloudflare, the protocol is usually http in dev and https in production
   const protocol = internalEvent.url.startsWith("http://") ? "http:" : "https:";
 
-  const host = internalEvent.headers.host
-    ? `${protocol}//${internalEvent.headers.host}`
+  const headers = internalEvent.headers;
+
+  const host = headers.host
+    ? `${protocol}//${headers.host}`
     : "http://localhost:3000";
 
   const initialUrl = new URL(normalizedPath, host);
-  initialUrl.search = convertToQueryString(query);
+  initialUrl.search = convertToQueryString(internalEvent.query);
   const url = initialUrl.toString();
 
   const middleware = await middlewareLoader();
 
   const result: Response = await middleware.default({
+    // `geo` is pre Next 15.
+    // `x-open-next` are checked first for backward compatibility.
     geo: {
-      city: internalEvent.headers["x-open-next-city"],
-      country: internalEvent.headers["x-open-next-country"],
-      region: internalEvent.headers["x-open-next-region"],
-      latitude: internalEvent.headers["x-open-next-latitude"],
-      longitude: internalEvent.headers["x-open-next-longitude"],
+      city: headers["x-open-next-city"] ?? headers["x-vercel-ip-city"],
+      country: headers["x-open-next-country"] ?? headers["x-vercel-ip-country"],
+      region:
+        headers["x-open-next-region"] ?? headers["x-vercel-ip-country-region"],
+      latitude:
+        headers["x-open-next-latitude"] ?? headers["x-vercel-ip-latitude"],
+      longitude:
+        headers["x-open-next-longitude"] ?? headers["x-vercel-ip-longitude"],
     },
-    headers: internalEvent.headers,
+    headers,
     method: internalEvent.method || "GET",
     nextConfig: {
       basePath: NextConfig.basePath,

packages/open-next/src/overrides/converters/aws-cloudfront.ts

@@ -21,7 +21,7 @@ import {
 } from "../../core/routing/util";
 import type { MiddlewareOutputEvent } from "../../core/routingHandler";
 
-const CloudFrontBlacklistedHeaders = [
+const cloudfrontBlacklistedHeaders = [
   // Disallowed headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-disallowed-headers
   "connection",
   "expect",
@@ -65,15 +65,27 @@ const cloudfrontReadOnlyHeaders = [
   "via",
 ];
 
+const cloudfrontHeaderToNextHeader: Record<string, string> = {
+  "x-open-next-city": "x-vercel-ip-city",
+  "x-open-next-country": "x-vercel-ip-country",
+  "x-open-next-region": "x-vercel-ip-country-region",
+  "x-open-next-latitude": "x-vercel-ip-latitude",
+  "x-open-next-longitude": "x-vercel-ip-longitude",
+};
+
 function normalizeCloudFrontRequestEventHeaders(
   rawHeaders: CloudFrontHeaders,
 ): Record<string, string> {
   const headers: Record<string, string> = {};
 
-  for (const [key, values] of Object.entries(rawHeaders)) {
+  for (const [rawKey, values] of Object.entries(rawHeaders)) {
     for (const { value } of values) {
       if (value) {
-        headers[key.toLowerCase()] = value;
+        const key = rawKey.toLowerCase();
+        headers[key] = value;
+        if (key in cloudfrontHeaderToNextHeader) {
+          headers[cloudfrontHeaderToNextHeader[key]] = value;
+        }
       }
     }
   }
@@ -84,8 +96,16 @@ function normalizeCloudFrontRequestEventHeaders(
 async function convertFromCloudFrontRequestEvent(
   event: CloudFrontRequestEvent,
 ): Promise<InternalEvent> {
-  const { method, uri, querystring, body, headers, clientIp } =
-    event.Records[0].cf.request;
+  const {
+    method,
+    uri,
+    querystring,
+    body,
+    headers: rawHeaders,
+    clientIp,
+  } = event.Records[0].cf.request;
+  const headers = normalizeCloudFrontRequestEventHeaders(rawHeaders);
+
   return {
     type: "core",
     method,
@@ -95,11 +115,11 @@ async function convertFromCloudFrontRequestEvent(
       body?.data ?? "",
       body?.encoding === "base64" ? "base64" : "utf8",
     ),
-    headers: normalizeCloudFrontRequestEventHeaders(headers),
+    headers,
     remoteAddress: clientIp,
     query: convertToQuery(querystring),
     cookies:
-      headers.cookie?.reduce((acc, cur) => {
+      rawHeaders.cookie?.reduce((acc, cur) => {
         const { key, value } = cur;
         return { ...acc, [key ?? ""]: value };
       }, {}) ?? {},
@@ -119,7 +139,7 @@ function convertToCloudfrontHeaders(
     .map(([key, value]) => [key.toLowerCase(), value] as const)
     .filter(
       ([key]) =>
-        !CloudFrontBlacklistedHeaders.some((header) =>
+        !cloudfrontBlacklistedHeaders.some((header) =>
           typeof header === "string" ? header === key : header.test(key),
         ) &&
         // Only remove read-only headers when directly responding in lambda@edge