@opennextjs/aws 3.4.2 → 3.5.0

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, ResolvedRoute, StreamCreator } from "./open-next";
+import type { BaseEventOrResult, BaseOverride, InternalEvent, InternalResult, Origin, ResolvedRoute, StreamCreator, WaitUntil } from "./open-next";
 export interface QueueMessage {
     MessageDeduplicationId: string;
     MessageBody: {
@@ -32,12 +32,24 @@ export type CachedFile = {
     body: string;
     meta?: Meta;
 };
-export type FetchCache = Object;
+export type CachedFetchValue = {
+    kind: "FETCH";
+    data: {
+        headers: {
+            [k: string]: string;
+        };
+        body: string;
+        url: string;
+        status?: number;
+        tags?: string[];
+    };
+    tags?: string[];
+};
 export type WithLastModified<T> = {
     lastModified?: number;
     value?: T;
 };
-export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? FetchCache : CachedFile) & {
+export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? CachedFetchValue : CachedFile) & {
     revalidate?: number | false;
 };
 export type IncrementalCache = {
@@ -46,7 +58,57 @@ export type IncrementalCache = {
     delete(key: string): Promise<void>;
     name: string;
 };
-export type TagCache = {
+type BaseTagCache = {
+    name: string;
+};
+/**
+ * On get :
+We have to check for every tag (after reading the incremental cache) that they have not been revalidated.
+
+In DynamoDB, this would require 1 GetItem per tag (including internal one), more realistically 1 BatchGetItem per get (In terms of pricing, it would be billed as multiple single GetItem)
+
+On set :
+We don't have to do anything here
+
+On revalidateTag for each tag :
+We have to update a single entry for this tag
+
+Pros :
+- No need to prepopulate DDB
+- Very little write
+
+Cons :
+- Might be slower on read
+- 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 NextModeTagCache = BaseTagCache & {
+    mode: "nextMode";
+    hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
+    writeTags(tags: string[]): Promise<void>;
+    getPathsByTags?: (tags: string[]) => Promise<string[]>;
+};
+/**
+ * On get :
+We just check for the cache key in the tag cache. If it has been revalidated we just return null, otherwise we continue
+
+On set :
+We have to write both the incremental cache and check the tag cache for non existing tag/key combination. For non existing tag/key combination, we have to add them
+
+On revalidateTag for each tag :
+We have to update every possible combination for the requested tag
+
+Pros :
+- Very fast on read
+- Only one query per get (On DynamoDB it's a lot cheaper)
+- Can allow for automatic cdn invalidation on revalidateTag
+
+Cons :
+- Lots of write on set and revalidateTag
+- Needs to be prepopulated at build time to work properly
+ */
+export type OriginalTagCache = BaseTagCache & {
+    mode?: "original";
     getByTag(tag: string): Promise<string[]>;
     getByPath(path: string): Promise<string[]>;
     getLastModified(path: string, lastModified?: number): Promise<number>;
@@ -55,15 +117,19 @@ export type TagCache = {
         path: string;
         revalidatedAt?: number;
     }[]): Promise<void>;
-    name: string;
 };
+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>;
 export type Wrapper<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = BaseOverride & {
     wrapper: WrapperHandler<E, R>;
     supportStreaming: boolean;
     edgeRuntime?: boolean;
 };
-export type OpenNextHandler<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = (event: E, responseStream?: StreamCreator) => Promise<R>;
+export type OpenNextHandlerOptions = {
+    streamCreator?: StreamCreator;
+    waitUntil?: WaitUntil;
+};
+export type OpenNextHandler<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = (event: E, options?: OpenNextHandlerOptions) => Promise<R>;
 export type Converter<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = BaseOverride & {
     convertFrom: (event: any) => Promise<E>;
     convertTo: (result: R, originalRequest?: any) => Promise<any>;

package/dist/utils/cache.d.ts

@@ -0,0 +1,3 @@
+import type { CacheValue, WithLastModified } from "../types/overrides";
+export declare function hasBeenRevalidated(key: string, tags: string[], cacheEntry: WithLastModified<CacheValue<any>>): Promise<boolean>;
+export declare function getTagsFromValue(value?: CacheValue<false>): string[];

package/dist/utils/cache.js

@@ -0,0 +1,32 @@
+export async function hasBeenRevalidated(key, tags, cacheEntry) {
+    if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+        return false;
+    }
+    const value = cacheEntry.value;
+    if (!value) {
+        // We should never reach this point
+        return true;
+    }
+    if ("type" in cacheEntry && cacheEntry.type === "page") {
+        return false;
+    }
+    const lastModified = cacheEntry.lastModified ?? Date.now();
+    if (globalThis.tagCache.mode === "nextMode") {
+        return await globalThis.tagCache.hasBeenRevalidated(tags, lastModified);
+    }
+    // TODO: refactor this, we should introduce a new method in the tagCache interface so that both implementations use hasBeenRevalidated
+    const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
+    return _lastModified === -1;
+}
+export function getTagsFromValue(value) {
+    if (!value) {
+        return [];
+    }
+    // The try catch is necessary for older version of next.js that may fail on this
+    try {
+        return value.meta?.headers?.["x-next-cache-tags"]?.split(",") ?? [];
+    }
+    catch (e) {
+        return [];
+    }
+}

package/dist/utils/promise.d.ts

@@ -1,3 +1,4 @@
+import type { WaitUntil } from "../types/open-next";
 /**
  * A `Promise.withResolvers` implementation that exposes the `resolve` and
  * `reject` functions on a `Promise`.
@@ -16,6 +17,7 @@ export declare class DetachedPromiseRunner {
     add<T>(promise: Promise<T>): void;
     await(): Promise<void>;
 }
-export declare function runWithOpenNextRequestContext<T>({ isISRRevalidation }: {
+export declare function runWithOpenNextRequestContext<T>({ isISRRevalidation, waitUntil, }: {
     isISRRevalidation: boolean;
+    waitUntil?: WaitUntil;
 }, fn: () => Promise<T>): Promise<T>;

package/dist/utils/promise.js

@@ -47,23 +47,22 @@ export class DetachedPromiseRunner {
     }
 }
 async function awaitAllDetachedPromise() {
-    const promisesToAwait = globalThis.__openNextAls.getStore()?.pendingPromiseRunner.await() ??
-        Promise.resolve();
-    if (globalThis.openNextWaitUntil) {
-        globalThis.openNextWaitUntil(promisesToAwait);
+    const store = globalThis.__openNextAls.getStore();
+    const promisesToAwait = store?.pendingPromiseRunner.await() ?? Promise.resolve();
+    if (store?.waitUntil) {
+        store.waitUntil(promisesToAwait);
         return;
     }
     await promisesToAwait;
 }
 function provideNextAfterProvider() {
-    /** This should be considered unstable until `unstable_after` is stablized. */
     const NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for("@next/request-context");
     // This is needed by some lib that relies on the vercel request context to properly await stuff.
     // Remove this when vercel builder is updated to provide '@next/request-context'.
     const VERCEL_REQUEST_CONTEXT_SYMBOL = Symbol.for("@vercel/request-context");
-    const openNextStoreContext = globalThis.__openNextAls.getStore();
-    const waitUntil = globalThis.openNextWaitUntil ??
-        ((promise) => openNextStoreContext?.pendingPromiseRunner.add(promise));
+    const store = globalThis.__openNextAls.getStore();
+    const waitUntil = store?.waitUntil ??
+        ((promise) => store?.pendingPromiseRunner.add(promise));
     const nextAfterContext = {
         get: () => ({
             waitUntil,
@@ -78,15 +77,23 @@ function provideNextAfterProvider() {
         globalThis[VERCEL_REQUEST_CONTEXT_SYMBOL] = nextAfterContext;
     }
 }
-export function runWithOpenNextRequestContext({ isISRRevalidation }, fn) {
+export function runWithOpenNextRequestContext({ isISRRevalidation, waitUntil, }, fn) {
     return globalThis.__openNextAls.run({
         requestId: Math.random().toString(36),
         pendingPromiseRunner: new DetachedPromiseRunner(),
         isISRRevalidation,
+        waitUntil,
     }, async () => {
         provideNextAfterProvider();
-        const result = await fn();
-        await awaitAllDetachedPromise();
+        let result;
+        try {
+            result = await fn();
+            // We always await all detached promises before returning the result
+            // However we don't want to catch errors here, we want to let the parent handle it
+        }
+        finally {
+            await awaitAllDetachedPromise();
+        }
         return result;
     });
 }

package/dist/utils/regex.js

@@ -10,7 +10,7 @@
  * getCrossPlatformPathRegex(String.raw`\./middleware\.(mjs|cjs)`, { escape: false })
  * ```
  */
-export function getCrossPlatformPathRegex(regex, { escape: shouldEscape = true, flags = "g" } = {}) {
+export function getCrossPlatformPathRegex(regex, { escape: shouldEscape = true, flags = "" } = {}) {
     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.4.2",
+  "version": "3.5.0",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -13,7 +13,10 @@
   "homepage": "https://opennext.js.org/aws",
   "main": "./dist/index.js",
   "exports": {
-    "./*": "./dist/*"
+    "./*": {
+      "default": "./dist/*",
+      "types": "./dist/*.d.ts"
+    }
   },
   "typesVersions": {
     "*": {
@@ -35,7 +38,6 @@
     "@aws-sdk/client-lambda": "^3.398.0",
     "@aws-sdk/client-s3": "^3.398.0",
     "@aws-sdk/client-sqs": "^3.398.0",
-    "@esbuild-plugins/node-resolve": "0.2.2",
     "@node-minify/core": "^8.0.6",
     "@node-minify/terser": "^8.0.6",
     "@tsconfig/node18": "^1.0.1",
@@ -44,7 +46,6 @@
     "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": {