@opennextjs/aws 3.2.2 → 3.3.1

package/dist/overrides/proxyExternalRequest/node.js

@@ -1,7 +1,7 @@
-import { debug, error } from "node:console";
 import { request } from "node:https";
 import { Readable } from "node:stream";
-import { isBinaryContentType } from "../../adapters/binary";
+import { debug, error } from "../../adapters/logger";
+import { isBinaryContentType } from "../../utils/binary";
 function filterHeadersForProxy(headers) {
     const filteredHeaders = {};
     const disallowedHeaders = [

package/dist/overrides/queue/dummy.js

@@ -1,7 +1,8 @@
+import { FatalError } from "../../utils/error";
 const dummyQueue = {
     name: "dummy",
     send: async () => {
-        throw new Error("Dummy queue is not implemented");
+        throw new FatalError("Dummy queue is not implemented");
     },
 };
 export default dummyQueue;

package/dist/overrides/warmer/dummy.js

@@ -1,7 +1,8 @@
+import { FatalError } from "../../utils/error";
 const dummyWarmer = {
     name: "dummy",
     invoke: async (_) => {
-        throw new Error("Dummy warmer is not implemented");
+        throw new FatalError("Dummy warmer is not implemented");
     },
 };
 export default dummyWarmer;

package/dist/overrides/wrappers/aws-lambda-streaming.d.ts

@@ -2,6 +2,6 @@ import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
     wrapper: WrapperHandler;
     name: string;
-    supportStreaming: boolean;
+    supportStreaming: true;
 };
 export default _default;

package/dist/overrides/wrappers/aws-lambda-streaming.js

@@ -62,10 +62,6 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             responseStream.write(new Uint8Array(8));
             return compressedStream ?? responseStream;
         },
-        onWrite: () => {
-            // _hasWriten = true;
-        },
-        onFinish: () => { },
     };
     const response = await handler(internalEvent, streamCreator);
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;

package/dist/overrides/wrappers/aws-lambda.js

@@ -25,9 +25,6 @@ const handler = async (handler, converter) => async (event) => {
                 },
             });
         },
-        onFinish: () => {
-            // Do nothing
-        },
     };
     const response = await handler(internalEvent, fakeStream);
     return converter.convertTo(response, event);

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

@@ -0,0 +1,9 @@
+import type { InternalEvent, InternalResult, MiddlewareResult } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
+declare const _default: {
+    wrapper: WrapperHandler<InternalEvent, InternalResult | MiddlewareResult>;
+    name: string;
+    supportStreaming: true;
+    edgeRuntime: true;
+};
+export default _default;

package/dist/overrides/wrappers/{cloudflare.js → cloudflare-edge.js}

@@ -21,8 +21,8 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
     // 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)) {
-        const propValue = cfProperties[propName];
-        if (propValue !== null) {
+        const propValue = cfProperties?.[propName];
+        if (propValue != null) {
             internalEvent.headers[headerName] = propValue;
         }
     }
@@ -32,7 +32,7 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
 };
 export default {
     wrapper: handler,
-    name: "cloudflare",
+    name: "cloudflare-edge",
     supportStreaming: true,
     edgeRuntime: true,
 };

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

@@ -0,0 +1,8 @@
+import type { InternalEvent, InternalResult } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
+declare const _default: {
+    wrapper: WrapperHandler<InternalEvent, InternalResult>;
+    name: string;
+    supportStreaming: true;
+};
+export default _default;

package/dist/overrides/wrappers/cloudflare-node.js

@@ -0,0 +1,50 @@
+import { Writable } from "node:stream";
+// Response with null body status (101, 204, 205, or 304) cannot have a body.
+const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
+const handler = async (handler, converter) => async (request, env, ctx) => {
+    globalThis.process = process;
+    globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
+    // 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(request);
+    // TODO:
+    // The edge converter populate event.url with the url including the origin.
+    // This is required for middleware to keep track of the protocol (i.e. http with wrangler dev).
+    // However the server expects that the origin is not included.
+    const url = new URL(internalEvent.url);
+    internalEvent.url = url.href.slice(url.origin.length);
+    const { promise: promiseResponse, resolve: resolveResponse } = Promise.withResolvers();
+    const streamCreator = {
+        writeHeaders(prelude) {
+            const { statusCode, cookies, headers } = prelude;
+            const responseHeaders = new Headers(headers);
+            for (const cookie of cookies) {
+                responseHeaders.append("Set-Cookie", cookie);
+            }
+            const { readable, writable } = new TransformStream({
+                transform(chunk, controller) {
+                    controller.enqueue(Uint8Array.from(chunk.chunk ?? chunk));
+                },
+            });
+            const body = NULL_BODY_STATUSES.has(statusCode) ? null : readable;
+            const response = new Response(body, {
+                status: statusCode,
+                headers: responseHeaders,
+            });
+            resolveResponse(response);
+            return Writable.fromWeb(writable);
+        },
+    };
+    ctx.waitUntil(handler(internalEvent, streamCreator));
+    return promiseResponse;
+};
+export default {
+    wrapper: handler,
+    name: "cloudflare-node",
+    supportStreaming: true,
+};

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

@@ -1,7 +1,7 @@
 import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
     name: string;
-    handler: WrapperHandler;
-    supportStreaming: boolean;
+    wrapper: WrapperHandler;
+    supportStreaming: false;
 };
 export default _default;

package/dist/overrides/wrappers/dummy.js

@@ -1,6 +1,6 @@
 const dummyWrapper = async () => async () => undefined;
 export default {
     name: "dummy",
-    handler: dummyWrapper,
+    wrapper: dummyWrapper,
     supportStreaming: false,
 };

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

@@ -2,6 +2,6 @@ import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
     wrapper: WrapperHandler;
     name: string;
-    supportStreaming: boolean;
+    supportStreaming: true;
 };
 export default _default;

package/dist/overrides/wrappers/node.js

@@ -11,9 +11,6 @@ const wrapper = async (handler, converter) => {
                 res.uncork();
                 return res;
             },
-            onFinish: () => {
-                // Is it necessary to do something here?
-            },
         };
         if (internalEvent.rawPath === "/__health") {
             res.writeHead(200, {

package/dist/plugins/edge.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
 /**
  * @param opts.nextDir - The path to the .next directory
@@ -126,6 +126,8 @@ ${contents}
                 const PrerenderManifest = loadPrerenderManifest(nextDir);
                 const AppPathsManifestKeys = loadAppPathsManifestKeys(nextDir);
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
+                const AppPathsManifest = loadAppPathsManifest(nextDir);
+                const AppPathRoutesManifest = loadAppPathRoutesManifest(nextDir);
                 const contents = `
   import path from "node:path";
 
@@ -146,6 +148,9 @@ ${contents}
   export const PrerenderManifest = ${JSON.stringify(PrerenderManifest)};
   export const AppPathsManifestKeys = ${JSON.stringify(AppPathsManifestKeys)};
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
+  export const AppPathsManifest = ${JSON.stringify(AppPathsManifest)};
+  export const AppPathRoutesManifest = ${JSON.stringify(AppPathRoutesManifest)};
+
 
   process.env.NEXT_BUILD_ID = BuildId;
 `;

package/dist/plugins/resolve.js

@@ -43,10 +43,14 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
             build.onLoad({ filter: /core(\/|\\)resolve\.js/g }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
                 const overridesEntries = Object.entries(overrides ?? {});
-                for (const [overrideName, overrideValue] of overridesEntries) {
+                for (let [overrideName, overrideValue] of overridesEntries) {
                     if (!overrideValue) {
                         continue;
                     }
+                    if (overrideName === "wrapper" && overrideValue === "cloudflare") {
+                        // "cloudflare" is deprecated and replaced by "cloudflare-edge".
+                        overrideValue = "cloudflare-edge";
+                    }
                     const folder = nameToFolder[overrideName];
                     const defaultOverride = defaultOverrides[overrideName];
                     contents = contents.replace(`../overrides/${folder}/${defaultOverride}.js`, `../overrides/${folder}/${getOverrideOrDummy(overrideValue)}.js`);

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

@@ -1,4 +1,5 @@
 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";
 export type BaseEventOrResult<T extends string = string> = {
@@ -20,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.
@@ -56,8 +66,23 @@ export interface Origin {
     port?: number;
     customHeaders?: Record<string, string>;
 }
-export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare" | "dummy";
+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 RouteType = "route" | "page" | "app";
+export interface ResolvedRoute {
+    route: string;
+    type: RouteType;
+}
+export interface RoutingResult {
+    internalEvent: InternalEvent;
+    isExternalRewrite: boolean;
+    origin: Origin | false;
+    isISR: boolean;
+    initialPath: string;
+    resolvedRoutes: ResolvedRoute[];
+}
+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";

package/dist/types/overrides.d.ts

@@ -1,7 +1,6 @@
 import type { Readable } from "node:stream";
-import type { StreamCreator } from "../http/index";
 import type { Meta } from "./cache";
-import type { BaseEventOrResult, BaseOverride, InternalEvent, InternalResult, Origin } from "./open-next";
+import type { BaseEventOrResult, BaseOverride, InternalEvent, InternalResult, Origin, StreamCreator } from "./open-next";
 export interface QueueMessage {
     MessageDeduplicationId: string;
     MessageBody: {
@@ -14,7 +13,7 @@ export interface Queue {
     send(message: QueueMessage): Promise<void>;
     name: string;
 }
-export type S3CachedFile = {
+export type CachedFile = {
     type: "redirect";
     props?: Object;
     meta?: Meta;
@@ -33,12 +32,12 @@ export type S3CachedFile = {
     body: string;
     meta?: Meta;
 };
-export type S3FetchCache = Object;
+export type FetchCache = Object;
 export type WithLastModified<T> = {
     lastModified?: number;
     value?: T;
 };
-export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? S3FetchCache : S3CachedFile) & {
+export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? FetchCache : CachedFile) & {
     revalidate?: number | false;
 };
 export type IncrementalCache = {

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/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.2.2",
+  "version": "3.3.1",
   "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": "^5.6.3"
+    "typescript": "5.6.3"
   },
   "bugs": {
     "url": "https://github.com/opennextjs/opennextjs-aws/issues"

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

@@ -1,12 +0,0 @@
-import type { InternalEvent, InternalResult } from "../../types/open-next";
-import type { WrapperHandler } from "../../types/overrides";
-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;