@opennextjs/aws 3.1.5 → 3.2.0

package/dist/build/createAssets.d.ts

@@ -0,0 +1,11 @@
+import * as buildHelper from "./helper.js";
+export declare function createStaticAssets(options: buildHelper.BuildOptions): void;
+/**
+ * Create the cache assets.
+ *
+ * @param options Build options.
+ * @returns Whether tag cache is used.
+ */
+export declare function createCacheAssets(options: buildHelper.BuildOptions): {
+    useTagCache: boolean;
+};

package/dist/build/createAssets.js

@@ -0,0 +1,161 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isBinaryContentType } from "../adapters/binary.js";
+import logger from "../logger.js";
+import * as buildHelper from "./helper.js";
+export function createStaticAssets(options) {
+    logger.info(`Bundling static assets...`);
+    const { appBuildOutputPath, appPublicPath, outputDir, appPath } = options;
+    // Create output folder
+    const outputPath = path.join(outputDir, "assets");
+    fs.mkdirSync(outputPath, { recursive: true });
+    // Next.js outputs assets into multiple files. Copy into the same directory.
+    // Copy over:
+    // - .next/BUILD_ID => _next/BUILD_ID
+    // - .next/static   => _next/static
+    // - public/*       => *
+    // - app/favicon.ico or src/app/favicon.ico  => favicon.ico
+    fs.copyFileSync(path.join(appBuildOutputPath, ".next/BUILD_ID"), path.join(outputPath, "BUILD_ID"));
+    fs.cpSync(path.join(appBuildOutputPath, ".next/static"), path.join(outputPath, "_next", "static"), { recursive: true });
+    if (fs.existsSync(appPublicPath)) {
+        fs.cpSync(appPublicPath, outputPath, { recursive: true });
+    }
+    const appSrcPath = fs.existsSync(path.join(appPath, "src"))
+        ? "src/app"
+        : "app";
+    const faviconPath = path.join(appPath, appSrcPath, "favicon.ico");
+    if (fs.existsSync(faviconPath)) {
+        fs.copyFileSync(faviconPath, path.join(outputPath, "favicon.ico"));
+    }
+}
+/**
+ * Create the cache assets.
+ *
+ * @param options Build options.
+ * @returns Whether tag cache is used.
+ */
+export function createCacheAssets(options) {
+    logger.info(`Bundling cache assets...`);
+    const { appBuildOutputPath, outputDir } = options;
+    const packagePath = path.relative(options.monorepoRoot, appBuildOutputPath);
+    const buildId = buildHelper.getBuildId(appBuildOutputPath);
+    let useTagCache = false;
+    // Copy pages to cache folder
+    const dotNextPath = path.join(appBuildOutputPath, ".next/standalone", packagePath);
+    const outputPath = path.join(outputDir, "cache", buildId);
+    [".next/server/pages", ".next/server/app"]
+        .map((dir) => path.join(dotNextPath, dir))
+        .filter(fs.existsSync)
+        .forEach((dir) => fs.cpSync(dir, outputPath, { recursive: true }));
+    // Remove non-cache files
+    const htmlPages = buildHelper.getHtmlPages(dotNextPath);
+    buildHelper.removeFiles(outputPath, (file) => file.endsWith(".js") ||
+        file.endsWith(".js.nft.json") ||
+        (file.endsWith(".html") && htmlPages.has(file)));
+    // Merge cache files into a single file
+    const cacheFilesPath = {};
+    buildHelper.traverseFiles(outputPath, () => true, (filepath) => {
+        const ext = path.extname(filepath);
+        switch (ext) {
+            case ".meta":
+            case ".html":
+            case ".json":
+            case ".body":
+            case ".rsc":
+                const newFilePath = filepath
+                    .substring(0, filepath.length - ext.length)
+                    .replace(/\.prefetch$/, "") + ".cache";
+                cacheFilesPath[newFilePath] = {
+                    [ext.slice(1)]: filepath,
+                    ...cacheFilesPath[newFilePath],
+                };
+                break;
+            case ".map":
+                break;
+            default:
+                logger.warn(`Unknown file extension: ${ext}`);
+                break;
+        }
+    });
+    // Generate cache file
+    Object.entries(cacheFilesPath).forEach(([cacheFilePath, files]) => {
+        const cacheFileMeta = files.meta
+            ? JSON.parse(fs.readFileSync(files.meta, "utf8"))
+            : undefined;
+        const cacheFileContent = {
+            type: files.body ? "route" : files.json ? "page" : "app",
+            meta: cacheFileMeta,
+            html: files.html ? fs.readFileSync(files.html, "utf8") : undefined,
+            json: files.json
+                ? JSON.parse(fs.readFileSync(files.json, "utf8"))
+                : undefined,
+            rsc: files.rsc ? fs.readFileSync(files.rsc, "utf8") : undefined,
+            body: files.body
+                ? fs
+                    .readFileSync(files.body)
+                    .toString(isBinaryContentType(cacheFileMeta.headers["content-type"])
+                    ? "base64"
+                    : "utf8")
+                : undefined,
+        };
+        fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
+    });
+    if (!options.config.dangerous?.disableTagCache) {
+        // Generate dynamodb data
+        // We need to traverse the cache to find every .meta file
+        const metaFiles = [];
+        // Compute dynamodb cache data
+        // Traverse files inside cache to find all meta files and cache tags associated with them
+        buildHelper.traverseFiles(outputPath, (file) => file.endsWith(".meta"), (filePath) => {
+            const fileContent = fs.readFileSync(filePath, "utf8");
+            const fileData = JSON.parse(fileContent);
+            if (fileData.headers?.["x-next-cache-tags"]) {
+                fileData.headers["x-next-cache-tags"]
+                    .split(",")
+                    .forEach((tag) => {
+                    // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation
+                    metaFiles.push({
+                        tag: { S: path.posix.join(buildId, tag.trim()) },
+                        path: {
+                            S: path.posix.join(buildId, path.relative(outputPath, filePath).replace(".meta", "")),
+                        },
+                        // We don't care about the revalidation time here, we just need to make sure it's there
+                        revalidatedAt: { N: "1" },
+                    });
+                });
+            }
+        });
+        // Copy fetch-cache to cache folder
+        const fetchCachePath = path.join(appBuildOutputPath, ".next/cache/fetch-cache");
+        if (fs.existsSync(fetchCachePath)) {
+            const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
+            fs.mkdirSync(fetchOutputPath, { recursive: true });
+            fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
+            buildHelper.traverseFiles(fetchCachePath, () => true, (filepath) => {
+                const fileContent = fs.readFileSync(filepath, "utf8");
+                const fileData = JSON.parse(fileContent);
+                fileData?.tags?.forEach((tag) => {
+                    metaFiles.push({
+                        tag: { S: path.posix.join(buildId, tag) },
+                        path: {
+                            S: path.posix.join(buildId, path.relative(fetchCachePath, filepath)),
+                        },
+                        revalidatedAt: { N: "1" },
+                    });
+                });
+            });
+        }
+        if (metaFiles.length > 0) {
+            useTagCache = true;
+            const providerPath = path.join(outputDir, "dynamodb-provider");
+            //Copy open-next.config.mjs into the bundle
+            fs.mkdirSync(providerPath, { recursive: true });
+            buildHelper.copyOpenNextConfig(options.buildDir, providerPath);
+            // TODO: check if metafiles doesn't contain duplicates
+            fs.writeFileSync(path.join(providerPath, "dynamodb-cache.json"), JSON.stringify(metaFiles));
+        }
+    }
+    // We need to remove files later because we need the metafiles for dynamodb tags cache
+    buildHelper.removeFiles(outputPath, (file) => !file.endsWith(".cache"));
+    return { useTagCache };
+}

package/dist/build/createImageOptimizationBundle.d.ts

@@ -0,0 +1,2 @@
+import * as buildHelper from "./helper.js";
+export declare function createImageOptimizationBundle(options: buildHelper.BuildOptions): Promise<void>;

package/dist/build/createImageOptimizationBundle.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import logger from "../logger.js";
+import { openNextReplacementPlugin } from "../plugins/replacement.js";
+import { openNextResolvePlugin } from "../plugins/resolve.js";
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
+const require = createRequire(import.meta.url);
+export async function createImageOptimizationBundle(options) {
+    logger.info(`Bundling image optimization function...`);
+    const { appBuildOutputPath, config, outputDir } = options;
+    // Create output folder
+    const outputPath = path.join(outputDir, "image-optimization-function");
+    fs.mkdirSync(outputPath, { recursive: true });
+    // Copy open-next.config.mjs into the bundle
+    buildHelper.copyOpenNextConfig(options.buildDir, outputPath);
+    const plugins = [
+        openNextResolvePlugin({
+            fnName: "imageOptimization",
+            overrides: {
+                converter: config.imageOptimization?.override?.converter,
+                wrapper: config.imageOptimization?.override?.wrapper,
+                imageLoader: config.imageOptimization?.loader,
+            },
+        }),
+    ];
+    if (buildHelper.compareSemver(options.nextVersion, "14.1.1") >= 0) {
+        plugins.push(openNextReplacementPlugin({
+            name: "opennext-14.1.1-image-optimization",
+            target: /plugins(\/|\\)image-optimization(\/|\\)image-optimization\.js/g,
+            replacements: [
+                require.resolve("../adapters/plugins/image-optimization/image-optimization.replacement.js"),
+            ],
+        }));
+    }
+    // Build Lambda code (1st pass)
+    // note: bundle in OpenNext package b/c the adapter relies on the
+    //       "@aws-sdk/client-s3" package which is not a dependency in user's
+    //       Next.js app.
+    await buildHelper.esbuildAsync({
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "image-optimization-adapter.js"),
+        ],
+        external: ["sharp", "next"],
+        outfile: path.join(outputPath, "index.mjs"),
+        plugins,
+    }, options);
+    // Build Lambda code (2nd pass)
+    // note: bundle in user's Next.js app again b/c the adapter relies on the
+    //       "next" package. And the "next" package from user's app should
+    //       be used. We also set @opentelemetry/api as external because it seems to be
+    //       required by Next 15 even though it's not used.
+    buildHelper.esbuildSync({
+        entryPoints: [path.join(outputPath, "index.mjs")],
+        external: ["sharp", "@opentelemetry/api"],
+        allowOverwrite: true,
+        outfile: path.join(outputPath, "index.mjs"),
+        banner: {
+            js: [
+                "import { createRequire as topLevelCreateRequire } from 'module';",
+                "const require = topLevelCreateRequire(import.meta.url);",
+                "import bannerUrl from 'url';",
+                "const __dirname = bannerUrl.fileURLToPath(new URL('.', import.meta.url));",
+            ].join("\n"),
+        },
+    }, options);
+    // Copy over .next/required-server-files.json file and BUILD_ID
+    fs.mkdirSync(path.join(outputPath, ".next"));
+    fs.copyFileSync(path.join(appBuildOutputPath, ".next/required-server-files.json"), path.join(outputPath, ".next/required-server-files.json"));
+    fs.copyFileSync(path.join(appBuildOutputPath, ".next/BUILD_ID"), path.join(outputPath, ".next/BUILD_ID"));
+    // Sharp provides pre-build binaries for all platforms. https://github.com/lovell/sharp/blob/main/docs/install.md#cross-platform
+    // Target should be same as used by Lambda, see https://github.com/sst/sst/blob/ca6f763fdfddd099ce2260202d0ce48c72e211ea/packages/sst/src/constructs/NextjsSite.ts#L114
+    // For SHARP_IGNORE_GLOBAL_LIBVIPS see: https://github.com/lovell/sharp/blob/main/docs/install.md#aws-lambda
+    const sharpVersion = process.env.SHARP_VERSION ?? "0.32.6";
+    installDependencies(outputPath, config.imageOptimization?.install ?? {
+        packages: [`sharp@${sharpVersion}`],
+    });
+}

package/dist/build/createMiddleware.d.ts

@@ -0,0 +1,10 @@
+import * as buildHelper from "./helper.js";
+/**
+ * Compiles the middleware bundle.
+ *
+ * @param options Build Options.
+ * @returns Whether the app uses a Middleware.
+ */
+export declare function createMiddleware(options: buildHelper.BuildOptions): Promise<{
+    useMiddleware: boolean;
+}>;

package/dist/build/createMiddleware.js

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import path from "node:path";
+import logger from "../logger.js";
+import { buildEdgeBundle } from "./edge/createEdgeBundle.js";
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
+/**
+ * Compiles the middleware bundle.
+ *
+ * @param options Build Options.
+ * @returns Whether the app uses a Middleware.
+ */
+export async function createMiddleware(options) {
+    logger.info(`Bundling middleware function...`);
+    const { appBuildOutputPath, config, outputDir } = options;
+    // Get middleware manifest
+    const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
+    const entry = middlewareManifest.middleware["/"];
+    if (!entry) {
+        return { useMiddleware: false };
+    }
+    // Create output folder
+    let outputPath = path.join(outputDir, "server-function");
+    const commonMiddlewareOptions = {
+        middlewareInfo: entry,
+        options,
+        appBuildOutputPath,
+    };
+    if (config.middleware?.external) {
+        outputPath = path.join(outputDir, "middleware");
+        fs.mkdirSync(outputPath, { recursive: true });
+        // Copy open-next.config.mjs
+        buildHelper.copyOpenNextConfig(options.buildDir, outputPath, config.middleware.override?.wrapper === "cloudflare");
+        // Bundle middleware
+        await buildEdgeBundle({
+            entrypoint: path.join(options.openNextDistDir, "adapters", "middleware.js"),
+            outfile: path.join(outputPath, "handler.mjs"),
+            ...commonMiddlewareOptions,
+            overrides: config.middleware?.override,
+            defaultConverter: "aws-cloudfront",
+            includeCache: config.dangerous?.enableCacheInterception,
+            additionalExternals: config.edgeExternals,
+        });
+        installDependencies(outputPath, config.middleware?.install);
+    }
+    else {
+        await buildEdgeBundle({
+            entrypoint: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
+            outfile: path.join(options.buildDir, "middleware.mjs"),
+            ...commonMiddlewareOptions,
+            onlyBuildOnce: true,
+        });
+    }
+    return { useMiddleware: true };
+}

package/dist/build/createRevalidationBundle.d.ts

@@ -0,0 +1,2 @@
+import * as buildHelper from "./helper.js";
+export declare function createRevalidationBundle(options: buildHelper.BuildOptions): Promise<void>;

package/dist/build/createRevalidationBundle.js

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import logger from "../logger.js";
+import { openNextResolvePlugin } from "../plugins/resolve.js";
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
+export async function createRevalidationBundle(options) {
+    logger.info(`Bundling revalidation function...`);
+    const { appBuildOutputPath, config, outputDir } = options;
+    // Create output folder
+    const outputPath = path.join(outputDir, "revalidation-function");
+    fs.mkdirSync(outputPath, { recursive: true });
+    //Copy open-next.config.mjs into the bundle
+    buildHelper.copyOpenNextConfig(options.buildDir, outputPath);
+    // Build Lambda code
+    await buildHelper.esbuildAsync({
+        external: ["next", "styled-jsx", "react"],
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "revalidate.js"),
+        ],
+        outfile: path.join(outputPath, "index.mjs"),
+        plugins: [
+            openNextResolvePlugin({
+                fnName: "revalidate",
+                overrides: {
+                    converter: config.revalidate?.override?.converter ?? "sqs-revalidate",
+                    wrapper: config.revalidate?.override?.wrapper,
+                },
+            }),
+        ],
+    }, options);
+    installDependencies(outputPath, config.revalidate?.install);
+    // Copy over .next/prerender-manifest.json file
+    fs.copyFileSync(path.join(appBuildOutputPath, ".next", "prerender-manifest.json"), path.join(outputPath, "prerender-manifest.json"));
+}

package/dist/build/createServerBundle.d.ts

@@ -1,2 +1,2 @@
-import type { BuildOptions } from "./helper.js";
-export declare function createServerBundle(options: BuildOptions): Promise<void>;
+import * as buildHelper from "./helper.js";
+export declare function createServerBundle(options: buildHelper.BuildOptions): Promise<void>;

package/dist/build/createServerBundle.js

@@ -1,19 +1,17 @@
-import { existsSync } from "node:fs";
-import { createRequire as topLevelCreateRequire } from "node:module";
-import fs from "fs";
-import path from "path";
-import url from "url";
-import { compileCache } from "../build.js";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
 import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
 import { openNextResolvePlugin } from "../plugins/resolve.js";
 import { bundleNextServer } from "./bundleNextServer.js";
+import { compileCache } from "./compileCache.js";
 import { copyTracedFiles } from "./copyTracedFiles.js";
 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));
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
+const require = createRequire(import.meta.url);
 export async function createServerBundle(options) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -44,9 +42,9 @@ export async function createServerBundle(options) {
     // Find remaining routes
     const serverPath = path.join(appBuildOutputPath, ".next", "standalone", packagePath, ".next", "server");
     // Find app dir routes
-    if (existsSync(path.join(serverPath, "app"))) {
+    if (fs.existsSync(path.join(serverPath, "app"))) {
         const appPath = path.join(serverPath, "app");
-        traverseFiles(appPath, (file) => {
+        buildHelper.traverseFiles(appPath, (file) => {
             if (file.endsWith("page.js") || file.endsWith("route.js")) {
                 const route = `app/${file.replace(/\.js$/, "")}`;
                 if (!foundRoutes.has(route)) {
@@ -57,9 +55,9 @@ export async function createServerBundle(options) {
         }, () => { });
     }
     // Find pages dir routes
-    if (existsSync(path.join(serverPath, "pages"))) {
+    if (fs.existsSync(path.join(serverPath, "pages"))) {
         const pagePath = path.join(serverPath, "pages");
-        traverseFiles(pagePath, (file) => {
+        buildHelper.traverseFiles(pagePath, (file) => {
             if (file.endsWith(".js")) {
                 const route = `pages/${file.replace(/\.js$/, "")}`;
                 if (!foundRoutes.has(route)) {
@@ -91,7 +89,7 @@ async function generateBundle(name, config, options, fnOptions) {
     const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
     fs.mkdirSync(path.join(outputPath, packagePath), { recursive: true });
     const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
-    fs.copyFileSync(path.join(outputDir, ".build", `cache.${ext}`), path.join(outputPath, packagePath, "cache.cjs"));
+    fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outputPath, packagePath, "cache.cjs"));
     if (fnOptions.runtime === "deno") {
         addDenoJson(outputPath, packagePath);
     }
@@ -100,26 +98,26 @@ async function generateBundle(name, config, options, fnOptions) {
     if (isBundled) {
         await bundleNextServer(path.join(outputPath, packagePath), appPath);
     }
-    // // Copy middleware
+    // Copy middleware
     if (!config.middleware?.external &&
-        existsSync(path.join(outputDir, ".build", "middleware.mjs"))) {
-        fs.copyFileSync(path.join(outputDir, ".build", "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
+        fs.existsSync(path.join(options.buildDir, "middleware.mjs"))) {
+        fs.copyFileSync(path.join(options.buildDir, "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
     }
     // Copy open-next.config.mjs
-    copyOpenNextConfig(path.join(outputDir, ".build"), path.join(outputPath, packagePath));
-    //Copy env files
-    copyEnvFile(appBuildOutputPath, packagePath, outputPath);
+    buildHelper.copyOpenNextConfig(options.buildDir, path.join(outputPath, packagePath));
+    // Copy env files
+    buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
     // Copy all necessary traced files
     await copyTracedFiles(appBuildOutputPath, packagePath, outputPath, fnOptions.routes ?? ["app/page.tsx"], isBundled);
     // Build Lambda code
     // note: bundle in OpenNext package b/c the adapter relies on the
     //       "serverless-http" package which is not a dependency in user's
     //       Next.js app.
-    const disableNextPrebundledReact = compareSemver(options.nextVersion, "13.5.1") >= 0 ||
-        compareSemver(options.nextVersion, "13.4.1") <= 0;
+    const disableNextPrebundledReact = buildHelper.compareSemver(options.nextVersion, "13.5.1") >= 0 ||
+        buildHelper.compareSemver(options.nextVersion, "13.4.1") <= 0;
     const overrides = fnOptions.override ?? {};
-    const isBefore13413 = compareSemver(options.nextVersion, "13.4.13") <= 0;
-    const isAfter141 = compareSemver(options.nextVersion, "14.0.4") >= 0;
+    const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "13.4.13") <= 0;
+    const isAfter141 = buildHelper.compareSemver(options.nextVersion, "14.0.4") >= 0;
     const disableRouting = isBefore13413 || config.middleware?.external;
     const plugins = [
         openNextReplacementPlugin({
@@ -154,8 +152,10 @@ async function generateBundle(name, config, options, fnOptions) {
             .join(",")}] for Next version: ${options.nextVersion}`);
     }
     const outfileExt = fnOptions.runtime === "deno" ? "ts" : "mjs";
-    await esbuildAsync({
-        entryPoints: [path.join(__dirname, "../adapters", "server-adapter.js")],
+    await buildHelper.esbuildAsync({
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "server-adapter.js"),
+        ],
         external: ["next", "./middleware.mjs", "./next-server.runtime.prod.js"],
         outfile: path.join(outputPath, packagePath, `index.${outfileExt}`),
         banner: {
@@ -180,6 +180,7 @@ async function generateBundle(name, config, options, fnOptions) {
     if (isMonorepo) {
         addMonorepoEntrypoint(outputPath, packagePath);
     }
+    installDependencies(outputPath, fnOptions.install);
     if (fnOptions.minify) {
         await minifyServerBundle(outputPath);
     }

package/dist/build/createWarmerBundle.d.ts

@@ -0,0 +1,2 @@
+import * as buildHelper from "./helper.js";
+export declare function createWarmerBundle(options: buildHelper.BuildOptions): Promise<void>;

package/dist/build/createWarmerBundle.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import logger from "../logger.js";
+import { openNextResolvePlugin } from "../plugins/resolve.js";
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
+export async function createWarmerBundle(options) {
+    logger.info(`Bundling warmer function...`);
+    const { config, outputDir } = options;
+    // Create output folder
+    const outputPath = path.join(outputDir, "warmer-function");
+    fs.mkdirSync(outputPath, { recursive: true });
+    // Copy open-next.config.mjs into the bundle
+    buildHelper.copyOpenNextConfig(options.buildDir, outputPath);
+    // Build Lambda code
+    // note: bundle in OpenNext package b/c the adatper relys on the
+    //       "serverless-http" package which is not a dependency in user's
+    //       Next.js app.
+    await buildHelper.esbuildAsync({
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "warmer-function.js"),
+        ],
+        external: ["next"],
+        outfile: path.join(outputPath, "index.mjs"),
+        plugins: [
+            openNextResolvePlugin({
+                overrides: {
+                    converter: config.warmer?.override?.converter ?? "dummy",
+                    wrapper: config.warmer?.override?.wrapper,
+                },
+                fnName: "warmer",
+            }),
+        ],
+        banner: {
+            js: [
+                "import { createRequire as topLevelCreateRequire } from 'module';",
+                "const require = topLevelCreateRequire(import.meta.url);",
+                "import bannerUrl from 'url';",
+                "const __dirname = bannerUrl.fileURLToPath(new URL('.', import.meta.url));",
+            ].join(""),
+        },
+    }, options);
+    installDependencies(outputPath, config.warmer?.install);
+}

package/dist/build/edge/createEdgeBundle.d.ts

@@ -1,6 +1,6 @@
-import { MiddlewareInfo } from "../../types/next-types";
-import { IncludedConverter, OpenNextConfig, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
-import { BuildOptions } from "../helper.js";
+import type { MiddlewareInfo } from "../../types/next-types";
+import type { IncludedConverter, OpenNextConfig, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { BuildOptions } from "../helper.js";
 interface BuildEdgeBundleOptions {
     appBuildOutputPath: string;
     middlewareInfo: MiddlewareInfo;

package/dist/build/edge/createEdgeBundle.js

@@ -1,5 +1,4 @@
 import { mkdirSync } from "node:fs";
-import url from "node:url";
 import { build } from "esbuild";
 import fs from "fs";
 import path from "path";
@@ -8,7 +7,6 @@ import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
-const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
     const isInCloudfare = typeof overrides?.wrapper === "string"
         ? overrides.wrapper === "cloudflare"
@@ -53,7 +51,7 @@ export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entr
             openNextEdgePlugins({
                 middlewareInfo,
                 nextDir: path.join(appBuildOutputPath, ".next"),
-                edgeFunctionHandlerPath: path.join(__dirname, "../../core", "edgeFunctionHandler.js"),
+                edgeFunctionHandlerPath: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
                 isInCloudfare,
             }),
         ],
@@ -116,7 +114,7 @@ export async function generateEdgeBundle(name, config, options, fnOptions) {
     const outputPath = path.join(outputDir, "server-functions", name);
     fs.mkdirSync(outputPath, { recursive: true });
     // Copy open-next.config.mjs
-    copyOpenNextConfig(path.join(outputDir, ".build"), outputPath, true);
+    copyOpenNextConfig(options.buildDir, outputPath, true);
     // Load middleware manifest
     const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
     // Find functions
@@ -140,7 +138,7 @@ export async function generateEdgeBundle(name, config, options, fnOptions) {
     await buildEdgeBundle({
         appBuildOutputPath,
         middlewareInfo: fn,
-        entrypoint: path.join(__dirname, "../../adapters", "edge-adapter.js"),
+        entrypoint: path.join(options.openNextDistDir, "adapters", "edge-adapter.js"),
         outfile: path.join(outputPath, "index.mjs"),
         options,
         overrides: fnOptions.override,

package/dist/build/helper.d.ts

@@ -1,19 +1,21 @@
-import { BuildOptions as ESBuildOptions } from "esbuild";
-import { OpenNextConfig } from "../types/open-next.js";
+import type { BuildOptions as ESBuildOptions } from "esbuild";
+import type { OpenNextConfig } from "../types/open-next.js";
 export type BuildOptions = ReturnType<typeof normalizeOptions>;
-export declare function normalizeOptions(config: OpenNextConfig): {
+export declare function normalizeOptions(config: OpenNextConfig, distDir: string, tempBuildDir: string): {
     appBuildOutputPath: string;
     appPackageJsonPath: string;
     appPath: string;
     appPublicPath: string;
+    buildDir: string;
     config: OpenNextConfig;
     debug: boolean;
     monorepoRoot: string;
     nextVersion: string;
     openNextVersion: string;
+    openNextDistDir: string;
     outputDir: string;
     packager: "npm" | "yarn" | "pnpm" | "bun";
-    tempDir: string;
+    tempBuildDir: string;
 };
 export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
 export declare function esbuildAsync(esbuildOptions: ESBuildOptions, options: BuildOptions): Promise<void>;
@@ -31,5 +33,20 @@ export declare function getBuildId(dotNextPath: string): string;
 export declare function getOpenNextVersion(): string;
 export declare function getNextVersion(appPath: string): string;
 export declare function compareSemver(v1: string, v2: string): number;
-export declare function copyOpenNextConfig(tempDir: string, outputPath: string, isEdge?: boolean): void;
+export declare function copyOpenNextConfig(inputDir: string, outputDir: string, isEdge?: boolean): void;
 export declare function copyEnvFile(appPath: string, packagePath: string, outputPath: string): void;
+/**
+ * Check we are in a Nextjs app by looking for the Nextjs config file.
+ */
+export declare function checkRunningInsideNextjsApp(options: BuildOptions): void;
+export declare function printNextjsVersion(options: BuildOptions): void;
+export declare function printOpenNextVersion(options: BuildOptions): void;
+/**
+ * Populates the build directory with the compiled configuration files.
+ *
+ * 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.
+ */
+export declare function initOutputDir(options: BuildOptions): void;