astro 4.9.2 → 4.10.0

package/dist/env/vite-plugin-env.js

@@ -0,0 +1,174 @@
+import { fileURLToPath } from "node:url";
+import { loadEnv } from "vite";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import {
+  ENV_TYPES_FILE,
+  MODULE_TEMPLATE_URL,
+  TYPES_TEMPLATE_URL,
+  VIRTUAL_MODULES_IDS,
+  VIRTUAL_MODULES_IDS_VALUES,
+  VIRTUAL_MODULE_SETUP_ID
+} from "./constants.js";
+import { getEnvFieldType, validateEnvVariable } from "./validators.js";
+function astroEnv({
+  settings,
+  mode,
+  fs
+}) {
+  if (!settings.config.experimental.env) {
+    return;
+  }
+  const schema = settings.config.experimental.env.schema ?? {};
+  let templates = null;
+  return {
+    name: "astro-env-plugin",
+    enforce: "pre",
+    buildStart() {
+      const loadedEnv = loadEnv(
+        mode === "dev" ? "development" : "production",
+        fileURLToPath(settings.config.root),
+        ""
+      );
+      const validatedVariables = validatePublicVariables({ schema, loadedEnv });
+      const clientTemplates = getClientTemplates({ validatedVariables });
+      const serverTemplates = getServerTemplates({ validatedVariables, schema, fs });
+      templates = {
+        client: clientTemplates.module,
+        server: serverTemplates.module,
+        internal: `export const schema = ${JSON.stringify(schema)};`
+      };
+      generateDts({
+        settings,
+        fs,
+        content: getDts({
+          fs,
+          clientPublic: clientTemplates.types,
+          serverPublic: serverTemplates.types.public,
+          serverSecret: serverTemplates.types.secret
+        })
+      });
+    },
+    buildEnd() {
+      templates = null;
+    },
+    resolveId(id) {
+      if (VIRTUAL_MODULES_IDS_VALUES.has(id)) {
+        return resolveVirtualModuleId(id);
+      }
+      if (id === VIRTUAL_MODULE_SETUP_ID) {
+        return this.resolve("astro/virtual-modules/env-setup.js");
+      }
+    },
+    load(id, options) {
+      if (id === resolveVirtualModuleId(VIRTUAL_MODULES_IDS.client)) {
+        return templates.client;
+      }
+      if (id === resolveVirtualModuleId(VIRTUAL_MODULES_IDS.server)) {
+        if (options?.ssr) {
+          return templates.server;
+        }
+        throw new AstroError({
+          ...AstroErrorData.ServerOnlyModule,
+          message: AstroErrorData.ServerOnlyModule.message(VIRTUAL_MODULES_IDS.server)
+        });
+      }
+      if (id === resolveVirtualModuleId(VIRTUAL_MODULES_IDS.internal)) {
+        return templates.internal;
+      }
+    }
+  };
+}
+function resolveVirtualModuleId(id) {
+  return `\0${id}`;
+}
+function generateDts({
+  content,
+  settings,
+  fs
+}) {
+  fs.mkdirSync(settings.dotAstroDir, { recursive: true });
+  fs.writeFileSync(new URL(ENV_TYPES_FILE, settings.dotAstroDir), content, "utf-8");
+}
+function validatePublicVariables({
+  schema,
+  loadedEnv
+}) {
+  const valid = [];
+  const invalid = [];
+  for (const [key, options] of Object.entries(schema)) {
+    if (options.access !== "public") {
+      continue;
+    }
+    const variable = loadedEnv[key];
+    const result = validateEnvVariable(variable === "" ? void 0 : variable, options);
+    if (result.ok) {
+      valid.push({ key, value: result.value, type: result.type, context: options.context });
+    } else {
+      invalid.push({ key, type: result.type });
+    }
+  }
+  if (invalid.length > 0) {
+    throw new AstroError({
+      ...AstroErrorData.EnvInvalidVariables,
+      message: AstroErrorData.EnvInvalidVariables.message(
+        invalid.map(({ key, type }) => `Variable ${key} is not of type: ${type}.`).join("\n")
+      )
+    });
+  }
+  return valid;
+}
+function getDts({
+  clientPublic,
+  serverPublic,
+  serverSecret,
+  fs
+}) {
+  const template = fs.readFileSync(TYPES_TEMPLATE_URL, "utf-8");
+  return template.replace("// @@CLIENT@@", clientPublic).replace("// @@SERVER@@", serverPublic).replace("// @@SECRET_VALUES@@", serverSecret);
+}
+function getClientTemplates({
+  validatedVariables
+}) {
+  let module = "";
+  let types = "";
+  for (const { key, type, value } of validatedVariables.filter((e) => e.context === "client")) {
+    module += `export const ${key} = ${JSON.stringify(value)};`;
+    types += `export const ${key}: ${type};	
+`;
+  }
+  return {
+    module,
+    types
+  };
+}
+function getServerTemplates({
+  validatedVariables,
+  schema,
+  fs
+}) {
+  let module = fs.readFileSync(MODULE_TEMPLATE_URL, "utf-8");
+  let publicTypes = "";
+  let secretTypes = "";
+  for (const { key, type, value } of validatedVariables.filter((e) => e.context === "server")) {
+    module += `export const ${key} = ${JSON.stringify(value)};`;
+    publicTypes += `export const ${key}: ${type};	
+`;
+  }
+  for (const [key, options] of Object.entries(schema)) {
+    if (!(options.context === "server" && options.access === "secret")) {
+      continue;
+    }
+    secretTypes += `${key}: ${getEnvFieldType(options)};		
+`;
+  }
+  return {
+    module,
+    types: {
+      public: publicTypes,
+      secret: secretTypes
+    }
+  };
+}
+export {
+  astroEnv
+};

package/dist/integrations/features-validation.js

@@ -13,7 +13,8 @@ function validateSupportedFeatures(adapterName, featureMap, config, adapterFeatu
     serverOutput = UNSUPPORTED,
     staticOutput = UNSUPPORTED,
     hybridOutput = UNSUPPORTED,
-    i18nDomains = UNSUPPORTED
+    i18nDomains = UNSUPPORTED,
+    envGetSecret = UNSUPPORTED
   } = featureMap;
   const validationResult = {};
   validationResult.staticOutput = validateSupportKind(
@@ -55,6 +56,13 @@ function validateSupportedFeatures(adapterName, featureMap, config, adapterFeatu
       );
     }
   }
+  validationResult.envGetSecret = validateSupportKind(
+    envGetSecret,
+    adapterName,
+    logger,
+    "astro:env getSecret",
+    () => config?.experimental?.env !== void 0
+  );
   return validationResult;
 }
 function validateSupportKind(supportKind, adapterName, logger, featureName, hasCorrectConfig) {

package/dist/jsx/server.js

@@ -1,4 +1,4 @@
-import { AstroError } from "../core/errors/errors.js";
+import { AstroError, AstroUserError } from "../core/errors/errors.js";
 import { AstroJSX, jsx } from "../jsx-runtime/index.js";
 import { renderJSX } from "../runtime/server/jsx.js";
 const slotName = (str) => str.trim().replace(/[-_]([a-z])/g, (_, w) => w.toUpperCase());
@@ -34,6 +34,7 @@ async function renderToStaticMarkup(Component, props = {}, { default: children =
 }
 function throwEnhancedErrorIfMdxComponent(error, Component) {
   if (Component[Symbol.for("mdx-component")]) {
+    if (AstroUserError.is(error)) return;
     throw new AstroError({
       message: error.message,
       title: error.name,

package/dist/runtime/server/render/astro/render.js

@@ -90,6 +90,20 @@ async function callComponentAsTemplateResultOrResponse(result, componentFactory,
   const factoryResult = await componentFactory(result, props, children);
   if (factoryResult instanceof Response) {
     return factoryResult;
+  } else if (isHeadAndContent(factoryResult)) {
+    if (!isRenderTemplateResult(factoryResult.content)) {
+      throw new AstroError({
+        ...AstroErrorData.OnlyResponseCanBeReturned,
+        message: AstroErrorData.OnlyResponseCanBeReturned.message(
+          route?.route,
+          typeof factoryResult
+        ),
+        location: {
+          file: route?.component
+        }
+      });
+    }
+    return factoryResult.content;
   } else if (!isRenderTemplateResult(factoryResult)) {
     throw new AstroError({
       ...AstroErrorData.OnlyResponseCanBeReturned,
@@ -99,7 +113,7 @@ async function callComponentAsTemplateResultOrResponse(result, componentFactory,
       }
     });
   }
-  return isHeadAndContent(factoryResult) ? factoryResult.content : factoryResult;
+  return factoryResult;
 }
 async function bufferHeadContent(result) {
   const iterator = result._metadata.propagators.values();

package/dist/runtime/server/util.js

@@ -1,5 +1,5 @@
 function isPromise(value) {
-  return !!value && typeof value === "object" && typeof value.then === "function";
+  return !!value && typeof value === "object" && "then" in value && typeof value.then === "function";
 }
 async function* streamAsyncIterator(stream) {
   const reader = stream.getReader();

package/dist/virtual-modules/container.d.ts

@@ -0,0 +1,16 @@
+import type { AstroRenderer, SSRLoadedRenderer } from '../@types/astro.js';
+/**
+ * Use this function to provide renderers to the `AstroContainer`:
+ *
+ * ```js
+ * import { getContainerRenderer } from "@astrojs/react";
+ * import { experimental_AstroContainer as AstroContainer } from "astro/container";
+ * import { loadRenderers } from "astro:container"; // use this only when using vite/vitest
+ *
+ * const renderers = await loadRenderers([ getContainerRenderer ]);
+ * const container = await AstroContainer.create({ renderers });
+ *
+ * ```
+ * @param renderers
+ */
+export declare function loadRenderers(renderers: AstroRenderer[]): Promise<SSRLoadedRenderer[]>;

package/dist/virtual-modules/container.js

@@ -0,0 +1,18 @@
+async function loadRenderers(renderers) {
+  const loadedRenderers = await Promise.all(
+    renderers.map(async (renderer) => {
+      const mod = await import(renderer.serverEntrypoint);
+      if (typeof mod.default !== "undefined") {
+        return {
+          ...renderer,
+          ssr: mod.default
+        };
+      }
+      return void 0;
+    })
+  );
+  return loadedRenderers.filter((r) => Boolean(r));
+}
+export {
+  loadRenderers
+};

package/dist/virtual-modules/env-setup.d.ts

@@ -0,0 +1 @@
+export { setGetEnv, type GetEnv } from '../env/runtime.js';

package/dist/virtual-modules/env-setup.js

@@ -0,0 +1,4 @@
+import { setGetEnv } from "../env/runtime.js";
+export {
+  setGetEnv
+};

package/dist/vite-plugin-astro-server/pipeline.d.ts

@@ -1,5 +1,5 @@
 import type { AstroSettings, ComponentInstance, ManifestData, RewritePayload, RouteData, SSRLoadedRenderer, SSRManifest } from '../@types/astro.js';
-import type { HeadElements } from '../core/base-pipeline.js';
+import { type HeadElements } from '../core/base-pipeline.js';
 import type { Logger } from '../core/logger/core.js';
 import type { ModuleLoader } from '../core/module-loader/index.js';
 import { Pipeline } from '../core/render/index.js';
@@ -19,6 +19,7 @@ export declare class DevPipeline extends Pipeline {
     preload(routeData: RouteData, filePath: URL): Promise<ComponentInstance>;
     clearRouteCache(): void;
     getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-    tryRewrite(payload: RewritePayload, request: Request): Promise<[RouteData, ComponentInstance]>;
+    tryRewrite(payload: RewritePayload, request: Request, sourceRoute: RouteData): Promise<[RouteData, ComponentInstance]>;
     setManifestData(manifestData: ManifestData): void;
+    rewriteKnownRoute(route: string, sourceRoute: RouteData): ComponentInstance;
 }

package/dist/vite-plugin-astro-server/pipeline.js

@@ -1,16 +1,17 @@
 import { fileURLToPath } from "node:url";
 import { getInfoOutput } from "../cli/info/index.js";
+import {} from "../core/base-pipeline.js";
 import { ASTRO_VERSION, DEFAULT_404_COMPONENT } from "../core/constants.js";
 import { enhanceViteSSRError } from "../core/errors/dev/index.js";
-import { RouteNotFound } from "../core/errors/errors-data.js";
+import { InvalidRewrite404, RewriteEncounteredAnError } from "../core/errors/errors-data.js";
 import { AggregateError, AstroError, CSSError, MarkdownError } from "../core/errors/index.js";
 import { Pipeline, loadRenderer } from "../core/render/index.js";
+import { DEFAULT_404_ROUTE, default404Page } from "../core/routing/astro-designed-error-pages.js";
 import { isPage, isServerLikeOutput, resolveIdToUrl, viteID } from "../core/util.js";
 import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
 import { getStylesForURL } from "./css.js";
 import { getComponentMetadata } from "./metadata.js";
 import { createResolve } from "./resolve.js";
-import { default404Page } from "./response.js";
 import { getScriptsForURL } from "./scripts.js";
 class DevPipeline extends Pipeline {
   constructor(loader, logger, manifest, settings, config = settings.config) {
@@ -132,41 +133,54 @@ class DevPipeline extends Pipeline {
       return await this.preload(routeData, filePath);
     }
   }
-  async tryRewrite(payload, request) {
+  async tryRewrite(payload, request, sourceRoute) {
     let foundRoute;
     if (!this.manifestData) {
       throw new Error("Missing manifest data. This is an internal error, please file an issue.");
     }
     for (const route of this.manifestData.routes) {
+      let finalUrl = void 0;
       if (payload instanceof URL) {
-        if (route.pattern.test(payload.pathname)) {
-          foundRoute = route;
-          break;
-        }
+        finalUrl = payload;
       } else if (payload instanceof Request) {
-        const url = new URL(payload.url);
-        if (route.pattern.test(url.pathname)) {
-          foundRoute = route;
-          break;
-        }
+        finalUrl = new URL(payload.url);
       } else {
-        const newUrl = new URL(payload, new URL(request.url).origin);
-        if (route.pattern.test(decodeURI(newUrl.pathname))) {
-          foundRoute = route;
-          break;
-        }
+        finalUrl = new URL(payload, new URL(request.url).origin);
+      }
+      if (route.pattern.test(decodeURI(finalUrl.pathname))) {
+        foundRoute = route;
+        break;
+      } else if (finalUrl.pathname === "/404") {
+        foundRoute = DEFAULT_404_ROUTE;
+        break;
       }
     }
     if (foundRoute) {
-      const componentInstance = await this.getComponentByRoute(foundRoute);
-      return [foundRoute, componentInstance];
+      if (foundRoute.pathname === "/404") {
+        const componentInstance = this.rewriteKnownRoute(foundRoute.pathname, sourceRoute);
+        return [foundRoute, componentInstance];
+      } else {
+        const componentInstance = await this.getComponentByRoute(foundRoute);
+        return [foundRoute, componentInstance];
+      }
     } else {
-      throw new AstroError(RouteNotFound);
+      throw new AstroError({
+        ...RewriteEncounteredAnError,
+        message: RewriteEncounteredAnError.message(payload.toString())
+      });
     }
   }
   setManifestData(manifestData) {
     this.manifestData = manifestData;
   }
+  rewriteKnownRoute(route, sourceRoute) {
+    if (isServerLikeOutput(this.config) && sourceRoute.prerender) {
+      if (route === "/404") {
+        return { default: default404Page };
+      }
+    }
+    throw new AstroError(InvalidRewrite404);
+  }
 }
 export {
   DevPipeline

package/dist/vite-plugin-astro-server/plugin.js

@@ -115,6 +115,7 @@ function createDevelopmentManifest(settings) {
     i18n: i18nManifest,
     checkOrigin: settings.config.security?.checkOrigin ?? false,
     rewritingEnabled: settings.config.experimental.rewriting,
+    experimentalEnvGetSecretEnabled: false,
     middleware(_, next) {
       return next();
     }

package/dist/vite-plugin-astro-server/response.d.ts

@@ -3,12 +3,6 @@ import type http from 'node:http';
 import type { ErrorWithMetadata } from '../core/errors/index.js';
 import type { ModuleLoader } from '../core/module-loader/index.js';
 export declare function handle404Response(origin: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
-export declare function default404Page({ pathname }: {
-    pathname: string;
-}): Promise<Response>;
-export declare namespace default404Page {
-    var isAstroComponentFactory: boolean;
-}
 export declare function handle500Response(loader: ModuleLoader, res: http.ServerResponse, err: ErrorWithMetadata): Promise<void>;
 export declare function writeHtmlResponse(res: http.ServerResponse, statusCode: number, html: string): void;
 export declare function writeWebResponse(res: http.ServerResponse, webResponse: Response): Promise<void>;

package/dist/vite-plugin-astro-server/response.js

@@ -12,18 +12,6 @@ async function handle404Response(origin, req, res) {
   });
   writeHtmlResponse(res, 404, html);
 }
-async function default404Page({ pathname }) {
-  return new Response(
-    notFoundTemplate({
-      statusCode: 404,
-      title: "Not found",
-      tabTitle: "404: Not Found",
-      pathname
-    }),
-    { status: 404, headers: { "Content-Type": "text/html; charset=utf-8" } }
-  );
-}
-default404Page.isAstroComponentFactory = true;
 async function handle500Response(loader, res, err) {
   res.on(
     "close",
@@ -92,7 +80,6 @@ async function writeSSRResult(webRequest, webResponse, res) {
   return writeWebResponse(res, webResponse);
 }
 export {
-  default404Page,
   handle404Response,
   handle500Response,
   writeHtmlResponse,

package/dist/vite-plugin-astro-server/route.js

@@ -9,10 +9,11 @@ import { loadMiddleware } from "../core/middleware/loadMiddleware.js";
 import { RenderContext } from "../core/render-context.js";
 import { getProps } from "../core/render/index.js";
 import { createRequest } from "../core/request.js";
+import { default404Page } from "../core/routing/astro-designed-error-pages.js";
 import { matchAllRoutes } from "../core/routing/index.js";
 import { normalizeTheLocale } from "../i18n/index.js";
 import { getSortedPreloadedMatches } from "../prerender/routing.js";
-import { default404Page, handle404Response, writeSSRResult, writeWebResponse } from "./response.js";
+import { handle404Response, writeSSRResult, writeWebResponse } from "./response.js";
 function isLoggedRequest(url) {
   return url !== "/favicon.ico";
 }

package/dist/vite-plugin-inject-env-ts/index.js

@@ -4,8 +4,8 @@ import { bold } from "kleur/colors";
 import { normalizePath } from "vite";
 import { ACTIONS_TYPES_FILE } from "../actions/consts.js";
 import { CONTENT_TYPES_FILE } from "../content/consts.js";
-import { getContentPaths } from "../content/index.js";
 import {} from "../core/logger/core.js";
+import { ENV_TYPES_FILE } from "../env/constants.js";
 function getEnvTsPath({ srcDir }) {
   return new URL("env.d.ts", srcDir);
 }
@@ -24,62 +24,70 @@ function astroInjectEnvTsPlugin({
     }
   };
 }
+function getDotAstroTypeReference({
+  settings,
+  filename
+}) {
+  const relativePath = normalizePath(
+    path.relative(
+      fileURLToPath(settings.config.srcDir),
+      fileURLToPath(new URL(filename, settings.dotAstroDir))
+    )
+  );
+  return `/// <reference path=${JSON.stringify(relativePath)} />`;
+}
 async function setUpEnvTs({
   settings,
   logger,
   fs
 }) {
   const envTsPath = getEnvTsPath(settings.config);
-  const dotAstroDir = getContentPaths(settings.config).cacheDir;
-  const dotAstroTypeReferences = getDotAstroTypeReferences({
-    root: settings.config.root,
-    srcDir: settings.config.srcDir,
-    fs
-  });
-  const envTsPathRelativeToRoot = normalizePath(
+  const envTsPathRelativetoRoot = normalizePath(
     path.relative(fileURLToPath(settings.config.root), fileURLToPath(envTsPath))
   );
+  const injectedTypes = [
+    {
+      filename: CONTENT_TYPES_FILE,
+      meetsCondition: () => fs.existsSync(new URL(CONTENT_TYPES_FILE, settings.dotAstroDir))
+    },
+    {
+      filename: ACTIONS_TYPES_FILE,
+      meetsCondition: () => fs.existsSync(new URL(ACTIONS_TYPES_FILE, settings.dotAstroDir))
+    }
+  ];
+  if (settings.config.experimental.env) {
+    injectedTypes.push({
+      filename: ENV_TYPES_FILE
+    });
+  }
   if (fs.existsSync(envTsPath)) {
     let typesEnvContents = await fs.promises.readFile(envTsPath, "utf-8");
-    let addedTypes = false;
-    for (const typeReference of dotAstroTypeReferences) {
-      if (typesEnvContents.includes(typeReference)) continue;
-      typesEnvContents = `${typeReference}
+    for (const injectedType of injectedTypes) {
+      if (!injectedType.meetsCondition || await injectedType.meetsCondition?.()) {
+        const expectedTypeReference = getDotAstroTypeReference({
+          settings,
+          filename: injectedType.filename
+        });
+        if (!typesEnvContents.includes(expectedTypeReference)) {
+          typesEnvContents = `${expectedTypeReference}
 ${typesEnvContents}`;
-      await fs.promises.writeFile(envTsPath, typesEnvContents, "utf-8");
-      addedTypes = true;
-    }
-    if (addedTypes) {
-      logger.info("types", `Added ${bold(envTsPathRelativeToRoot)} type declarations`);
+        }
+      }
     }
+    logger.info("types", `Added ${bold(envTsPathRelativetoRoot)} type declarations.`);
+    await fs.promises.writeFile(envTsPath, typesEnvContents, "utf-8");
   } else {
     let referenceDefs = [];
     referenceDefs.push('/// <reference types="astro/client" />');
-    if (fs.existsSync(dotAstroDir)) {
-      referenceDefs.push(...dotAstroTypeReferences);
+    for (const injectedType of injectedTypes) {
+      if (!injectedType.meetsCondition || await injectedType.meetsCondition?.()) {
+        referenceDefs.push(getDotAstroTypeReference({ settings, filename: injectedType.filename }));
+      }
     }
     await fs.promises.mkdir(settings.config.srcDir, { recursive: true });
     await fs.promises.writeFile(envTsPath, referenceDefs.join("\n"), "utf-8");
-    logger.info("types", `Added ${bold(envTsPathRelativeToRoot)} type declarations`);
-  }
-}
-function getDotAstroTypeReferences({
-  fs,
-  root,
-  srcDir
-}) {
-  const { cacheDir } = getContentPaths({ root, srcDir });
-  let referenceDefs = [];
-  const typesFiles = [CONTENT_TYPES_FILE, ACTIONS_TYPES_FILE];
-  for (const typesFile of typesFiles) {
-    const url = new URL(typesFile, cacheDir);
-    if (!fs.existsSync(url)) continue;
-    const typesRelativeToSrcDir = normalizePath(
-      path.relative(fileURLToPath(srcDir), fileURLToPath(url))
-    );
-    referenceDefs.push(`/// <reference path=${JSON.stringify(typesRelativeToSrcDir)} />`);
+    logger.info("types", `Added ${bold(envTsPathRelativetoRoot)} type declarations`);
   }
-  return referenceDefs;
 }
 export {
   astroInjectEnvTsPlugin,