@opennextjs/aws 3.4.1 → 3.5.0

package/dist/types/global.d.ts

@@ -2,7 +2,7 @@ import type { AsyncLocalStorage } from "node:async_hooks";
 import type { OutgoingHttpHeaders } from "node:http";
 import type { CDNInvalidationHandler, IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
 import type { DetachedPromiseRunner } from "../utils/promise";
-import type { OpenNextConfig } from "./open-next";
+import type { OpenNextConfig, WaitUntil } from "./open-next";
 export interface RequestData {
     geo?: {
         city?: string;
@@ -51,20 +51,28 @@ interface OpenNextRequestContext {
     pendingPromiseRunner: DetachedPromiseRunner;
     isISRRevalidation?: boolean;
     mergeHeadersPriority?: "middleware" | "handler";
+    lastModified?: number;
+    waitUntil?: WaitUntil;
 }
 declare global {
     /**
      * The cache adapter for incremental static regeneration.
-     * Only available in main functions or in the external middleware with `enableCacheInterception` set to `true`.
-     * Defined in `createMainHandler` or in `adapter/middleware.ts`.
+     * Only available in main functions and in the external middleware when `enableCacheInterception` is `true`.
+     * Defined in `createMainHandler` and in `adapters/middleware.ts`.
      */
     var incrementalCache: IncrementalCache;
     /**
      * The cache adapter for the tag cache.
-     * Only available in main functions, the initializationFunction or in the external middleware with `enableCacheInterception` set to `true`.
-     * Defined in `createMainHandler` or in `adapter/middleware.ts`.
+     * Only available in main functions and in the external middleware when `enableCacheInterception` is `true`.
+     * Defined in `createMainHandler` and in `adapters/middleware.ts`.
      */
     var tagCache: TagCache;
+    /**
+     * The queue that is used to handle ISR revalidation requests.
+     * Only available in main functions and in the external middleware when `enableCacheInterception` is `true`.
+     * Defined in `createMainHandler` and in `adapters/middleware.ts`.
+     */
+    var queue: Queue;
     /**
      * A boolean that indicates if the DynamoDB cache is disabled.
      * @deprecated This will be removed, use `globalThis.openNextConfig.dangerous?.disableTagCache` instead.
@@ -77,13 +85,6 @@ declare global {
      * Defined in esbuild banner for the cache adapter.
      */
     var disableIncrementalCache: boolean;
-    /**
-     * An object that contains the last modified time of the pages.
-     * Only available in main functions.
-     * TODO: Integrate this directly in the AsyncLocalStorage context
-     * Defined in `createMainHandler`.
-     */
-    var lastModified: Record<string, number>;
     /**
      * A boolean that indicates if Next is V15 or higher.
      * Only available in the cache adapter.
@@ -93,7 +94,7 @@ declare global {
     /**
      * A boolean that indicates if the runtime is Edge.
      * Only available in `edge` runtime functions (i.e. external middleware or function with edge runtime).
-     * Defined in the `edge-adapter.ts`.
+     * Defined in `adapters/edge-adapter.ts`.
      */
     var isEdgeRuntime: true;
     /**
@@ -105,40 +106,33 @@ declare global {
     /**
      * The fetch function that should be used to make requests during the execution of the function.
      * Used to bypass Next intercepting and caching the fetch calls. Only available in main functions.
-     * Defined in the `server-adapter.ts` and in `adapters/middleware.ts`.
+     * Defined in `adapters/server-adapter.ts` and in `adapters/middleware.ts`.
      */
     var internalFetch: typeof fetch;
     /**
      * The Open Next configuration object.
      * Available in all functions.
-     * Defined in the `createMainHandler` or in the `createGenericHandler`.
+     * Defined in `createMainHandler` and in the `createGenericHandler`.
      */
     var openNextConfig: Partial<OpenNextConfig>;
     /**
      * The name of the function that is currently being executed.
      * Only available in main functions.
-     * Defined in the `createMainHandler`.
+     * Defined in `createMainHandler`.
      */
     var fnName: string | undefined;
     /**
      * The unique identifier of the server.
      * Only available in main functions.
-     * Defined in the `createMainHandler`.
+     * Defined in `createMainHandler`.
      */
     var serverId: string;
     /**
      * The AsyncLocalStorage instance that is used to store the request context.
      * Only available in main, middleware and edge functions.
-     * TODO: should be available everywhere in the future.
-     * Defined in `requestHandler.ts`, `middleware.ts` and `edge-adapter.ts`.
+     * Defined in `requestHandler.ts`, `adapters/middleware.ts` and `adapters/edge-adapter.ts`.
      */
     var __openNextAls: AsyncLocalStorage<OpenNextRequestContext>;
-    /**
-     * The function that is used to run background tasks even after the response has been sent.
-     * This one is defined by the wrapper function as most of them don't need or support this feature.
-     * If not present, all the awaiting promises will be resolved before sending the response.
-     */
-    var openNextWaitUntil: ((promise: Promise<void>) => void) | undefined;
     /**
      * The entries object that contains the functions that are available in the function.
      * Only available in edge runtime functions.
@@ -173,12 +167,6 @@ declare global {
      * Defined in the esbuild banner.
      */
     var openNextVersion: string;
-    /**
-     * The queue that is used to handle ISR revalidation requests.
-     * Only available in main functions and in the external middleware with `enableCacheInterception` set to `true`.
-     * Defined in `createMainHandler` or in `adapter/middleware.ts`.
-     */
-    var queue: Queue;
     /**
      * The function that is used when resolving external rewrite requests.
      * Only available in main functions

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

@@ -152,4 +152,17 @@ export type Options = {
     isExternalRewrite?: boolean;
 };
 export type PluginHandler = (req: IncomingMessage, res: OpenNextNodeResponse, options: Options) => Promise<OpenNextNodeResponse | undefined>;
+export interface FunctionsConfigManifest {
+    version: number;
+    functions: Record<string, {
+        maxDuration?: number | undefined;
+        runtime?: "nodejs";
+        matchers?: Array<{
+            regexp: string;
+            originalSource: string;
+            has?: Rewrite["has"];
+            missing?: Rewrite["has"];
+        }>;
+    }>;
+}
 export {};

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

@@ -30,6 +30,7 @@ export interface StreamCreator {
     onWrite?: () => void;
     onFinish?: (length: number) => void;
 }
+export type WaitUntil = (promise: Promise<void>) => void;
 export interface DangerousOptions {
     /**
      * The tag cache is used for revalidateTags and revalidatePath.
@@ -59,7 +60,7 @@ export interface DangerousOptions {
 export type BaseOverride = {
     name: string;
 };
-export type LazyLoadedOverride<T extends BaseOverride> = () => Promise<T>;
+export type LazyLoadedOverride<T extends BaseOverride> = () => T | Promise<T>;
 export interface Origin {
     host: string;
     protocol: "http" | "https";
@@ -78,15 +79,16 @@ export interface RoutingResult {
     isExternalRewrite: boolean;
     origin: Origin | false;
     isISR: boolean;
-    initialPath: string;
+    initialURL: string;
+    locale?: string;
     resolvedRoutes: ResolvedRoute[];
 }
 export interface MiddlewareResult extends RoutingResult, BaseEventOrResult<"middleware"> {
 }
 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 IncludedTagCache = "dynamodb" | "dynamodb-lite" | "dynamodb-nextMode" | "fs-dev" | "dummy";
+export type IncludedImageLoader = "s3" | "s3-lite" | "host" | "fs-dev" | "dummy";
 export type IncludedOriginResolver = "pattern-env" | "dummy";
 export type IncludedWarmer = "aws-lambda" | "dummy";
 export type IncludedProxyExternalRequest = "node" | "fetch" | "dummy";
@@ -241,6 +243,11 @@ export interface OpenNextConfig {
      */
     middleware?: DefaultFunctionOptions & {
         external: true;
+        /**
+         * The runtime used by next for the middleware.
+         * @default "edge"
+         */
+        runtime?: "node" | "edge";
         /**
          * The override options for the middleware.
          * By default the lite override are used (.i.e. s3-lite, dynamodb-lite, sqs-lite)
@@ -295,7 +302,7 @@ export interface OpenNextConfig {
      * Supports only node runtime
      */
     initializationFunction?: DefaultFunctionOptions & {
-        tagCache?: "dynamodb" | LazyLoadedOverride<TagCache>;
+        tagCache?: IncludedTagCache | LazyLoadedOverride<TagCache>;
     };
     /**
      * Dangerous options. This break some functionnality but can be useful in some cases.

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,21 +32,83 @@ 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 = {
-    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>>>;
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     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.1",
+  "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": {