@opennextjs/aws 3.1.4

package/dist/build/createServerBundle.js

@@ -0,0 +1,228 @@
+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 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 { 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));
+export async function createServerBundle(config, options) {
+    const foundRoutes = new Set();
+    // Get all functions to build
+    const defaultFn = config.default;
+    const functions = Object.entries(config.functions ?? {});
+    // Recompile cache.ts as ESM if any function is using Deno runtime
+    if (defaultFn.runtime === "deno" ||
+        functions.some(([, fn]) => fn.runtime === "deno")) {
+        compileCache("esm");
+    }
+    const promises = functions.map(async ([name, fnOptions]) => {
+        const routes = fnOptions.routes;
+        routes.forEach((route) => foundRoutes.add(route));
+        if (fnOptions.runtime === "edge") {
+            await generateEdgeBundle(name, config, options, fnOptions);
+        }
+        else {
+            await generateBundle(name, config, options, fnOptions);
+        }
+    });
+    //TODO: throw an error if not all edge runtime routes has been bundled in a separate function
+    // We build every other function than default before so we know which route there is left
+    await Promise.all(promises);
+    const remainingRoutes = new Set();
+    const { monorepoRoot, appBuildOutputPath } = options;
+    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    // Find remaining routes
+    const serverPath = path.join(appBuildOutputPath, ".next", "standalone", packagePath, ".next", "server");
+    // Find app dir routes
+    if (existsSync(path.join(serverPath, "app"))) {
+        const appPath = path.join(serverPath, "app");
+        traverseFiles(appPath, (file) => {
+            if (file.endsWith("page.js") || file.endsWith("route.js")) {
+                const route = `app/${file.replace(/\.js$/, "")}`;
+                if (!foundRoutes.has(route)) {
+                    remainingRoutes.add(route);
+                }
+            }
+            return false;
+        }, () => { });
+    }
+    // Find pages dir routes
+    if (existsSync(path.join(serverPath, "pages"))) {
+        const pagePath = path.join(serverPath, "pages");
+        traverseFiles(pagePath, (file) => {
+            if (file.endsWith(".js")) {
+                const route = `pages/${file.replace(/\.js$/, "")}`;
+                if (!foundRoutes.has(route)) {
+                    remainingRoutes.add(route);
+                }
+            }
+            return false;
+        }, () => { });
+    }
+    // Generate default function
+    await generateBundle("default", config, options, {
+        ...defaultFn,
+        // @ts-expect-error - Those string are RouteTemplate
+        routes: Array.from(remainingRoutes),
+        patterns: ["*"],
+    });
+}
+async function generateBundle(name, config, options, fnOptions) {
+    const { appPath, appBuildOutputPath, outputDir, monorepoRoot } = options;
+    logger.info(`Building server function: ${name}...`);
+    // Create output folder
+    const outputPath = path.join(outputDir, "server-functions", name);
+    // Resolve path to the Next.js app if inside the monorepo
+    // note: if user's app is inside a monorepo, standalone mode places
+    //       `node_modules` inside `.next/standalone`, and others inside
+    //       `.next/standalone/package/path` (ie. `.next`, `server.js`).
+    //       We need to output the handler file inside the package path.
+    const isMonorepo = monorepoRoot !== appPath;
+    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"));
+    if (fnOptions.runtime === "deno") {
+        addDenoJson(outputPath, packagePath);
+    }
+    // Bundle next server if necessary
+    const isBundled = fnOptions.experimentalBundledNextServer ?? false;
+    if (isBundled) {
+        await bundleNextServer(path.join(outputPath, packagePath), appPath);
+    }
+    // // 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"));
+    }
+    // Copy open-next.config.mjs
+    copyOpenNextConfig(path.join(outputDir, ".build"), path.join(outputPath, packagePath));
+    //Copy env files
+    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 overrides = fnOptions.override ?? {};
+    const isBefore13413 = compareSemver(options.nextVersion, "13.4.13") <= 0;
+    const isAfter141 = compareSemver(options.nextVersion, "14.0.4") >= 0;
+    const disableRouting = isBefore13413 || config.middleware?.external;
+    const plugins = [
+        openNextReplacementPlugin({
+            name: `requestHandlerOverride ${name}`,
+            target: /core(\/|\\)requestHandler\.js/g,
+            deletes: disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : [],
+            replacements: disableRouting
+                ? [
+                    require.resolve("../adapters/plugins/without-routing/requestHandler.js"),
+                ]
+                : [],
+        }),
+        openNextReplacementPlugin({
+            name: `utilOverride ${name}`,
+            target: /core(\/|\\)util\.js/g,
+            deletes: [
+                ...(disableNextPrebundledReact ? ["requireHooks"] : []),
+                ...(disableRouting ? ["trustHostHeader"] : []),
+                ...(!isBefore13413 ? ["requestHandlerHost"] : []),
+                ...(!isAfter141 ? ["stableIncrementalCache"] : []),
+                ...(isAfter141 ? ["experimentalIncrementalCacheHandler"] : []),
+            ],
+        }),
+        openNextResolvePlugin({
+            fnName: name,
+            overrides: overrides,
+        }),
+    ];
+    if (plugins && plugins.length > 0) {
+        logger.debug(`Applying plugins:: [${plugins
+            .map(({ name }) => name)
+            .join(",")}] for Next version: ${options.nextVersion}`);
+    }
+    const outfileExt = fnOptions.runtime === "deno" ? "ts" : "mjs";
+    await esbuildAsync({
+        entryPoints: [path.join(__dirname, "../adapters", "server-adapter.js")],
+        external: ["next", "./middleware.mjs", "./next-server.runtime.prod.js"],
+        outfile: path.join(outputPath, packagePath, `index.${outfileExt}`),
+        banner: {
+            js: [
+                `globalThis.monorepoPackagePath = "${packagePath}";`,
+                "import process from 'node:process';",
+                "import { Buffer } from 'node:buffer';",
+                "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));",
+                name === "default" ? "" : `globalThis.fnName = "${name}";`,
+            ].join(""),
+        },
+        plugins,
+        alias: {
+            "next/dist/server/next-server.js": isBundled
+                ? "./next-server.runtime.prod.js"
+                : "next/dist/server/next-server.js",
+        },
+    }, options);
+    if (isMonorepo) {
+        addMonorepoEntrypoint(outputPath, packagePath);
+    }
+    if (fnOptions.minify) {
+        await minifyServerBundle(outputPath);
+    }
+    const shouldGenerateDocker = shouldGenerateDockerfile(fnOptions);
+    if (shouldGenerateDocker) {
+        fs.writeFileSync(path.join(outputPath, "Dockerfile"), typeof shouldGenerateDocker === "string"
+            ? shouldGenerateDocker
+            : `
+FROM node:18-alpine
+WORKDIR /app
+COPY . /app
+EXPOSE 3000
+CMD ["node", "index.mjs"]
+    `);
+    }
+}
+function shouldGenerateDockerfile(options) {
+    return options.override?.generateDockerfile ?? false;
+}
+// Add deno.json file to enable "bring your own node_modules" mode.
+// TODO: this won't be necessary in Deno 2. See https://github.com/denoland/deno/issues/23151
+function addDenoJson(outputPath, packagePath) {
+    const config = {
+        // Enable "bring your own node_modules" mode
+        // and allow `__proto__`
+        unstable: ["byonm", "fs", "unsafe-proto"],
+    };
+    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
+function addMonorepoEntrypoint(outputPath, packagePath) {
+    // Note: in the monorepo case, the handler file is output to
+    //       `.next/standalone/package/path/index.mjs`, but we want
+    //       the Lambda function to be able to find the handler at
+    //       the root of the bundle. We will create a dummy `index.mjs`
+    //       that re-exports the real handler.
+    // Always use posix path for import path
+    const packagePosixPath = packagePath.split(path.sep).join(path.posix.sep);
+    fs.writeFileSync(path.join(outputPath, "index.mjs"), [`export * from "./${packagePosixPath}/index.mjs";`].join(""));
+}
+async function minifyServerBundle(outputDir) {
+    logger.info(`Minimizing server function...`);
+    await minifyAll(outputDir, {
+        compress_json: true,
+        mangle: true,
+    });
+}

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

@@ -0,0 +1,20 @@
+import { MiddlewareInfo } from "../../types/next-types";
+import { IncludedConverter, OpenNextConfig, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import { BuildOptions } from "../helper.js";
+interface BuildEdgeBundleOptions {
+    appBuildOutputPath: string;
+    middlewareInfo: MiddlewareInfo;
+    entrypoint: string;
+    outfile: string;
+    options: BuildOptions;
+    overrides?: OverrideOptions;
+    defaultConverter?: IncludedConverter;
+    additionalInject?: string;
+    includeCache?: boolean;
+    additionalExternals?: string[];
+    onlyBuildOnce?: boolean;
+}
+export declare function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): Promise<void>;
+export declare function copyMiddlewareAssetsAndWasm({}: {}): void;
+export declare function generateEdgeBundle(name: string, config: OpenNextConfig, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
+export {};

package/dist/build/edge/createEdgeBundle.js

@@ -0,0 +1,149 @@
+import { mkdirSync } from "node:fs";
+import url from "node:url";
+import { build } from "esbuild";
+import fs from "fs";
+import path from "path";
+import logger from "../../logger.js";
+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"
+        : (await overrides?.wrapper?.())?.edgeRuntime;
+    await esbuildAsync({
+        entryPoints: [entrypoint],
+        // inject: ,
+        bundle: true,
+        outfile,
+        external: ["node:*", "next", "@aws-sdk/*"],
+        target: "es2022",
+        platform: "neutral",
+        plugins: [
+            openNextResolvePlugin({
+                overrides: {
+                    wrapper: typeof overrides?.wrapper === "string"
+                        ? overrides.wrapper
+                        : "aws-lambda",
+                    converter: typeof overrides?.converter === "string"
+                        ? overrides.converter
+                        : defaultConverter,
+                    ...(includeCache
+                        ? {
+                            tagCache: typeof overrides?.tagCache === "string"
+                                ? overrides.tagCache
+                                : "dynamodb-lite",
+                            incrementalCache: typeof overrides?.incrementalCache === "string"
+                                ? overrides.incrementalCache
+                                : "s3-lite",
+                            queue: typeof overrides?.queue === "string"
+                                ? overrides.queue
+                                : "sqs-lite",
+                        }
+                        : {}),
+                },
+            }),
+            openNextReplacementPlugin({
+                name: "externalMiddlewareOverrides",
+                target: /adapters(\/|\\)middleware\.js/g,
+                deletes: includeCache ? [] : ["includeCacheInMiddleware"],
+            }),
+            openNextEdgePlugins({
+                middlewareInfo,
+                nextDir: path.join(appBuildOutputPath, ".next"),
+                edgeFunctionHandlerPath: path.join(__dirname, "../../core", "edgeFunctionHandler.js"),
+                isInCloudfare,
+            }),
+        ],
+        treeShaking: true,
+        alias: {
+            path: "node:path",
+            stream: "node:stream",
+            fs: "node:fs",
+        },
+        conditions: ["module"],
+        mainFields: ["module", "main"],
+        banner: {
+            js: `
+import {Buffer} from "node:buffer";
+globalThis.Buffer = Buffer;
+
+import {AsyncLocalStorage} from "node:async_hooks";
+globalThis.AsyncLocalStorage = AsyncLocalStorage;
+  ${isInCloudfare
+                ? ""
+                : `
+  const require = (await import("node:module")).createRequire(import.meta.url);
+  const __filename = (await import("node:url")).fileURLToPath(import.meta.url);
+  const __dirname = (await import("node:path")).dirname(__filename);
+
+  const defaultDefineProperty = Object.defineProperty;
+  Object.defineProperty = function(o, p, a) {
+    if(p=== '__import_unsupported' && Boolean(globalThis.__import_unsupported)) {
+      return;
+    }
+    return defaultDefineProperty(o, p, a);
+  };
+  `}
+  ${additionalInject ?? ""}
+  `,
+        },
+    }, options);
+    if (!onlyBuildOnce) {
+        await build({
+            entryPoints: [outfile],
+            outfile,
+            allowOverwrite: true,
+            bundle: true,
+            minify: true,
+            platform: "node",
+            format: "esm",
+            conditions: ["workerd", "worker", "browser"],
+            external: ["node:*", ...(additionalExternals ?? [])],
+            banner: {
+                js: 'import * as process from "node:process";',
+            },
+        });
+    }
+}
+export function copyMiddlewareAssetsAndWasm({}) { }
+export async function generateEdgeBundle(name, config, options, fnOptions) {
+    const { appBuildOutputPath, outputDir } = options;
+    logger.info(`Generating edge bundle for: ${name}`);
+    // Create output folder
+    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);
+    // Load middleware manifest
+    const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
+    // Find functions
+    const functions = Object.values(middlewareManifest.functions).filter((fn) => fnOptions.routes.includes(fn.name));
+    if (functions.length > 1) {
+        throw new Error("Only one function is supported for now");
+    }
+    const fn = functions[0];
+    //Copy wasm files
+    const wasmFiles = fn.wasm;
+    mkdirSync(path.join(outputPath, "wasm"), { recursive: true });
+    for (const wasmFile of wasmFiles) {
+        fs.copyFileSync(path.join(appBuildOutputPath, ".next", wasmFile.filePath), path.join(outputPath, `wasm/${wasmFile.name}.wasm`));
+    }
+    // Copy assets
+    const assets = fn.assets;
+    mkdirSync(path.join(outputPath, "assets"), { recursive: true });
+    for (const asset of assets) {
+        fs.copyFileSync(path.join(appBuildOutputPath, ".next", asset.filePath), path.join(outputPath, `assets/${asset.name}`));
+    }
+    await buildEdgeBundle({
+        appBuildOutputPath,
+        middlewareInfo: fn,
+        entrypoint: path.join(__dirname, "../../adapters", "edge-adapter.js"),
+        outfile: path.join(outputPath, "index.mjs"),
+        options,
+        overrides: fnOptions.override,
+        additionalExternals: config.edgeExternals,
+    });
+}

package/dist/build/generateOutput.d.ts

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

package/dist/build/generateOutput.js

@@ -0,0 +1,239 @@
+import * as fs from "node:fs";
+import path from "node:path";
+import { getBuildId } from "./helper.js";
+async function canStream(opts) {
+    if (!opts.override?.wrapper) {
+        return false;
+    }
+    else {
+        if (typeof opts.override.wrapper === "string") {
+            return opts.override.wrapper === "aws-lambda-streaming";
+        }
+        else {
+            const wrapper = await opts.override.wrapper();
+            return wrapper.supportStreaming;
+        }
+    }
+}
+async function extractOverrideName(defaultName, override) {
+    if (!override) {
+        return defaultName;
+    }
+    if (typeof override === "string") {
+        return override;
+    }
+    else {
+        const overrideModule = await override();
+        return overrideModule.name;
+    }
+}
+async function extractOverrideFn(override) {
+    if (!override) {
+        return {
+            wrapper: "aws-lambda",
+            converter: "aws-apigw-v2",
+        };
+    }
+    const wrapper = await extractOverrideName("aws-lambda", override.wrapper);
+    const converter = await extractOverrideName("aws-apigw-v2", override.converter);
+    return { wrapper, converter };
+}
+async function extractCommonOverride(override) {
+    if (!override) {
+        return {
+            queue: "sqs",
+            incrementalCache: "s3",
+            tagCache: "dynamodb",
+        };
+    }
+    const queue = await extractOverrideName("sqs", override.queue);
+    const incrementalCache = await extractOverrideName("s3", override.incrementalCache);
+    const tagCache = await extractOverrideName("dynamodb", override.tagCache);
+    return { queue, incrementalCache, tagCache };
+}
+function prefixPattern(basePath) {
+    // Prefix CloudFront distribution behavior path patterns with `basePath` if configured
+    return (pattern) => {
+        return basePath && basePath.length > 0
+            ? `${basePath.slice(1)}/${pattern}`
+            : pattern;
+    };
+}
+export async function generateOutput(outputPath, config) {
+    const edgeFunctions = {};
+    const isExternalMiddleware = config.middleware?.external ?? false;
+    if (isExternalMiddleware) {
+        edgeFunctions.middleware = {
+            bundle: ".open-next/middleware",
+            handler: "handler.handler",
+            pathResolver: await extractOverrideName("pattern-env", config.middleware.originResolver),
+            ...(await extractOverrideFn(config.middleware?.override)),
+        };
+    }
+    // Add edge functions
+    Object.entries(config.functions ?? {}).forEach(async ([key, value]) => {
+        if (value.placement === "global") {
+            edgeFunctions[key] = {
+                bundle: `.open-next/functions/${key}`,
+                handler: "index.handler",
+                ...(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 prefixer = prefixPattern(requiredServerFiles.basePath ?? "");
+    // First add s3 origins and image optimization
+    const defaultOrigins = {
+        s3: {
+            type: "s3",
+            originPath: "_assets",
+            copy: [
+                {
+                    from: ".open-next/assets",
+                    to: requiredServerFiles.basePath
+                        ? `_assets${requiredServerFiles.basePath}`
+                        : "_assets",
+                    cached: true,
+                    versionedSubDir: prefixer("_next"),
+                },
+                ...(config.dangerous?.disableIncrementalCache
+                    ? []
+                    : [
+                        {
+                            from: ".open-next/cache",
+                            to: "_cache",
+                            cached: false,
+                        },
+                    ]),
+            ],
+        },
+        imageOptimizer: {
+            type: "function",
+            handler: "index.handler",
+            bundle: ".open-next/image-optimization-function",
+            streaming: false,
+            imageLoader: await extractOverrideName("s3", config.imageOptimization?.loader),
+            ...(await extractOverrideFn(config.imageOptimization?.override)),
+        },
+        default: config.default.override?.generateDockerfile
+            ? {
+                type: "ecs",
+                bundle: ".open-next/server-functions/default",
+                dockerfile: ".open-next/server-functions/default/Dockerfile",
+                ...(await extractOverrideFn(config.default.override)),
+                ...(await extractCommonOverride(config.default.override)),
+            }
+            : {
+                type: "function",
+                handler: "index.handler",
+                bundle: ".open-next/server-functions/default",
+                streaming: defaultOriginCanstream,
+                ...(await extractOverrideFn(config.default.override)),
+                ...(await extractCommonOverride(config.default.override)),
+            },
+    };
+    //@ts-expect-error - Not sure how to fix typing here, it complains about the type of imageOptimizer and s3
+    const origins = defaultOrigins;
+    // Then add function origins
+    await Promise.all(Object.entries(config.functions ?? {}).map(async ([key, value]) => {
+        if (!value.placement || value.placement === "regional") {
+            if (value.override?.generateDockerfile) {
+                origins[key] = {
+                    type: "ecs",
+                    bundle: `.open-next/server-functions/${key}`,
+                    dockerfile: `.open-next/server-functions/${key}/Dockerfile`,
+                    ...(await extractOverrideFn(value.override)),
+                    ...(await extractCommonOverride(value.override)),
+                };
+            }
+            else {
+                const streaming = await canStream(value);
+                origins[key] = {
+                    type: "function",
+                    handler: "index.handler",
+                    bundle: `.open-next/server-functions/${key}`,
+                    streaming,
+                    ...(await extractOverrideFn(value.override)),
+                    ...(await extractCommonOverride(value.override)),
+                };
+            }
+        }
+    }));
+    // Then we need to compute the behaviors
+    const behaviors = [
+        { pattern: prefixer("_next/image*"), origin: "imageOptimizer" },
+    ];
+    // Then we add the routes
+    Object.entries(config.functions ?? {}).forEach(([key, value]) => {
+        const patterns = "patterns" in value ? value.patterns : ["*"];
+        patterns.forEach((pattern) => {
+            behaviors.push({
+                pattern: prefixer(pattern.replace(/BUILD_ID/, getBuildId(outputPath))),
+                origin: value.placement === "global" ? undefined : key,
+                edgeFunction: value.placement === "global"
+                    ? key
+                    : isExternalMiddleware
+                        ? "middleware"
+                        : undefined,
+            });
+        });
+    });
+    // We finish with the default behavior so that they don't override the others
+    behaviors.push({
+        pattern: prefixer("_next/data/*"),
+        origin: "default",
+        edgeFunction: isExternalMiddleware ? "middleware" : undefined,
+    });
+    behaviors.push({
+        pattern: "*",
+        origin: "default",
+        edgeFunction: isExternalMiddleware ? "middleware" : undefined,
+    });
+    //Compute behaviors for assets files
+    const assetPath = path.join(outputPath, ".open-next", "assets");
+    fs.readdirSync(assetPath).forEach((item) => {
+        if (fs.statSync(path.join(assetPath, item)).isDirectory()) {
+            behaviors.push({
+                pattern: prefixer(`${item}/*`),
+                origin: "s3",
+            });
+        }
+        else {
+            behaviors.push({
+                pattern: prefixer(item),
+                origin: "s3",
+            });
+        }
+    });
+    // Check if we produced a dynamodb provider output
+    const isTagCacheDisabled = config.dangerous?.disableTagCache ||
+        !fs.existsSync(path.join(outputPath, ".open-next", "dynamodb-provider"));
+    const output = {
+        edgeFunctions,
+        origins,
+        behaviors,
+        additionalProps: {
+            disableIncrementalCache: config.dangerous?.disableIncrementalCache,
+            disableTagCache: config.dangerous?.disableTagCache,
+            warmer: {
+                handler: "index.handler",
+                bundle: ".open-next/warmer-function",
+            },
+            initializationFunction: isTagCacheDisabled
+                ? undefined
+                : {
+                    handler: "index.handler",
+                    bundle: ".open-next/dynamodb-provider",
+                },
+            revalidationFunction: config.dangerous?.disableIncrementalCache
+                ? undefined
+                : {
+                    handler: "index.handler",
+                    bundle: ".open-next/revalidation-function",
+                },
+        },
+    };
+    fs.writeFileSync(path.join(outputPath, ".open-next", "open-next.output.json"), JSON.stringify(output));
+}

package/dist/build/helper.d.ts

@@ -0,0 +1,33 @@
+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;
+    appPackageJsonPath: string;
+    appPath: string;
+    appBuildOutputPath: string;
+    appPublicPath: string;
+    outputDir: string;
+    tempDir: string;
+    debug: boolean;
+    monorepoRoot: string;
+};
+export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
+export declare function esbuildAsync(esbuildOptions: ESBuildOptions, options: BuildOptions): Promise<void>;
+export declare function removeFiles(root: string, conditionFn: (file: string) => boolean, searchingDir?: string): void;
+/**
+ * Recursively traverse files in a directory and call `callbackFn` when `conditionFn` returns true
+ * @param root - Root directory to search
+ * @param conditionFn - Called to determine if `callbackFn` should be called
+ * @param callbackFn - Called when `conditionFn` returns true
+ * @param searchingDir - Directory to search (used for recursion)
+ */
+export declare function traverseFiles(root: string, conditionFn: (file: string) => boolean, callbackFn: (filePath: string) => void, searchingDir?: string): void;
+export declare function getHtmlPages(dotNextPath: string): Set<string>;
+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 copyEnvFile(appPath: string, packagePath: string, outputPath: string): void;