@opennextjs/aws 3.9.15 → 3.10.0

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

@@ -9,9 +9,9 @@ export default {
         }
         let lastRevalidated = 0;
         tags.forEach((tag) => {
-            const tagTime = tagsMap.get(tag);
-            if (tagTime && tagTime > lastRevalidated) {
-                lastRevalidated = tagTime;
+            const tagData = tagsMap.get(tag);
+            if (tagData && tagData.revalidatedAt > lastRevalidated) {
+                lastRevalidated = tagData.revalidatedAt;
             }
         });
         debug("getLastRevalidated result:", lastRevalidated);
@@ -21,13 +21,37 @@ export default {
         if (globalThis.openNextConfig.dangerous?.disableTagCache) {
             return false;
         }
+        const now = Date.now();
         const hasRevalidatedTag = tags.some((tag) => {
-            const tagRevalidatedAt = tagsMap.get(tag);
-            return tagRevalidatedAt ? tagRevalidatedAt > (lastModified ?? 0) : false;
+            const tagData = tagsMap.get(tag);
+            if (!tagData) {
+                return false;
+            }
+            // Check if tag has expired
+            if (typeof tagData.expire === "number") {
+                const isExpired = tagData.expire <= now && tagData.expire > (lastModified ?? 0);
+                return isExpired;
+            }
+            // Check if tag has been revalidated
+            return tagData.revalidatedAt > (lastModified ?? 0);
         });
         debug("hasBeenRevalidated result:", hasRevalidatedTag);
         return hasRevalidatedTag;
     },
+    isStale: async (tags, lastModified) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return false;
+        }
+        const hasStaleTag = tags.some((tag) => {
+            const tagData = tagsMap.get(tag);
+            if (!tagData || typeof tagData.stale !== "number") {
+                return false;
+            }
+            return tagData.stale > (lastModified ?? 0);
+        });
+        debug("isStale result:", hasStaleTag);
+        return hasStaleTag;
+    },
     writeTags: async (tags) => {
         if (globalThis.openNextConfig.dangerous?.disableTagCache ||
             tags.length === 0) {
@@ -35,7 +59,14 @@ export default {
         }
         debug("writeTags", { tags: tags });
         tags.forEach((tag) => {
-            tagsMap.set(tag, Date.now());
+            const tagStr = typeof tag === "string" ? tag : tag.tag;
+            const stale = typeof tag === "string" ? undefined : tag.stale;
+            const expire = typeof tag === "string" ? undefined : tag.expire;
+            tagsMap.set(tagStr, {
+                revalidatedAt: Date.now(),
+                stale,
+                expire,
+            });
         });
         debug("writeTags completed, written", tags.length, "tags");
     },

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

@@ -22,18 +22,50 @@ const tagCache = {
             .map((tagEntry) => tagEntry.path.S.replace(`${NEXT_BUILD_ID}/`, ""));
     },
     getLastModified: async (path, lastModified) => {
-        const revalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === buildKey(path) &&
-            Number.parseInt(tagPathMapping.revalidatedAt.N) > (lastModified ?? 0));
-        return revalidatedTags.length > 0 ? -1 : (lastModified ?? Date.now());
+        // Check if any tag has expired
+        const now = Date.now();
+        const hasExpiredTag = tags.some((tagPathMapping) => {
+            if (tagPathMapping.path.S === buildKey(path) &&
+                tagPathMapping.expire?.N) {
+                const expiry = Number.parseInt(tagPathMapping.expire.N);
+                return expiry <= now && expiry > (lastModified ?? 0);
+            }
+            return false;
+        });
+        const nonExpiredRevalidatedTags = tags.filter((tagPathMapping) => tagPathMapping.path.S === buildKey(path) &&
+            Number.parseInt(tagPathMapping.revalidatedAt.N) > (lastModified ?? 0) &&
+            (!tagPathMapping.expire?.N ||
+                Number.parseInt(tagPathMapping.expire.N) > now));
+        return nonExpiredRevalidatedTags.length > 0 || hasExpiredTag
+            ? -1
+            : (lastModified ?? Date.now());
+    },
+    isStale: async (path, lastModified) => {
+        return tags.some((entry) => {
+            if (entry.path.S !== buildKey(path))
+                return false;
+            if (!entry.stale?.N)
+                return false;
+            return Number.parseInt(entry.stale.N) > (lastModified ?? 0);
+        });
     },
     writeTags: async (newTags) => {
         const newTagsSet = new Set(newTags.map(({ tag, path }) => `${buildKey(tag)}-${buildKey(path)}`));
         const unchangedTags = tags.filter(({ tag, path }) => !newTagsSet.has(`${tag.S}-${path.S}`));
-        tags = unchangedTags.concat(newTags.map((item) => ({
-            tag: { S: buildKey(item.tag) },
-            path: { S: buildKey(item.path) },
-            revalidatedAt: { N: `${item.revalidatedAt ?? Date.now()}` },
-        })));
+        tags = unchangedTags.concat(newTags.map((item) => {
+            const tagEntry = {
+                tag: { S: buildKey(item.tag) },
+                path: { S: buildKey(item.path) },
+                revalidatedAt: { N: `${item.revalidatedAt ?? Date.now()}` },
+                ...(item.stale !== undefined
+                    ? { stale: { N: `${item.stale}` } }
+                    : undefined),
+                ...(item.expire !== undefined
+                    ? { expire: { N: `${item.expire}` } }
+                    : undefined),
+            };
+            return tagEntry;
+        }));
     },
 };
 export default tagCache;

package/dist/types/cache.d.ts

@@ -44,6 +44,7 @@ interface IncrementalCachedAppPageValue {
     headers?: Record<string, undefined | string | string[]>;
     postponed?: string;
     status?: number;
+    segmentData?: Map<string, Buffer>;
 }
 export type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | IncrementalCachedAppPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
 export interface CacheHandlerContext {
@@ -82,6 +83,18 @@ export type TagCacheMetaFile = {
     revalidatedAt: {
         N: string;
     };
+    /**
+     * The time at which the tag should be considered stale, in milliseconds since epoch. Optional, if not set the tag will never be stale.
+     */
+    stale?: {
+        N: string;
+    };
+    /**
+     * The time at which the tag should expire, in milliseconds since epoch. Optional, if not set the tag will never expire.
+     */
+    expire?: {
+        N: string;
+    };
 };
 interface SetIncrementalFetchCacheContext {
     fetchCache: true;
@@ -138,5 +151,13 @@ export interface ComposableCacheHandler {
      * This function is only there for older versions and do nothing
      */
     receiveExpiredTags(...tags: string[]): Promise<void>;
+    /**
+     * Added in Next.js 16. Updates tags with optional stale/expire durations.
+     * When durations is provided, marks tags as stale immediately and sets expiry;
+     * when omitted, immediately expires tags (same as expireTags).
+     */
+    updateTags(tags: string[], durations?: {
+        expire?: number;
+    }): Promise<void>;
 }
 export {};

package/dist/types/global.d.ts

@@ -2,6 +2,7 @@ import type { AsyncLocalStorage } from "node:async_hooks";
 import type { OutgoingHttpHeaders } from "node:http";
 import type { AssetResolver, CDNInvalidationHandler, IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
 import type { DetachedPromiseRunner } from "../utils/promise";
+import type { RequestCache } from "../utils/requestCache";
 import type { OpenNextConfig, WaitUntil } from "./open-next";
 export interface RequestData {
     geo?: {
@@ -55,6 +56,8 @@ interface OpenNextRequestContext {
     waitUntil?: WaitUntil;
     /** We use this to deduplicate write of the tags*/
     writtenTags: Set<string>;
+    /** Per-request in-memory cache. Overrides can use this to store data scoped to the current request. */
+    requestCache: RequestCache;
 }
 declare global {
     /**
@@ -88,11 +91,11 @@ declare global {
      */
     var disableIncrementalCache: boolean;
     /**
-     * A boolean that indicates if Next is V15 or higher.
+     * The Next.js version of the application.
      * Only available in the cache adapter.
      * Defined in the esbuild banner for the cache adapter.
      */
-    var isNextAfter15: boolean;
+    var nextVersion: string;
     /**
      * A boolean that indicates if the runtime is Edge.
      * Only available in `edge` runtime functions (i.e. external middleware or function with edge runtime).

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

@@ -73,6 +73,7 @@ export interface NextConfig {
         serverActions?: boolean;
         appDir?: boolean;
         optimizeCss?: boolean;
+        prefetchInlining?: boolean;
     };
     images: ImageConfig;
     poweredByHeader?: boolean;

package/dist/types/overrides.d.ts

@@ -107,17 +107,47 @@ Cons :
 - One page request (i.e. GET request) could require to check a lot of tags (And some of them multiple time when used with the fetch cache)
 - Almost impossible to do automatic cdn revalidation by itself
 */
+export type NextModeTagCacheWriteInput = string | {
+    tag: string;
+    /**
+     * Timestamp in milliseconds since epoch after which the tag should be considered stale.
+     */
+    stale?: number;
+    /**
+     * Timestamp in milliseconds since epoch after which the tag should be considered expired.
+     */
+    expire?: number;
+};
 export type NextModeTagCache = BaseTagCache & {
     mode: "nextMode";
     getLastRevalidated(tags: string[]): Promise<number>;
     hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
-    writeTags(tags: string[]): Promise<void>;
+    writeTags(tags: NextModeTagCacheWriteInput[]): Promise<void>;
     getPathsByTags?: (tags: string[]) => Promise<string[]>;
+    /**
+     * Optional method to check if any tag has become stale (but not yet expired).
+     * There are three possible states for a cache entry:
+     * - **Fresh**: no tag has been revalidated since `lastModified` → returns `false`.
+     * - **Stale**: at least one tag was revalidated after `lastModified` but has not yet expired →
+     *   returns `true`. The cache entry is still served but `revalidate` is set to `1` to trigger
+     *   background revalidation.
+     * - **Expired**: at least one tag has fully expired → handled by `hasBeenRevalidated` returning
+     *   `true`. This method is only called when `hasBeenRevalidated` returned `false`.
+     */
+    isStale?(tags: string[], lastModified?: number): Promise<boolean>;
 };
 export interface OriginalTagCacheWriteInput {
     tag: string;
     path: string;
     revalidatedAt?: number;
+    /**
+     * Timestamp in milliseconds since epoch after which the tag/path combination should be considered stale.
+     */
+    stale?: number;
+    /**
+     * Timestamp in milliseconds since epoch after which the tag/path combination should be considered expired.
+     */
+    expire?: number;
 }
 /**
  * On get :
@@ -144,6 +174,17 @@ export type OriginalTagCache = BaseTagCache & {
     getByPath(path: string): Promise<string[]>;
     getLastModified(path: string, lastModified?: number): Promise<number>;
     writeTags(tags: OriginalTagCacheWriteInput[]): Promise<void>;
+    /**
+     * Optional method to check if any tag entry for the given path has become stale (but not yet expired).
+     * There are three possible states for a cache entry:
+     * - **Fresh**: no tag/path combination has been revalidated since `lastModified` → returns `false`.
+     * - **Stale**: at least one tag/path combination was revalidated after `lastModified` but has not
+     *   yet expired → returns `true`. The cache entry is still served but `revalidate` is set to `1`
+     *   to trigger background revalidation.
+     * - **Expired**: at least one tag/path combination has fully expired → handled by `getLastModified`
+     *   returning `-1`. This method is only called when the entry is not fully expired.
+     */
+    isStale?(path: string, lastModified?: number): Promise<boolean>;
 };
 export type TagCache = NextModeTagCache | OriginalTagCache;
 export type WrapperHandler<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = (handler: OpenNextHandler<E, R>, converter: Converter<E, R>) => Promise<(...args: any[]) => any>;

package/dist/utils/cache.d.ts

@@ -1,4 +1,24 @@
-import type { CacheValue, OriginalTagCacheWriteInput, WithLastModified } from "../types/overrides";
+import type { CacheValue, NextModeTagCacheWriteInput, OriginalTagCacheWriteInput, WithLastModified } from "../types/overrides";
+/**
+ *
+ * @param key The key for that specific cache entry
+ * @param tags Array of tags associated with that cache entry
+ * @param lastModified Time of the last update to the cache entry
+ * @returns A boolean indicating whether the cache entry has become stale -
+ * A cache entry is considered stale if at least one of its associated tags has been revalidated since the `lastModified` time, but none of them has expired yet.
+ * In this case, the cache entry is still valid and can be served, but it should trigger a background revalidation to update the cache.
+ */
+export declare function isStale(key: string, tags: string[], lastModified?: number): Promise<boolean>;
+/**
+ * @param key The key for that specific cache entry
+ * @param tags Array of tags associated with that cache entry
+ * @param cacheEntry The cache entry with its last modified time and value
+ * @returns A boolean indicating whether the cache entry has been revalidated -
+ * A cache entry is considered revalidated if at least one of its associated tags has been revalidated
+ * after the entry's `lastModified` time, meaning the cached data is stale and must be re-fetched.
+ * For Next 16+ you need {@link isStale}, to know if a revalidated entry is stale (valid but needs background revalidation) or expired (needs to be re-fetched immediately).
+ * Without it, we consider all revalidated entries as expired, which means that they will be re-fetched immediately without a chance to be served stale.
+ */
 export declare function hasBeenRevalidated(key: string, tags: string[], cacheEntry: WithLastModified<CacheValue<any>>): Promise<boolean>;
 export declare function getTagsFromValue(value?: CacheValue<"cache">): string[];
-export declare function writeTags(tags: (string | OriginalTagCacheWriteInput)[]): Promise<void>;
+export declare function writeTags(tags: (string | OriginalTagCacheWriteInput | NextModeTagCacheWriteInput)[]): Promise<void>;

package/dist/utils/cache.js

@@ -1,4 +1,39 @@
 import { debug } from "../adapters/logger";
+import { compareSemver } from "./semver";
+/**
+ *
+ * @param key The key for that specific cache entry
+ * @param tags Array of tags associated with that cache entry
+ * @param lastModified Time of the last update to the cache entry
+ * @returns A boolean indicating whether the cache entry has become stale -
+ * A cache entry is considered stale if at least one of its associated tags has been revalidated since the `lastModified` time, but none of them has expired yet.
+ * In this case, the cache entry is still valid and can be served, but it should trigger a background revalidation to update the cache.
+ */
+export async function isStale(key, tags, lastModified) {
+    // SWR for revalidateTag has been implemented starting from Next.js 16
+    if (!compareSemver(globalThis.nextVersion, ">=", "16.0.0")) {
+        return false;
+    }
+    if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+        return false;
+    }
+    if (globalThis.tagCache.mode === "nextMode") {
+        return tags.length === 0
+            ? false
+            : ((await globalThis.tagCache.isStale?.(tags, lastModified)) ?? false);
+    }
+    return (await globalThis.tagCache.isStale?.(key, lastModified)) ?? false;
+}
+/**
+ * @param key The key for that specific cache entry
+ * @param tags Array of tags associated with that cache entry
+ * @param cacheEntry The cache entry with its last modified time and value
+ * @returns A boolean indicating whether the cache entry has been revalidated -
+ * A cache entry is considered revalidated if at least one of its associated tags has been revalidated
+ * after the entry's `lastModified` time, meaning the cached data is stale and must be re-fetched.
+ * For Next 16+ you need {@link isStale}, to know if a revalidated entry is stale (valid but needs background revalidation) or expired (needs to be re-fetched immediately).
+ * Without it, we consider all revalidated entries as expired, which means that they will be re-fetched immediately without a chance to be served stale.
+ */
 export async function hasBeenRevalidated(key, tags, cacheEntry) {
     if (globalThis.openNextConfig.dangerous?.disableTagCache) {
         return false;
@@ -39,10 +74,15 @@ function getTagKey(tag) {
     if (typeof tag === "string") {
         return tag;
     }
-    return JSON.stringify({
-        tag: tag.tag,
-        path: tag.path,
-    });
+    // For OriginalTagCacheWriteInput, include path in the key
+    if ("path" in tag) {
+        return JSON.stringify({
+            tag: tag.tag,
+            path: tag.path,
+        });
+    }
+    // For NextModeTagCacheWriteInput, just use the tag
+    return tag.tag;
 }
 export async function writeTags(tags) {
     const store = globalThis.__openNextAls.getStore();

package/dist/utils/promise.js

@@ -1,4 +1,5 @@
 import { debug, error } from "../adapters/logger";
+import { RequestCache } from "./requestCache";
 /**
  * A `Promise.withResolvers` implementation that exposes the `resolve` and
  * `reject` functions on a `Promise`.
@@ -84,6 +85,7 @@ export function runWithOpenNextRequestContext({ isISRRevalidation, waitUntil, re
         isISRRevalidation,
         waitUntil,
         writtenTags: new Set(),
+        requestCache: new RequestCache(),
     }, async () => {
         provideNextAfterProvider();
         let result;

package/dist/utils/requestCache.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A per-request cache that provides named Map instances.
+ * Overrides can use this to store and share data within the scope of a single request
+ * without polluting global state.
+ *
+ * Retrieve it from the ALS context:
+ * ```ts
+ * const store = globalThis.__openNextAls.getStore();
+ * const myMap = store?.requestCache.getOrCreate<MyKey, MyValue>("my-override");
+ * ```
+ */
+export declare class RequestCache {
+    private _caches;
+    /**
+     * Returns the Map registered under `key`.
+     * If no Map exists yet for that key, a new empty Map is created, stored, and returned.
+     * Repeated calls with the same key always return the **same** Map instance.
+     */
+    getOrCreate<K = unknown, V = unknown>(key: string): Map<K, V>;
+}

package/dist/utils/requestCache.js

@@ -0,0 +1,27 @@
+/**
+ * A per-request cache that provides named Map instances.
+ * Overrides can use this to store and share data within the scope of a single request
+ * without polluting global state.
+ *
+ * Retrieve it from the ALS context:
+ * ```ts
+ * const store = globalThis.__openNextAls.getStore();
+ * const myMap = store?.requestCache.getOrCreate<MyKey, MyValue>("my-override");
+ * ```
+ */
+export class RequestCache {
+    _caches = new Map();
+    /**
+     * Returns the Map registered under `key`.
+     * If no Map exists yet for that key, a new empty Map is created, stored, and returned.
+     * Repeated calls with the same key always return the **same** Map instance.
+     */
+    getOrCreate(key) {
+        let cache = this._caches.get(key);
+        if (!cache) {
+            cache = new Map();
+            this._caches.set(key, cache);
+        }
+        return cache;
+    }
+}

package/dist/utils/semver.d.ts

@@ -0,0 +1,10 @@
+export type SemverOp = "=" | ">=" | "<=" | ">" | "<";
+/**
+ * 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("2.0.0", ">=", "1.0.0") === true
+ */
+export declare function compareSemver(v1: string, operator: SemverOp, v2: string): boolean;

package/dist/utils/semver.js

@@ -0,0 +1,55 @@
+/**
+ * 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("2.0.0", ">=", "1.0.0") === true
+ */
+export function compareSemver(v1, operator, v2) {
+    // - = 0 when versions are equal
+    // - > 0 if v1 > v2
+    // - < 0 if v2 > v1
+    let versionDiff = 0;
+    if (v1 === "latest") {
+        versionDiff = 1;
+    }
+    else {
+        if (/^[^\d]/.test(v1)) {
+            // biome-ignore lint/style/noParameterAssign:
+            v1 = v1.substring(1);
+        }
+        if (/^[^\d]/.test(v2)) {
+            // biome-ignore lint/style/noParameterAssign:
+            v2 = v2.substring(1);
+        }
+        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) {
+            versionDiff = major1 - major2;
+        }
+        else if (minor1 !== minor2) {
+            versionDiff = minor1 - minor2;
+        }
+        else if (patch1 !== patch2) {
+            versionDiff = patch1 - patch2;
+        }
+    }
+    switch (operator) {
+        case "=":
+            return versionDiff === 0;
+        case ">=":
+            return versionDiff >= 0;
+        case "<=":
+            return versionDiff <= 0;
+        case ">":
+            return versionDiff > 0;
+        case "<":
+            return versionDiff < 0;
+        default:
+            throw new Error(`Unsupported operator: ${operator}`);
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.9.15",
+  "version": "3.10.0",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -34,11 +34,11 @@
   ],
   "dependencies": {
     "@ast-grep/napi": "^0.40.5",
-    "@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",
-    "@aws-sdk/client-sqs": "^3.398.0",
+    "@aws-sdk/client-cloudfront": "3.984.0",
+    "@aws-sdk/client-dynamodb": "3.984.0",
+    "@aws-sdk/client-lambda": "3.984.0",
+    "@aws-sdk/client-s3": "3.984.0",
+    "@aws-sdk/client-sqs": "3.984.0",
     "@node-minify/core": "^8.0.6",
     "@node-minify/terser": "^8.0.6",
     "@tsconfig/node18": "^1.0.3",