@opennextjs/aws 3.1.4

package/dist/build/helper.js

@@ -0,0 +1,193 @@
+import fs from "node:fs";
+import { createRequire as topLevelCreateRequire } from "node:module";
+import path from "node:path";
+import url from "node:url";
+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) {
+    const appPath = path.join(process.cwd(), config.appPath || ".");
+    const buildOutputPath = path.join(process.cwd(), config.buildOutputPath || ".");
+    const outputDir = path.join(buildOutputPath, ".open-next");
+    let appPackageJsonPath;
+    if (config.packageJsonPath) {
+        const _pkgPath = path.join(process.cwd(), config.packageJsonPath);
+        appPackageJsonPath = _pkgPath.endsWith("package.json")
+            ? _pkgPath
+            : path.join(_pkgPath, "./package.json");
+    }
+    else {
+        appPackageJsonPath = findNextPackageJsonPath(appPath, root);
+    }
+    return {
+        openNextVersion: getOpenNextVersion(),
+        nextVersion: getNextVersion(appPath),
+        appPackageJsonPath,
+        appPath,
+        appBuildOutputPath: buildOutputPath,
+        appPublicPath: path.join(appPath, "public"),
+        outputDir,
+        tempDir: path.join(outputDir, ".build"),
+        debug: Boolean(process.env.OPEN_NEXT_DEBUG) ?? false,
+        monorepoRoot: root,
+    };
+}
+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"))
+        ? path.join(appPath, "./package.json")
+        : path.join(root, "./package.json");
+}
+export function esbuildSync(esbuildOptions, options) {
+    const { openNextVersion, debug } = options;
+    const result = buildSync({
+        target: "esnext",
+        format: "esm",
+        platform: "node",
+        bundle: true,
+        minify: debug ? false : true,
+        mainFields: ["module", "main"],
+        sourcemap: debug ? "inline" : false,
+        sourcesContent: false,
+        ...esbuildOptions,
+        external: ["./open-next.config.mjs", ...(esbuildOptions.external ?? [])],
+        banner: {
+            ...esbuildOptions.banner,
+            js: [
+                esbuildOptions.banner?.js || "",
+                `globalThis.openNextDebug = ${debug};`,
+                `globalThis.openNextVersion = "${openNextVersion}";`,
+            ].join(""),
+        },
+    });
+    if (result.errors.length > 0) {
+        result.errors.forEach((error) => logger.error(error));
+        throw new Error(`There was a problem bundling ${esbuildOptions.entryPoints[0]}.`);
+    }
+}
+export async function esbuildAsync(esbuildOptions, options) {
+    const { openNextVersion, debug } = options;
+    const result = await buildAsync({
+        target: "esnext",
+        format: "esm",
+        platform: "node",
+        bundle: true,
+        minify: debug ? false : true,
+        mainFields: ["module", "main"],
+        sourcemap: debug ? "inline" : false,
+        sourcesContent: false,
+        ...esbuildOptions,
+        external: [
+            ...(esbuildOptions.external ?? []),
+            "next",
+            "./open-next.config.mjs",
+        ],
+        banner: {
+            ...esbuildOptions.banner,
+            js: [
+                esbuildOptions.banner?.js || "",
+                `globalThis.openNextDebug = ${debug};`,
+                `globalThis.openNextVersion = "${openNextVersion}";`,
+            ].join(""),
+        },
+    });
+    if (result.errors.length > 0) {
+        result.errors.forEach((error) => logger.error(error));
+        throw new Error(`There was a problem bundling ${esbuildOptions.entryPoints[0]}.`);
+    }
+}
+export function removeFiles(root, conditionFn, searchingDir = "") {
+    traverseFiles(root, conditionFn, (filePath) => fs.rmSync(filePath, { force: true }), searchingDir);
+}
+/**
+ * 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 function traverseFiles(root, conditionFn, callbackFn, searchingDir = "") {
+    fs.readdirSync(path.join(root, searchingDir)).forEach((file) => {
+        const filePath = path.join(root, searchingDir, file);
+        if (fs.statSync(filePath).isDirectory()) {
+            traverseFiles(root, conditionFn, callbackFn, path.join(searchingDir, file));
+            return;
+        }
+        if (conditionFn(path.join(searchingDir, file))) {
+            callbackFn(filePath);
+        }
+    });
+}
+export function getHtmlPages(dotNextPath) {
+    // Get a list of HTML pages
+    //
+    // sample return value:
+    // Set([
+    //   '404.html',
+    //   'csr.html',
+    //   'image-html-tag.html',
+    // ])
+    const manifestPath = path.join(dotNextPath, ".next/server/pages-manifest.json");
+    const manifest = fs.readFileSync(manifestPath, "utf-8");
+    return Object.entries(JSON.parse(manifest))
+        .filter(([_, value]) => value.endsWith(".html"))
+        .map(([_, value]) => value.replace(/^pages\//, ""))
+        .reduce((acc, page) => {
+        acc.add(page);
+        return acc;
+    }, new Set());
+}
+export function getBuildId(dotNextPath) {
+    return fs
+        .readFileSync(path.join(dotNextPath, ".next/BUILD_ID"), "utf-8")
+        .trim();
+}
+export function getOpenNextVersion() {
+    return require(path.join(__dirname, "../../package.json")).version;
+}
+export function getNextVersion(appPath) {
+    // We cannot just require("next/package.json") because it could be executed in a different directory
+    const nextPackageJsonPath = require.resolve("next/package.json", {
+        paths: [appPath],
+    });
+    const version = require(nextPackageJsonPath)?.version;
+    if (!version) {
+        throw new Error("Failed to find Next version");
+    }
+    // Drop the -canary.n suffix
+    return version.split("-")[0];
+}
+export function compareSemver(v1, v2) {
+    if (v1 === "latest")
+        return 1;
+    if (/^[^\d]/.test(v1)) {
+        v1 = v1.substring(1);
+    }
+    if (/^[^\d]/.test(v2)) {
+        v2 = v2.substring(1);
+    }
+    const [major1, minor1, patch1] = v1.split(".").map(Number);
+    const [major2, minor2, patch2] = v2.split(".").map(Number);
+    if (major1 !== major2)
+        return major1 - major2;
+    if (minor1 !== minor2)
+        return minor1 - minor2;
+    return patch1 - patch2;
+}
+export function copyOpenNextConfig(tempDir, outputPath, isEdge = false) {
+    // Copy open-next.config.mjs
+    fs.copyFileSync(path.join(tempDir, isEdge ? "open-next.config.edge.mjs" : "open-next.config.mjs"), path.join(outputPath, "open-next.config.mjs"));
+}
+export function copyEnvFile(appPath, packagePath, outputPath) {
+    const baseAppPath = path.join(appPath, ".next/standalone", packagePath);
+    const baseOutputPath = path.join(outputPath, packagePath);
+    const envPath = path.join(baseAppPath, ".env");
+    if (fs.existsSync(envPath)) {
+        fs.copyFileSync(envPath, path.join(baseOutputPath, ".env"));
+    }
+    const envProdPath = path.join(baseAppPath, ".env.production");
+    if (fs.existsSync(envProdPath)) {
+        fs.copyFileSync(envProdPath, path.join(baseOutputPath, ".env.production"));
+    }
+}

package/dist/build/patch/patchedAsyncStorage.d.ts

@@ -0,0 +1,5 @@
+declare const asyncStorage: any;
+declare const staticGenerationAsyncStorage: {
+    run: (store: any, cb: any, ...args: any[]) => any;
+    getStore: () => any;
+};

package/dist/build/patch/patchedAsyncStorage.js

@@ -0,0 +1,16 @@
+"use strict";
+//@ts-nocheck
+const asyncStorage = require("next/dist/client/components/static-generation-async-storage.external.original");
+const staticGenerationAsyncStorage = {
+    run: (store, cb, ...args) => asyncStorage.staticGenerationAsyncStorage.run(store, cb, ...args),
+    getStore: () => {
+        const store = asyncStorage.staticGenerationAsyncStorage.getStore();
+        if (store) {
+            store.isOnDemandRevalidate =
+                store.isOnDemandRevalidate &&
+                    !globalThis.__als.getStore().isISRRevalidation;
+        }
+        return store;
+    },
+};
+exports.staticGenerationAsyncStorage = staticGenerationAsyncStorage;

package/dist/build/validateConfig.d.ts

@@ -0,0 +1,2 @@
+import { OpenNextConfig } from "../types/open-next";
+export declare function validateConfig(config: OpenNextConfig): void;

package/dist/build/validateConfig.js

@@ -0,0 +1,76 @@
+import logger from "../logger.js";
+const compatibilityMatrix = {
+    "aws-lambda": [
+        "aws-apigw-v1",
+        "aws-apigw-v2",
+        "aws-cloudfront",
+        "sqs-revalidate",
+    ],
+    "aws-lambda-streaming": ["aws-apigw-v2"],
+    cloudflare: ["edge"],
+    node: ["node"],
+};
+function validateFunctionOptions(fnOptions) {
+    if (fnOptions.runtime === "edge" && fnOptions.experimentalBundledNextServer) {
+        logger.warn("experimentalBundledNextServer has no effect for edge functions");
+    }
+    const wrapper = typeof fnOptions.override?.wrapper === "string"
+        ? fnOptions.override.wrapper
+        : "aws-lambda";
+    const converter = typeof fnOptions.override?.converter === "string"
+        ? fnOptions.override.converter
+        : "aws-apigw-v2";
+    if (fnOptions.override?.generateDockerfile &&
+        converter !== "node" &&
+        wrapper !== "node") {
+        logger.warn("You've specified generateDockerfile without node converter and wrapper. Without custom converter and wrapper the dockerfile will not work");
+    }
+    if (converter === "aws-cloudfront" && fnOptions.placement !== "global") {
+        logger.warn("You've specified aws-cloudfront converter without global placement. This may not generate the correct output");
+    }
+    const isCustomWrapper = typeof fnOptions.override?.wrapper === "function";
+    const isCustomConverter = typeof fnOptions.override?.converter === "function";
+    // Check if the wrapper and converter are compatible
+    // Only check if using one of the included converters or wrapper
+    if (!compatibilityMatrix[wrapper].includes(converter) &&
+        !isCustomWrapper &&
+        !isCustomConverter) {
+        logger.error(`Wrapper ${wrapper} and converter ${converter} are not compatible. For the wrapper ${wrapper} you should only use the following converters: ${compatibilityMatrix[wrapper].join(", ")}`);
+    }
+}
+function validateSplittedFunctionOptions(fnOptions, name) {
+    validateFunctionOptions(fnOptions);
+    if (fnOptions.routes.length === 0) {
+        throw new Error(`Splitted function ${name} must have at least one route`);
+    }
+    // Check if the routes are properly formated
+    fnOptions.routes.forEach((route) => {
+        if (!route.startsWith("app/") && !route.startsWith("pages/")) {
+            throw new Error(`Route ${route} in function ${name} is not a valid route. It should starts with app/ or pages/ depending on if you use page or app router`);
+        }
+    });
+    if (fnOptions.runtime === "edge" && fnOptions.routes.length > 1) {
+        throw new Error(`Edge function ${name} can only have one route`);
+    }
+}
+export function validateConfig(config) {
+    validateFunctionOptions(config.default);
+    Object.entries(config.functions ?? {}).forEach(([name, fnOptions]) => {
+        validateSplittedFunctionOptions(fnOptions, name);
+    });
+    if (config.dangerous?.disableIncrementalCache) {
+        logger.warn("You've disabled incremental cache. This means that ISR and SSG will not work.");
+    }
+    if (config.dangerous?.disableTagCache) {
+        logger.warn(`You've disabled tag cache. 
+       This means that revalidatePath and revalidateTag from next/cache will not work.
+       It is safe to disable if you only use page router`);
+    }
+    validateFunctionOptions(config.imageOptimization ?? {});
+    validateFunctionOptions(config.middleware ?? {});
+    //@ts-expect-error - Revalidate custom wrapper type is different
+    validateFunctionOptions(config.revalidate ?? {});
+    //@ts-expect-error - Warmer custom wrapper type is different
+    validateFunctionOptions(config.warmer ?? {});
+    validateFunctionOptions(config.initializationFunction ?? {});
+}

package/dist/build.d.ts

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