@opennextjs/aws 3.2.1 → 3.3.0

package/dist/core/resolve.d.ts

@@ -1,5 +1,6 @@
-import type { BaseEventOrResult, Converter, DefaultOverrideOptions, ImageLoader, InternalEvent, InternalResult, LazyLoadedOverride, OriginResolver, OverrideOptions, Warmer, Wrapper } from "../types/open-next.js";
-import type { TagCache } from "../overrides/tagCache/types.js";
+import type { BaseEventOrResult, DefaultOverrideOptions, InternalEvent, InternalResult, OpenNextConfig, OverrideOptions } from "../types/open-next";
+import type { Converter, TagCache, Wrapper } from "../types/overrides";
+type RemoveUndefined<T> = T extends undefined ? never : T;
 export declare function resolveConverter<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(converter: DefaultOverrideOptions<E, R>["converter"]): Promise<Converter<E, R>>;
 export declare function resolveWrapper<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(wrapper: DefaultOverrideOptions<E, R>["wrapper"]): Promise<Wrapper<E, R>>;
 /**
@@ -15,26 +16,31 @@ export declare function resolveTagCache(tagCache: OverrideOptions["tagCache"]):
  * @returns
  * @__PURE__
  */
-export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../overrides/queue/types.js").Queue>;
+export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../types/overrides").Queue>;
 /**
  *
  * @param incrementalCache
  * @returns
  * @__PURE__
  */
-export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../overrides/incrementalCache/types.js").IncrementalCache>;
+export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../types/overrides").IncrementalCache>;
 /**
  * @param imageLoader
  * @returns
  * @__PURE__
  */
-export declare function resolveImageLoader(imageLoader: LazyLoadedOverride<ImageLoader> | string): Promise<ImageLoader>;
+export declare function resolveImageLoader(imageLoader: RemoveUndefined<OpenNextConfig["imageOptimization"]>["loader"]): Promise<import("../types/overrides").ImageLoader>;
 /**
  * @returns
  * @__PURE__
  */
-export declare function resolveOriginResolver(originResolver?: LazyLoadedOverride<OriginResolver> | string): Promise<OriginResolver>;
+export declare function resolveOriginResolver(originResolver: RemoveUndefined<OpenNextConfig["middleware"]>["originResolver"]): Promise<import("../types/overrides").OriginResolver>;
 /**
  * @__PURE__
  */
-export declare function resolveWarmerInvoke(warmer?: LazyLoadedOverride<Warmer> | "aws-lambda"): Promise<Warmer>;
+export declare function resolveWarmerInvoke(warmer: RemoveUndefined<OpenNextConfig["warmer"]>["invokeFunction"]): Promise<import("../types/overrides").Warmer>;
+/**
+ * @__PURE__
+ */
+export declare function resolveProxyRequest(proxyRequest: OverrideOptions["proxyExternalRequest"]): Promise<import("../types/overrides").ProxyExternalRequest>;
+export {};

package/dist/core/resolve.js

@@ -2,22 +2,18 @@ export async function resolveConverter(converter) {
     if (typeof converter === "function") {
         return converter();
     }
-    else {
-        const m_1 = await import(`../overrides/converters/aws-apigw-v2.js`);
-        // @ts-expect-error
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/converters/aws-apigw-v2.js");
+    // @ts-expect-error
+    return m_1.default;
 }
 export async function resolveWrapper(wrapper) {
     if (typeof wrapper === "function") {
         return wrapper();
     }
-    else {
-        // This will be replaced by the bundler
-        const m_1 = await import("../overrides/wrappers/aws-lambda.js");
-        // @ts-expect-error
-        return m_1.default;
-    }
+    // This will be replaced by the bundler
+    const m_1 = await import("../overrides/wrappers/aws-lambda.js");
+    // @ts-expect-error
+    return m_1.default;
 }
 /**
  *
@@ -29,11 +25,9 @@ export async function resolveTagCache(tagCache) {
     if (typeof tagCache === "function") {
         return tagCache();
     }
-    else {
-        // This will be replaced by the bundler
-        const m_1 = await import("../overrides/tagCache/dynamodb.js");
-        return m_1.default;
-    }
+    // This will be replaced by the bundler
+    const m_1 = await import("../overrides/tagCache/dynamodb.js");
+    return m_1.default;
 }
 /**
  *
@@ -45,10 +39,8 @@ export async function resolveQueue(queue) {
     if (typeof queue === "function") {
         return queue();
     }
-    else {
-        const m_1 = await import("../overrides/queue/sqs.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/queue/sqs.js");
+    return m_1.default;
 }
 /**
  *
@@ -60,10 +52,8 @@ export async function resolveIncrementalCache(incrementalCache) {
     if (typeof incrementalCache === "function") {
         return incrementalCache();
     }
-    else {
-        const m_1 = await import("../overrides/incrementalCache/s3.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/incrementalCache/s3.js");
+    return m_1.default;
 }
 /**
  * @param imageLoader
@@ -74,10 +64,8 @@ export async function resolveImageLoader(imageLoader) {
     if (typeof imageLoader === "function") {
         return imageLoader();
     }
-    else {
-        const m_1 = await import("../overrides/imageLoader/s3.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/imageLoader/s3.js");
+    return m_1.default;
 }
 /**
  * @returns
@@ -87,10 +75,8 @@ export async function resolveOriginResolver(originResolver) {
     if (typeof originResolver === "function") {
         return originResolver();
     }
-    else {
-        const m_1 = await import("../overrides/originResolver/pattern-env.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/originResolver/pattern-env.js");
+    return m_1.default;
 }
 /**
  * @__PURE__
@@ -99,8 +85,16 @@ export async function resolveWarmerInvoke(warmer) {
     if (typeof warmer === "function") {
         return warmer();
     }
-    else {
-        const m_1 = await import("../overrides/warmer/aws-lambda.js");
-        return m_1.default;
+    const m_1 = await import("../overrides/warmer/aws-lambda.js");
+    return m_1.default;
+}
+/**
+ * @__PURE__
+ */
+export async function resolveProxyRequest(proxyRequest) {
+    if (typeof proxyRequest === "function") {
+        return proxyRequest();
     }
+    const m_1 = await import("../overrides/proxyExternalRequest/node.js");
+    return m_1.default;
 }

package/dist/core/routing/cacheInterceptor.js

@@ -31,7 +31,7 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
             etag,
         };
     }
-    else if (finalRevalidate !== CACHE_ONE_YEAR) {
+    if (finalRevalidate !== CACHE_ONE_YEAR) {
         const sMaxAge = Math.max(finalRevalidate - age, 1);
         debug("sMaxAge", {
             finalRevalidate,
@@ -58,13 +58,11 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
             etag,
         };
     }
-    else {
-        return {
-            "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
-            "x-opennext-cache": "HIT",
-            etag,
-        };
-    }
+    return {
+        "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+        "x-opennext-cache": "HIT",
+        etag,
+    };
 }
 async function generateResult(event, localizedPath, cachedValue, lastModified) {
     debug("Returning result from experimental cache");
@@ -73,19 +71,19 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     let isDataRequest = false;
     switch (cachedValue.type) {
         case "app":
-            isDataRequest = Boolean(event.headers["rsc"]);
+            isDataRequest = Boolean(event.headers.rsc);
             body = isDataRequest ? cachedValue.rsc : cachedValue.html;
             type = isDataRequest ? "text/x-component" : "text/html; charset=utf-8";
             break;
         case "page":
-            isDataRequest = Boolean(event.query["__nextDataReq"]);
+            isDataRequest = Boolean(event.query.__nextDataReq);
             body = isDataRequest
                 ? JSON.stringify(cachedValue.json)
                 : cachedValue.html;
             type = isDataRequest ? "application/json" : "text/html; charset=utf-8";
             break;
     }
-    const cacheControl = await computeCacheControl(localizedPath, body, event.headers["host"], cachedValue.revalidate, lastModified);
+    const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
     return {
         type: "core",
         statusCode: 200,
@@ -130,12 +128,12 @@ export async function cacheInterceptor(event) {
                     return event;
                 }
             }
-            const host = event.headers["host"];
+            const host = event.headers.host;
             switch (cachedData.value?.type) {
                 case "app":
                 case "page":
                     return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified);
-                case "redirect":
+                case "redirect": {
                     const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified);
                     return {
                         type: "core",
@@ -148,6 +146,7 @@ export async function cacheInterceptor(event) {
                         },
                         isBase64Encoded: false,
                     };
+                }
                 default:
                     return event;
             }

package/dist/core/routing/i18n/accept-header.js

@@ -11,6 +11,7 @@ function parse(raw, preferences, options) {
             lowers.set(lower, { orig: preference, pos: pos++ });
             if (options.prefixMatch) {
                 const parts = lower.split("-");
+                // biome-ignore lint/style/noCommaOperator:
                 while ((parts.pop(), parts.length > 0)) {
                     const joined = parts.join("-");
                     if (!lowers.has(joined)) {
@@ -32,7 +33,7 @@ function parse(raw, preferences, options) {
         if (params.length > 2) {
             throw new Error(`Invalid ${options.type} header`);
         }
-        let token = params[0].toLowerCase();
+        const token = params[0].toLowerCase();
         if (!token) {
             throw new Error(`Invalid ${options.type} header`);
         }
@@ -47,7 +48,7 @@ function parse(raw, preferences, options) {
             if (!value || (key !== "q" && key !== "Q")) {
                 throw new Error(`Invalid ${options.type} header`);
             }
-            const score = parseFloat(value);
+            const score = Number.parseFloat(value);
             if (score === 0) {
                 continue;
             }

package/dist/core/routing/matcher.d.ts

@@ -1,14 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types";
 import type { InternalEvent, InternalResult } from "../../types/open-next";
-export declare function addNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
+export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
 export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
     internalEvent: {
         rawPath: string;
         url: string;
         method: string;
-        body?: Buffer | undefined;
+        body?: Buffer;
         headers: Record<string, string>;
         query: Record<string, string | string[]>;
         cookies: Record<string, string>;

package/dist/core/routing/matcher.js

@@ -59,30 +59,22 @@ const computeParamHas = (headers, cookies, query) => (has) => {
     }
 };
 function convertMatch(match, toDestination, destination) {
-    if (match) {
-        const { params } = match;
-        const isUsingParams = Object.keys(params).length > 0;
-        if (isUsingParams) {
-            return toDestination(params);
-        }
-        else {
-            return destination;
-        }
-    }
-    else {
+    if (!match) {
         return destination;
     }
+    const { params } = match;
+    const isUsingParams = Object.keys(params).length > 0;
+    return isUsingParams ? toDestination(params) : destination;
 }
-export function addNextConfigHeaders(event, configHeaders) {
-    const addedHeaders = {};
-    if (!configHeaders)
-        return addedHeaders;
-    const { rawPath, headers, query, cookies } = event;
-    const matcher = routeHasMatcher(headers, cookies, query);
+export function getNextConfigHeaders(event, configHeaders) {
+    if (!configHeaders) {
+        return {};
+    }
+    const matcher = routeHasMatcher(event.headers, event.cookies, event.query);
     const requestHeaders = {};
     const localizedRawPath = localizePath(event);
     for (const { headers, has, missing, regex, source, locale, } of configHeaders) {
-        const path = locale === false ? rawPath : localizedRawPath;
+        const path = locale === false ? event.rawPath : localizedRawPath;
         if (new RegExp(regex).test(path) &&
             checkHas(matcher, has) &&
             checkHas(matcher, missing, true)) {
@@ -95,7 +87,7 @@ export function addNextConfigHeaders(event, configHeaders) {
                     requestHeaders[key] = value;
                 }
                 catch {
-                    debug("Error matching header ", h.key, " with value ", h.value);
+                    debug(`Error matching header ${h.key} with value ${h.value}`);
                     requestHeaders[h.key] = h.value;
                 }
             });
@@ -132,16 +124,16 @@ export function handleRewrites(event, rewrites) {
         const toDestinationPath = compile(escapeRegex(pathname ?? "") ?? "");
         const toDestinationHost = compile(escapeRegex(hostname ?? "") ?? "");
         const toDestinationQuery = compile(escapeRegex(encodePlusQueryString ?? "") ?? "");
-        let params = {
+        const params = {
             // params for the source
             ...getParamsFromSource(match(escapeRegex(rewrite?.source) ?? ""))(pathToUse),
             // params for the has
             ...rewrite.has?.reduce((acc, cur) => {
-                return { ...acc, ...computeHas(cur) };
+                return Object.assign(acc, computeHas(cur));
             }, {}),
             // params for the missing
             ...rewrite.missing?.reduce((acc, cur) => {
-                return { ...acc, ...computeHas(cur) };
+                return Object.assign(acc, computeHas(cur));
             }, {}),
         };
         const isUsingParams = Object.keys(params).length > 0;
@@ -200,7 +192,7 @@ function handleTrailingSlashRedirect(event) {
         };
         // eslint-disable-next-line sonarjs/elseif-without-else
     }
-    else if (!NextConfig.trailingSlash &&
+    if (!NextConfig.trailingSlash &&
         event.rawPath.endsWith("/") &&
         event.rawPath !== "/") {
         const headersLocation = event.url.split("?");
@@ -214,8 +206,7 @@ function handleTrailingSlashRedirect(event) {
             isBase64Encoded: false,
         };
     }
-    else
-        return false;
+    return false;
 }
 export function handleRedirects(event, redirects) {
     const trailingSlashRedirect = handleTrailingSlashRedirect(event);
@@ -236,7 +227,7 @@ export function handleRedirects(event, redirects) {
 }
 export function fixDataPage(internalEvent, buildId) {
     const { rawPath, query } = internalEvent;
-    const dataPattern = `/_next/data/${buildId}`;
+    const dataPattern = `${NextConfig.basePath ?? ""}/_next/data/${buildId}`;
     // Return 404 for data requests that don't match the buildId
     if (rawPath.startsWith("/_next/data") && !rawPath.startsWith(dataPattern)) {
         return {
@@ -273,7 +264,7 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
         return routeRegexExp.test(rawPath);
     });
     const locales = NextConfig.i18n?.locales;
-    const routesAlreadyHaveLocale = (locales !== undefined && locales.includes(rawPath.split("/")[1])) ||
+    const routesAlreadyHaveLocale = locales?.includes(rawPath.split("/")[1]) ||
         // If we don't use locales, we don't need to add the default locale
         locales === undefined;
     const localizedPath = routesAlreadyHaveLocale

package/dist/core/routing/middleware.d.ts

@@ -1,11 +1,11 @@
 import type { InternalEvent, InternalResult } from "../../types/open-next.js";
-type MiddlewareOutputEvent = InternalEvent & {
+type MiddlewareEvent = InternalEvent & {
     responseHeaders?: Record<string, string | string[]>;
-    externalRewrite?: boolean;
+    isExternalRewrite?: boolean;
 };
 type Middleware = (request: Request) => Response | Promise<Response>;
 type MiddlewareLoader = () => Promise<{
     default: Middleware;
 }>;
-export declare function handleMiddleware(internalEvent: InternalEvent, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareOutputEvent | InternalResult>;
+export declare function handleMiddleware(internalEvent: InternalEvent, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareEvent | InternalResult>;
 export {};

package/dist/core/routing/middleware.js

@@ -21,35 +21,36 @@ function defaultMiddlewareLoader() {
 // @returns undefined | res.end()
 //    if res.end() is return, the parent needs to return and not process next server
 export async function handleMiddleware(internalEvent, middlewareLoader = defaultMiddlewareLoader) {
-    const { query } = internalEvent;
-    const normalizedPath = localizePath(internalEvent);
+    const headers = internalEvent.headers;
+    // We bypass the middleware if the request is internal
+    if (headers["x-isr"])
+        return internalEvent;
     // We only need the normalizedPath to check if the middleware should run
+    const normalizedPath = localizePath(internalEvent);
     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 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 = await middleware.default({
+        // `geo` is pre Next 15.
         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"],
+            country: headers["x-open-next-country"],
+            region: headers["x-open-next-region"],
+            latitude: headers["x-open-next-latitude"],
+            longitude: headers["x-open-next-longitude"],
         },
-        headers: internalEvent.headers,
+        headers,
         method: internalEvent.method || "GET",
         nextConfig: {
             basePath: NextConfig.basePath,
@@ -113,7 +114,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     // NOTE: the header was added to `req` from above
     const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
     let rewritten = false;
-    let externalRewrite = false;
+    let isExternalRewrite = false;
     let middlewareQueryString = internalEvent.query;
     let newUrl = internalEvent.url;
     if (rewriteUrl) {
@@ -121,15 +122,15 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
         if (isExternal(rewriteUrl, internalEvent.headers.host)) {
             newUrl = rewriteUrl;
             rewritten = true;
-            externalRewrite = true;
+            isExternalRewrite = true;
         }
         else {
             const rewriteUrlObject = new URL(rewriteUrl);
             newUrl = rewriteUrlObject.pathname;
             // Reset the query params if the middleware is a rewrite
-            if (middlewareQueryString["__nextDataReq"]) {
+            if (middlewareQueryString.__nextDataReq) {
                 middlewareQueryString = {
-                    __nextDataReq: middlewareQueryString["__nextDataReq"],
+                    __nextDataReq: middlewareQueryString.__nextDataReq,
                 };
             }
             else {
@@ -146,7 +147,6 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     if (result.body) {
         // transfer response body to res
         const body = result.body;
-        // await pipeReadable(result.response.body, res);
         return {
             type: internalEvent.type,
             statusCode: statusCode,
@@ -168,6 +168,6 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
         query: middlewareQueryString,
         cookies: internalEvent.cookies,
         remoteAddress: internalEvent.remoteAddress,
-        externalRewrite,
+        isExternalRewrite,
     };
 }

package/dist/core/routing/util.d.ts

@@ -1,11 +1,8 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { OutgoingHttpHeaders } from "node:http";
-import type { IncomingMessage, StreamCreator } from "../../http/index.js";
+import type { IncomingMessage } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import type { MiddlewareManifest } from "../../types/next-types";
-import type { InternalEvent, InternalResult } from "../../types/open-next.js";
+import type { InternalEvent, InternalResult, StreamCreator } from "../../types/open-next.js";
 /**
  *
  * @__PURE__
@@ -59,16 +56,6 @@ export declare function unescapeRegex(str: string): string;
  * @__PURE__
  */
 export declare function convertBodyToReadableStream(method: string, body?: string | Buffer): ReadableStream<any> | undefined;
-/**
- *
- * @__PURE__
- */
-export declare function proxyRequest(internalEvent: InternalEvent, res: OpenNextNodeResponse): Promise<void>;
-declare global {
-    var openNextDebug: boolean;
-    var openNextVersion: string;
-    var lastModified: Record<string, number>;
-}
 /**
  *
  * @__PURE__