astro 5.5.5 → 5.6.0

package/dist/integrations/hooks.js

@@ -9,15 +9,16 @@ import { globalContentLayer } from "../content/content-layer.js";
 import { globalContentConfigObserver } from "../content/utils.js";
 import { buildClientDirectiveEntrypoint } from "../core/client-directive/index.js";
 import { mergeConfig } from "../core/config/index.js";
+import { validateConfigRefined } from "../core/config/validate.js";
 import { validateSetAdapter } from "../core/dev/adapter-validation.js";
 import { validateSessionConfig } from "../core/session.js";
 import { validateSupportedFeatures } from "./features-validation.js";
 async function withTakingALongTimeMsg({
   name,
   hookName,
-  hookResult,
-  timeoutMs = 3e3,
-  logger
+  hookFn,
+  logger,
+  integrationLogger
 }) {
   const timeout = setTimeout(() => {
     logger.info(
@@ -26,10 +27,36 @@ async function withTakingALongTimeMsg({
         JSON.stringify(hookName)
       )}...`
     );
-  }, timeoutMs);
-  const result = await hookResult;
-  clearTimeout(timeout);
-  return result;
+  }, 3e3);
+  try {
+    return await hookFn();
+  } catch (err) {
+    integrationLogger.error(
+      `An unhandled error occurred while running the ${bold(JSON.stringify(hookName))} hook`
+    );
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function runHookInternal({
+  integration,
+  hookName,
+  logger,
+  params
+}) {
+  const hook = integration?.hooks?.[hookName];
+  const integrationLogger = getLogger(integration, logger);
+  if (hook) {
+    await withTakingALongTimeMsg({
+      name: integration.name,
+      hookName,
+      hookFn: () => hook(Object.assign(params(), { logger: integrationLogger })),
+      logger,
+      integrationLogger
+    });
+  }
+  return { integrationLogger };
 }
 const Loggers = /* @__PURE__ */ new WeakMap();
 function getLogger(integration, logger) {
@@ -108,113 +135,122 @@ async function runHookConfigSetup({
   let astroJSXRenderer = null;
   for (let i = 0; i < updatedConfig.integrations.length; i++) {
     const integration = updatedConfig.integrations[i];
-    if (integration.hooks?.["astro:config:setup"]) {
-      let addPageExtension2 = function(...input) {
-        const exts = input.flat(Infinity).map((ext) => `.${ext.replace(/^\./, "")}`);
-        updatedSettings.pageExtensions.push(...exts);
-      }, addContentEntryType2 = function(contentEntryType) {
-        updatedSettings.contentEntryTypes.push(contentEntryType);
-      }, addDataEntryType2 = function(dataEntryType) {
-        updatedSettings.dataEntryTypes.push(dataEntryType);
-      };
-      var addPageExtension = addPageExtension2, addContentEntryType = addContentEntryType2, addDataEntryType = addDataEntryType2;
-      const integrationLogger = getLogger(integration, logger);
-      const hooks = {
-        config: updatedConfig,
-        command,
-        isRestart,
-        addRenderer(renderer) {
-          if (!renderer.name) {
-            throw new Error(`Integration ${bold(integration.name)} has an unnamed renderer.`);
-          }
-          if (!renderer.serverEntrypoint) {
-            throw new Error(`Renderer ${bold(renderer.name)} does not provide a serverEntrypoint.`);
-          }
-          if (renderer.name === "astro:jsx") {
-            astroJSXRenderer = renderer;
-          } else {
-            updatedSettings.renderers.push(renderer);
-          }
-        },
-        injectScript: (stage, content) => {
-          updatedSettings.scripts.push({ stage, content });
-        },
-        updateConfig: (newConfig) => {
-          updatedConfig = mergeConfig(updatedConfig, newConfig);
-          return { ...updatedConfig };
-        },
-        injectRoute: (injectRoute) => {
-          if (injectRoute.entrypoint == null && "entryPoint" in injectRoute) {
-            logger.warn(
-              null,
-              `The injected route "${injectRoute.pattern}" by ${integration.name} specifies the entry point with the "entryPoint" property. This property is deprecated, please use "entrypoint" instead.`
+    const { integrationLogger } = await runHookInternal({
+      integration,
+      hookName: "astro:config:setup",
+      logger,
+      params: () => {
+        const hooks = {
+          config: updatedConfig,
+          command,
+          isRestart,
+          addRenderer(renderer) {
+            if (!renderer.name) {
+              throw new Error(`Integration ${bold(integration.name)} has an unnamed renderer.`);
+            }
+            if (!renderer.serverEntrypoint) {
+              throw new Error(
+                `Renderer ${bold(renderer.name)} does not provide a serverEntrypoint.`
+              );
+            }
+            if (renderer.name === "astro:jsx") {
+              astroJSXRenderer = renderer;
+            } else {
+              updatedSettings.renderers.push(renderer);
+            }
+          },
+          injectScript: (stage, content) => {
+            updatedSettings.scripts.push({ stage, content });
+          },
+          updateConfig: (newConfig) => {
+            updatedConfig = mergeConfig(updatedConfig, newConfig);
+            return { ...updatedConfig };
+          },
+          injectRoute: (injectRoute) => {
+            if (injectRoute.entrypoint == null && "entryPoint" in injectRoute) {
+              logger.warn(
+                null,
+                `The injected route "${injectRoute.pattern}" by ${integration.name} specifies the entry point with the "entryPoint" property. This property is deprecated, please use "entrypoint" instead.`
+              );
+              injectRoute.entrypoint = injectRoute.entryPoint;
+            }
+            updatedSettings.injectedRoutes.push({ ...injectRoute, origin: "external" });
+          },
+          addWatchFile: (path) => {
+            updatedSettings.watchFiles.push(path instanceof URL ? fileURLToPath(path) : path);
+          },
+          addDevToolbarApp: (entrypoint) => {
+            updatedSettings.devToolbarApps.push(entrypoint);
+          },
+          addClientDirective: ({ name, entrypoint }) => {
+            if (updatedSettings.clientDirectives.has(name) || addedClientDirectives.has(name)) {
+              throw new Error(
+                `The "${integration.name}" integration is trying to add the "${name}" client directive, but it already exists.`
+              );
+            }
+            addedClientDirectives.set(
+              name,
+              buildClientDirectiveEntrypoint(name, entrypoint, settings.config.root)
             );
-            injectRoute.entrypoint = injectRoute.entryPoint;
-          }
-          updatedSettings.injectedRoutes.push({ ...injectRoute, origin: "external" });
-        },
-        addWatchFile: (path) => {
-          updatedSettings.watchFiles.push(path instanceof URL ? fileURLToPath(path) : path);
-        },
-        addDevToolbarApp: (entrypoint) => {
-          updatedSettings.devToolbarApps.push(entrypoint);
-        },
-        addClientDirective: ({ name, entrypoint }) => {
-          if (updatedSettings.clientDirectives.has(name) || addedClientDirectives.has(name)) {
-            throw new Error(
-              `The "${integration.name}" integration is trying to add the "${name}" client directive, but it already exists.`
+          },
+          addMiddleware: ({ order, entrypoint }) => {
+            if (typeof updatedSettings.middlewares[order] === "undefined") {
+              throw new Error(
+                `The "${integration.name}" integration is trying to add middleware but did not specify an order.`
+              );
+            }
+            logger.debug(
+              "middleware",
+              `The integration ${integration.name} has added middleware that runs ${order === "pre" ? "before" : "after"} any application middleware you define.`
             );
-          }
-          addedClientDirectives.set(
-            name,
-            buildClientDirectiveEntrypoint(name, entrypoint, settings.config.root)
-          );
-        },
-        addMiddleware: ({ order, entrypoint }) => {
-          if (typeof updatedSettings.middlewares[order] === "undefined") {
-            throw new Error(
-              `The "${integration.name}" integration is trying to add middleware but did not specify an order.`
+            updatedSettings.middlewares[order].push(
+              typeof entrypoint === "string" ? entrypoint : fileURLToPath(entrypoint)
             );
+          },
+          createCodegenDir: () => {
+            const codegenDir = new URL(normalizeCodegenDir(integration.name), settings.dotAstroDir);
+            fs.mkdirSync(codegenDir, { recursive: true });
+            return codegenDir;
           }
-          logger.debug(
-            "middleware",
-            `The integration ${integration.name} has added middleware that runs ${order === "pre" ? "before" : "after"} any application middleware you define.`
-          );
-          updatedSettings.middlewares[order].push(
-            typeof entrypoint === "string" ? entrypoint : fileURLToPath(entrypoint)
+        };
+        function addPageExtension(...input) {
+          const exts = input.flat(Infinity).map(
+            (ext) => `.${ext.replace(/^\./, "")}`
           );
-        },
-        createCodegenDir: () => {
-          const codegenDir = new URL(normalizeCodegenDir(integration.name), settings.dotAstroDir);
-          fs.mkdirSync(codegenDir, { recursive: true });
-          return codegenDir;
-        },
-        logger: integrationLogger
-      };
-      Object.defineProperty(hooks, "addPageExtension", {
-        value: addPageExtension2,
-        writable: false,
-        enumerable: false
-      });
-      Object.defineProperty(hooks, "addContentEntryType", {
-        value: addContentEntryType2,
-        writable: false,
-        enumerable: false
-      });
-      Object.defineProperty(hooks, "addDataEntryType", {
-        value: addDataEntryType2,
-        writable: false,
-        enumerable: false
-      });
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:config:setup",
-        hookResult: integration.hooks["astro:config:setup"](hooks),
-        logger
-      });
-      for (const [name, compiled] of addedClientDirectives) {
-        updatedSettings.clientDirectives.set(name, await compiled);
+          updatedSettings.pageExtensions.push(...exts);
+        }
+        function addContentEntryType(contentEntryType) {
+          updatedSettings.contentEntryTypes.push(contentEntryType);
+        }
+        function addDataEntryType(dataEntryType) {
+          updatedSettings.dataEntryTypes.push(dataEntryType);
+        }
+        Object.defineProperty(hooks, "addPageExtension", {
+          value: addPageExtension,
+          writable: false,
+          enumerable: false
+        });
+        Object.defineProperty(hooks, "addContentEntryType", {
+          value: addContentEntryType,
+          writable: false,
+          enumerable: false
+        });
+        Object.defineProperty(hooks, "addDataEntryType", {
+          value: addDataEntryType,
+          writable: false,
+          enumerable: false
+        });
+        return hooks;
       }
+    });
+    for (const [name, compiled] of addedClientDirectives) {
+      updatedSettings.clientDirectives.set(name, await compiled);
+    }
+    try {
+      updatedConfig = await validateConfigRefined(updatedConfig);
+    } catch (error) {
+      integrationLogger.error("An error occurred while updating the config");
+      throw error;
     }
   }
   if (astroJSXRenderer) {
@@ -229,50 +265,47 @@ async function runHookConfigDone({
   command
 }) {
   for (const integration of settings.config.integrations) {
-    if (integration?.hooks?.["astro:config:done"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:config:done",
-        hookResult: integration.hooks["astro:config:done"]({
-          config: settings.config,
-          setAdapter(adapter) {
-            validateSetAdapter(logger, settings, adapter, integration.name, command);
-            if (adapter.adapterFeatures?.buildOutput !== "static") {
-              settings.buildOutput = "server";
-            }
-            if (!adapter.supportedAstroFeatures) {
-              throw new Error(
-                `The adapter ${adapter.name} doesn't provide a feature map. It is required in Astro 4.0.`
-              );
-            } else {
-              validateSupportedFeatures(
-                adapter.name,
-                adapter.supportedAstroFeatures,
-                settings,
-                logger
-              );
-            }
-            settings.adapter = adapter;
-          },
-          injectTypes(injectedType) {
-            const normalizedFilename = normalizeInjectedTypeFilename(
-              injectedType.filename,
-              integration.name
+    await runHookInternal({
+      integration,
+      hookName: "astro:config:done",
+      logger,
+      params: () => ({
+        config: settings.config,
+        setAdapter(adapter) {
+          validateSetAdapter(logger, settings, adapter, integration.name, command);
+          if (adapter.adapterFeatures?.buildOutput !== "static") {
+            settings.buildOutput = "server";
+          }
+          if (!adapter.supportedAstroFeatures) {
+            throw new Error(
+              `The adapter ${adapter.name} doesn't provide a feature map. It is required in Astro 4.0.`
+            );
+          } else {
+            validateSupportedFeatures(
+              adapter.name,
+              adapter.supportedAstroFeatures,
+              settings,
+              logger
             );
-            settings.injectedTypes.push({
-              filename: normalizedFilename,
-              content: injectedType.content
-            });
-            return new URL(normalizedFilename, settings.dotAstroDir);
-          },
-          logger: getLogger(integration, logger),
-          get buildOutput() {
-            return settings.buildOutput;
           }
-        }),
-        logger
-      });
-    }
+          settings.adapter = adapter;
+        },
+        injectTypes(injectedType) {
+          const normalizedFilename = normalizeInjectedTypeFilename(
+            injectedType.filename,
+            integration.name
+          );
+          settings.injectedTypes.push({
+            filename: normalizedFilename,
+            content: injectedType.content
+          });
+          return new URL(normalizedFilename, settings.dotAstroDir);
+        },
+        get buildOutput() {
+          return settings.buildOutput;
+        }
+      })
+    });
   }
   validateSessionConfig(settings);
 }
@@ -293,19 +326,16 @@ async function runHookServerSetup({
     await contentLayer?.sync(options);
   };
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:server:setup"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:server:setup",
-        hookResult: integration.hooks["astro:server:setup"]({
-          server,
-          logger: getLogger(integration, logger),
-          toolbar: getToolbarServerCommunicationHelpers(server),
-          refreshContent
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:server:setup",
+      logger,
+      params: () => ({
+        server,
+        toolbar: getToolbarServerCommunicationHelpers(server),
+        refreshContent
+      })
+    });
   }
 }
 async function runHookServerStart({
@@ -314,17 +344,12 @@ async function runHookServerStart({
   logger
 }) {
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:server:start"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:server:start",
-        hookResult: integration.hooks["astro:server:start"]({
-          address,
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:server:start",
+      logger,
+      params: () => ({ address })
+    });
   }
 }
 async function runHookServerDone({
@@ -332,32 +357,25 @@ async function runHookServerDone({
   logger
 }) {
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:server:done"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:server:done",
-        hookResult: integration.hooks["astro:server:done"]({
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:server:done",
+      logger,
+      params: () => ({})
+    });
   }
 }
 async function runHookBuildStart({
   config,
-  logging
+  logger
 }) {
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:start"]) {
-      const logger = getLogger(integration, logging);
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:start",
-        hookResult: integration.hooks["astro:build:start"]({ logger }),
-        logger: logging
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:start",
+      logger,
+      params: () => ({})
+    });
   }
 }
 async function runHookBuildSetup({
@@ -369,23 +387,20 @@ async function runHookBuildSetup({
 }) {
   let updatedConfig = vite;
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:setup"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:setup",
-        hookResult: integration.hooks["astro:build:setup"]({
-          vite,
-          pages,
-          target,
-          updateConfig: (newConfig) => {
-            updatedConfig = mergeViteConfig(updatedConfig, newConfig);
-            return { ...updatedConfig };
-          },
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:setup",
+      logger,
+      params: () => ({
+        vite,
+        pages,
+        target,
+        updateConfig: (newConfig) => {
+          updatedConfig = mergeViteConfig(updatedConfig, newConfig);
+          return { ...updatedConfig };
+        }
+      })
+    });
   }
   return updatedConfig;
 }
@@ -401,19 +416,16 @@ async function runHookBuildSsr({
     entryPointsMap.set(toIntegrationRouteData(key), value);
   }
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:ssr"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:ssr",
-        hookResult: integration.hooks["astro:build:ssr"]({
-          manifest,
-          entryPoints: entryPointsMap,
-          middlewareEntryPoint,
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:ssr",
+      logger,
+      params: () => ({
+        manifest,
+        entryPoints: entryPointsMap,
+        middlewareEntryPoint
+      })
+    });
   }
 }
 async function runHookBuildGenerated({
@@ -422,41 +434,32 @@ async function runHookBuildGenerated({
 }) {
   const dir = settings.buildOutput === "server" ? settings.config.build.client : settings.config.outDir;
   for (const integration of settings.config.integrations) {
-    if (integration?.hooks?.["astro:build:generated"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:generated",
-        hookResult: integration.hooks["astro:build:generated"]({
-          dir,
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:generated",
+      logger,
+      params: () => ({ dir })
+    });
   }
 }
-async function runHookBuildDone({ settings, pages, routes, logging }) {
+async function runHookBuildDone({ settings, pages, routes, logger }) {
   const dir = settings.buildOutput === "server" ? settings.config.build.client : settings.config.outDir;
   await fsMod.promises.mkdir(dir, { recursive: true });
   const integrationRoutes = routes.map(toIntegrationRouteData);
   for (const integration of settings.config.integrations) {
-    if (integration?.hooks?.["astro:build:done"]) {
-      const logger = getLogger(integration, logging);
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:done",
-        hookResult: integration.hooks["astro:build:done"]({
-          pages: pages.map((p) => ({ pathname: p })),
-          dir,
-          routes: integrationRoutes,
-          assets: new Map(
-            routes.filter((r) => r.distURL !== void 0).map((r) => [r.route, r.distURL])
-          ),
-          logger
-        }),
-        logger: logging
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:done",
+      logger,
+      params: () => ({
+        pages: pages.map((p) => ({ pathname: p })),
+        dir,
+        routes: integrationRoutes,
+        assets: new Map(
+          routes.filter((r) => r.distURL !== void 0).map((r) => [r.route, r.distURL])
+        )
+      })
+    });
   }
 }
 async function runHookRouteSetup({
@@ -466,21 +469,15 @@ async function runHookRouteSetup({
 }) {
   const prerenderChangeLogs = [];
   for (const integration of settings.config.integrations) {
-    if (integration?.hooks?.["astro:route:setup"]) {
-      const originalRoute = { ...route };
-      const integrationLogger = getLogger(integration, logger);
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:route:setup",
-        hookResult: integration.hooks["astro:route:setup"]({
-          route,
-          logger: integrationLogger
-        }),
-        logger
-      });
-      if (route.prerender !== originalRoute.prerender) {
-        prerenderChangeLogs.push({ integrationName: integration.name, value: route.prerender });
-      }
+    const originalRoute = { ...route };
+    await runHookInternal({
+      integration,
+      hookName: "astro:route:setup",
+      logger,
+      params: () => ({ route })
+    });
+    if (route.prerender !== originalRoute.prerender) {
+      prerenderChangeLogs.push({ integrationName: integration.name, value: route.prerender });
     }
   }
   if (prerenderChangeLogs.length > 1) {
@@ -497,18 +494,14 @@ async function runHookRoutesResolved({
   logger
 }) {
   for (const integration of settings.config.integrations) {
-    if (integration?.hooks?.["astro:routes:resolved"]) {
-      const integrationLogger = getLogger(integration, logger);
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:routes:resolved",
-        hookResult: integration.hooks["astro:routes:resolved"]({
-          routes: routes.map((route) => toIntegrationResolvedRoute(route)),
-          logger: integrationLogger
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:routes:resolved",
+      logger,
+      params: () => ({
+        routes: routes.map((route) => toIntegrationResolvedRoute(route))
+      })
+    });
   }
 }
 function toIntegrationResolvedRoute(route) {