@opennextjs/aws 3.3.1 → 3.4.1

package/dist/adapters/cache.js

@@ -16,7 +16,7 @@ export default class Cache {
     async get(key, 
     // fetchCache is for next 13.5 and above, kindHint is for next 14 and above and boolean is for earlier versions
     options) {
-        if (globalThis.disableIncrementalCache) {
+        if (globalThis.openNextConfig.dangerous?.disableIncrementalCache) {
             return null;
         }
         const softTags = typeof options === "object" ? options.softTags : [];
@@ -130,7 +130,7 @@ export default class Cache {
         }
     }
     async set(key, data, ctx) {
-        if (globalThis.disableIncrementalCache) {
+        if (globalThis.openNextConfig.dangerous?.disableIncrementalCache) {
             return;
         }
         // This one might not even be necessary anymore
@@ -242,7 +242,8 @@ export default class Cache {
         }
     }
     async revalidateTag(tags) {
-        if (globalThis.disableDynamoDBCache || globalThis.disableIncrementalCache) {
+        const config = globalThis.openNextConfig.dangerous;
+        if (config?.disableTagCache || config?.disableIncrementalCache) {
             return;
         }
         try {
@@ -275,6 +276,25 @@ export default class Cache {
                 }
                 // Update all keys with the given tag with revalidatedAt set to now
                 await globalThis.tagCache.writeTags(toInsert);
+                // We can now invalidate all paths in the CDN
+                // This only applies to `revalidateTag`, not to `res.revalidate()`
+                const uniquePaths = Array.from(new Set(toInsert
+                    // We need to filter fetch cache key as they are not in the CDN
+                    .filter((t) => t.tag.startsWith("_N_T_/"))
+                    .map((t) => `/${t.path}`)));
+                if (uniquePaths.length > 0) {
+                    await globalThis.cdnInvalidationHandler.invalidatePaths(uniquePaths.map((path) => ({
+                        initialPath: path,
+                        rawPath: path,
+                        resolvedRoutes: [
+                            {
+                                route: path,
+                                // TODO: ideally here we should check if it's an app router page or route
+                                type: "app",
+                            },
+                        ],
+                    })));
+                }
             }
         }
         catch (e) {

package/dist/adapters/logger.js

@@ -21,9 +21,9 @@ const isDownplayedErrorLog = (errorLog) => DOWNPLAYED_ERROR_LOGS.some((downplaye
 export function error(...args) {
     // we try to catch errors from the aws-sdk client and downplay some of them
     if (args.some((arg) => isDownplayedErrorLog(arg))) {
-        debug(...args);
+        return debug(...args);
     }
-    else if (args.some((arg) => isOpenNextError(arg))) {
+    if (args.some((arg) => isOpenNextError(arg))) {
         // In case of an internal error, we log it with the appropriate log level
         const error = args.find((arg) => isOpenNextError(arg));
         if (error.logLevel < getOpenNextErrorLogLevel()) {

package/dist/build/createAssets.js

@@ -44,7 +44,7 @@ export function createStaticAssets(options) {
 export function createCacheAssets(options) {
     logger.info("Bundling cache assets...");
     const { appBuildOutputPath, outputDir } = options;
-    const packagePath = path.relative(options.monorepoRoot, appBuildOutputPath);
+    const packagePath = buildHelper.getPackagePath(options);
     const buildId = buildHelper.getBuildId(appBuildOutputPath);
     let useTagCache = false;
     // Copy pages to cache folder

package/dist/build/createImageOptimizationBundle.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import logger from "../logger.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
 import { openNextResolvePlugin } from "../plugins/resolve.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 const require = createRequire(import.meta.url);
@@ -28,7 +29,7 @@ export async function createImageOptimizationBundle(options) {
     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,
+            target: getCrossPlatformPathRegex("plugins/image-optimization/image-optimization.js"),
             replacements: [
                 require.resolve("../adapters/plugins/image-optimization/image-optimization.replacement.js"),
             ],

package/dist/build/createServerBundle.js

@@ -4,6 +4,7 @@ import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
 import { openNextResolvePlugin } from "../plugins/resolve.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 import { bundleNextServer } from "./bundleNextServer.js";
 import { compileCache } from "./compileCache.js";
 import { copyTracedFiles } from "./copyTracedFiles.js";
@@ -35,10 +36,9 @@ export async function createServerBundle(options) {
     // 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 { appBuildOutputPath, monorepoRoot } = options;
-    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    const { appBuildOutputPath } = options;
     // Find remaining routes
-    const serverPath = path.join(appBuildOutputPath, ".next", "standalone", packagePath, ".next", "server");
+    const serverPath = path.join(appBuildOutputPath, ".next/standalone", buildHelper.getPackagePath(options), ".next/server");
     // Find app dir routes
     if (fs.existsSync(path.join(serverPath, "app"))) {
         const appPath = path.join(serverPath, "app");
@@ -77,7 +77,7 @@ async function generateBundle(name, options, fnOptions) {
     //       `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 packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    const packagePath = buildHelper.getPackagePath(options);
     fs.mkdirSync(path.join(outputPath, packagePath), { recursive: true });
     const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
     fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outputPath, packagePath, "cache.cjs"));
@@ -109,12 +109,12 @@ async function generateBundle(name, options, fnOptions) {
         buildHelper.compareSemver(options.nextVersion, "13.4.1") <= 0;
     const overrides = fnOptions.override ?? {};
     const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "13.4.13") <= 0;
-    const isAfter141 = buildHelper.compareSemver(options.nextVersion, "14.0.4") >= 0;
+    const isAfter141 = buildHelper.compareSemver(options.nextVersion, "14.1") >= 0;
     const disableRouting = isBefore13413 || config.middleware?.external;
     const plugins = [
         openNextReplacementPlugin({
             name: `requestHandlerOverride ${name}`,
-            target: /core(\/|\\)requestHandler\.js/g,
+            target: getCrossPlatformPathRegex("core/requestHandler.js"),
             deletes: [
                 ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
                 ...(disableRouting ? ["withRouting"] : []),
@@ -122,11 +122,10 @@ async function generateBundle(name, options, fnOptions) {
         }),
         openNextReplacementPlugin({
             name: `utilOverride ${name}`,
-            target: /core(\/|\\)util\.js/g,
+            target: getCrossPlatformPathRegex("core/util.js"),
             deletes: [
                 ...(disableNextPrebundledReact ? ["requireHooks"] : []),
-                ...(disableRouting ? ["trustHostHeader"] : []),
-                ...(!isBefore13413 ? ["requestHandlerHost"] : []),
+                ...(isBefore13413 ? ["trustHostHeader"] : ["requestHandlerHost"]),
                 ...(isAfter141
                     ? ["experimentalIncrementalCacheHandler"]
                     : ["stableIncrementalCache"]),

package/dist/build/edge/createEdgeBundle.js

@@ -6,6 +6,7 @@ import logger from "../../logger.js";
 import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
+import { getCrossPlatformPathRegex } from "../../utils/regex.js";
 import { isEdgeRuntime } from "../helper.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
 export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }) {
@@ -41,7 +42,7 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
             }),
             openNextReplacementPlugin({
                 name: "externalMiddlewareOverrides",
-                target: /adapters(\/|\\)middleware\.js/g,
+                target: getCrossPlatformPathRegex("adapters/middleware.js"),
                 deletes: includeCache ? [] : ["includeCacheInMiddleware"],
             }),
             openNextEdgePlugins({

package/dist/build/helper.d.ts

@@ -15,7 +15,7 @@ export declare function normalizeOptions(config: OpenNextConfig, distDir: string
     openNextVersion: string;
     openNextDistDir: string;
     outputDir: string;
-    packager: "npm" | "yarn" | "pnpm" | "bun";
+    packager: "bun" | "npm" | "yarn" | "pnpm";
     tempBuildDir: string;
 };
 export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
@@ -51,6 +51,14 @@ 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;
+/**
+ * Compare two semver versions.
+ *
+ * @param v1 - First version. Can be "latest", otherwise it should be a valid semver version in the format of `major.minor.patch`. Usually is the next version from the package.json without canary suffix. If minor or patch are missing, they are considered 0.
+ * @param v2 - Second version. Should not be "latest", it should be a valid semver version in the format of `major.minor.patch`. If minor or patch are missing, they are considered 0.
+ * @example
+ * compareSemver("1.0.0", "1.0.0") // 0
+ */
 export declare function compareSemver(v1: string, v2: string): number;
 export declare function copyOpenNextConfig(inputDir: string, outputDir: string, isEdge?: boolean): void;
 export declare function copyEnvFile(appPath: string, packagePath: string, outputPath: string): void;
@@ -73,3 +81,4 @@ export declare function initOutputDir(options: BuildOptions): void;
  * @returns Whether the edge runtime is used
  */
 export declare function isEdgeRuntime(overrides: DefaultOverrideOptions | undefined): Promise<boolean | undefined>;
+export declare function getPackagePath(options: BuildOptions): string;

package/dist/build/helper.js

@@ -45,10 +45,12 @@ function findMonorepoRoot(appPath) {
     let currentPath = appPath;
     while (currentPath !== "/") {
         const found = [
+            // bun can generate yaml lock files (`bun install --yarn`) so bun should be before yarn
+            { file: "bun.lockb", packager: "bun" },
+            { file: "bun.lock", packager: "bun" },
             { file: "package-lock.json", packager: "npm" },
             { file: "yarn.lock", packager: "yarn" },
             { file: "pnpm-lock.yaml", packager: "pnpm" },
-            { file: "bun.lockb", packager: "bun" },
         ].find((f) => fs.existsSync(path.join(currentPath, f.file)));
         if (found) {
             if (currentPath !== appPath) {
@@ -198,6 +200,14 @@ export function getNextVersion(appPath) {
     // Drop the -canary.n suffix
     return version.split("-")[0];
 }
+/**
+ * Compare two semver versions.
+ *
+ * @param v1 - First version. Can be "latest", otherwise it should be a valid semver version in the format of `major.minor.patch`. Usually is the next version from the package.json without canary suffix. If minor or patch are missing, they are considered 0.
+ * @param v2 - Second version. Should not be "latest", it should be a valid semver version in the format of `major.minor.patch`. If minor or patch are missing, they are considered 0.
+ * @example
+ * compareSemver("1.0.0", "1.0.0") // 0
+ */
 export function compareSemver(v1, v2) {
     if (v1 === "latest")
         return 1;
@@ -209,8 +219,11 @@ export function compareSemver(v1, v2) {
         // biome-ignore lint/style/noParameterAssign:
         v2 = v2.substring(1);
     }
-    const [major1, minor1, patch1] = v1.split(".").map(Number);
-    const [major2, minor2, patch2] = v2.split(".").map(Number);
+    const [major1, minor1 = 0, patch1 = 0] = v1.split(".").map(Number);
+    const [major2, minor2 = 0, patch2 = 0] = v2.split(".").map(Number);
+    if (Number.isNaN(major1) || Number.isNaN(major2)) {
+        throw new Error("The major version is required.");
+    }
     if (major1 !== major2)
         return major1 - major2;
     if (minor1 !== minor2)
@@ -276,3 +289,6 @@ export async function isEdgeRuntime(overrides) {
     }
     return (await overrides?.wrapper?.())?.edgeRuntime;
 }
+export function getPackagePath(options) {
+    return path.relative(options.monorepoRoot, options.appBuildOutputPath);
+}

package/dist/build/validateConfig.js

@@ -11,7 +11,8 @@ const compatibilityMatrix = {
     "cloudflare-edge": ["edge"],
     "cloudflare-node": ["edge"],
     node: ["node"],
-    dummy: [],
+    "express-dev": ["node"],
+    dummy: ["dummy"],
 };
 function validateFunctionOptions(fnOptions) {
     if (fnOptions.runtime === "edge" && fnOptions.experimentalBundledNextServer) {

package/dist/core/createMainHandler.js

@@ -1,7 +1,7 @@
 import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";
 import { openNextHandler } from "./requestHandler";
-import { resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
+import { resolveCdnInvalidation, resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
 export async function createMainHandler() {
     // @ts-expect-error `./open-next.config.mjs` exists only in the build output
     const config = await import("./open-next.config.mjs").then((m) => m.default);
@@ -15,6 +15,7 @@ export async function createMainHandler() {
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
     globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
     globalThis.proxyExternalRequest = await resolveProxyRequest(thisFunction.override?.proxyExternalRequest);
+    globalThis.cdnInvalidationHandler = await resolveCdnInvalidation(thisFunction.override?.cdnInvalidation);
     globalThis.lastModified = {};
     // From the config, we create the converter
     const converter = await resolveConverter(thisFunction.override?.converter);

package/dist/core/edgeFunctionHandler.js

@@ -6,7 +6,8 @@ export default async function edgeFunctionHandler(request) {
     if (!correspondingRoute) {
         throw new Error(`No route found for ${request.url}`);
     }
-    const result = await self._ENTRIES[`middleware_${correspondingRoute.name}`].default({
+    const entry = await self._ENTRIES[`middleware_${correspondingRoute.name}`];
+    const result = await entry.default({
         page: correspondingRoute.page,
         request: {
             ...request,

package/dist/core/requestHandler.js

@@ -82,7 +82,14 @@ export async function openNextHandler(internalEvent, responseStreaming) {
         if ("type" in routingResult) {
             // response is used only in the streaming case
             if (responseStreaming) {
-                const response = createServerResponse(internalEvent, headers, responseStreaming);
+                const response = createServerResponse({
+                    internalEvent,
+                    isExternalRewrite: false,
+                    isISR: false,
+                    resolvedRoutes: [],
+                    origin: false,
+                    initialPath: internalEvent.rawPath,
+                }, headers, responseStreaming);
                 response.statusCode = routingResult.statusCode;
                 response.flushHeaders();
                 const [bodyToConsume, bodyToReturn] = routingResult.body.tee();
@@ -117,7 +124,7 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             store.mergeHeadersPriority = mergeHeadersPriority;
         }
         const req = new IncomingMessage(reqProps);
-        const res = createServerResponse(preprocessedEvent, overwrittenResponseHeaders, responseStreaming);
+        const res = createServerResponse(routingResult, overwrittenResponseHeaders, responseStreaming);
         await processRequest(req, res, preprocessedEvent);
         const { statusCode, headers: responseHeaders, isBase64Encoded, body, } = convertRes(res);
         const internalResult = {

package/dist/core/resolve.d.ts

@@ -43,4 +43,8 @@ export declare function resolveWarmerInvoke(warmer: RemoveUndefined<OpenNextConf
  * @__PURE__
  */
 export declare function resolveProxyRequest(proxyRequest: OverrideOptions["proxyExternalRequest"]): Promise<import("../types/overrides").ProxyExternalRequest>;
+/**
+ * @__PURE__
+ */
+export declare function resolveCdnInvalidation(cdnInvalidation: OverrideOptions["cdnInvalidation"]): Promise<import("../types/overrides").CDNInvalidationHandler>;
 export {};

package/dist/core/resolve.js

@@ -98,3 +98,13 @@ export async function resolveProxyRequest(proxyRequest) {
     const m_1 = await import("../overrides/proxyExternalRequest/node.js");
     return m_1.default;
 }
+/**
+ * @__PURE__
+ */
+export async function resolveCdnInvalidation(cdnInvalidation) {
+    if (typeof cdnInvalidation === "function") {
+        return cdnInvalidation();
+    }
+    const m_1 = await import("../overrides/cdnInvalidation/dummy.js");
+    return m_1.default;
+}

package/dist/core/routing/middleware.js

@@ -44,7 +44,9 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     const result = await middleware.default({
         // `geo` is pre Next 15.
         geo: {
-            city: headers["x-open-next-city"],
+            // The city name is percent-encoded.
+            // See https://github.com/vercel/vercel/blob/4cb6143/packages/functions/src/headers.ts#L94C19-L94C37
+            city: decodeURIComponent(headers["x-open-next-city"]),
             country: headers["x-open-next-country"],
             region: headers["x-open-next-region"],
             latitude: headers["x-open-next-latitude"],

package/dist/core/routing/util.d.ts

@@ -2,7 +2,7 @@ import type { OutgoingHttpHeaders } from "node:http";
 import type { IncomingMessage } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import type { MiddlewareManifest } from "../../types/next-types";
-import type { InternalEvent, InternalResult, StreamCreator } from "../../types/open-next.js";
+import type { InternalEvent, InternalResult, RoutingResult, StreamCreator } from "../../types/open-next.js";
 /**
  *
  * @__PURE__
@@ -90,4 +90,5 @@ export declare function fixISRHeaders(headers: OutgoingHttpHeaders): void;
  * @returns
  * @__PURE__
  */
-export declare function createServerResponse(internalEvent: InternalEvent, headers: Record<string, string | string[] | undefined>, responseStream?: StreamCreator): OpenNextNodeResponse;
+export declare function createServerResponse(routingResult: RoutingResult, headers: Record<string, string | string[] | undefined>, responseStream?: StreamCreator): OpenNextNodeResponse;
+export declare function invalidateCDNOnRequest(params: RoutingResult, headers: OutgoingHttpHeaders): Promise<void>;

package/dist/core/routing/util.js

@@ -352,7 +352,8 @@ export function fixISRHeaders(headers) {
  * @returns
  * @__PURE__
  */
-export function createServerResponse(internalEvent, headers, responseStream) {
+export function createServerResponse(routingResult, headers, responseStream) {
+    const internalEvent = routingResult.internalEvent;
     return new OpenNextNodeResponse((_headers) => {
         fixCacheHeaderForHtmlPages(internalEvent, _headers);
         fixSWRCacheHeader(_headers);
@@ -360,5 +361,21 @@ export function createServerResponse(internalEvent, headers, responseStream) {
         fixISRHeaders(_headers);
     }, async (_headers) => {
         await revalidateIfRequired(internalEvent.headers.host, internalEvent.rawPath, _headers);
+        await invalidateCDNOnRequest(routingResult, _headers);
     }, responseStream, headers);
 }
+// This function is used only for `res.revalidate()`
+export async function invalidateCDNOnRequest(params, headers) {
+    const { internalEvent, initialPath, resolvedRoutes } = params;
+    const isIsrRevalidation = internalEvent.headers["x-isr"] === "1";
+    if (!isIsrRevalidation &&
+        headers[CommonHeaders.NEXT_CACHE] === "REVALIDATED") {
+        await globalThis.cdnInvalidationHandler.invalidatePaths([
+            {
+                initialPath,
+                rawPath: internalEvent.rawPath,
+                resolvedRoutes,
+            },
+        ]);
+    }
+}

package/dist/overrides/cdnInvalidation/cloudfront.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    name: string;
+    invalidatePaths: (paths: {
+        initialPath: string;
+        rawPath: string;
+        resolvedRoutes: import("../../types/open-next").ResolvedRoute[];
+    }[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/cdnInvalidation/cloudfront.js

@@ -0,0 +1,26 @@
+import { CloudFrontClient, CreateInvalidationCommand, } from "@aws-sdk/client-cloudfront";
+const cloudfront = new CloudFrontClient({});
+export default {
+    name: "cloudfront",
+    invalidatePaths: async (paths) => {
+        const constructedPaths = paths.flatMap(({ initialPath, resolvedRoutes }) => {
+            const isAppRouter = resolvedRoutes.some((route) => route.type === "app");
+            // revalidateTag doesn't have any leading slash, remove it just to be sure
+            const path = initialPath.replace(/^\//, "");
+            return isAppRouter
+                ? [`/${path}`, `/${path}?_rsc=*`]
+                : [
+                    `/${path}`,
+                    `/_next/data/${process.env.NEXT_BUILD_ID}${path === "/" ? "/index" : `/${path}`}.json*`,
+                ];
+        });
+        await cloudfront.send(new CreateInvalidationCommand({
+            DistributionId: process.env.CLOUDFRONT_DISTRIBUTION_ID,
+            InvalidationBatch: {
+                // Do we need to limit the number of paths? Or batch them into multiple commands?
+                Paths: { Quantity: constructedPaths.length, Items: constructedPaths },
+                CallerReference: `${Date.now()}`,
+            },
+        }));
+    },
+};

package/dist/overrides/cdnInvalidation/dummy.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    name: string;
+    invalidatePaths: (_: {
+        initialPath: string;
+        rawPath: string;
+        resolvedRoutes: import("../../types/open-next").ResolvedRoute[];
+    }[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/cdnInvalidation/dummy.js

@@ -0,0 +1,6 @@
+export default {
+    name: "dummy",
+    invalidatePaths: (_) => {
+        return Promise.resolve();
+    },
+};

package/dist/overrides/imageLoader/fs-dev.d.ts

@@ -0,0 +1,10 @@
+import fs from "node:fs";
+declare const _default: {
+    name: string;
+    load: (url: string) => Promise<{
+        body: fs.ReadStream;
+        contentType: string;
+        cacheControl: string;
+    }>;
+};
+export default _default;

package/dist/overrides/imageLoader/fs-dev.js

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+export default {
+    name: "fs-dev",
+    load: async (url) => {
+        const basePath = "../../assets";
+        const body = fs.createReadStream(`${basePath}/${url}`);
+        const contentType = url.endsWith(".png") ? "image/png" : "image/jpeg";
+        return {
+            body,
+            contentType,
+            cacheControl: "public, max-age=31536000, immutable",
+        };
+    },
+};

package/dist/overrides/incrementalCache/fs-dev.d.ts

@@ -0,0 +1,3 @@
+import type { IncrementalCache } from "../../types/overrides.js";
+declare const cache: IncrementalCache;
+export default cache;

package/dist/overrides/incrementalCache/fs-dev.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const buildId = process.env.NEXT_BUILD_ID;
+const basePath = path.resolve(process.cwd(), `../../cache/${buildId}`);
+const getCacheKey = (key) => {
+    return path.join(basePath, `${key}.cache`);
+};
+const cache = {
+    name: "fs-dev",
+    get: async (key) => {
+        const fileData = await fs.readFile(getCacheKey(key), "utf-8");
+        const data = JSON.parse(fileData);
+        const { mtime } = await fs.stat(getCacheKey(key));
+        return {
+            value: data,
+            lastModified: mtime.getTime(),
+        };
+    },
+    set: async (key, value, isFetch) => {
+        const data = JSON.stringify(value);
+        const cacheKey = getCacheKey(key);
+        // We need to create the directory before writing the file
+        await fs.mkdir(path.dirname(cacheKey), { recursive: true });
+        await fs.writeFile(cacheKey, data);
+    },
+    delete: async (key) => {
+        await fs.rm(getCacheKey(key));
+    },
+};
+export default cache;

package/dist/overrides/incrementalCache/multi-tier-ddb-s3.d.ts

@@ -0,0 +1,10 @@
+import type { IncrementalCache } from "../../types/overrides";
+/**
+ * This cache implementation uses a multi-tier cache with a local cache, a DynamoDB metadata cache and an S3 cache.
+ * It uses the same DynamoDB table as the default tag cache and the same S3 bucket as the default incremental cache.
+ * It will first check the local cache.
+ * If the local cache is expired, it will check the DynamoDB metadata cache to see if the local cache is still valid.
+ * Lastly it will check the S3 cache.
+ */
+declare const multiTierCache: IncrementalCache;
+export default multiTierCache;