astro 5.0.0-alpha.6 → 5.0.0-alpha.7

package/config.d.ts

@@ -1,3 +1,4 @@
+/// <reference path='./client.d.ts' />
 type ViteUserConfig = import('vite').UserConfig;
 type ViteUserConfigFn = import('vite').UserConfigFn;
 type AstroUserConfig = import('./dist/types/public/config.js').AstroUserConfig;

package/dist/actions/runtime/virtual/server.js

@@ -34,7 +34,7 @@ function getFormServerHandler(handler, inputSchema) {
       });
     }
     if (!inputSchema) return await handler(unparsedInput, context);
-    const baseSchema = unwrapSchemaEffects(inputSchema);
+    const baseSchema = unwrapBaseObjectSchema(inputSchema, unparsedInput);
     const parsed = await inputSchema.safeParseAsync(
       baseSchema instanceof z.ZodObject ? formDataToObject(unparsedInput, baseSchema) : unparsedInput
     );
@@ -100,7 +100,7 @@ function handleFormDataGet(key, formData, validator, baseValidator) {
   }
   return validator instanceof z.ZodNumber ? Number(value) : value;
 }
-function unwrapSchemaEffects(schema) {
+function unwrapBaseObjectSchema(schema, unparsedInput) {
   while (schema instanceof z.ZodEffects || schema instanceof z.ZodPipeline) {
     if (schema instanceof z.ZodEffects) {
       schema = schema._def.schema;
@@ -109,6 +109,14 @@ function unwrapSchemaEffects(schema) {
       schema = schema._def.in;
     }
   }
+  if (schema instanceof z.ZodDiscriminatedUnion) {
+    const typeKey = schema._def.discriminator;
+    const typeValue = unparsedInput.get(typeKey);
+    if (typeof typeValue !== "string") return schema;
+    const objSchema = schema._def.optionsMap.get(typeValue);
+    if (!objSchema) return schema;
+    return objSchema;
+  }
   return schema;
 }
 export {

package/dist/assets/build/generate.js

@@ -48,9 +48,9 @@ function getFullImagePath(originalFilePath, env) {
   return new URL(removeLeadingForwardSlash(originalFilePath), env.serverRoot);
 }
 async function generateImagesForPath(originalFilePath, transformsAndPath, env, queue) {
-  const originalImageData = await loadImage(originalFilePath, env);
+  let originalImage;
   for (const [_, transform] of transformsAndPath.transforms) {
-    await queue.add(async () => generateImage(originalImageData, transform.finalPath, transform.transform)).catch((e) => {
+    await queue.add(async () => generateImage(transform.finalPath, transform.transform)).catch((e) => {
       throw e;
     });
   }
@@ -66,9 +66,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     } catch {
     }
   }
-  async function generateImage(originalImage, filepath, options) {
+  async function generateImage(filepath, options) {
     const timeStart = performance.now();
-    const generationData = await generateImageInternal(originalImage, filepath, options);
+    const generationData = await generateImageInternal(filepath, options);
     const timeEnd = performance.now();
     const timeChange = getTimeStat(timeStart, timeEnd);
     const timeIncrease = `(+${timeChange})`;
@@ -80,7 +80,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     );
     env.count.current++;
   }
-  async function generateImageInternal(originalImage, filepath, options) {
+  async function generateImageInternal(filepath, options) {
     const isLocalImage = isESMImportedImage(options.src);
     const finalFileURL = new URL("." + filepath, env.clientRoot);
     const cacheFile = basename(filepath) + (isLocalImage ? "" : ".json");
@@ -116,6 +116,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const finalFolderURL = new URL("./", finalFileURL);
     await fs.promises.mkdir(finalFolderURL, { recursive: true });
     const originalImagePath = isLocalImage ? options.src.src : options.src;
+    if (!originalImage) {
+      originalImage = await loadImage(originalFilePath, env);
+    }
     let resultData = {
       data: void 0,
       expires: originalImage.expires

package/dist/assets/endpoint/config.js

@@ -1,4 +1,9 @@
+import {
+  removeLeadingForwardSlash,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
 import { resolveInjectedRoute } from "../../core/routing/manifest/create.js";
+import { getPattern } from "../../core/routing/manifest/pattern.js";
 function injectImageEndpoint(settings, manifest, mode, cwd) {
   manifest.routes.push(getImageEndpointData(settings, mode, cwd));
 }
@@ -8,17 +13,28 @@ function ensureImageEndpointRoute(settings, manifest, mode, cwd) {
   }
 }
 function getImageEndpointData(settings, mode, cwd) {
-  const endpointEntrypoint = settings.config.image.endpoint ?? (mode === "dev" ? "astro/assets/endpoint/node" : "astro/assets/endpoint/generic");
+  const endpointEntrypoint = settings.config.image.endpoint.entrypoint === void 0 ? mode === "dev" ? "astro/assets/endpoint/node" : "astro/assets/endpoint/generic" : settings.config.image.endpoint.entrypoint;
+  const segments = [
+    [
+      {
+        content: removeTrailingForwardSlash(
+          removeLeadingForwardSlash(settings.config.image.endpoint.route)
+        ),
+        dynamic: false,
+        spread: false
+      }
+    ]
+  ];
   return {
     type: "endpoint",
     isIndex: false,
-    route: "/_image",
-    pattern: /^\/_image$/,
-    segments: [[{ content: "_image", dynamic: false, spread: false }]],
+    route: settings.config.image.endpoint.route,
+    pattern: getPattern(segments, settings.config.base, settings.config.trailingSlash),
+    segments,
     params: [],
     component: resolveInjectedRoute(endpointEntrypoint, settings.config.root, cwd).component,
     generate: () => "",
-    pathname: "/_image",
+    pathname: settings.config.image.endpoint.route,
     prerender: false,
     fallbackRoutes: []
   };

package/dist/assets/services/service.d.ts

@@ -13,7 +13,7 @@ interface SharedServiceProps<T extends Record<string, any> = Record<string, any>
     /**
      * Return the URL to the endpoint or URL your images are generated from.
      *
-     * For a local service, your service should expose an endpoint handling the image requests, or use Astro's at `/_image`.
+     * For a local service, your service should expose an endpoint handling the image requests, or use Astro's which by default, is located at `/_image`.
      *
      * For external services, this should point to the URL your images are coming from, for instance, `/_vercel/image`
      *

package/dist/assets/services/service.js

@@ -167,7 +167,7 @@ const baseService = {
     Object.entries(params).forEach(([param, key]) => {
       options[key] && searchParams.append(param, options[key].toString());
     });
-    const imageEndpoint = joinPaths(import.meta.env.BASE_URL, "/_image");
+    const imageEndpoint = joinPaths(import.meta.env.BASE_URL, imageConfig.endpoint.route);
     return `${imageEndpoint}?${searchParams}`;
   },
   parseURL(url) {

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

@@ -72,7 +72,7 @@ function assets({
     referencedImages: /* @__PURE__ */ new Set()
   };
   return [
-    // Expose the components and different utilities from `astro:assets` and handle serving images from `/_image` in dev
+    // Expose the components and different utilities from `astro:assets`
     {
       name: "astro:assets",
       async resolveId(id) {

package/dist/cli/add/index.d.ts

@@ -10,5 +10,5 @@ interface IntegrationInfo {
     type: 'integration' | 'adapter';
 }
 export declare function add(names: string[], { flags }: AddOptions): Promise<void>;
-export declare function setAdapter(mod: ProxifiedModule<any>, adapter: IntegrationInfo): void;
+export declare function setAdapter(mod: ProxifiedModule<any>, adapter: IntegrationInfo, exportName: string): void;
 export {};

package/dist/cli/add/index.js

@@ -247,7 +247,7 @@ async function add(names, { flags }) {
       if (isAdapter(integration)) {
         const officialExportName = OFFICIAL_ADAPTER_TO_IMPORT_MAP[integration.id];
         if (officialExportName) {
-          setAdapter(mod, integration);
+          setAdapter(mod, integration, officialExportName);
         } else {
           logger.info(
             "SKIP_FORMAT",
@@ -371,14 +371,14 @@ function addIntegration(mod, integration) {
     config.integrations.push(builders.functionCall(integrationId));
   }
 }
-function setAdapter(mod, adapter) {
+function setAdapter(mod, adapter, exportName) {
   const config = getDefaultExportOptions(mod);
   const adapterId = toIdent(adapter.id);
   if (!mod.imports.$items.some((imp) => imp.local === adapterId)) {
     mod.imports.$append({
       imported: "default",
       local: adapterId,
-      from: adapter.packageName
+      from: exportName
     });
   }
   if (!config.output) {

package/dist/cli/create-key/index.d.ts

@@ -0,0 +1,6 @@
+import { type Flags } from '../flags.js';
+interface CreateKeyOptions {
+    flags: Flags;
+}
+export declare function createKey({ flags }: CreateKeyOptions): Promise<0 | 1>;
+export {};

package/dist/cli/create-key/index.js

@@ -0,0 +1,27 @@
+import { createNodeLogger } from "../../core/config/logging.js";
+import { createKey as createCryptoKey, encodeKey } from "../../core/encryption.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function createKey({ flags }) {
+  try {
+    const inlineConfig = flagsToAstroInlineConfig(flags);
+    const logger = createNodeLogger(inlineConfig);
+    const keyPromise = createCryptoKey();
+    const key = await keyPromise;
+    const encoded = await encodeKey(key);
+    logger.info(
+      "crypto",
+      `Generated a key to encrypt props passed to Server islands. To reuse the same key across builds, set this value as ASTRO_KEY in an environment variable on your build server.
+
+ASTRO_KEY=${encoded}`
+    );
+  } catch (err) {
+    if (err != null) {
+      console.error(err.toString());
+    }
+    return 1;
+  }
+  return 0;
+}
+export {
+  createKey
+};

package/dist/cli/index.js

@@ -12,6 +12,7 @@ async function printAstroHelp() {
         ["add", "Add an integration."],
         ["build", "Build your project and write it to disk."],
         ["check", "Check your project for errors."],
+        ["create-key", "Create a cryptography key"],
         ["db", "Manage your Astro database."],
         ["dev", "Start the development server."],
         ["docs", "Open documentation in your web browser."],
@@ -55,6 +56,7 @@ function resolveCommand(flags) {
     "build",
     "preview",
     "check",
+    "create-key",
     "docs",
     "db",
     "info",
@@ -81,6 +83,11 @@ async function runCommand(cmd, flags) {
       await printInfo({ flags });
       return;
     }
+    case "create-key": {
+      const { createKey } = await import("./create-key/index.js");
+      const exitCode = await createKey({ flags });
+      return process.exit(exitCode);
+    }
     case "docs": {
       const { docs } = await import("./docs/index.js");
       await docs({ flags });

package/dist/core/build/generate.js

@@ -283,7 +283,6 @@ async function generatePath(pathname, pipeline, gopts, route) {
     route.type
   );
   const request = createRequest({
-    base: config.base,
     url,
     headers: new Headers(),
     logger,
@@ -329,7 +328,11 @@ async function generatePath(pathname, pipeline, gopts, route) {
   }
   const outFolder = getOutFolder(pipeline.settings, pathname, route);
   const outFile = getOutFile(config, outFolder, pathname, route);
-  route.distURL = outFile;
+  if (route.distURL) {
+    route.distURL.push(outFile);
+  } else {
+    route.distURL = [outFile];
+  }
   await fs.promises.mkdir(outFolder, { recursive: true });
   await fs.promises.writeFile(outFile, body);
 }

package/dist/core/build/index.js

@@ -15,7 +15,7 @@ import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
 import { createSettings } from "../config/settings.js";
 import { createVite } from "../create-vite.js";
-import { createKey } from "../encryption.js";
+import { createKey, getEnvironmentKey, hasEnvironmentKey } from "../encryption.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { levels, timerMessage } from "../logger/core.js";
 import { apply as applyPolyfill } from "../polyfill.js";
@@ -137,6 +137,8 @@ class AstroBuilder {
       "build",
       green(`\u2713 Completed in ${getTimeStat(this.timer.init, performance.now())}.`)
     );
+    const hasKey = hasEnvironmentKey();
+    const keyPromise = hasKey ? getEnvironmentKey() : createKey();
     const opts = {
       allPages,
       settings: this.settings,
@@ -147,9 +149,13 @@ class AstroBuilder {
       pageNames,
       teardownCompiler: this.teardownCompiler,
       viteConfig,
-      key: createKey()
+      key: keyPromise
     };
     const { internals, ssrOutputChunkNames, contentFileNames } = await viteBuild(opts);
+    const hasServerIslands = this.settings.serverIslandNameMap.size > 0;
+    if (hasServerIslands && this.settings.buildOutput !== "server") {
+      throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
+    }
     await staticBuild(opts, internals, ssrOutputChunkNames, contentFileNames);
     this.timer.assetsStart = performance.now();
     Object.keys(assets).map((k) => {
@@ -163,9 +169,7 @@ class AstroBuilder {
     await runHookBuildDone({
       settings: this.settings,
       pages: pageNames,
-      routes: Object.values(allPages).flat().map((pageData) => pageData.route).concat(
-        this.settings.config.experimental.serverIslands ? [getServerIslandRouteData(this.settings.config)] : []
-      ),
+      routes: Object.values(allPages).flat().map((pageData) => pageData.route).concat(hasServerIslands ? getServerIslandRouteData(this.settings.config) : []),
       logging: this.logger,
       cacheManifest: internals.cacheManifestUsed
     });

package/dist/core/build/plugins/plugin-manifest.js

@@ -3,6 +3,7 @@ import glob from "fast-glob";
 import { getAssetsPrefix } from "../../../assets/utils/getAssetsPrefix.js";
 import { normalizeTheLocale } from "../../../i18n/index.js";
 import { toFallbackType, toRoutingStrategy } from "../../../i18n/utils.js";
+import { unwrapSupportKind } from "../../../integrations/features-validation.js";
 import { runHookBuildSsr } from "../../../integrations/hooks.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
 import { encodeKey } from "../../encryption.js";
@@ -208,7 +209,7 @@ function buildManifest(opts, internals, staticFiles, encodedKey) {
     checkOrigin: settings.config.security?.checkOrigin ?? false,
     serverIslandNameMap: Array.from(settings.serverIslandNameMap),
     key: encodedKey,
-    envGetSecretEnabled: (settings.adapter?.supportedAstroFeatures.envGetSecret ?? "unsupported") !== "unsupported"
+    envGetSecretEnabled: (unwrapSupportKind(settings.adapter?.supportedAstroFeatures.envGetSecret) ?? "unsupported") !== "unsupported"
   };
 }
 export {

package/dist/core/build/plugins/plugin-ssr.js

@@ -141,10 +141,9 @@ function generateSSRCode(settings, adapter, middlewareId) {
     `import * as serverEntrypointModule from '${ADAPTER_VIRTUAL_MODULE_ID}';`,
     `import { manifest as defaultManifest } from '${SSR_MANIFEST_VIRTUAL_MODULE_ID}';`,
     edgeMiddleware ? `` : `import { onRequest as middleware } from '${middlewareId}';`,
-    settings.config.experimental.serverIslands ? `import { serverIslandMap } from '${VIRTUAL_ISLAND_MAP_ID}';` : ""
+    `import { serverIslandMap } from '${VIRTUAL_ISLAND_MAP_ID}';`
   ];
   const contents = [
-    settings.config.experimental.serverIslands ? "" : `const serverIslandMap = new Map()`,
     edgeMiddleware ? `const middleware = (_, next) => next()` : "",
     `const _manifest = Object.assign(defaultManifest, {`,
     `    pageMap,`,