@opennextjs/aws 3.2.1 → 3.3.0

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

@@ -1,3 +1,3 @@
-import type { Queue } from "./types";
+import type { Queue } from "../../types/overrides";
 declare const dummyQueue: Queue;
 export default dummyQueue;

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/queue/sqs-lite.d.ts

@@ -1,3 +1,3 @@
-import type { Queue } from "./types";
+import type { Queue } from "../../types/overrides";
 declare const queue: Queue;
 export default queue;

package/dist/overrides/queue/sqs-lite.js

@@ -7,15 +7,13 @@ const getAwsClient = () => {
     if (awsClient) {
         return awsClient;
     }
-    else {
-        awsClient = new AwsClient({
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            sessionToken: process.env.AWS_SESSION_TOKEN,
-            region: process.env.REVALIDATION_QUEUE_REGION,
-        });
-        return awsClient;
-    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: process.env.REVALIDATION_QUEUE_REGION,
+    });
+    return awsClient;
 };
 const awsFetch = (body) => {
     const { REVALIDATION_QUEUE_REGION } = process.env;

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

@@ -1,3 +1,3 @@
-import type { Queue } from "./types";
+import type { Queue } from "../../types/overrides";
 declare const queue: Queue;
 export default queue;

package/dist/overrides/queue/sqs.js

@@ -1,4 +1,4 @@
-import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
 import { awsLogger } from "../../adapters/logger";
 // Expected environment variables
 const { REVALIDATION_QUEUE_REGION, REVALIDATION_QUEUE_URL } = process.env;

package/dist/overrides/tagCache/constants.js

@@ -7,10 +7,10 @@ const DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY = 4;
 export const getDynamoBatchWriteCommandConcurrency = () => {
     const dynamoBatchWriteCommandConcurrencyFromEnv = process.env.DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;
     const parsedDynamoBatchWriteCommandConcurrencyFromEnv = dynamoBatchWriteCommandConcurrencyFromEnv
-        ? parseInt(dynamoBatchWriteCommandConcurrencyFromEnv)
+        ? Number.parseInt(dynamoBatchWriteCommandConcurrencyFromEnv)
         : undefined;
     if (parsedDynamoBatchWriteCommandConcurrencyFromEnv &&
-        !isNaN(parsedDynamoBatchWriteCommandConcurrencyFromEnv)) {
+        !Number.isNaN(parsedDynamoBatchWriteCommandConcurrencyFromEnv)) {
         return parsedDynamoBatchWriteCommandConcurrencyFromEnv;
     }
     return DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;

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

@@ -1,3 +1,3 @@
-import type { TagCache } from "./types";
+import type { TagCache } from "../../types/overrides";
 declare const dummyTagCache: TagCache;
 export default dummyTagCache;

package/dist/overrides/tagCache/dynamodb-lite.d.ts

@@ -1,3 +1,3 @@
-import type { TagCache } from "./types";
+import type { TagCache } from "../../types/overrides";
 declare const tagCache: TagCache;
 export default tagCache;

package/dist/overrides/tagCache/dynamodb-lite.js

@@ -1,27 +1,25 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import path from "node:path";
 import { AwsClient } from "aws4fetch";
-import path from "path";
 import { RecoverableError } from "../../utils/error";
 import { customFetchClient } from "../../utils/fetch";
 import { debug, error } from "../../adapters/logger";
 import { chunk, parseNumberFromEnv } from "../../adapters/util";
-import { getDynamoBatchWriteCommandConcurrency, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, } from "./constants";
+import { MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, getDynamoBatchWriteCommandConcurrency, } from "./constants";
 let awsClient = null;
 const getAwsClient = () => {
     const { CACHE_BUCKET_REGION } = process.env;
     if (awsClient) {
         return awsClient;
     }
-    else {
-        awsClient = new AwsClient({
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            sessionToken: process.env.AWS_SESSION_TOKEN,
-            region: CACHE_BUCKET_REGION,
-            retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
-        });
-        return awsClient;
-    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: CACHE_BUCKET_REGION,
+        retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
+    });
+    return awsClient;
 };
 const awsFetch = (body, type = "query") => {
     const { CACHE_BUCKET_REGION } = process.env;

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

@@ -1,3 +1,3 @@
-import type { TagCache } from "./types";
+import type { TagCache } from "../../types/overrides";
 declare const tagCache: TagCache;
 export default tagCache;

package/dist/overrides/tagCache/dynamodb.js

@@ -1,8 +1,8 @@
+import path from "node:path";
 import { BatchWriteItemCommand, DynamoDBClient, QueryCommand, } from "@aws-sdk/client-dynamodb";
-import path from "path";
 import { awsLogger, debug, error } from "../../adapters/logger";
 import { chunk, parseNumberFromEnv } from "../../adapters/util";
-import { getDynamoBatchWriteCommandConcurrency, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, } from "./constants";
+import { MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, getDynamoBatchWriteCommandConcurrency, } from "./constants";
 const { CACHE_BUCKET_REGION, CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
 function parseDynamoClientConfigFromEnv() {
     return {

package/dist/overrides/warmer/aws-lambda.d.ts

@@ -1,3 +1,3 @@
-import type { Warmer } from "../../types/open-next";
+import type { Warmer } from "../../types/overrides";
 declare const lambdaWarmerInvoke: Warmer;
 export default lambdaWarmerInvoke;

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

@@ -1,3 +1,3 @@
-import type { Warmer } from "../../types/open-next";
+import type { Warmer } from "../../types/overrides";
 declare const dummyWarmer: Warmer;
 export default dummyWarmer;

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

@@ -1,7 +1,7 @@
-import type { WrapperHandler } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
-    wrapper: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
+    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.d.ts

@@ -1,6 +1,6 @@
-import type { WrapperHandler } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
-    wrapper: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
+    wrapper: WrapperHandler;
     name: string;
     supportStreaming: boolean;
 };

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-edge.js

@@ -0,0 +1,38 @@
+const cfPropNameToHeaderName = {
+    city: "x-open-next-city",
+    country: "x-open-next-country",
+    regionCode: "x-open-next-region",
+    latitude: "x-open-next-latitude",
+    longitude: "x-open-next-longitude",
+};
+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);
+    // Retrieve geo information from the cloudflare request
+    // See https://developers.cloudflare.com/workers/runtime-apis/request
+    // 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) {
+            internalEvent.headers[headerName] = propValue;
+        }
+    }
+    const response = await handler(internalEvent);
+    const result = await converter.convertTo(response);
+    return result;
+};
+export default {
+    wrapper: handler,
+    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,47 @@
+import { Writable } from "node:stream";
+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 response = new Response(readable, {
+                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/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
     name: string;
-    handler: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
-    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

@@ -1,7 +1,7 @@
-import type { WrapperHandler } from "../../types/open-next";
+import type { WrapperHandler } from "../../types/overrides";
 declare const _default: {
-    wrapper: WrapperHandler<import("../../types/open-next").InternalEvent, import("../../types/open-next").InternalResult>;
+    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, {
@@ -28,9 +25,9 @@ const wrapper = async (handler, converter) => {
     await new Promise((resolve) => {
         server.on("listening", () => {
             const cleanup = (code) => {
-                debug(`Closing server`);
+                debug("Closing server");
                 server.close(() => {
-                    debug(`Server closed`);
+                    debug("Server closed");
                     process.exit(code);
                 });
             };
@@ -41,7 +38,7 @@ const wrapper = async (handler, converter) => {
             process.on("SIGTERM", () => cleanup(0));
             resolve();
         });
-        server.listen(parseInt(process.env.PORT ?? "3000", 10));
+        server.listen(Number.parseInt(process.env.PORT ?? "3000", 10));
     });
     server.on("error", (err) => {
         error(err);

package/dist/plugins/edge.js

@@ -1,6 +1,8 @@
 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 logger from "../logger.js";
 /**
  * @param opts.nextDir - The path to the .next directory
  * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
@@ -23,6 +25,7 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
     return {
         name: "opennext-edge",
         setup(build) {
+            logger.debug(chalk.blue("OpenNext Edge plugin"));
             if (edgeFunctionHandlerPath) {
                 // If we bundle the routing, we need to resolve the middleware
                 build.onResolve({ filter: /\.\/middleware.mjs/g }, () => {
@@ -60,7 +63,7 @@ globalThis.self = globalThis;
 globalThis._ROUTES = ${JSON.stringify(routes)};
 
 ${isInCloudfare
-                    ? ``
+                    ? ""
                     : `
 import {readFileSync} from "node:fs";
 import path from "node:path";
@@ -124,13 +127,11 @@ ${contents}
                 const AppPathsManifestKeys = loadAppPathsManifestKeys(nextDir);
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
                 const contents = `
-  import path from "path";
+  import path from "node:path";
 
   import { debug } from "../logger";
 
-  if(!globalThis.__dirname) {
-    globalThis.__dirname = ""
-  }
+  globalThis.__dirname ??= "";
 
   export const NEXT_DIR = path.join(__dirname, ".next");
   export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");

package/dist/plugins/replacement.js

@@ -46,7 +46,7 @@ export function openNextReplacementPlugin({ target, replacements, deletes, name,
                 await Promise.all([
                     ...(deletes ?? []).map(async (id) => {
                         const pattern = new RegExp(`\/\/#override (${id})\n([\\s\\S]*?)\/\/#endOverride`);
-                        logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), ` -- Deleting override for ${id}`);
+                        logger.debug(chalk.blue(`OpenNext Replacement plugin ${name}`), `Delete override ${id}`);
                         contents = contents.replace(pattern, "");
                     }),
                     ...(replacements ?? []).map(async (filename) => {
@@ -59,7 +59,7 @@ export function openNextReplacementPlugin({ target, replacements, deletes, name,
                             const replacement = match[2];
                             const id = match[1];
                             const pattern = new RegExp(`\/\/#override (${id})\n([\\s\\S]*?)\/\/#endOverride`, "g");
-                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `-- Applying override for ${id} from ${filename}`);
+                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `Apply override ${id} from ${filename}`);
                             contents = contents.replace(pattern, replacement);
                         }
                     }),

package/dist/plugins/resolve.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin } from "esbuild";
-import type { DefaultOverrideOptions, ImageLoader, IncludedImageLoader, IncludedOriginResolver, IncludedWarmer, LazyLoadedOverride, OriginResolver, OverrideOptions, Warmer } from "../types/open-next";
+import type { DefaultOverrideOptions, IncludedImageLoader, IncludedOriginResolver, IncludedWarmer, LazyLoadedOverride, OverrideOptions } from "../types/open-next";
+import type { ImageLoader, OriginResolver, Warmer } from "../types/overrides";
 export interface IPluginSettings {
     overrides?: {
         wrapper?: DefaultOverrideOptions<any, any>["wrapper"];
@@ -10,6 +11,7 @@ export interface IPluginSettings {
         imageLoader?: LazyLoadedOverride<ImageLoader> | IncludedImageLoader;
         originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
         warmer?: LazyLoadedOverride<Warmer> | IncludedWarmer;
+        proxyExternalRequest?: OverrideOptions["proxyExternalRequest"];
     };
     fnName?: string;
 }

package/dist/plugins/resolve.js

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import chalk from "chalk";
 import logger from "../logger.js";
 function getOverrideOrDummy(override) {
     if (typeof override === "string") {
@@ -17,6 +18,7 @@ const nameToFolder = {
     imageLoader: "imageLoader",
     originResolver: "originResolver",
     warmer: "warmer",
+    proxyExternalRequest: "proxyExternalRequest",
 };
 const defaultOverrides = {
     wrapper: "aws-lambda",
@@ -27,6 +29,7 @@ const defaultOverrides = {
     imageLoader: "s3",
     originResolver: "pattern-env",
     warmer: "aws-lambda",
+    proxyExternalRequest: "node",
 };
 /**
  * @param opts.overrides - The name of the overrides to use
@@ -36,14 +39,18 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
     return {
         name: "opennext-resolve",
         setup(build) {
-            logger.debug(`OpenNext Resolve plugin for ${fnName}`);
+            logger.debug(chalk.blue("OpenNext Resolve plugin"), fnName ? `for ${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/aws-lambda.d.ts

@@ -1,8 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
+import type { Writable } from "node:stream";
 import type { APIGatewayProxyEventV2, Context } from "aws-lambda";
-import type { Writable } from "stream";
 export interface ResponseStream extends Writable {
     getBufferedData(): Buffer;
     setContentType(contentType: string): void;
@@ -15,7 +12,7 @@ interface Metadata {
 declare global {
     namespace awslambda {
         function streamifyResponse(handler: Handler): Handler;
-        module HttpResponseStream {
+        namespace HttpResponseStream {
             function from(res: Writable, metadata: Metadata): ResponseStream;
         }
     }

package/dist/types/cache.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 interface CachedFetchValue {
     kind: "FETCH";
     data: {