@opennextjs/aws 3.3.1 → 3.4.0

package/dist/adapters/cache.js

@@ -275,6 +275,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/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";
@@ -114,7 +115,7 @@ async function generateBundle(name, options, fnOptions) {
     const plugins = [
         openNextReplacementPlugin({
             name: `requestHandlerOverride ${name}`,
-            target: /core(\/|\\)requestHandler\.js/g,
+            target: getCrossPlatformPathRegex("core/requestHandler.js"),
             deletes: [
                 ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
                 ...(disableRouting ? ["withRouting"] : []),
@@ -122,11 +123,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/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/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;

package/dist/overrides/incrementalCache/multi-tier-ddb-s3.js

@@ -0,0 +1,120 @@
+import { customFetchClient } from "../../utils/fetch";
+import { LRUCache } from "../../utils/lru";
+import { debug } from "../../adapters/logger";
+import S3Cache, { getAwsClient } from "./s3-lite";
+// TTL for the local cache in milliseconds
+const localCacheTTL = process.env.OPEN_NEXT_LOCAL_CACHE_TTL_MS
+    ? Number.parseInt(process.env.OPEN_NEXT_LOCAL_CACHE_TTL_MS, 10)
+    : 0;
+// Maximum size of the local cache in nb of entries
+const maxCacheSize = process.env.OPEN_NEXT_LOCAL_CACHE_SIZE
+    ? Number.parseInt(process.env.OPEN_NEXT_LOCAL_CACHE_SIZE, 10)
+    : 1000;
+const localCache = new LRUCache(maxCacheSize);
+const awsFetch = (body, type = "get") => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    const client = getAwsClient();
+    return customFetchClient(client)(`https://dynamodb.${CACHE_BUCKET_REGION}.amazonaws.com`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-amz-json-1.0",
+            "X-Amz-Target": `DynamoDB_20120810.${type === "get" ? "GetItem" : "PutItem"}`,
+        },
+        body,
+    });
+};
+const buildDynamoKey = (key) => {
+    const { NEXT_BUILD_ID } = process.env;
+    return `__meta_${NEXT_BUILD_ID}_${key}`;
+};
+/**
+ * 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.
+ */
+const multiTierCache = {
+    name: "multi-tier-ddb-s3",
+    async get(key, isFetch) {
+        // First we check the local cache
+        const localCacheEntry = localCache.get(key);
+        if (localCacheEntry) {
+            if (Date.now() - localCacheEntry.lastModified < localCacheTTL) {
+                debug("Using local cache without checking ddb");
+                return localCacheEntry;
+            }
+            try {
+                // Here we'll check ddb metadata to see if the local cache is still valid
+                const { CACHE_DYNAMO_TABLE } = process.env;
+                const result = await awsFetch(JSON.stringify({
+                    TableName: CACHE_DYNAMO_TABLE,
+                    Key: {
+                        path: { S: buildDynamoKey(key) },
+                        tag: { S: buildDynamoKey(key) },
+                    },
+                }));
+                if (result.status === 200) {
+                    const data = await result.json();
+                    const hasBeenDeleted = data.Item?.deleted?.BOOL;
+                    if (hasBeenDeleted) {
+                        localCache.delete(key);
+                        return { value: undefined, lastModified: 0 };
+                    }
+                    // If the metadata is older than the local cache, we can use the local cache
+                    // If it's not found we assume that no write has been done yet and we can use the local cache
+                    const lastModified = data.Item?.revalidatedAt?.N
+                        ? Number.parseInt(data.Item.revalidatedAt.N, 10)
+                        : 0;
+                    if (lastModified <= localCacheEntry.lastModified) {
+                        debug("Using local cache after checking ddb");
+                        return localCacheEntry;
+                    }
+                }
+            }
+            catch (e) {
+                debug("Failed to get metadata from ddb", e);
+            }
+        }
+        const result = await S3Cache.get(key, isFetch);
+        if (result.value) {
+            localCache.set(key, {
+                value: result.value,
+                lastModified: result.lastModified ?? Date.now(),
+            });
+        }
+        return result;
+    },
+    // Both for set and delete we choose to do the write to S3 first and then to DynamoDB
+    // Which means that if it fails in DynamoDB, instance that don't have local cache will work as expected.
+    // But instance that have local cache will have a stale cache until the next working set or delete.
+    async set(key, value, isFetch) {
+        const revalidatedAt = Date.now();
+        await S3Cache.set(key, value, isFetch);
+        await awsFetch(JSON.stringify({
+            TableName: process.env.CACHE_DYNAMO_TABLE,
+            Item: {
+                tag: { S: buildDynamoKey(key) },
+                path: { S: buildDynamoKey(key) },
+                revalidatedAt: { N: String(revalidatedAt) },
+            },
+        }), "set");
+        localCache.set(key, {
+            value,
+            lastModified: revalidatedAt,
+        });
+    },
+    async delete(key) {
+        await S3Cache.delete(key);
+        await awsFetch(JSON.stringify({
+            TableName: process.env.CACHE_DYNAMO_TABLE,
+            Item: {
+                tag: { S: buildDynamoKey(key) },
+                path: { S: buildDynamoKey(key) },
+                deleted: { BOOL: true },
+            },
+        }), "set");
+        localCache.delete(key);
+    },
+};
+export default multiTierCache;

package/dist/overrides/incrementalCache/s3-lite.d.ts

@@ -1,3 +1,5 @@
+import { AwsClient } from "aws4fetch";
 import type { IncrementalCache } from "../../types/overrides";
+export declare const getAwsClient: () => AwsClient;
 declare const incrementalCache: IncrementalCache;
 export default incrementalCache;

package/dist/overrides/incrementalCache/s3-lite.js

@@ -5,7 +5,7 @@ import { IgnorableError, RecoverableError } from "../../utils/error";
 import { customFetchClient } from "../../utils/fetch";
 import { parseNumberFromEnv } from "../../adapters/util";
 let awsClient = null;
-const getAwsClient = () => {
+export const getAwsClient = () => {
     const { CACHE_BUCKET_REGION } = process.env;
     if (awsClient) {
         return awsClient;

package/dist/overrides/proxyExternalRequest/node.js

@@ -36,16 +36,17 @@ const nodeProxy = {
                 method,
                 rejectUnauthorized: false,
             }, (_res) => {
-                const nodeReadableStream = _res.headers["content-encoding"] === "br"
+                const resHeaders = _res.headers;
+                const nodeReadableStream = resHeaders["content-encoding"] === "br"
                     ? _res.pipe(require("node:zlib").createBrotliDecompress())
-                    : _res.headers["content-encoding"] === "gzip"
+                    : resHeaders["content-encoding"] === "gzip"
                         ? _res.pipe(require("node:zlib").createGunzip())
                         : _res;
-                const isBase64Encoded = isBinaryContentType(headers["content-type"]) ||
-                    !!headers["content-encoding"];
+                const isBase64Encoded = isBinaryContentType(resHeaders["content-type"]) ||
+                    !!resHeaders["content-encoding"];
                 const result = {
                     type: "core",
-                    headers: filterHeadersForProxy(_res.headers),
+                    headers: filterHeadersForProxy(resHeaders),
                     statusCode: _res.statusCode ?? 200,
                     // TODO: check base64 encoding
                     isBase64Encoded,

package/dist/overrides/queue/direct.d.ts

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

package/dist/overrides/queue/direct.js

@@ -0,0 +1,18 @@
+const queue = {
+    name: "dev-queue",
+    send: async (message) => {
+        const prerenderManifest = (await import("../../adapters/config/index.js"))
+            .PrerenderManifest;
+        const { host, url } = message.MessageBody;
+        const protocol = host.includes("localhost") ? "http" : "https";
+        const revalidateId = prerenderManifest.preview.previewModeId;
+        await globalThis.internalFetch(`${protocol}://${host}${url}`, {
+            method: "HEAD",
+            headers: {
+                "x-prerender-revalidate": revalidateId,
+                "x-isr": "1",
+            },
+        });
+    },
+};
+export default queue;

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

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

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

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+const tagFile = "../../dynamodb-provider/dynamodb-cache.json";
+const tagContent = fs.readFileSync(tagFile, "utf-8");
+let tags = JSON.parse(tagContent);
+const tagCache = {
+    name: "fs-dev",
+    getByPath: async (path) => {
+        return tags
+            .filter((tagPathMapping) => tagPathMapping.path.S === path)
+            .map((tag) => tag.tag.S);
+    },
+    getByTag: async (tag) => {
+        return tags
+            .filter((tagPathMapping) => tagPathMapping.tag.S === tag)
+            .map((tag) => tag.path.S);
+    },
+    getLastModified: async (path, lastModified) => {
+        const revalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === path &&
+            Number.parseInt(tagPathMapping.revalidatedAt.N) > (lastModified ?? 0));
+        return revalidatedTags.length > 0 ? -1 : (lastModified ?? Date.now());
+    },
+    writeTags: async (newTags) => {
+        const newTagsSet = new Set(newTags.map(({ tag, path }) => `${tag}-${path}`));
+        const unchangedTags = tags.filter(({ tag, path }) => !newTagsSet.has(`${tag.S}-${path.S}`));
+        tags = unchangedTags.concat(newTags.map((tag) => ({
+            tag: { S: tag.tag },
+            path: { S: tag.path },
+            revalidatedAt: { N: String(tag.revalidatedAt) },
+        })));
+    },
+};
+export default tagCache;

package/dist/overrides/wrappers/cloudflare-edge.js

@@ -1,5 +1,7 @@
-const cfPropNameToHeaderName = {
-    city: "x-open-next-city",
+const cfPropNameMapping = {
+    // The city name is percent-encoded.
+    // See https://github.com/vercel/vercel/blob/4cb6143/packages/functions/src/headers.ts#L94C19-L94C37
+    city: [encodeURIComponent, "x-open-next-city"],
     country: "x-open-next-country",
     regionCode: "x-open-next-region",
     latitude: "x-open-next-latitude",
@@ -20,10 +22,15 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
     // See https://developers.cloudflare.com/workers/runtime-apis/request
     // Note: This code could be moved to a cloudflare specific converter when one is created.
     const cfProperties = request.cf;
-    for (const [propName, headerName] of Object.entries(cfPropNameToHeaderName)) {
+    for (const [propName, mapping] of Object.entries(cfPropNameMapping)) {
         const propValue = cfProperties?.[propName];
         if (propValue != null) {
-            internalEvent.headers[headerName] = propValue;
+            const [encode, headerName] = Array.isArray(mapping)
+                ? mapping
+                : [null, mapping];
+            internalEvent.headers[headerName] = encode
+                ? encode(propValue)
+                : propValue;
         }
     }
     const response = await handler(internalEvent);

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

@@ -2,6 +2,6 @@ import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
     name: string;
     wrapper: WrapperHandler;
-    supportStreaming: false;
+    supportStreaming: true;
 };
 export default _default;

package/dist/overrides/wrappers/dummy.js

@@ -1,6 +1,10 @@
-const dummyWrapper = async () => async () => undefined;
+const dummyWrapper = async (handler, converter) => {
+    return async (event, responseStream) => {
+        return await handler(event, responseStream);
+    };
+};
 export default {
     name: "dummy",
     wrapper: dummyWrapper,
-    supportStreaming: false,
+    supportStreaming: true,
 };

package/dist/overrides/wrappers/express-dev.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../../types/overrides.js";
+declare const _default: {
+    wrapper: WrapperHandler;
+    name: string;
+    supportStreaming: boolean;
+};
+export default _default;

package/dist/overrides/wrappers/express-dev.js

@@ -0,0 +1,43 @@
+import express from "express";
+const wrapper = async (handler, converter) => {
+    const app = express();
+    // To serve static assets
+    app.use(express.static("../../assets"));
+    const imageHandlerPath = "../../image-optimization-function/index.mjs";
+    const imageHandler = await import(imageHandlerPath).then((m) => m.handler);
+    app.all("/_next/image", async (req, res) => {
+        const internalEvent = await converter.convertFrom(req);
+        const _res = {
+            writeHeaders: (prelude) => {
+                res.writeHead(prelude.statusCode, prelude.headers);
+                return res;
+            },
+        };
+        await imageHandler(internalEvent, _res);
+    });
+    app.all("*paths", async (req, res) => {
+        const internalEvent = await converter.convertFrom(req);
+        const _res = {
+            writeHeaders: (prelude) => {
+                res.writeHead(prelude.statusCode, prelude.headers);
+                return res;
+            },
+            onFinish: () => { },
+        };
+        await handler(internalEvent, _res);
+    });
+    const server = app.listen(Number.parseInt(process.env.PORT ?? "3000", 10), () => {
+        console.log(`Server running on port ${process.env.PORT ?? 3000}`);
+    });
+    app.on("error", (err) => {
+        console.error("error", err);
+    });
+    return () => {
+        server.close();
+    };
+};
+export default {
+    wrapper,
+    name: "expresss-dev",
+    supportStreaming: true,
+};

package/dist/plugins/edge.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import chalk from "chalk";
 import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 /**
  * @param opts.nextDir - The path to the .next directory
  * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
@@ -28,7 +29,7 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
             logger.debug(chalk.blue("OpenNext Edge plugin"));
             if (edgeFunctionHandlerPath) {
                 // If we bundle the routing, we need to resolve the middleware
-                build.onResolve({ filter: /\.\/middleware.mjs/g }, () => {
+                build.onResolve({ filter: getCrossPlatformPathRegex("./middleware.mjs") }, () => {
                     return {
                         path: edgeFunctionHandlerPath,
                     };
@@ -55,7 +56,7 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
                 loader: "js",
             }));
             // We inject the entry files into the edgeFunctionHandler
-            build.onLoad({ filter: /\/edgeFunctionHandler.js/g }, async (args) => {
+            build.onLoad({ filter: getCrossPlatformPathRegex("/edgeFunctionHandler.js") }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
                 contents = `
 globalThis._ENTRIES = {};
@@ -117,7 +118,7 @@ ${contents}
                     contents,
                 };
             });
-            build.onLoad({ filter: /adapters\/config\/index/g }, async () => {
+            build.onLoad({ filter: getCrossPlatformPathRegex("adapters/config/index") }, async () => {
                 const NextConfig = loadConfig(nextDir);
                 const BuildId = loadBuildId(nextDir);
                 const HtmlPages = loadHtmlPages(nextDir);

package/dist/plugins/replacement.d.ts

@@ -8,7 +8,7 @@ export interface IPluginSettings {
 /**
  *
  * openNextPlugin({
- *   target: /plugins\/default\.js/g,
+ *   target: /plugins(\/|\\)default\.js/g,
  *   replacements: [require.resolve("./plugins/default.js")],
  *   deletes: ["id1"],
  * })

package/dist/plugins/replacement.js

@@ -6,7 +6,7 @@ const importPattern = /\/\/#import([\s\S]*?)\n\/\/#endImport/gm;
 /**
  *
  * openNextPlugin({
- *   target: /plugins\/default\.js/g,
+ *   target: /plugins(\/|\\)default\.js/g,
  *   replacements: [require.resolve("./plugins/default.js")],
  *   deletes: ["id1"],
  * })

package/dist/plugins/resolve.d.ts

@@ -12,6 +12,7 @@ export interface IPluginSettings {
         originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
         warmer?: LazyLoadedOverride<Warmer> | IncludedWarmer;
         proxyExternalRequest?: OverrideOptions["proxyExternalRequest"];
+        cdnInvalidation?: OverrideOptions["cdnInvalidation"];
     };
     fnName?: string;
 }

package/dist/plugins/resolve.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import chalk from "chalk";
 import logger from "../logger.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 function getOverrideOrDummy(override) {
     if (typeof override === "string") {
         return override;
@@ -19,6 +20,7 @@ const nameToFolder = {
     originResolver: "originResolver",
     warmer: "warmer",
     proxyExternalRequest: "proxyExternalRequest",
+    cdnInvalidation: "cdnInvalidation",
 };
 const defaultOverrides = {
     wrapper: "aws-lambda",
@@ -30,6 +32,7 @@ const defaultOverrides = {
     originResolver: "pattern-env",
     warmer: "aws-lambda",
     proxyExternalRequest: "node",
+    cdnInvalidation: "dummy",
 };
 /**
  * @param opts.overrides - The name of the overrides to use
@@ -40,7 +43,7 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
         name: "opennext-resolve",
         setup(build) {
             logger.debug(chalk.blue("OpenNext Resolve plugin"), fnName ? `for ${fnName}` : "");
-            build.onLoad({ filter: /core(\/|\\)resolve\.js/g }, async (args) => {
+            build.onLoad({ filter: getCrossPlatformPathRegex("core/resolve.js") }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
                 const overridesEntries = Object.entries(overrides ?? {});
                 for (let [overrideName, overrideValue] of overridesEntries) {

package/dist/types/global.d.ts

@@ -1,6 +1,6 @@
 import type { AsyncLocalStorage } from "node:async_hooks";
 import type { OutgoingHttpHeaders } from "node:http";
-import type { IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
+import type { CDNInvalidationHandler, IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
 import type { DetachedPromiseRunner } from "../utils/promise";
 import type { OpenNextConfig } from "./open-next";
 export interface RequestData {
@@ -184,5 +184,11 @@ declare global {
      * Defined in `createMainHandler`.
      */
     var proxyExternalRequest: ProxyExternalRequest;
+    /**
+     * The function that will be called when the CDN needs invalidating (either from `revalidateTag` or from `res.revalidate`)
+     * Available in main functions
+     * Defined in `createMainHandler`
+     */
+    var cdnInvalidationHandler: CDNInvalidationHandler;
 }
 export {};

package/dist/types/open-next.d.ts

@@ -1,7 +1,7 @@
 import type { ReadableStream } from "node:stream/web";
 import type { Writable } from "node:stream";
 import type { WarmerEvent, WarmerResponse } from "../adapters/warmer-function";
-import type { Converter, ImageLoader, IncrementalCache, OriginResolver, ProxyExternalRequest, Queue, TagCache, Warmer, Wrapper } from "./overrides";
+import type { CDNInvalidationHandler, Converter, ImageLoader, IncrementalCache, OriginResolver, ProxyExternalRequest, Queue, TagCache, Warmer, Wrapper } from "./overrides";
 export type BaseEventOrResult<T extends string = string> = {
     type: T;
 };
@@ -66,7 +66,7 @@ export interface Origin {
     port?: number;
     customHeaders?: Record<string, string>;
 }
-export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "dummy";
+export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
 export type IncludedConverter = "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront" | "edge" | "node" | "sqs-revalidate" | "dummy";
 export type RouteType = "route" | "page" | "app";
 export interface ResolvedRoute {
@@ -83,13 +83,14 @@ export interface RoutingResult {
 }
 export interface MiddlewareResult extends RoutingResult, BaseEventOrResult<"middleware"> {
 }
-export type IncludedQueue = "sqs" | "sqs-lite" | "dummy";
-export type IncludedIncrementalCache = "s3" | "s3-lite" | "dummy";
-export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "dummy";
-export type IncludedImageLoader = "s3" | "host" | "dummy";
+export type IncludedQueue = "sqs" | "sqs-lite" | "direct" | "dummy";
+export type IncludedIncrementalCache = "s3" | "s3-lite" | "multi-tier-ddb-s3" | "fs-dev" | "dummy";
+export type IncludedTagCache = "dynamodb" | "dynamodb-lite" | "fs-dev" | "dummy";
+export type IncludedImageLoader = "s3" | "host" | "fs-dev" | "dummy";
 export type IncludedOriginResolver = "pattern-env" | "dummy";
 export type IncludedWarmer = "aws-lambda" | "dummy";
 export type IncludedProxyExternalRequest = "node" | "fetch" | "dummy";
+export type IncludedCDNInvalidationHandler = "cloudfront" | "dummy";
 export interface DefaultOverrideOptions<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> {
     /**
      * This is the main entrypoint of your app.
@@ -129,6 +130,11 @@ export interface OverrideOptions extends DefaultOverrideOptions {
      * @default "node"
      */
     proxyExternalRequest?: IncludedProxyExternalRequest | LazyLoadedOverride<ProxyExternalRequest>;
+    /**
+     * Add possibility to override the default cdn invalidation for On Demand Revalidation
+     * @default "dummy"
+     */
+    cdnInvalidation?: IncludedCDNInvalidationHandler | LazyLoadedOverride<CDNInvalidationHandler>;
 }
 export interface InstallOptions {
     /**

package/dist/types/overrides.d.ts

@@ -1,6 +1,6 @@
 import type { Readable } from "node:stream";
 import type { Meta } from "./cache";
-import type { BaseEventOrResult, BaseOverride, InternalEvent, InternalResult, Origin, StreamCreator } from "./open-next";
+import type { BaseEventOrResult, BaseOverride, InternalEvent, InternalResult, Origin, ResolvedRoute, StreamCreator } from "./open-next";
 export interface QueueMessage {
     MessageDeduplicationId: string;
     MessageBody: {
@@ -84,3 +84,12 @@ export type OriginResolver = BaseOverride & {
 export type ProxyExternalRequest = BaseOverride & {
     proxy: (event: InternalEvent) => Promise<InternalResult>;
 };
+type CDNPath = {
+    initialPath: string;
+    rawPath: string;
+    resolvedRoutes: ResolvedRoute[];
+};
+export type CDNInvalidationHandler = BaseOverride & {
+    invalidatePaths: (paths: CDNPath[]) => Promise<void>;
+};
+export {};

package/dist/utils/lru.d.ts

@@ -0,0 +1,8 @@
+export declare class LRUCache<T> {
+    private maxSize;
+    private cache;
+    constructor(maxSize: number);
+    get(key: string): T | undefined;
+    set(key: string, value: any): void;
+    delete(key: string): void;
+}

package/dist/utils/lru.js

@@ -0,0 +1,29 @@
+export class LRUCache {
+    maxSize;
+    cache = new Map();
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const result = this.cache.get(key);
+        // We could have used .has to allow for nullish value to be stored but we don't need that right now
+        if (result) {
+            // By removing and setting the key again we ensure it's the most recently used
+            this.cache.delete(key);
+            this.cache.set(key, result);
+        }
+        return result;
+    }
+    set(key, value) {
+        if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    delete(key) {
+        this.cache.delete(key);
+    }
+}

package/dist/utils/regex.d.ts

@@ -0,0 +1,18 @@
+type Options = {
+    escape?: boolean;
+    flags?: string;
+};
+/**
+ * Constructs a regular expression for a path that supports separators for multiple platforms
+ *  - Uses posix separators (`/`) as the input that should be made cross-platform.
+ *  - Special characters are escaped by default but can be controlled through opts.escape.
+ *  - Posix separators are always escaped.
+ *
+ * @example
+ * ```ts
+ * getCrossPlatformPathRegex("./middleware.mjs")
+ * getCrossPlatformPathRegex(String.raw`\./middleware\.(mjs|cjs)`, { escape: false })
+ * ```
+ */
+export declare function getCrossPlatformPathRegex(regex: string, { escape: shouldEscape, flags }?: Options): RegExp;
+export {};

package/dist/utils/regex.js

@@ -0,0 +1,16 @@
+/**
+ * Constructs a regular expression for a path that supports separators for multiple platforms
+ *  - Uses posix separators (`/`) as the input that should be made cross-platform.
+ *  - Special characters are escaped by default but can be controlled through opts.escape.
+ *  - Posix separators are always escaped.
+ *
+ * @example
+ * ```ts
+ * getCrossPlatformPathRegex("./middleware.mjs")
+ * getCrossPlatformPathRegex(String.raw`\./middleware\.(mjs|cjs)`, { escape: false })
+ * ```
+ */
+export function getCrossPlatformPathRegex(regex, { escape: shouldEscape = true, flags = "g" } = {}) {
+    const newExpr = (shouldEscape ? regex.replace(/([[\]().*+?^$|{}\\])/g, "\\$1") : regex).replaceAll("/", String.raw `(?:\/|\\)`);
+    return new RegExp(newExpr, flags);
+}

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -30,6 +30,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@aws-sdk/client-cloudfront": "3.398.0",
     "@aws-sdk/client-dynamodb": "^3.398.0",
     "@aws-sdk/client-lambda": "^3.398.0",
     "@aws-sdk/client-s3": "^3.398.0",
@@ -41,12 +42,14 @@
     "aws4fetch": "^1.0.18",
     "chalk": "^5.3.0",
     "esbuild": "0.19.2",
+    "express": "5.0.1",
     "path-to-regexp": "^6.3.0",
     "promise.series": "^0.2.0",
     "urlpattern-polyfill": "^10.0.0"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.109",
+    "@types/express": "5.0.0",
     "@types/node": "20.17.6",
     "tsc-alias": "^1.8.8",
     "typescript": "5.6.3"