moved warmer overrides

Author: conico974

packages/open-next/src/adapters/warmer-function.ts

@@ -1,7 +1,5 @@
-import { Warmer } from "types/open-next.js";
-
 import { createGenericHandler } from "../core/createGenericHandler.js";
-import { debug, error } from "./logger.js";
+import { resolveWarmerInvoke } from "../core/resolve.js";
 import { generateUniqueId } from "./util.js";
 
 export interface WarmerEvent {
@@ -17,88 +15,6 @@ export interface WarmerResponse {
   serverId: string;
 }
 
-const resolveWarmerInvoke = async () => {
-  const openNextParams = globalThis.openNextConfig.warmer!;
-  if (typeof openNextParams?.invokeFunction === "function") {
-    return await openNextParams.invokeFunction();
-  } else {
-    return Promise.resolve<Warmer>({
-      name: "aws-invoke",
-      invoke: async (warmerId: string) => {
-        const { InvokeCommand, LambdaClient } = await import(
-          "@aws-sdk/client-lambda"
-        );
-        const lambda = new LambdaClient({});
-        const warmParams = JSON.parse(process.env.WARM_PARAMS!) as {
-          concurrency: number;
-          function: string;
-        }[];
-
-        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,
-                      } satisfies WarmerEvent),
-                    ),
-                  }),
-                );
-              } 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(),
-              ) as WarmerResponse;
-              return {
-                statusCode: r.StatusCode,
-                payload,
-                type: "warmer" as const,
-              };
-            })
-            .filter((r): r is Exclude<typeof r, undefined> => !!r);
-
-          debug({
-            event: "warmer result",
-            sent: CONCURRENCY,
-            success: warmedServerIds.length,
-            uniqueServersWarmed: [...new Set(warmedServerIds)].length,
-          });
-        }
-      },
-    });
-  }
-};
-
 export const handler = await createGenericHandler({
   handler: defaultHandler,
   type: "warmer",
@@ -107,7 +23,9 @@ export const handler = await createGenericHandler({
 async function defaultHandler() {
   const warmerId = `warmer-${generateUniqueId()}`;
 
-  const invokeFn = await resolveWarmerInvoke();
+  const invokeFn = await resolveWarmerInvoke(
+    globalThis.openNextConfig.warmer?.invokeFunction,
+  );
 
   await invokeFn.invoke(warmerId);
 

packages/open-next/src/core/resolve.ts

@@ -8,6 +8,7 @@ import {
   LazyLoadedOverride,
   OriginResolver,
   OverrideOptions,
+  Warmer,
   Wrapper,
 } from "types/open-next.js";
 
@@ -118,7 +119,21 @@ export async function resolveOriginResolver(
   if (typeof originResolver === "function") {
     return originResolver();
   } else {
-    const m_1 = await import("../overrides/originResolver/env.js");
+    const m_1 = await import("../overrides/originResolver/pattern-env.js");
+    return m_1.default;
+  }
+}
+
+/**
+ * @__PURE__
+ */
+export async function resolveWarmerInvoke(
+  warmer?: LazyLoadedOverride<Warmer> | "aws-lambda",
+) {
+  if (typeof warmer === "function") {
+    return warmer();
+  } else {
+    const m_1 = await import("../overrides/warmer/aws-lambda.js");
     return m_1.default;
   }
 }

packages/open-next/src/overrides/warmer/aws-lambda.ts

@@ -0,0 +1,83 @@
+import { Warmer } from "types/open-next";
+
+import { debug, error } from "../../adapters/logger";
+import type {
+  WarmerEvent,
+  WarmerResponse,
+} from "../../adapters/warmer-function";
+
+const lambdaWarmerInvoke: Warmer = {
+  name: "aws-invoke",
+  invoke: async (warmerId: string) => {
+    const { InvokeCommand, LambdaClient } = await import(
+      "@aws-sdk/client-lambda"
+    );
+    const lambda = new LambdaClient({});
+    const warmParams = JSON.parse(process.env.WARM_PARAMS!) as {
+      concurrency: number;
+      function: string;
+    }[];
+
+    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,
+                  } satisfies WarmerEvent),
+                ),
+              }),
+            );
+          } 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(),
+          ) as WarmerResponse;
+          return {
+            statusCode: r.StatusCode,
+            payload,
+            type: "warmer" as const,
+          };
+        })
+        .filter((r): r is Exclude<typeof r, undefined> => !!r);
+
+      debug({
+        event: "warmer result",
+        sent: CONCURRENCY,
+        success: warmedServerIds.length,
+        uniqueServersWarmed: [...new Set(warmedServerIds)].length,
+      });
+    }
+  },
+};
+
+export default lambdaWarmerInvoke;

packages/open-next/src/plugins/resolve.ts

@@ -6,9 +6,11 @@ import type {
   ImageLoader,
   IncludedImageLoader,
   IncludedOriginResolver,
+  IncludedWarmer,
   LazyLoadedOverride,
   OriginResolver,
   OverrideOptions,
+  Warmer,
 } from "types/open-next";
 
 import logger from "../logger.js";
@@ -24,6 +26,7 @@ export interface IPluginSettings {
     originResolver?:
       | LazyLoadedOverride<OriginResolver>
       | IncludedOriginResolver;
+    warmer?: LazyLoadedOverride<Warmer> | IncludedWarmer;
   };
   fnName?: string;
 }
@@ -115,6 +118,15 @@ export function openNextResolvePlugin({
             )}.js`,
           );
         }
+        if (overrides?.warmer) {
+          contents = contents.replace(
+            "../overrides/warmer/aws-lambda.js",
+            `../overrides/warmer/${getOverrideOrDefault(
+              overrides.warmer,
+              "aws-lambda",
+            )}.js`,
+          );
+        }
         return {
           contents,
         };

packages/open-next/src/types/open-next.ts

@@ -141,6 +141,8 @@ export type IncludedImageLoader = "s3" | "host";
 
 export type IncludedOriginResolver = "pattern-env";
 
+export type IncludedWarmer = "aws-lambda";
+
 export interface DefaultOverrideOptions<
   E extends BaseEventOrResult = InternalEvent,
   R extends BaseEventOrResult = InternalResult,
@@ -298,7 +300,7 @@ export interface OpenNextConfig {
    * @default undefined
    */
   warmer?: DefaultFunctionOptions<WarmerEvent, WarmerResponse> & {
-    invokeFunction: "aws-lambda" | LazyLoadedOverride<Warmer>;
+    invokeFunction: IncludedWarmer | LazyLoadedOverride<Warmer>;
   };
 
   /**