@opennextjs/aws 3.3.1 → 3.4.1

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/dynamodb-lite.js

@@ -49,8 +49,9 @@ function buildDynamoObject(path, tags, revalidatedAt) {
 const tagCache = {
     async getByPath(path) {
         try {
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return [];
+            }
             const { CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
             const result = await awsFetch(JSON.stringify({
                 TableName: CACHE_DYNAMO_TABLE,
@@ -79,8 +80,9 @@ const tagCache = {
     },
     async getByTag(tag) {
         try {
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return [];
+            }
             const { CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
             const result = await awsFetch(JSON.stringify({
                 TableName: CACHE_DYNAMO_TABLE,
@@ -107,8 +109,9 @@ const tagCache = {
     },
     async getLastModified(key, lastModified) {
         try {
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return lastModified ?? Date.now();
+            }
             const { CACHE_DYNAMO_TABLE } = process.env;
             const result = await awsFetch(JSON.stringify({
                 TableName: CACHE_DYNAMO_TABLE,
@@ -139,8 +142,9 @@ const tagCache = {
     async writeTags(tags) {
         try {
             const { CACHE_DYNAMO_TABLE } = process.env;
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return;
+            }
             const dataChunks = chunk(tags, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT).map((Items) => ({
                 RequestItems: {
                     [CACHE_DYNAMO_TABLE ?? ""]: Items.map((Item) => ({

package/dist/overrides/tagCache/dynamodb.js

@@ -27,8 +27,9 @@ function buildDynamoObject(path, tags, revalidatedAt) {
 const tagCache = {
     async getByPath(path) {
         try {
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return [];
+            }
             const result = await dynamoClient.send(new QueryCommand({
                 TableName: CACHE_DYNAMO_TABLE,
                 IndexName: "revalidate",
@@ -52,8 +53,9 @@ const tagCache = {
     },
     async getByTag(tag) {
         try {
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return [];
+            }
             const { Items } = await dynamoClient.send(new QueryCommand({
                 TableName: CACHE_DYNAMO_TABLE,
                 KeyConditionExpression: "#tag = :tag",
@@ -75,8 +77,9 @@ const tagCache = {
     },
     async getLastModified(key, lastModified) {
         try {
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return lastModified ?? Date.now();
+            }
             const result = await dynamoClient.send(new QueryCommand({
                 TableName: CACHE_DYNAMO_TABLE,
                 IndexName: "revalidate",
@@ -102,8 +105,9 @@ const tagCache = {
     },
     async writeTags(tags) {
         try {
-            if (globalThis.disableDynamoDBCache)
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return;
+            }
             const dataChunks = chunk(tags, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT).map((Items) => ({
                 RequestItems: {
                     [CACHE_DYNAMO_TABLE ?? ""]: Items.map((Item) => ({

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 {
@@ -29,16 +29,17 @@ export interface RequestData {
     body?: ReadableStream<Uint8Array>;
     signal: AbortSignal;
 }
+interface Entry {
+    default: (props: {
+        page: string;
+        request: RequestData;
+    }) => Promise<{
+        response: Response;
+        waitUntil: Promise<void>;
+    }>;
+}
 interface Entries {
-    [k: string]: {
-        default: (props: {
-            page: string;
-            request: RequestData;
-        }) => Promise<{
-            response: Response;
-            waitUntil: Promise<void>;
-        }>;
-    };
+    [k: string]: Entry | Promise<Entry>;
 }
 export interface EdgeRoute {
     name: string;
@@ -66,13 +67,13 @@ declare global {
     var tagCache: TagCache;
     /**
      * A boolean that indicates if the DynamoDB cache is disabled.
-     * TODO: Remove this, we already have access to the config file
+     * @deprecated This will be removed, use `globalThis.openNextConfig.dangerous?.disableTagCache` instead.
      * Defined in esbuild banner for the cache adapter.
      */
     var disableDynamoDBCache: boolean;
     /**
      * A boolean that indicates if the incremental cache is disabled.
-     * TODO: Remove this, we already have access to the config file
+     * @deprecated This will be removed, use `globalThis.openNextConfig.dangerous?.disableIncrementalCache` instead.
      * Defined in esbuild banner for the cache adapter.
      */
     var disableIncrementalCache: boolean;
@@ -184,5 +185,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;
+}