@opennextjs/aws 3.1.6 → 3.2.1

package/dist/build/compileConfig.js

@@ -1,19 +1,53 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { buildSync } from "esbuild";
 import logger from "../logger.js";
-export function compileOpenNextConfigNode(tempDir, openNextConfigPath, nodeExternals) {
-    const sourcePath = path.join(process.cwd(), openNextConfigPath ?? "open-next.config.ts");
-    const outputPath = path.join(tempDir, "open-next.config.mjs");
+import { validateConfig } from "./validateConfig.js";
+/**
+ * Compiles the OpenNext configuration.
+ *
+ * The configuration is always compiled for Node.js and for the edge only if needed.
+ *
+ * @param baseDir Directory where to look for the configuration.
+ * @param openNextConfigPath Override the default configuration when provided. Relative to baseDir.
+ * @param nodeExternals Externals for the Node.js compilation.
+ * @return The configuration and the build directory.
+ */
+export async function compileOpenNextConfig(baseDir, openNextConfigPath, nodeExternals) {
+    const sourcePath = path.join(baseDir, openNextConfigPath ?? "open-next.config.ts");
+    const buildDir = fs.mkdtempSync(path.join(os.tmpdir(), "open-next-tmp"));
+    let configPath = compileOpenNextConfigNode(sourcePath, buildDir, nodeExternals ? nodeExternals.split(",") : []);
+    // On Windows, we need to use file:// protocol to load the config file using import()
+    if (process.platform === "win32")
+        configPath = `file://${configPath}`;
+    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://opennext.js.org/config#configuration-file`);
+        process.exit(1);
+    }
+    validateConfig(config);
+    // We need to check if the config uses the edge runtime at any point
+    // If it does, we need to compile it with the edge runtime
+    const usesEdgeRuntime = config.middleware?.external ||
+        Object.values(config.functions || {}).some((fn) => fn.runtime === "edge");
+    if (!usesEdgeRuntime) {
+        logger.debug("No edge runtime found in the open-next.config.ts. Using default config.");
+        //Nothing to do here
+    }
+    else {
+        compileOpenNextConfigEdge(sourcePath, buildDir, config.edgeExternals ?? []);
+    }
+    return { config, buildDir };
+}
+export function compileOpenNextConfigNode(sourcePath, outputDir, externals) {
+    const outputPath = path.join(outputDir, "open-next.config.mjs");
+    logger.debug("Compiling open-next.config.ts for Node.", outputPath);
     //Check if open-next.config.ts exists
     if (!fs.existsSync(sourcePath)) {
         //Create a simple open-next.config.mjs file
         logger.debug("Cannot find open-next.config.ts. Using default config.");
-        fs.writeFileSync(outputPath, [
-            "var config = { default: { } };",
-            "var open_next_config_default = config;",
-            "export { open_next_config_default as default };",
-        ].join("\n"));
+        fs.writeFileSync(outputPath, "export default { default: { } };");
     }
     else {
         buildSync({
@@ -22,7 +56,7 @@ export function compileOpenNextConfigNode(tempDir, openNextConfigPath, nodeExter
             bundle: true,
             format: "esm",
             target: ["node18"],
-            external: nodeExternals ? nodeExternals.split(",") : [],
+            external: externals,
             platform: "node",
             banner: {
                 js: [
@@ -36,29 +70,17 @@ export function compileOpenNextConfigNode(tempDir, openNextConfigPath, nodeExter
     }
     return outputPath;
 }
-export function compileOpenNextConfigEdge(tempDir, config, openNextConfigPath) {
-    const sourcePath = path.join(process.cwd(), openNextConfigPath ?? "open-next.config.ts");
-    const outputPath = path.join(tempDir, "open-next.config.edge.mjs");
-    // We need to check if the config uses the edge runtime at any point
-    // If it does, we need to compile it with the edge runtime
-    const usesEdgeRuntime = config.middleware?.external ||
-        Object.values(config.functions || {}).some((fn) => fn.runtime === "edge");
-    if (!usesEdgeRuntime) {
-        logger.debug("No edge runtime found in the open-next.config.ts. Using default config.");
-        //Nothing to do here
-    }
-    else {
-        logger.info("Compiling open-next.config.ts for edge runtime.", outputPath);
-        buildSync({
-            entryPoints: [sourcePath],
-            outfile: outputPath,
-            bundle: true,
-            format: "esm",
-            target: ["es2020"],
-            conditions: ["worker", "browser"],
-            platform: "browser",
-            external: config.edgeExternals ?? [],
-        });
-        logger.info("Compiled open-next.config.ts for edge runtime.");
-    }
+export function compileOpenNextConfigEdge(sourcePath, outputDir, externals) {
+    const outputPath = path.join(outputDir, "open-next.config.edge.mjs");
+    logger.debug("Compiling open-next.config.ts for edge runtime.", outputPath);
+    buildSync({
+        entryPoints: [sourcePath],
+        outfile: outputPath,
+        bundle: true,
+        format: "esm",
+        target: ["es2020"],
+        conditions: ["worker", "browser"],
+        platform: "browser",
+        external: externals,
+    });
 }

package/dist/build/compileTagCacheProvider.d.ts

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

package/dist/build/compileTagCacheProvider.js

@@ -0,0 +1,26 @@
+import path from "node:path";
+import { openNextResolvePlugin } from "../plugins/resolve.js";
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
+export async function compileTagCacheProvider(options) {
+    const providerPath = path.join(options.outputDir, "dynamodb-provider");
+    const overrides = options.config.initializationFunction?.override;
+    await buildHelper.esbuildAsync({
+        external: ["@aws-sdk/client-dynamodb"],
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "dynamo-provider.js"),
+        ],
+        outfile: path.join(providerPath, "index.mjs"),
+        target: ["node18"],
+        plugins: [
+            openNextResolvePlugin({
+                fnName: "initializationFunction",
+                overrides: {
+                    converter: overrides?.converter ?? "dummy",
+                    wrapper: overrides?.wrapper,
+                },
+            }),
+        ],
+    }, options);
+    installDependencies(providerPath, options.config.initializationFunction?.install);
+}

package/dist/build/copyTracedFiles.js

@@ -54,7 +54,7 @@ export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, r
                 throw new Error(`
 --------------------------------------------------------------------------------
 ${pagePath} cannot use the edge runtime.
-OpenNext requires edge runtime function to be defined in a separate function. 
+OpenNext requires edge runtime function to be defined in a separate function.
 See the docs for more information on how to bundle edge runtime functions.
 --------------------------------------------------------------------------------
         `);
@@ -71,7 +71,7 @@ File ${fullFilePath} does not exist
         extractFiles(requiredFiles.files, path.join(standaloneNextDir, dir)).forEach((f) => {
             filesToCopy.set(f, f.replace(standaloneDir, outputDir));
         });
-        if (!existsSync(path.join(standaloneNextDir, `${fullFilePath}`))) {
+        if (!existsSync(path.join(standaloneNextDir, fullFilePath))) {
             throw new Error(`This error should only happen for static 404 and 500 page from page router. Report this if that's not the case.,
         File ${fullFilePath} does not exist`);
         }

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,82 @@
+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}`],
+        arch: "arm64",
+        nodeVersion: "18",
+        libc: "glibc",
+    });
+}

package/dist/build/createMiddleware.d.ts

@@ -0,0 +1,10 @@
+import * as buildHelper from "./helper.js";
+/**
+ * Compiles the middleware bundle.
+ *
+ * @param options Build Options.
+ * @param forceOnlyBuildOnce force to build only once.
+ */
+export declare function createMiddleware(options: buildHelper.BuildOptions, { forceOnlyBuildOnce }?: {
+    forceOnlyBuildOnce?: boolean | undefined;
+}): Promise<void>;

package/dist/build/createMiddleware.js

@@ -0,0 +1,47 @@
+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.
+ * @param forceOnlyBuildOnce force to build only once.
+ */
+export async function createMiddleware(options, { forceOnlyBuildOnce = false } = {}) {
+    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 middlewareInfo = middlewareManifest.middleware["/"];
+    if (config.middleware?.external) {
+        const 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"),
+            middlewareInfo,
+            options,
+            overrides: config.middleware?.override,
+            defaultConverter: "aws-cloudfront",
+            includeCache: config.dangerous?.enableCacheInterception,
+            additionalExternals: config.edgeExternals,
+            onlyBuildOnce: forceOnlyBuildOnce === true,
+        });
+        installDependencies(outputPath, config.middleware?.install);
+    }
+    else {
+        await buildEdgeBundle({
+            entrypoint: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
+            outfile: path.join(options.buildDir, "middleware.mjs"),
+            middlewareInfo,
+            options,
+            onlyBuildOnce: 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>;