@opennextjs/aws 3.2.1 → 3.3.0

package/dist/types/global.d.ts

@@ -0,0 +1,188 @@
+import type { AsyncLocalStorage } from "node:async_hooks";
+import type { OutgoingHttpHeaders } from "node:http";
+import type { IncrementalCache, ProxyExternalRequest, Queue, TagCache } from "./overrides";
+import type { DetachedPromiseRunner } from "../utils/promise";
+import type { OpenNextConfig } from "./open-next";
+export interface RequestData {
+    geo?: {
+        city?: string;
+        country?: string;
+        region?: string;
+        latitude?: string;
+        longitude?: string;
+    };
+    headers: OutgoingHttpHeaders;
+    ip?: string;
+    method: string;
+    nextConfig?: {
+        basePath?: string;
+        i18n?: any;
+        trailingSlash?: boolean;
+    };
+    page?: {
+        name?: string;
+        params?: {
+            [key: string]: string | string[];
+        };
+    };
+    url: string;
+    body?: ReadableStream<Uint8Array>;
+    signal: AbortSignal;
+}
+interface Entries {
+    [k: string]: {
+        default: (props: {
+            page: string;
+            request: RequestData;
+        }) => Promise<{
+            response: Response;
+            waitUntil: Promise<void>;
+        }>;
+    };
+}
+export interface EdgeRoute {
+    name: string;
+    page: string;
+    regex: string[];
+}
+interface OpenNextRequestContext {
+    requestId: string;
+    pendingPromiseRunner: DetachedPromiseRunner;
+    isISRRevalidation?: boolean;
+    mergeHeadersPriority?: "middleware" | "handler";
+}
+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`.
+     */
+    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`.
+     */
+    var tagCache: TagCache;
+    /**
+     * A boolean that indicates if the DynamoDB cache is disabled.
+     * TODO: Remove this, we already have access to the config file
+     * 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
+     * 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.
+     * Defined in the esbuild banner for the cache adapter.
+     */
+    var isNextAfter15: boolean;
+    /**
+     * 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`.
+     */
+    var isEdgeRuntime: true;
+    /**
+     * A boolean that indicates if we are running in debug mode.
+     * Available in all functions.
+     * Defined in the esbuild banner.
+     */
+    var openNextDebug: boolean;
+    /**
+     * 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`.
+     */
+    var internalFetch: typeof fetch;
+    /**
+     * The Open Next configuration object.
+     * Available in all functions.
+     * Defined in the `createMainHandler` or 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`.
+     */
+    var fnName: string | undefined;
+    /**
+     * The unique identifier of the server.
+     * Only available in main functions.
+     * Defined in the `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`.
+     */
+    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.
+     * Defined in the esbuild edge plugin.
+     */
+    var _ENTRIES: Entries;
+    /**
+     * The routes object that contains the routes that are available in the function.
+     * Only available in edge runtime functions.
+     * Defined in the esbuild edge plugin.
+     */
+    var _ROUTES: EdgeRoute[];
+    /**
+     * A map that is used in the edge runtime.
+     * Only available in edge runtime functions.
+     */
+    var __storage__: Map<unknown, unknown>;
+    /**
+     * AsyncContext available globally in the edge runtime.
+     * Only available in edge runtime functions.
+     */
+    var AsyncContext: any;
+    /**
+     * AsyncLocalStorage available globally in the edge runtime.
+     * Only available in edge runtime functions.
+     * Defined in createEdgeBundle.
+     */
+    var AsyncLocalStorage: any;
+    /**
+     * The version of the Open Next runtime.
+     * Available everywhere.
+     * 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
+     * Defined in `createMainHandler`.
+     */
+    var proxyExternalRequest: ProxyExternalRequest;
+}
+export {};

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

@@ -151,7 +151,5 @@ export type Options = {
     buildId: string;
     isExternalRewrite?: boolean;
 };
-export interface PluginHandler {
-    (req: IncomingMessage, res: OpenNextNodeResponse, options: Options): Promise<OpenNextNodeResponse | undefined>;
-}
+export type PluginHandler = (req: IncomingMessage, res: OpenNextNodeResponse, options: Options) => Promise<OpenNextNodeResponse | undefined>;
 export {};

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

@@ -1,14 +1,7 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Readable } from "node:stream";
 import type { ReadableStream } from "node:stream/web";
-import type { StreamCreator } from "../http/index.js";
+import type { Writable } from "node:stream";
 import type { WarmerEvent, WarmerResponse } from "../adapters/warmer-function";
-import type { IncrementalCache } from "../overrides/incrementalCache/types";
-import type { Queue } from "../overrides/queue/types";
-import type { TagCache } from "../overrides/tagCache/types";
+import type { Converter, ImageLoader, IncrementalCache, OriginResolver, ProxyExternalRequest, Queue, TagCache, Warmer, Wrapper } from "./overrides";
 export type BaseEventOrResult<T extends string = string> = {
     type: T;
 };
@@ -28,6 +21,15 @@ export type InternalResult = {
     body: ReadableStream;
     isBase64Encoded: boolean;
 } & BaseEventOrResult<"core">;
+export interface StreamCreator {
+    writeHeaders(prelude: {
+        statusCode: number;
+        cookies: string[];
+        headers: Record<string, string>;
+    }): Writable;
+    onWrite?: () => void;
+    onFinish?: (length: number) => void;
+}
 export interface DangerousOptions {
     /**
      * The tag cache is used for revalidateTags and revalidatePath.
@@ -58,44 +60,29 @@ export type BaseOverride = {
     name: string;
 };
 export type LazyLoadedOverride<T extends BaseOverride> = () => Promise<T>;
-export type OpenNextHandler<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = (event: E, responseStream?: StreamCreator) => 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>;
-};
-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 Warmer = BaseOverride & {
-    invoke: (warmerId: string) => Promise<void>;
-};
-export type ImageLoader = BaseOverride & {
-    load: (url: string) => Promise<{
-        body?: Readable;
-        contentType?: string;
-        cacheControl?: string;
-    }>;
-};
 export interface Origin {
     host: string;
     protocol: "http" | "https";
     port?: number;
     customHeaders?: Record<string, string>;
 }
-export type OriginResolver = BaseOverride & {
-    resolve: (path: string) => Promise<Origin | false>;
-};
-export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare";
+export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "dummy";
 export type IncludedConverter = "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront" | "edge" | "node" | "sqs-revalidate" | "dummy";
-export type IncludedQueue = "sqs" | "sqs-lite";
-export type IncludedIncrementalCache = "s3" | "s3-lite";
-export type IncludedTagCache = "dynamodb" | "dynamodb-lite";
-export type IncludedImageLoader = "s3" | "host";
-export type IncludedOriginResolver = "pattern-env";
-export type IncludedWarmer = "aws-lambda";
+export interface RoutingResult {
+    internalEvent: InternalEvent;
+    isExternalRewrite: boolean;
+    origin: Origin | false;
+    isISR: boolean;
+}
+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 IncludedOriginResolver = "pattern-env" | "dummy";
+export type IncludedWarmer = "aws-lambda" | "dummy";
+export type IncludedProxyExternalRequest = "node" | "fetch" | "dummy";
 export interface DefaultOverrideOptions<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> {
     /**
      * This is the main entrypoint of your app.
@@ -130,6 +117,11 @@ export interface OverrideOptions extends DefaultOverrideOptions {
      * @default "sqs"
      */
     queue?: IncludedQueue | LazyLoadedOverride<Queue>;
+    /**
+     * Add possibility to override the default proxy for external rewrite
+     * @default "node"
+     */
+    proxyExternalRequest?: IncludedProxyExternalRequest | LazyLoadedOverride<ProxyExternalRequest>;
 }
 export interface InstallOptions {
     /**
@@ -258,7 +250,7 @@ export interface OpenNextConfig {
      * @default undefined
      */
     warmer?: DefaultFunctionOptions<WarmerEvent, WarmerResponse> & {
-        invokeFunction: IncludedWarmer | LazyLoadedOverride<Warmer>;
+        invokeFunction?: IncludedWarmer | LazyLoadedOverride<Warmer>;
     };
     /**
      * Override the default revalidate function

package/dist/types/overrides.d.ts

@@ -0,0 +1,86 @@
+import type { Readable } from "node:stream";
+import type { Meta } from "./cache";
+import type { BaseEventOrResult, BaseOverride, InternalEvent, InternalResult, Origin, StreamCreator } from "./open-next";
+export interface QueueMessage {
+    MessageDeduplicationId: string;
+    MessageBody: {
+        host: string;
+        url: string;
+    };
+    MessageGroupId: string;
+}
+export interface Queue {
+    send(message: QueueMessage): Promise<void>;
+    name: string;
+}
+export type S3CachedFile = {
+    type: "redirect";
+    props?: Object;
+    meta?: Meta;
+} | {
+    type: "page";
+    html: string;
+    json: Object;
+    meta?: Meta;
+} | {
+    type: "app";
+    html: string;
+    rsc: string;
+    meta?: Meta;
+} | {
+    type: "route";
+    body: string;
+    meta?: Meta;
+};
+export type S3FetchCache = Object;
+export type WithLastModified<T> = {
+    lastModified?: number;
+    value?: T;
+};
+export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? S3FetchCache : S3CachedFile) & {
+    revalidate?: number | false;
+};
+export type IncrementalCache = {
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>>>;
+    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    delete(key: string): Promise<void>;
+    name: string;
+};
+export type TagCache = {
+    getByTag(tag: string): Promise<string[]>;
+    getByPath(path: string): Promise<string[]>;
+    getLastModified(path: string, lastModified?: number): Promise<number>;
+    writeTags(tags: {
+        tag: string;
+        path: string;
+        revalidatedAt?: number;
+    }[]): Promise<void>;
+    name: string;
+};
+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 Converter<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = BaseOverride & {
+    convertFrom: (event: any) => Promise<E>;
+    convertTo: (result: R, originalRequest?: any) => Promise<any>;
+};
+export type Warmer = BaseOverride & {
+    invoke: (warmerId: string) => Promise<void>;
+};
+export type ImageLoader = BaseOverride & {
+    load: (url: string) => Promise<{
+        body?: Readable;
+        contentType?: string;
+        cacheControl?: string;
+    }>;
+};
+export type OriginResolver = BaseOverride & {
+    resolve: (path: string) => Promise<Origin | false>;
+};
+export type ProxyExternalRequest = BaseOverride & {
+    proxy: (event: InternalEvent) => Promise<InternalResult>;
+};

package/dist/{adapters → utils}/binary.js

@@ -27,6 +27,7 @@ const commonBinaryMimeTypes = new Set([
     "audio/3gpp",
     "audio/aac",
     "audio/basic",
+    "audio/flac",
     "audio/mpeg",
     "audio/ogg",
     "audio/wavaudio/webm",

package/dist/utils/error.d.ts

@@ -21,3 +21,4 @@ export declare class FatalError extends Error implements BaseOpenNextError {
     readonly logLevel = 2;
     constructor(message: string);
 }
+export declare function isOpenNextError(e: any): e is BaseOpenNextError & Error;

package/dist/utils/error.js

@@ -30,3 +30,11 @@ export class FatalError extends Error {
         this.name = "FatalError";
     }
 }
+export function isOpenNextError(e) {
+    try {
+        return "__openNextInternal" in e;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/promise.d.ts

@@ -16,3 +16,6 @@ export declare class DetachedPromiseRunner {
     add<T>(promise: Promise<T>): void;
     await(): Promise<void>;
 }
+export declare function runWithOpenNextRequestContext<T>({ isISRRevalidation }: {
+    isISRRevalidation: boolean;
+}, fn: () => Promise<T>): Promise<T>;

package/dist/utils/promise.js

@@ -46,3 +46,47 @@ export class DetachedPromiseRunner {
         });
     }
 }
+async function awaitAllDetachedPromise() {
+    const promisesToAwait = globalThis.__openNextAls.getStore()?.pendingPromiseRunner.await() ??
+        Promise.resolve();
+    if (globalThis.openNextWaitUntil) {
+        globalThis.openNextWaitUntil(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 nextAfterContext = {
+        get: () => ({
+            waitUntil,
+        }),
+    };
+    //@ts-expect-error
+    globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = nextAfterContext;
+    // We probably want to avoid providing this everytime since some lib may incorrectly think they are running in Vercel
+    // It may break stuff, but at the same time it will allow libs like `@vercel/otel` to work as expected
+    if (process.env.EMULATE_VERCEL_REQUEST_CONTEXT) {
+        //@ts-expect-error
+        globalThis[VERCEL_REQUEST_CONTEXT_SYMBOL] = nextAfterContext;
+    }
+}
+export function runWithOpenNextRequestContext({ isISRRevalidation }, fn) {
+    return globalThis.__openNextAls.run({
+        requestId: Math.random().toString(36),
+        pendingPromiseRunner: new DetachedPromiseRunner(),
+        isISRRevalidation,
+    }, async () => {
+        provideNextAfterProvider();
+        const result = await fn();
+        await awaitAllDetachedPromise();
+        return result;
+    });
+}

package/dist/utils/stream.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { ReadableStream } from "node:stream/web";
 export declare function fromReadableStream(stream: ReadableStream<Uint8Array>, base64?: boolean): Promise<string>;
 export declare function toReadableStream(value: string, isBase64?: boolean): ReadableStream;

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -47,9 +47,9 @@
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.109",
-    "@types/node": "^18.16.1",
+    "@types/node": "20.17.6",
     "tsc-alias": "^1.8.8",
-    "typescript": "^4.9.3"
+    "typescript": "5.6.3"
   },
   "bugs": {
     "url": "https://github.com/opennextjs/opennextjs-aws/issues"

package/dist/overrides/incrementalCache/types.d.ts

@@ -1,34 +0,0 @@
-import type { Meta } from "../../types/cache";
-export type S3CachedFile = {
-    type: "redirect";
-    props?: Object;
-    meta?: Meta;
-} | {
-    type: "page";
-    html: string;
-    json: Object;
-    meta?: Meta;
-} | {
-    type: "app";
-    html: string;
-    rsc: string;
-    meta?: Meta;
-} | {
-    type: "route";
-    body: string;
-    meta?: Meta;
-};
-export type S3FetchCache = Object;
-export type WithLastModified<T> = {
-    lastModified?: number;
-    value?: T;
-};
-export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? S3FetchCache : S3CachedFile) & {
-    revalidate?: number | false;
-};
-export type IncrementalCache = {
-    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>>>;
-    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
-    delete(key: string): Promise<void>;
-    name: string;
-};

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

@@ -1,12 +0,0 @@
-export interface QueueMessage {
-    MessageDeduplicationId: string;
-    MessageBody: {
-        host: string;
-        url: string;
-    };
-    MessageGroupId: string;
-}
-export interface Queue {
-    send(message: QueueMessage): Promise<void>;
-    name: string;
-}

package/dist/overrides/tagCache/types.d.ts

@@ -1,11 +0,0 @@
-export type TagCache = {
-    getByTag(tag: string): Promise<string[]>;
-    getByPath(path: string): Promise<string[]>;
-    getLastModified(path: string, lastModified?: number): Promise<number>;
-    writeTags(tags: {
-        tag: string;
-        path: string;
-        revalidatedAt?: number;
-    }[]): Promise<void>;
-    name: string;
-};

package/dist/overrides/tagCache/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,11 +0,0 @@
-import type { InternalEvent, InternalResult, WrapperHandler } from "../../types/open-next";
-import type { MiddlewareOutputEvent } from "../../core/routingHandler";
-declare const _default: {
-    wrapper: WrapperHandler<InternalEvent, InternalResult | ({
-        type: "middleware";
-    } & MiddlewareOutputEvent)>;
-    name: string;
-    supportStreaming: boolean;
-    edgeRuntime: boolean;
-};
-export default _default;

package/dist/overrides/wrappers/cloudflare.js

@@ -1,20 +0,0 @@
-const handler = async (handler, converter) => async (event, env) => {
-    globalThis.process = process;
-    // Set the environment variables
-    // Cloudflare suggests to not override the process.env object but instead apply the values to it
-    for (const [key, value] of Object.entries(env)) {
-        if (typeof value === "string") {
-            process.env[key] = value;
-        }
-    }
-    const internalEvent = await converter.convertFrom(event);
-    const response = await handler(internalEvent);
-    const result = await converter.convertTo(response);
-    return result;
-};
-export default {
-    wrapper: handler,
-    name: "cloudflare",
-    supportStreaming: true,
-    edgeRuntime: true,
-};