@opennextjs/aws 3.1.6 → 3.2.1

package/dist/overrides/incrementalCache/dummy.js

@@ -0,0 +1,13 @@
+const dummyIncrementalCache = {
+    name: "dummy",
+    get: async () => {
+        throw new Error("Dummy cache is not implemented");
+    },
+    set: async () => {
+        throw new Error("Dummy cache is not implemented");
+    },
+    delete: async () => {
+        throw new Error("Dummy cache is not implemented");
+    },
+};
+export default dummyIncrementalCache;

package/dist/{cache/incremental → overrides/incrementalCache}/s3-lite.d.ts

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

package/dist/{cache/incremental → overrides/incrementalCache}/s3.d.ts

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

package/dist/{cache/incremental → overrides/incrementalCache}/types.d.ts

@@ -1,4 +1,4 @@
-import { Meta } from "../next-types";
+import type { Meta } from "../../types/cache";
 export type S3CachedFile = {
     type: "redirect";
     props?: Object;

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

@@ -0,0 +1,3 @@
+import type { OriginResolver } from "../../types/open-next";
+declare const dummyOriginResolver: OriginResolver;
+export default dummyOriginResolver;

package/dist/overrides/originResolver/dummy.js

@@ -0,0 +1,7 @@
+const dummyOriginResolver = {
+    name: "dummy",
+    resolve: async (_path) => {
+        return false;
+    },
+};
+export default dummyOriginResolver;

package/dist/overrides/originResolver/pattern-env.d.ts

@@ -0,0 +1,3 @@
+import type { OriginResolver } from "../../types/open-next";
+declare const envLoader: OriginResolver;
+export default envLoader;

package/dist/overrides/originResolver/pattern-env.js

@@ -0,0 +1,39 @@
+import { debug, error } from "../../adapters/logger";
+const envLoader = {
+    name: "env",
+    resolve: async (_path) => {
+        try {
+            const origin = JSON.parse(process.env.OPEN_NEXT_ORIGIN ?? "{}");
+            for (const [key, value] of Object.entries(globalThis.openNextConfig.functions ?? {}).filter(([key]) => key !== "default")) {
+                if (value.patterns.some((pattern) => {
+                    // Convert cloudfront pattern to regex
+                    return new RegExp(
+                    // transform glob pattern to regex
+                    "/" +
+                        pattern
+                            .replace(/\*\*/g, "(.*)")
+                            .replace(/\*/g, "([^/]*)")
+                            .replace(/\//g, "\\/")
+                            .replace(/\?/g, ".")).test(_path);
+                })) {
+                    debug("Using origin", key, value.patterns);
+                    return origin[key];
+                }
+            }
+            if (_path.startsWith("/_next/image") && origin["imageOptimizer"]) {
+                debug("Using origin", "imageOptimizer", _path);
+                return origin["imageOptimizer"];
+            }
+            if (origin["default"]) {
+                debug("Using default origin", origin["default"], _path);
+                return origin["default"];
+            }
+            return false;
+        }
+        catch (e) {
+            error("Error while resolving origin", e);
+            return false;
+        }
+    },
+};
+export default envLoader;

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

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

package/dist/overrides/queue/dummy.js

@@ -0,0 +1,7 @@
+const dummyQueue = {
+    name: "dummy",
+    send: async () => {
+        throw new Error("Dummy queue is not implemented");
+    },
+};
+export default dummyQueue;

package/dist/{queue → overrides/queue}/sqs-lite.d.ts

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

package/dist/{queue → overrides/queue}/sqs-lite.js

@@ -1,7 +1,7 @@
 import { AwsClient } from "aws4fetch";
-import { RecoverableError } from "../utils/error";
-import { customFetchClient } from "../utils/fetch";
-import { error } from "../adapters/logger";
+import { RecoverableError } from "../../utils/error";
+import { customFetchClient } from "../../utils/fetch";
+import { error } from "../../adapters/logger";
 let awsClient = null;
 const getAwsClient = () => {
     if (awsClient) {

package/dist/{queue → overrides/queue}/sqs.d.ts

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

package/dist/{queue → overrides/queue}/sqs.js

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

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

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

package/dist/overrides/tagCache/dummy.js

@@ -0,0 +1,17 @@
+// We don't want to throw error on this one because we might use it when we don't need tag cache
+const dummyTagCache = {
+    name: "dummy",
+    getByPath: async () => {
+        return [];
+    },
+    getByTag: async () => {
+        return [];
+    },
+    getLastModified: async (_, lastModified) => {
+        return lastModified ?? Date.now();
+    },
+    writeTags: async () => {
+        return;
+    },
+};
+export default dummyTagCache;

package/dist/{cache/tag → overrides/tagCache}/dynamodb-lite.d.ts

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

package/dist/{cache/tag → overrides/tagCache}/dynamodb-lite.js

@@ -131,7 +131,7 @@ const tagCache = {
             const revalidatedTags = (await result.json()).Items ?? [];
             debug("revalidatedTags", revalidatedTags);
             // If we have revalidated tags we return -1 to force revalidation
-            return revalidatedTags.length > 0 ? -1 : lastModified ?? Date.now();
+            return revalidatedTags.length > 0 ? -1 : (lastModified ?? Date.now());
         }
         catch (e) {
             error("Failed to get revalidated tags", e);

package/dist/{cache/tag → overrides/tagCache}/dynamodb.d.ts

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

package/dist/{cache/tag → overrides/tagCache}/dynamodb.js

@@ -93,7 +93,7 @@ const tagCache = {
             const revalidatedTags = result.Items ?? [];
             debug("revalidatedTags", revalidatedTags);
             // If we have revalidated tags we return -1 to force revalidation
-            return revalidatedTags.length > 0 ? -1 : lastModified ?? Date.now();
+            return revalidatedTags.length > 0 ? -1 : (lastModified ?? Date.now());
         }
         catch (e) {
             error("Failed to get revalidated tags", e);

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

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

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

@@ -0,0 +1,59 @@
+import { debug, error } from "../../adapters/logger";
+const lambdaWarmerInvoke = {
+    name: "aws-invoke",
+    invoke: async (warmerId) => {
+        const { InvokeCommand, LambdaClient } = await import("@aws-sdk/client-lambda");
+        const lambda = new LambdaClient({});
+        const warmParams = JSON.parse(process.env.WARM_PARAMS);
+        for (const warmParam of warmParams) {
+            const { concurrency: CONCURRENCY, function: FUNCTION_NAME } = warmParam;
+            debug({
+                event: "warmer invoked",
+                functionName: FUNCTION_NAME,
+                concurrency: CONCURRENCY,
+                warmerId,
+            });
+            const ret = await Promise.all(Array.from({ length: CONCURRENCY }, (_v, i) => i).map((i) => {
+                try {
+                    return lambda.send(new InvokeCommand({
+                        FunctionName: FUNCTION_NAME,
+                        InvocationType: "RequestResponse",
+                        Payload: Buffer.from(JSON.stringify({
+                            type: "warmer",
+                            warmerId,
+                            index: i,
+                            concurrency: CONCURRENCY,
+                            delay: 75,
+                        })),
+                    }));
+                }
+                catch (e) {
+                    error(`failed to warm up #${i}`, e);
+                    // ignore error
+                }
+            }));
+            // Print status
+            const warmedServerIds = ret
+                .map((r, i) => {
+                if (r?.StatusCode !== 200 || !r?.Payload) {
+                    error(`failed to warm up #${i}:`, r?.Payload?.toString());
+                    return;
+                }
+                const payload = JSON.parse(Buffer.from(r.Payload).toString());
+                return {
+                    statusCode: r.StatusCode,
+                    payload,
+                    type: "warmer",
+                };
+            })
+                .filter((r) => !!r);
+            debug({
+                event: "warmer result",
+                sent: CONCURRENCY,
+                success: warmedServerIds.length,
+                uniqueServersWarmed: [...new Set(warmedServerIds)].length,
+            });
+        }
+    },
+};
+export default lambdaWarmerInvoke;

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

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

package/dist/overrides/warmer/dummy.js

@@ -0,0 +1,7 @@
+const dummyWarmer = {
+    name: "dummy",
+    invoke: async (_) => {
+        throw new Error("Dummy warmer is not implemented");
+    },
+};
+export default dummyWarmer;

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

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

package/dist/{wrappers → overrides/wrappers}/aws-lambda-streaming.js

@@ -1,6 +1,6 @@
 import { Readable } from "node:stream";
 import zlib from "node:zlib";
-import { debug, error } from "../adapters/logger";
+import { debug, error } from "../../adapters/logger";
 function formatWarmerResponse(event) {
     const result = new Promise((resolve) => {
         setTimeout(() => {

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

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

package/dist/{wrappers → overrides/wrappers}/cloudflare.d.ts

@@ -1,5 +1,5 @@
-import type { InternalEvent, InternalResult, WrapperHandler } from "../types/open-next";
-import { MiddlewareOutputEvent } from "../core/routingHandler";
+import type { InternalEvent, InternalResult, WrapperHandler } from "../../types/open-next";
+import type { MiddlewareOutputEvent } from "../../core/routingHandler";
 declare const _default: {
     wrapper: WrapperHandler<InternalEvent, InternalResult | ({
         type: "middleware";

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

@@ -1,7 +1,7 @@
 const handler = async (handler, converter) => async (event, env) => {
     globalThis.process = process;
     // Set the environment variables
-    // Cloudlare suggests to not override the process.env object but instead apply the values to it
+    // 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;

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

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

package/dist/overrides/wrappers/dummy.js

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

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

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

package/dist/{wrappers → overrides/wrappers}/node.js

@@ -1,5 +1,5 @@
 import { createServer } from "node:http";
-import { debug, error } from "../adapters/logger";
+import { debug, error } from "../../adapters/logger";
 const wrapper = async (handler, converter) => {
     const server = createServer(async (req, res) => {
         const internalEvent = await converter.convertFrom(req);

package/dist/plugins/edge.d.ts

@@ -1,15 +1,16 @@
-import { Plugin } from "esbuild";
-import { MiddlewareInfo } from "../types/next-types.js";
+import type { Plugin } from "esbuild";
+import type { MiddlewareInfo } from "../types/next-types.js";
 export interface IPluginSettings {
     nextDir: string;
     edgeFunctionHandlerPath?: string;
-    middlewareInfo: MiddlewareInfo;
+    middlewareInfo?: MiddlewareInfo;
     isInCloudfare?: boolean;
 }
 /**
  * @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
- * @param opts.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @param opts.middlewareInfo - Information about the middleware
+ * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
 export declare function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;

package/dist/plugins/edge.js

@@ -4,19 +4,22 @@ import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, l
 /**
  * @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
- * @param opts.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @param opts.middlewareInfo - Information about the middleware
+ * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
 export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }) {
-    const entryFiles = middlewareInfo.files.map((file) => path.join(nextDir, file));
-    const routes = [
-        {
-            name: middlewareInfo.name || "/",
-            page: middlewareInfo.page,
-            regex: middlewareInfo.matchers.map((m) => m.regexp),
-        },
-    ];
-    const wasmFiles = middlewareInfo.wasm ?? [];
+    const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
+    const routes = middlewareInfo
+        ? [
+            {
+                name: middlewareInfo.name || "/",
+                page: middlewareInfo.page,
+                regex: middlewareInfo.matchers.map((m) => m.regexp),
+            },
+        ]
+        : [];
+    const wasmFiles = middlewareInfo?.wasm ?? [];
     return {
         name: "opennext-edge",
         setup(build) {
@@ -44,12 +47,10 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
             });
             // we convert the imports we tagged with the node-built-in-modules namespace so that instead of `require("node:*")`
             // they import from `export * from "node:*";`
-            build.onLoad({ filter: /.*/, namespace: "node-built-in-modules" }, ({ path }) => {
-                return {
-                    contents: `export * from '${path}'`,
-                    loader: "js",
-                };
-            });
+            build.onLoad({ filter: /.*/, namespace: "node-built-in-modules" }, ({ path }) => ({
+                contents: `export * from '${path}'`,
+                loader: "js",
+            }));
             // We inject the entry files into the edgeFunctionHandler
             build.onLoad({ filter: /\/edgeFunctionHandler.js/g }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
@@ -97,7 +98,7 @@ if(!globalThis.Crypto) {
   globalThis.Crypto = webcrypto.Crypto
 }
 // We also need to polyfill URLPattern
-if (!globalThis.URLPattern) { 
+if (!globalThis.URLPattern) {
   await import("urlpattern-polyfill");
 }
 `}
@@ -106,8 +107,8 @@ ${wasmFiles
                     ? `import ${file.name} from './wasm/${file.name}.wasm';`
                     : `const ${file.name} = readFileSync(path.join(__dirname,'/wasm/${file.name}.wasm'));`)
                     .join("\n")}
-${entryFiles?.map((file) => `require("${file}");`).join("\n")}
-${contents}        
+${entryFiles.map((file) => `require("${file}");`).join("\n")}
+${contents}
         `;
                 return {
                     contents,
@@ -124,18 +125,18 @@ ${contents}
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
                 const contents = `
   import path from "path";
-  
+
   import { debug } from "../logger";
-  
+
   if(!globalThis.__dirname) {
     globalThis.__dirname = ""
   }
-  
+
   export const NEXT_DIR = path.join(__dirname, ".next");
   export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
-  
+
   debug({ NEXT_DIR, OPEN_NEXT_DIR });
-  
+
   export const NextConfig = ${JSON.stringify(NextConfig)};
   export const BuildId = ${JSON.stringify(BuildId)};
   export const HtmlPages = ${JSON.stringify(HtmlPages)};
@@ -146,11 +147,8 @@ ${contents}
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
 
   process.env.NEXT_BUILD_ID = BuildId;
-  
-          `;
-                return {
-                    contents,
-                };
+`;
+                return { contents };
             });
         },
     };

package/dist/plugins/replacement.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from "esbuild";
+import type { Plugin } from "esbuild";
 export interface IPluginSettings {
     target: RegExp;
     replacements?: string[];
@@ -13,7 +13,7 @@ export interface IPluginSettings {
  *   deletes: ["id1"],
  * })
  *
- * To inject arbritary code by using (import at top of file):
+ * To inject arbitrary code by using (import at top of file):
  *
  * //#import
  *

package/dist/plugins/replacement.js

@@ -11,7 +11,7 @@ const importPattern = /\/\/#import([\s\S]*?)\n\/\/#endImport/gm;
  *   deletes: ["id1"],
  * })
  *
- * To inject arbritary code by using (import at top of file):
+ * To inject arbitrary code by using (import at top of file):
  *
  * //#import
  *
@@ -49,9 +49,8 @@ export function openNextReplacementPlugin({ target, replacements, deletes, name,
                         logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), ` -- Deleting override for ${id}`);
                         contents = contents.replace(pattern, "");
                     }),
-                    ...(replacements ?? []).map(async (fp) => {
-                        const p = fp;
-                        const replacementFile = await readFile(p, "utf-8");
+                    ...(replacements ?? []).map(async (filename) => {
+                        const replacementFile = await readFile(filename, "utf-8");
                         const matches = replacementFile.matchAll(overridePattern);
                         const importMatch = replacementFile.match(importPattern);
                         const addedImport = importMatch ? importMatch[0] : "";
@@ -60,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 ${fp}`);
+                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `-- Applying override for ${id} from ${filename}`);
                             contents = contents.replace(pattern, replacement);
                         }
                     }),

package/dist/plugins/resolve.d.ts

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

package/dist/plugins/resolve.js

@@ -1,11 +1,33 @@
 import { readFileSync } from "node:fs";
 import logger from "../logger.js";
-function getOverrideOrDefault(override, defaultOverride) {
+function getOverrideOrDummy(override) {
     if (typeof override === "string") {
         return override;
     }
-    return defaultOverride;
+    // We can return dummy here because if it's not a string, it's a LazyLoadedOverride
+    return "dummy";
 }
+// This could be useful in the future to map overrides to nested folders
+const nameToFolder = {
+    wrapper: "wrappers",
+    converter: "converters",
+    tagCache: "tagCache",
+    queue: "queue",
+    incrementalCache: "incrementalCache",
+    imageLoader: "imageLoader",
+    originResolver: "originResolver",
+    warmer: "warmer",
+};
+const defaultOverrides = {
+    wrapper: "aws-lambda",
+    converter: "aws-apigw-v2",
+    tagCache: "dynamodb",
+    queue: "sqs",
+    incrementalCache: "s3",
+    imageLoader: "s3",
+    originResolver: "pattern-env",
+    warmer: "aws-lambda",
+};
 /**
  * @param opts.overrides - The name of the overrides to use
  * @returns
@@ -17,24 +39,14 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
             logger.debug(`OpenNext Resolve plugin for ${fnName}`);
             build.onLoad({ filter: /core(\/|\\)resolve\.js/g }, async (args) => {
                 let contents = readFileSync(args.path, "utf-8");
-                //TODO: refactor this. Every override should be at the same place so we can generate this dynamically
-                if (overrides?.wrapper) {
-                    contents = contents.replace("../wrappers/aws-lambda.js", `../wrappers/${getOverrideOrDefault(overrides.wrapper, "aws-lambda")}.js`);
-                }
-                if (overrides?.converter) {
-                    contents = contents.replace("../converters/aws-apigw-v2.js", `../converters/${getOverrideOrDefault(overrides.converter, "dummy")}.js`);
-                }
-                if (overrides?.tagCache) {
-                    contents = contents.replace("../cache/tag/dynamodb.js", `../cache/tag/${getOverrideOrDefault(overrides.tagCache, "dynamodb-lite")}.js`);
-                }
-                if (overrides?.queue) {
-                    contents = contents.replace("../queue/sqs.js", `../queue/${getOverrideOrDefault(overrides.queue, "sqs-lite")}.js`);
-                }
-                if (overrides?.incrementalCache) {
-                    contents = contents.replace("../cache/incremental/s3.js", `../cache/incremental/${getOverrideOrDefault(overrides.incrementalCache, "s3-lite")}.js`);
-                }
-                if (overrides?.imageLoader) {
-                    contents = contents.replace("../overrides/imageLoader/s3.js", `../overrides/imageLoader/${getOverrideOrDefault(overrides.imageLoader, "s3")}.js`);
+                const overridesEntries = Object.entries(overrides ?? {});
+                for (const [overrideName, overrideValue] of overridesEntries) {
+                    if (!overrideValue) {
+                        continue;
+                    }
+                    const folder = nameToFolder[overrideName];
+                    const defaultOverride = defaultOverrides[overrideName];
+                    contents = contents.replace(`../overrides/${folder}/${defaultOverride}.js`, `../overrides/${folder}/${getOverrideOrDummy(overrideValue)}.js`);
                 }
                 return {
                     contents,

package/dist/types/aws-lambda.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { APIGatewayProxyEventV2, Context } from "aws-lambda";
-import { Writable } from "stream";
+/// <reference types="node" />
+import type { APIGatewayProxyEventV2, Context } from "aws-lambda";
+import type { Writable } from "stream";
 export interface ResponseStream extends Writable {
     getBufferedData(): Buffer;
     setContentType(contentType: string): void;

package/dist/{cache/next-types.d.ts → types/cache.d.ts}

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