@opennextjs/aws 3.1.4 → 3.1.5

package/dist/adapters/cache.js

@@ -101,6 +101,7 @@ export default class S3Cache {
                             rscData: Buffer.from(cacheData.rsc),
                             status: meta?.status,
                             headers: meta?.headers,
+                            postponed: meta?.postponed,
                         },
                     };
                 }
@@ -145,65 +146,76 @@ export default class S3Cache {
             .getStore()
             ?.pendingPromiseRunner.withResolvers();
         try {
-            if (data?.kind === "ROUTE" || data?.kind === "APP_ROUTE") {
-                const { body, status, headers } = data;
-                await globalThis.incrementalCache.set(key, {
-                    type: "route",
-                    body: body.toString(isBinaryContentType(String(headers["content-type"]))
-                        ? "base64"
-                        : "utf8"),
-                    meta: {
-                        status,
-                        headers,
-                    },
-                }, false);
+            if (data === null || data === undefined) {
+                await globalThis.incrementalCache.delete(key);
             }
-            else if (data?.kind === "PAGE" || data?.kind === "PAGES") {
-                const { html, pageData, status, headers } = data;
-                const isAppPath = typeof pageData === "string";
-                if (isAppPath) {
-                    await globalThis.incrementalCache.set(key, {
-                        type: "app",
-                        html,
-                        rsc: pageData,
-                        meta: {
-                            status,
-                            headers,
-                        },
-                    }, false);
-                }
-                else {
-                    await globalThis.incrementalCache.set(key, {
-                        type: "page",
-                        html,
-                        json: pageData,
-                    }, false);
+            else {
+                switch (data.kind) {
+                    case "ROUTE":
+                    case "APP_ROUTE":
+                        const { body, status, headers } = data;
+                        await globalThis.incrementalCache.set(key, {
+                            type: "route",
+                            body: body.toString(isBinaryContentType(String(headers["content-type"]))
+                                ? "base64"
+                                : "utf8"),
+                            meta: {
+                                status,
+                                headers,
+                            },
+                        }, false);
+                        break;
+                    case "PAGE":
+                    case "PAGES": {
+                        const { html, pageData, status, headers } = data;
+                        const isAppPath = typeof pageData === "string";
+                        if (isAppPath) {
+                            await globalThis.incrementalCache.set(key, {
+                                type: "app",
+                                html,
+                                rsc: pageData,
+                                meta: {
+                                    status,
+                                    headers,
+                                },
+                            }, false);
+                        }
+                        else {
+                            await globalThis.incrementalCache.set(key, {
+                                type: "page",
+                                html,
+                                json: pageData,
+                            }, false);
+                        }
+                        break;
+                    }
+                    case "APP_PAGE": {
+                        const { html, rscData, headers, status } = data;
+                        await globalThis.incrementalCache.set(key, {
+                            type: "app",
+                            html,
+                            rsc: rscData.toString("utf8"),
+                            meta: {
+                                status,
+                                headers,
+                            },
+                        }, false);
+                        break;
+                    }
+                    case "FETCH":
+                        await globalThis.incrementalCache.set(key, data, true);
+                        break;
+                    case "REDIRECT":
+                        await globalThis.incrementalCache.set(key, {
+                            type: "redirect",
+                            props: data.props,
+                        }, false);
+                        break;
+                    case "IMAGE":
+                        // Not implemented
+                        break;
                 }
             }
-            else if (data?.kind === "APP_PAGE") {
-                const { html, rscData, headers, status } = data;
-                await globalThis.incrementalCache.set(key, {
-                    type: "app",
-                    html,
-                    rsc: rscData.toString("utf8"),
-                    meta: {
-                        status,
-                        headers,
-                    },
-                }, false);
-            }
-            else if (data?.kind === "FETCH") {
-                await globalThis.incrementalCache.set(key, data, true);
-            }
-            else if (data?.kind === "REDIRECT") {
-                await globalThis.incrementalCache.set(key, {
-                    type: "redirect",
-                    props: data.props,
-                }, false);
-            }
-            else if (data === null || data === undefined) {
-                await globalThis.incrementalCache.delete(key);
-            }
             // Write derivedTags to dynamodb
             // If we use an in house version of getDerivedTags in build we should use it here instead of next's one
             const derivedTags = data?.kind === "FETCH"

package/dist/build/copyTracedFiles.js

@@ -8,6 +8,7 @@ function copyPatchFile(outputDir) {
     const outputPatchFile = path.join(outputDir, "patchedAsyncStorage.cjs");
     copyFileSync(patchFile, outputPatchFile);
 }
+// eslint-disable-next-line sonarjs/cognitive-complexity
 export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, routes, bundledNextServer) {
     const tsStart = Date.now();
     const dotNextDir = path.join(buildOutputPath, ".next");

package/dist/build/createServerBundle.d.ts

@@ -1,3 +1,2 @@
-import { OpenNextConfig } from "../types/open-next";
 import type { BuildOptions } from "./helper.js";
-export declare function createServerBundle(config: OpenNextConfig, options: BuildOptions): Promise<void>;
+export declare function createServerBundle(options: BuildOptions): Promise<void>;

package/dist/build/createServerBundle.js

@@ -14,7 +14,8 @@ import { generateEdgeBundle } from "./edge/createEdgeBundle.js";
 import { compareSemver, copyEnvFile, copyOpenNextConfig, esbuildAsync, traverseFiles, } from "./helper.js";
 const require = topLevelCreateRequire(import.meta.url);
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
-export async function createServerBundle(config, options) {
+export async function createServerBundle(options) {
+    const { config } = options;
     const foundRoutes = new Set();
     // Get all functions to build
     const defaultFn = config.default;
@@ -22,7 +23,7 @@ export async function createServerBundle(config, options) {
     // Recompile cache.ts as ESM if any function is using Deno runtime
     if (defaultFn.runtime === "deno" ||
         functions.some(([, fn]) => fn.runtime === "deno")) {
-        compileCache("esm");
+        compileCache(options, "esm");
     }
     const promises = functions.map(async ([name, fnOptions]) => {
         const routes = fnOptions.routes;
@@ -208,7 +209,7 @@ function addDenoJson(outputPath, packagePath) {
     };
     fs.writeFileSync(path.join(outputPath, packagePath, "deno.json"), JSON.stringify(config, null, 2));
 }
-//TODO: check if this PR is still necessary https://github.com/sst/open-next/pull/341
+//TODO: check if this PR is still necessary https://github.com/opennextjs/opennextjs-aws/pull/341
 function addMonorepoEntrypoint(outputPath, packagePath) {
     // Note: in the monorepo case, the handler file is output to
     //       `.next/standalone/package/path/index.mjs`, but we want

package/dist/build/generateOutput.d.ts

@@ -1,2 +1,2 @@
-import { OpenNextConfig } from "../types/open-next";
-export declare function generateOutput(outputPath: string, config: OpenNextConfig): Promise<void>;
+import { type BuildOptions } from "./helper.js";
+export declare function generateOutput(options: BuildOptions): Promise<void>;

package/dist/build/generateOutput.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import path from "node:path";
 import { getBuildId } from "./helper.js";
+const indexHandler = "index.handler";
 async function canStream(opts) {
     if (!opts.override?.wrapper) {
         return false;
@@ -59,7 +60,9 @@ function prefixPattern(basePath) {
             : pattern;
     };
 }
-export async function generateOutput(outputPath, config) {
+// eslint-disable-next-line sonarjs/cognitive-complexity
+export async function generateOutput(options) {
+    const { appBuildOutputPath, config } = options;
     const edgeFunctions = {};
     const isExternalMiddleware = config.middleware?.external ?? false;
     if (isExternalMiddleware) {
@@ -75,14 +78,14 @@ export async function generateOutput(outputPath, config) {
         if (value.placement === "global") {
             edgeFunctions[key] = {
                 bundle: `.open-next/functions/${key}`,
-                handler: "index.handler",
+                handler: indexHandler,
                 ...(await extractOverrideFn(value.override)),
             };
         }
     });
     const defaultOriginCanstream = await canStream(config.default);
     //Load required-server-files.json
-    const requiredServerFiles = JSON.parse(fs.readFileSync(path.join(outputPath, ".next", "required-server-files.json"), "utf-8")).config;
+    const requiredServerFiles = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next", "required-server-files.json"), "utf-8")).config;
     const prefixer = prefixPattern(requiredServerFiles.basePath ?? "");
     // First add s3 origins and image optimization
     const defaultOrigins = {
@@ -111,7 +114,7 @@ export async function generateOutput(outputPath, config) {
         },
         imageOptimizer: {
             type: "function",
-            handler: "index.handler",
+            handler: indexHandler,
             bundle: ".open-next/image-optimization-function",
             streaming: false,
             imageLoader: await extractOverrideName("s3", config.imageOptimization?.loader),
@@ -127,7 +130,7 @@ export async function generateOutput(outputPath, config) {
             }
             : {
                 type: "function",
-                handler: "index.handler",
+                handler: indexHandler,
                 bundle: ".open-next/server-functions/default",
                 streaming: defaultOriginCanstream,
                 ...(await extractOverrideFn(config.default.override)),
@@ -152,7 +155,7 @@ export async function generateOutput(outputPath, config) {
                 const streaming = await canStream(value);
                 origins[key] = {
                     type: "function",
-                    handler: "index.handler",
+                    handler: indexHandler,
                     bundle: `.open-next/server-functions/${key}`,
                     streaming,
                     ...(await extractOverrideFn(value.override)),
@@ -170,7 +173,7 @@ export async function generateOutput(outputPath, config) {
         const patterns = "patterns" in value ? value.patterns : ["*"];
         patterns.forEach((pattern) => {
             behaviors.push({
-                pattern: prefixer(pattern.replace(/BUILD_ID/, getBuildId(outputPath))),
+                pattern: prefixer(pattern.replace(/BUILD_ID/, getBuildId(appBuildOutputPath))),
                 origin: value.placement === "global" ? undefined : key,
                 edgeFunction: value.placement === "global"
                     ? key
@@ -192,7 +195,7 @@ export async function generateOutput(outputPath, config) {
         edgeFunction: isExternalMiddleware ? "middleware" : undefined,
     });
     //Compute behaviors for assets files
-    const assetPath = path.join(outputPath, ".open-next", "assets");
+    const assetPath = path.join(appBuildOutputPath, ".open-next", "assets");
     fs.readdirSync(assetPath).forEach((item) => {
         if (fs.statSync(path.join(assetPath, item)).isDirectory()) {
             behaviors.push({
@@ -209,7 +212,7 @@ export async function generateOutput(outputPath, config) {
     });
     // Check if we produced a dynamodb provider output
     const isTagCacheDisabled = config.dangerous?.disableTagCache ||
-        !fs.existsSync(path.join(outputPath, ".open-next", "dynamodb-provider"));
+        !fs.existsSync(path.join(appBuildOutputPath, ".open-next", "dynamodb-provider"));
     const output = {
         edgeFunctions,
         origins,
@@ -218,22 +221,22 @@ export async function generateOutput(outputPath, config) {
             disableIncrementalCache: config.dangerous?.disableIncrementalCache,
             disableTagCache: config.dangerous?.disableTagCache,
             warmer: {
-                handler: "index.handler",
+                handler: indexHandler,
                 bundle: ".open-next/warmer-function",
             },
             initializationFunction: isTagCacheDisabled
                 ? undefined
                 : {
-                    handler: "index.handler",
+                    handler: indexHandler,
                     bundle: ".open-next/dynamodb-provider",
                 },
             revalidationFunction: config.dangerous?.disableIncrementalCache
                 ? undefined
                 : {
-                    handler: "index.handler",
+                    handler: indexHandler,
                     bundle: ".open-next/revalidation-function",
                 },
         },
     };
-    fs.writeFileSync(path.join(outputPath, ".open-next", "open-next.output.json"), JSON.stringify(output));
+    fs.writeFileSync(path.join(appBuildOutputPath, ".open-next", "open-next.output.json"), JSON.stringify(output));
 }

package/dist/build/helper.d.ts

@@ -1,17 +1,19 @@
 import { BuildOptions as ESBuildOptions } from "esbuild";
 import { OpenNextConfig } from "../types/open-next.js";
 export type BuildOptions = ReturnType<typeof normalizeOptions>;
-export declare function normalizeOptions(config: OpenNextConfig, root: string): {
-    openNextVersion: string;
-    nextVersion: string;
+export declare function normalizeOptions(config: OpenNextConfig): {
+    appBuildOutputPath: string;
     appPackageJsonPath: string;
     appPath: string;
-    appBuildOutputPath: string;
     appPublicPath: string;
-    outputDir: string;
-    tempDir: string;
+    config: OpenNextConfig;
     debug: boolean;
     monorepoRoot: string;
+    nextVersion: string;
+    openNextVersion: string;
+    outputDir: string;
+    packager: "npm" | "yarn" | "pnpm" | "bun";
+    tempDir: string;
 };
 export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
 export declare function esbuildAsync(esbuildOptions: ESBuildOptions, options: BuildOptions): Promise<void>;

package/dist/build/helper.js

@@ -6,10 +6,11 @@ import { build as buildAsync, buildSync, } from "esbuild";
 import logger from "../logger.js";
 const require = topLevelCreateRequire(import.meta.url);
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
-export function normalizeOptions(config, root) {
+export function normalizeOptions(config) {
     const appPath = path.join(process.cwd(), config.appPath || ".");
     const buildOutputPath = path.join(process.cwd(), config.buildOutputPath || ".");
     const outputDir = path.join(buildOutputPath, ".open-next");
+    const { root: monorepoRoot, packager } = findMonorepoRoot(path.join(process.cwd(), config.appPath || "."));
     let appPackageJsonPath;
     if (config.packageJsonPath) {
         const _pkgPath = path.join(process.cwd(), config.packageJsonPath);
@@ -18,21 +19,45 @@ export function normalizeOptions(config, root) {
             : path.join(_pkgPath, "./package.json");
     }
     else {
-        appPackageJsonPath = findNextPackageJsonPath(appPath, root);
+        appPackageJsonPath = findNextPackageJsonPath(appPath, monorepoRoot);
     }
     return {
-        openNextVersion: getOpenNextVersion(),
-        nextVersion: getNextVersion(appPath),
+        appBuildOutputPath: buildOutputPath,
         appPackageJsonPath,
         appPath,
-        appBuildOutputPath: buildOutputPath,
         appPublicPath: path.join(appPath, "public"),
+        config,
+        debug: Boolean(process.env.OPEN_NEXT_DEBUG) ?? false,
+        monorepoRoot,
+        nextVersion: getNextVersion(appPath),
+        openNextVersion: getOpenNextVersion(),
         outputDir,
+        packager,
         tempDir: path.join(outputDir, ".build"),
-        debug: Boolean(process.env.OPEN_NEXT_DEBUG) ?? false,
-        monorepoRoot: root,
     };
 }
+function findMonorepoRoot(appPath) {
+    let currentPath = appPath;
+    while (currentPath !== "/") {
+        const found = [
+            { file: "package-lock.json", packager: "npm" },
+            { file: "yarn.lock", packager: "yarn" },
+            { file: "pnpm-lock.yaml", packager: "pnpm" },
+            { file: "bun.lockb", packager: "bun" },
+        ].find((f) => fs.existsSync(path.join(currentPath, f.file)));
+        if (found) {
+            if (currentPath !== appPath) {
+                logger.info("Monorepo detected at", currentPath);
+            }
+            return { root: currentPath, packager: found.packager };
+        }
+        currentPath = path.dirname(currentPath);
+    }
+    // note: a lock file (package-lock.json, yarn.lock, or pnpm-lock.yaml) is
+    //       not found in the app's directory or any of its parent directories.
+    //       We are going to assume that the app is not part of a monorepo.
+    return { root: appPath, packager: "npm" };
+}
 function findNextPackageJsonPath(appPath, root) {
     // This is needed for the case where the app is a single-version monorepo and the package.json is in the root of the monorepo
     return fs.existsSync(path.join(appPath, "./package.json"))

package/dist/build.d.ts

@@ -1,7 +1,8 @@
+import { BuildOptions } from "./build/helper.js";
 export type PublicFiles = {
     files: string[];
 };
 export declare function build(openNextConfigPath?: string, nodeExternals?: string): Promise<void>;
 /***************************/
 /***************************/
-export declare function compileCache(format?: "cjs" | "esm"): string;
+export declare function compileCache(options: BuildOptions, format?: "cjs" | "esm"): string;

package/dist/build.js

@@ -16,8 +16,6 @@ import { openNextReplacementPlugin } from "./plugins/replacement.js";
 import { openNextResolvePlugin } from "./plugins/resolve.js";
 const require = topLevelCreateRequire(import.meta.url);
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
-let options;
-let config;
 export async function build(openNextConfigPath, nodeExternals) {
     showWindowsWarning();
     // Load open-next.config.ts
@@ -26,39 +24,38 @@ export async function build(openNextConfigPath, nodeExternals) {
     // On Windows, we need to use file:// protocol to load the config file using import()
     if (process.platform === "win32")
         configPath = `file://${configPath}`;
-    config = (await import(configPath)).default;
+    const config = (await import(configPath)).default;
     if (!config || !config.default) {
         logger.error(`config.default cannot be empty, it should be at least {}, see more info here: https://open-next.js.org/config#configuration-file`);
         process.exit(1);
     }
     validateConfig(config);
     compileOpenNextConfigEdge(tempDir, config, openNextConfigPath);
-    const { root: monorepoRoot, packager } = findMonorepoRoot(path.join(process.cwd(), config.appPath || "."));
     // Initialize options
-    options = normalizeOptions(config, monorepoRoot);
+    const options = normalizeOptions(config);
     logger.setLevel(options.debug ? "debug" : "info");
     // Pre-build validation
-    checkRunningInsideNextjsApp();
-    printNextjsVersion();
-    printOpenNextVersion();
+    checkRunningInsideNextjsApp(options);
+    printNextjsVersion(options);
+    printOpenNextVersion(options);
     // Build Next.js app
     printHeader("Building Next.js app");
-    setStandaloneBuildMode(monorepoRoot);
-    buildNextjsApp(packager);
+    setStandaloneBuildMode(options);
+    buildNextjsApp(options);
     // Generate deployable bundle
     printHeader("Generating bundle");
-    initOutputDir(tempDir);
+    initOutputDir(tempDir, options);
     // Compile cache.ts
-    compileCache();
+    compileCache(options);
     // Compile middleware
-    await createMiddleware();
-    createStaticAssets();
-    await createCacheAssets(monorepoRoot);
-    await createServerBundle(config, options);
-    await createRevalidationBundle(config);
-    await createImageOptimizationBundle(config);
-    await createWarmerBundle(config);
-    await generateOutput(options.appBuildOutputPath, config);
+    await createMiddleware(options);
+    createStaticAssets(options);
+    await createCacheAssets(options);
+    await createServerBundle(options);
+    await createRevalidationBundle(options);
+    await createImageOptimizationBundle(options);
+    await createWarmerBundle(options);
+    await generateOutput(options);
     logger.info("OpenNext build complete.");
 }
 function showWindowsWarning() {
@@ -75,7 +72,7 @@ function initTempDir() {
     fs.mkdirSync(tempDir, { recursive: true });
     return tempDir;
 }
-function checkRunningInsideNextjsApp() {
+function checkRunningInsideNextjsApp(options) {
     const { appPath } = options;
     const extension = ["js", "cjs", "mjs", "ts"].find((ext) => fs.existsSync(path.join(appPath, `next.config.${ext}`)));
     if (!extension) {
@@ -83,43 +80,21 @@ function checkRunningInsideNextjsApp() {
         process.exit(1);
     }
 }
-function findMonorepoRoot(appPath) {
-    let currentPath = appPath;
-    while (currentPath !== "/") {
-        const found = [
-            { file: "package-lock.json", packager: "npm" },
-            { file: "yarn.lock", packager: "yarn" },
-            { file: "pnpm-lock.yaml", packager: "pnpm" },
-            { file: "bun.lockb", packager: "bun" },
-        ].find((f) => fs.existsSync(path.join(currentPath, f.file)));
-        if (found) {
-            if (currentPath !== appPath) {
-                logger.info("Monorepo detected at", currentPath);
-            }
-            return { root: currentPath, packager: found.packager };
-        }
-        currentPath = path.dirname(currentPath);
-    }
-    // note: a lock file (package-lock.json, yarn.lock, or pnpm-lock.yaml) is
-    //       not found in the app's directory or any of its parent directories.
-    //       We are going to assume that the app is not part of a monorepo.
-    return { root: appPath, packager: "npm" };
-}
-function setStandaloneBuildMode(monorepoRoot) {
-    // Equivalent to setting `target: "standalone"` in next.config.js
+function setStandaloneBuildMode(options) {
+    // Equivalent to setting `output: "standalone"` in next.config.js
     process.env.NEXT_PRIVATE_STANDALONE = "true";
     // Equivalent to setting `experimental.outputFileTracingRoot` in next.config.js
-    process.env.NEXT_PRIVATE_OUTPUT_TRACE_ROOT = monorepoRoot;
+    process.env.NEXT_PRIVATE_OUTPUT_TRACE_ROOT = options.monorepoRoot;
 }
-function buildNextjsApp(packager) {
-    const { appPackageJsonPath } = options;
+function buildNextjsApp(options) {
+    const { config, packager } = options;
     const command = config.buildCommand ??
         (["bun", "npm"].includes(packager)
             ? `${packager} run build`
             : `${packager} build`);
     cp.execSync(command, {
         stdio: "inherit",
-        cwd: path.dirname(appPackageJsonPath),
+        cwd: path.dirname(options.appPackageJsonPath),
     });
 }
 function printHeader(header) {
@@ -132,34 +107,32 @@ function printHeader(header) {
         "",
     ].join("\n"));
 }
-function printNextjsVersion() {
-    const { nextVersion } = options;
-    logger.info(`Next.js version : ${nextVersion}`);
+function printNextjsVersion(options) {
+    logger.info(`Next.js version : ${options.nextVersion}`);
 }
-function printOpenNextVersion() {
-    const { openNextVersion } = options;
-    logger.info(`OpenNext v${openNextVersion}`);
+function printOpenNextVersion(options) {
+    logger.info(`OpenNext v${options.openNextVersion}`);
 }
-function initOutputDir(tempDir) {
+function initOutputDir(srcTempDir, options) {
     // We need to get the build relative to the cwd to find the compiled config
     // This is needed for the case where the app is a single-version monorepo and the package.json is in the root of the monorepo
     // where the build is in the app directory, but the compiled config is in the root of the monorepo.
-    const { outputDir, tempDir: lTempDir } = options;
-    const openNextConfig = readFileSync(path.join(tempDir, "open-next.config.mjs"), "utf8");
+    const openNextConfig = readFileSync(path.join(srcTempDir, "open-next.config.mjs"), "utf8");
     let openNextConfigEdge = null;
-    if (fs.existsSync(path.join(tempDir, "open-next.config.edge.mjs"))) {
-        openNextConfigEdge = readFileSync(path.join(tempDir, "open-next.config.edge.mjs"), "utf8");
+    if (fs.existsSync(path.join(srcTempDir, "open-next.config.edge.mjs"))) {
+        openNextConfigEdge = readFileSync(path.join(srcTempDir, "open-next.config.edge.mjs"), "utf8");
     }
-    fs.rmSync(outputDir, { recursive: true, force: true });
-    fs.mkdirSync(lTempDir, { recursive: true });
-    fs.writeFileSync(path.join(lTempDir, "open-next.config.mjs"), openNextConfig);
+    fs.rmSync(options.outputDir, { recursive: true, force: true });
+    const destTempDir = options.tempDir;
+    fs.mkdirSync(destTempDir, { recursive: true });
+    fs.writeFileSync(path.join(destTempDir, "open-next.config.mjs"), openNextConfig);
     if (openNextConfigEdge) {
-        fs.writeFileSync(path.join(lTempDir, "open-next.config.edge.mjs"), openNextConfigEdge);
+        fs.writeFileSync(path.join(destTempDir, "open-next.config.edge.mjs"), openNextConfigEdge);
     }
 }
-async function createWarmerBundle(config) {
+async function createWarmerBundle(options) {
     logger.info(`Bundling warmer function...`);
-    const { outputDir } = options;
+    const { config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "warmer-function");
     fs.mkdirSync(outputPath, { recursive: true });
@@ -192,9 +165,9 @@ async function createWarmerBundle(config) {
         },
     }, options);
 }
-async function createRevalidationBundle(config) {
+async function createRevalidationBundle(options) {
     logger.info(`Bundling revalidation function...`);
-    const { appBuildOutputPath, outputDir } = options;
+    const { appBuildOutputPath, config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "revalidation-function");
     fs.mkdirSync(outputPath, { recursive: true });
@@ -218,9 +191,9 @@ async function createRevalidationBundle(config) {
     // Copy over .next/prerender-manifest.json file
     fs.copyFileSync(path.join(appBuildOutputPath, ".next", "prerender-manifest.json"), path.join(outputPath, "prerender-manifest.json"));
 }
-async function createImageOptimizationBundle(config) {
+async function createImageOptimizationBundle(options) {
     logger.info(`Bundling image optimization function...`);
-    const { appPath, appBuildOutputPath, outputDir } = options;
+    const { appPath, appBuildOutputPath, config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "image-optimization-function");
     fs.mkdirSync(outputPath, { recursive: true });
@@ -306,7 +279,7 @@ async function createImageOptimizationBundle(config) {
         logger.error("Failed to install sharp.");
     }
 }
-function createStaticAssets() {
+function createStaticAssets(options) {
     logger.info(`Bundling static assets...`);
     const { appBuildOutputPath, appPublicPath, outputDir, appPath } = options;
     // Create output folder
@@ -331,12 +304,13 @@ function createStaticAssets() {
         fs.copyFileSync(faviconPath, path.join(outputPath, "favicon.ico"));
     }
 }
-async function createCacheAssets(monorepoRoot) {
+async function createCacheAssets(options) {
+    const { config } = options;
     if (config.dangerous?.disableIncrementalCache)
         return;
     logger.info(`Bundling cache assets...`);
     const { appBuildOutputPath, outputDir } = options;
-    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    const packagePath = path.relative(options.monorepoRoot, appBuildOutputPath);
     const buildId = getBuildId(appBuildOutputPath);
     // Copy pages to cache folder
     const dotNextPath = path.join(appBuildOutputPath, ".next/standalone", packagePath);
@@ -354,7 +328,11 @@ async function createCacheAssets(monorepoRoot) {
     const cacheFilesPath = {};
     traverseFiles(outputPath, () => true, (filepath) => {
         const ext = path.extname(filepath);
-        const newFilePath = ext !== "" ? filepath.replace(ext, ".cache") : `${filepath}.cache`;
+        let newFilePath = ext !== "" ? filepath.replace(ext, ".cache") : `${filepath}.cache`;
+        // Handle prefetch cache files for partial prerendering
+        if (newFilePath.endsWith(".prefetch.cache")) {
+            newFilePath = newFilePath.replace(".prefetch.cache", ".cache");
+        }
         switch (ext) {
             case ".meta":
             case ".html":
@@ -470,7 +448,8 @@ async function createCacheAssets(monorepoRoot) {
 /***************************/
 /* Server Helper Functions */
 /***************************/
-export function compileCache(format = "cjs") {
+export function compileCache(options, format = "cjs") {
+    const { config } = options;
     const ext = format === "cjs" ? "cjs" : "mjs";
     const outfile = path.join(options.outputDir, ".build", `cache.${ext}`);
     const isAfter15 = compareSemver(options.nextVersion, "15.0.0") >= 0;
@@ -490,9 +469,9 @@ export function compileCache(format = "cjs") {
     }, options);
     return outfile;
 }
-async function createMiddleware() {
+async function createMiddleware(options) {
     console.info(`Bundling middleware function...`);
-    const { appBuildOutputPath, outputDir } = options;
+    const { appBuildOutputPath, config, outputDir } = options;
     // Get middleware manifest
     const middlewareManifest = JSON.parse(readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
     const entry = middlewareManifest.middleware["/"];

package/dist/cache/next-types.d.ts

@@ -58,5 +58,6 @@ export type Extension = "cache" | "fetch";
 export interface Meta {
     status?: number;
     headers?: Record<string, undefined | string | string[]>;
+    postponed?: string;
 }
 export {};

package/dist/converters/aws-cloudfront.js

@@ -75,6 +75,7 @@ async function convertFromCloudFrontRequestEvent(event) {
 function convertToCloudfrontHeaders(headers, directResponse) {
     const cloudfrontHeaders = {};
     Object.entries(headers)
+        .map(([key, value]) => [key.toLowerCase(), value])
         .filter(([key]) => !CloudFrontBlacklistedHeaders.some((header) => typeof header === "string" ? header === key : header.test(key)) &&
         // Only remove read-only headers when directly responding in lambda@edge
         (directResponse ? !cloudfrontReadOnlyHeaders.includes(key) : true))

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

@@ -1,5 +1,6 @@
 // Copied from Next.js source code
 // https://github.com/vercel/next.js/blob/canary/packages/next/src/server/accept-header.ts
+// eslint-disable-next-line sonarjs/cognitive-complexity
 function parse(raw, preferences, options) {
     const lowers = new Map();
     const header = raw.replace(/[ \t]/g, "");

package/dist/core/routing/util.js

@@ -212,7 +212,7 @@ export async function proxyRequest(internalEvent, res) {
                 res.end();
                 reject(e);
             });
-            _res.on("end", () => {
+            res.on("finish", () => {
                 resolve();
             });
         });

package/dist/core/routingHandler.js

@@ -5,7 +5,7 @@ import { addNextConfigHeaders, fixDataPage, handleFallbackFalse, handleRedirects
 import { handleMiddleware } from "./routing/middleware";
 // Add the locale prefix to the regex so we correctly match the rawPath
 const optionalLocalePrefixRegex = !!RoutesManifest.locales.length
-    ? `^/(?:${RoutesManifest.locales.map((locale) => `${locale}/?`).join("|")})?`
+    ? `^/(?:${RoutesManifest.locales.map((locale) => locale + "/?").join("|")})?`
     : "^/";
 // Add the basepath prefix to the regex so we correctly match the rawPath
 const optionalBasepathPrefixRegex = !!RoutesManifest.basePath

package/dist/index.js

@@ -15,6 +15,7 @@ function parseArgs() {
             }
             else if (self[ind + 1]) {
                 acc[key] = self[ind + 1];
+                // eslint-disable-next-line sonarjs/elseif-without-else
             }
             else if (!self[ind + 1]) {
                 acc[key] = undefined;

package/dist/minimize-js.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 // Copied and modified from node-minify-all-js by Adones Pitogo
 // https://github.com/adonespitogo/node-minify-all-js/blob/master/index.js
 // @ts-nocheck

package/dist/plugins/edge.js

@@ -28,7 +28,7 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
                     };
                 });
             }
-            build.onResolve({ filter: /\.(mjs|wasm)$/g }, (args) => {
+            build.onResolve({ filter: /\.(mjs|wasm)$/g }, () => {
                 return {
                     external: true,
                 };

package/dist/wrappers/aws-lambda-streaming.js

@@ -55,7 +55,6 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
     }
     const streamCreator = {
         writeHeaders: (_prelude) => {
-            _prelude.headers["content-encoding"] = contentEncoding;
             responseStream.setContentType("application/vnd.awslambda.http-integration-response");
             _prelude.headers["content-encoding"] = contentEncoding;
             const prelude = JSON.stringify(_prelude);

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.1.4",
+  "version": "3.1.5",
   "bin": {
     "open-next": "./dist/index.js",
     "@opennextjs/aws": "./dist/index.js"
@@ -53,11 +53,12 @@
     "typescript": "^4.9.3"
   },
   "bugs": {
-    "url": "https://github.com/sst/open-next/issues"
+    "url": "https://github.com/opennextjs/opennextjs-aws/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/sst/open-next.git"
+    "url": "https://github.com/opennextjs/opennextjs-aws",
+    "directory": "packages/open-next"
   },
   "scripts": {
     "build": "tsc && tsc-alias",