astro 6.0.0-alpha.0 → 6.0.0-alpha.1

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

@@ -1,10 +1,11 @@
 import { extname } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { getAssetsPrefix } from "../assets/utils/getAssetsPrefix.js";
+import { fileURLToPath } from "node:url";
+import { isRunnableDevEnvironment } from "vite";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
-import { joinPaths, prependForwardSlash } from "../core/path.js";
-import { getStylesForURL } from "../vite-plugin-astro-server/css.js";
+import { wrapId } from "../core/util.js";
+import { isBuildableCSSRequest } from "../vite-plugin-astro-server/util.js";
+import { crawlGraph } from "../vite-plugin-astro-server/vite.js";
 import {
   CONTENT_IMAGE_FLAG,
   CONTENT_RENDER_FLAG,
@@ -13,6 +14,9 @@ import {
   STYLES_PLACEHOLDER
 } from "./consts.js";
 import { hasContentFlag } from "./utils.js";
+import { joinPaths, prependForwardSlash, slash } from "@astrojs/internal-helpers/path";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+import { isAstroServerEnvironment } from "../environments.js";
 function astroContentAssetPropagationPlugin({
   settings
 }) {
@@ -49,13 +53,19 @@ function astroContentAssetPropagationPlugin({
       }
     },
     configureServer(server) {
-      devModuleLoader = createViteLoader(server);
+      if (!isRunnableDevEnvironment(server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
+        return;
+      }
+      devModuleLoader = createViteLoader(
+        server,
+        server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]
+      );
     },
-    async transform(_, id, options) {
+    async transform(_, id) {
       if (hasContentFlag(id, PROPAGATED_ASSET_FLAG)) {
         const basePath = id.split("?")[0];
         let stringifiedLinks, stringifiedStyles;
-        if (options?.ssr && devModuleLoader) {
+        if (isAstroServerEnvironment(this.environment) && devModuleLoader) {
           if (!devModuleLoader.getModuleById(basePath)?.ssrModule) {
             await devModuleLoader.import(basePath);
           }
@@ -63,7 +73,7 @@ function astroContentAssetPropagationPlugin({
             styles,
             urls,
             crawledFiles: styleCrawledFiles
-          } = await getStylesForURL(pathToFileURL(basePath), devModuleLoader);
+          } = await getStylesForURL(basePath, devModuleLoader.getSSREnvironment());
           for (const file of styleCrawledFiles) {
             if (!file.includes("node_modules")) {
               this.addWatchFile(file);
@@ -89,60 +99,94 @@ function astroContentAssetPropagationPlugin({
     }
   };
 }
-function astroConfigBuildPlugin(options, internals) {
-  return {
-    targets: ["server"],
-    hooks: {
-      "build:post": ({ ssrOutputs, mutate }) => {
-        const outputs = ssrOutputs.flatMap((o) => o.output);
-        const prependBase = (src) => {
-          const { assetsPrefix } = options.settings.config.build;
-          if (assetsPrefix) {
-            const fileExtension = extname(src);
-            const pf = getAssetsPrefix(fileExtension, assetsPrefix);
-            return joinPaths(pf, src);
+const INLINE_QUERY_REGEX = /(?:\?|&)inline(?:$|&)/;
+async function getStylesForURL(filePath, environment) {
+  const importedCssUrls = /* @__PURE__ */ new Set();
+  const importedStylesMap = /* @__PURE__ */ new Map();
+  const crawledFiles = /* @__PURE__ */ new Set();
+  for await (const importedModule of crawlGraph(environment, filePath, false)) {
+    if (importedModule.file) {
+      crawledFiles.add(importedModule.file);
+    }
+    if (isBuildableCSSRequest(importedModule.url)) {
+      let css = "";
+      if (typeof importedModule.ssrModule?.default === "string") {
+        css = importedModule.ssrModule.default;
+      } else {
+        let modId = importedModule.url;
+        if (!INLINE_QUERY_REGEX.test(importedModule.url)) {
+          if (importedModule.url.includes("?")) {
+            modId = importedModule.url.replace("?", "?inline&");
           } else {
-            return prependForwardSlash(joinPaths(options.settings.config.base, src));
-          }
-        };
-        for (const chunk of outputs) {
-          if (chunk.type === "chunk" && chunk.code.includes(LINKS_PLACEHOLDER)) {
-            const entryStyles = /* @__PURE__ */ new Set();
-            const entryLinks = /* @__PURE__ */ new Set();
-            for (const id of chunk.moduleIds) {
-              const _entryCss = internals.propagatedStylesMap.get(id);
-              if (_entryCss) {
-                for (const value of _entryCss) {
-                  if (value.type === "inline") entryStyles.add(value.content);
-                  if (value.type === "external") entryLinks.add(value.src);
-                }
-              }
-            }
-            let newCode = chunk.code;
-            if (entryStyles.size) {
-              newCode = newCode.replace(
-                JSON.stringify(STYLES_PLACEHOLDER),
-                JSON.stringify(Array.from(entryStyles))
-              );
-            } else {
-              newCode = newCode.replace(JSON.stringify(STYLES_PLACEHOLDER), "[]");
-            }
-            if (entryLinks.size) {
-              newCode = newCode.replace(
-                JSON.stringify(LINKS_PLACEHOLDER),
-                JSON.stringify(Array.from(entryLinks).map(prependBase))
-              );
-            } else {
-              newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
-            }
-            mutate(chunk, ["server"], newCode);
+            modId += "?inline";
           }
         }
+        try {
+          const ssrModule = await environment.runner.import(modId);
+          css = ssrModule.default;
+        } catch {
+          continue;
+        }
       }
+      importedStylesMap.set(importedModule.url, {
+        id: wrapId(importedModule.id ?? importedModule.url),
+        url: wrapId(importedModule.url),
+        content: css
+      });
     }
+  }
+  return {
+    urls: importedCssUrls,
+    styles: [...importedStylesMap.values()],
+    crawledFiles
   };
 }
+async function contentAssetsBuildPostHook(base, internals, {
+  ssrOutputs,
+  prerenderOutputs,
+  mutate
+}) {
+  const outputs = ssrOutputs.flatMap((o) => o.output).concat(
+    ...(Array.isArray(prerenderOutputs) ? prerenderOutputs : [prerenderOutputs]).flatMap(
+      (o) => o.output
+    )
+  );
+  for (const chunk of outputs) {
+    if (chunk.type !== "chunk") continue;
+    if (!chunk.code.includes(LINKS_PLACEHOLDER)) continue;
+    const entryStyles = /* @__PURE__ */ new Set();
+    const entryLinks = /* @__PURE__ */ new Set();
+    for (const id of chunk.moduleIds) {
+      const entryCss = internals.propagatedStylesMap.get(id);
+      if (entryCss) {
+        for (const value of entryCss) {
+          if (value.type === "inline") entryStyles.add(value.content);
+          if (value.type === "external")
+            entryLinks.add(prependForwardSlash(joinPaths(base, slash(value.src))));
+        }
+      }
+    }
+    let newCode = chunk.code;
+    if (entryStyles.size) {
+      newCode = newCode.replace(
+        JSON.stringify(STYLES_PLACEHOLDER),
+        JSON.stringify(Array.from(entryStyles))
+      );
+    } else {
+      newCode = newCode.replace(JSON.stringify(STYLES_PLACEHOLDER), "[]");
+    }
+    if (entryLinks.size) {
+      newCode = newCode.replace(
+        JSON.stringify(LINKS_PLACEHOLDER),
+        JSON.stringify(Array.from(entryLinks))
+      );
+    } else {
+      newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
+    }
+    mutate(chunk, ["server"], newCode);
+  }
+}
 export {
-  astroConfigBuildPlugin,
-  astroContentAssetPropagationPlugin
+  astroContentAssetPropagationPlugin,
+  contentAssetsBuildPostHook
 };

package/dist/content/vite-plugin-content-imports.js

@@ -22,6 +22,7 @@ import {
   reloadContentConfigObserver,
   reverseSymlink
 } from "./utils.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 function getContentRendererByViteId(viteId, settings) {
   let ext = viteId.split(".").pop();
   if (!ext) return void 0;
@@ -111,17 +112,22 @@ export const _internal = {
       configureServer(viteServer) {
         viteServer.watcher.on("all", async (event, entry) => {
           if (CHOKIDAR_MODIFIED_EVENTS.includes(event)) {
+            const environment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
             const entryType = getEntryType(entry, contentPaths, contentEntryExts, dataEntryExts);
             if (!COLLECTION_TYPES_TO_INVALIDATE_ON.includes(entryType)) return;
             if (entryType === "content" || entryType === "data") {
-              await reloadContentConfigObserver({ fs, settings, viteServer });
+              await reloadContentConfigObserver({
+                fs,
+                settings,
+                environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro]
+              });
             }
-            for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
+            for (const modUrl of environment.moduleGraph.urlToModuleMap.keys()) {
               if (hasContentFlag(modUrl, CONTENT_FLAG) || hasContentFlag(modUrl, DATA_FLAG) || Boolean(getContentRendererByViteId(modUrl, settings))) {
                 try {
-                  const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);
+                  const mod = await environment.moduleGraph.getModuleByUrl(modUrl);
                   if (mod) {
-                    viteServer.moduleGraph.invalidateModule(mod);
+                    environment.moduleGraph.invalidateModule(mod);
                   }
                 } catch (e) {
                   if (e.code === "ERR_CLOSED_SERVER") break;

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -1,7 +1,8 @@
+import { dataToEsm } from "@rollup/pluginutils";
 import nodeFs from "node:fs";
 import { fileURLToPath } from "node:url";
-import { dataToEsm } from "@rollup/pluginutils";
 import { normalizePath } from "vite";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
 import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
@@ -20,12 +21,14 @@ import {
 } from "./consts.js";
 import { getDataStoreFile } from "./content-layer.js";
 import { getContentPaths, isDeferredModule } from "./utils.js";
-function invalidateDataStore(server) {
-  const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
+import { isAstroClientEnvironment } from "../environments.js";
+function invalidateDataStore(viteServer) {
+  const environment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+  const module = environment.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
   if (module) {
-    server.moduleGraph.invalidateModule(module);
+    environment.moduleGraph.invalidateModule(module);
   }
-  server.ws.send({
+  viteServer.environments.client.hot.send({
     type: "full-reload",
     path: "*"
   });
@@ -92,9 +95,9 @@ function astroContentVirtualModPlugin({
         return ASSET_IMPORTS_RESOLVED_STUB_ID;
       }
     },
-    async load(id, args) {
+    async load(id) {
       if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        const isClient = !args?.ssr;
+        const isClient = isAstroClientEnvironment(this.environment);
         const code = await generateContentEntryFile({
           settings,
           fs,

package/dist/core/app/app.d.ts

@@ -0,0 +1,5 @@
+import { BaseApp } from './base.js';
+import { AppPipeline } from './pipeline.js';
+export declare class App extends BaseApp {
+    createPipeline(streaming: boolean): AppPipeline;
+}

package/dist/core/app/app.js

@@ -0,0 +1,13 @@
+import { BaseApp } from "./base.js";
+import { AppPipeline } from "./pipeline.js";
+class App extends BaseApp {
+  createPipeline(streaming) {
+    return AppPipeline.create({
+      manifest: this.manifest,
+      streaming
+    });
+  }
+}
+export {
+  App
+};

package/dist/core/app/base.d.ts

@@ -0,0 +1,132 @@
+import type { RoutesList } from '../../types/astro.js';
+import type { RemotePattern, RouteData } from '../../types/public/index.js';
+import type { Pipeline } from '../base-pipeline.js';
+import { getSetCookiesFromResponse } from '../cookies/index.js';
+import { AstroIntegrationLogger, Logger } from '../logger/core.js';
+import { type CreateRenderContext, RenderContext } from '../render-context.js';
+import type { AppPipeline } from './pipeline.js';
+import type { SSRManifest } from './types.js';
+export interface RenderOptions {
+    /**
+     * Whether to automatically add all cookies written by `Astro.cookie.set()` to the response headers.
+     *
+     * When set to `true`, they will be added to the `Set-Cookie` header as comma-separated key=value pairs. You can use the standard `response.headers.getSetCookie()` API to read them individually.
+     *
+     * When set to `false`, the cookies will only be available from `App.getSetCookieFromResponse(response)`.
+     *
+     * @default {false}
+     */
+    addCookieHeader?: boolean;
+    /**
+     * The client IP address that will be made available as `Astro.clientAddress` in pages, and as `ctx.clientAddress` in API routes and middleware.
+     *
+     * Default: `request[Symbol.for("astro.clientAddress")]`
+     */
+    clientAddress?: string;
+    /**
+     * The mutable object that will be made available as `Astro.locals` in pages, and as `ctx.locals` in API routes and middleware.
+     */
+    locals?: object;
+    /**
+     * A custom fetch function for retrieving prerendered pages - 404 or 500.
+     *
+     * If not provided, Astro will fallback to its default behavior for fetching error pages.
+     *
+     * When a dynamic route is matched but ultimately results in a 404, this function will be used
+     * to fetch the prerendered 404 page if available. Similarly, it may be used to fetch a
+     * prerendered 500 error page when necessary.
+     *
+     * @param {ErrorPagePath} url - The URL of the prerendered 404 or 500 error page to fetch.
+     * @returns {Promise<Response>} A promise resolving to the prerendered response.
+     */
+    prerenderedErrorPageFetch?: (url: ErrorPagePath) => Promise<Response>;
+    /**
+     * **Advanced API**: you probably do not need to use this.
+     *
+     * Default: `app.match(request)`
+     */
+    routeData?: RouteData;
+}
+export interface RenderErrorOptions {
+    locals?: App.Locals;
+    routeData?: RouteData;
+    response?: Response;
+    status: 404 | 500;
+    /**
+     * Whether to skip middleware while rendering the error page. Defaults to false.
+     */
+    skipMiddleware?: boolean;
+    /**
+     * Allows passing an error to 500.astro. It will be available through `Astro.props.error`.
+     */
+    error?: unknown;
+    clientAddress: string | undefined;
+    prerenderedErrorPageFetch: ((url: ErrorPagePath) => Promise<Response>) | undefined;
+}
+type ErrorPagePath = `${string}/404` | `${string}/500` | `${string}/404/` | `${string}/500/` | `${string}404.html` | `${string}500.html`;
+export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
+    manifest: SSRManifest;
+    manifestData: RoutesList;
+    pipeline: P;
+    adapterLogger: AstroIntegrationLogger;
+    baseWithoutTrailingSlash: string;
+    logger: Logger;
+    constructor(manifest: SSRManifest, streaming?: boolean, ...args: any[]);
+    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
+    getAdapterLogger(): AstroIntegrationLogger;
+    getAllowedDomains(): Partial<RemotePattern>[] | undefined;
+    protected matchesAllowedDomains(forwardedHost: string, protocol?: string): boolean;
+    static validateForwardedHost(forwardedHost: string, allowedDomains?: Partial<RemotePattern>[], protocol?: string): boolean;
+    /**
+     * Creates a pipeline by reading the stored manifest
+     *
+     * @param streaming
+     * @param manifest
+     * @param args
+     * @private
+     */
+    abstract createPipeline(streaming: boolean, manifest: SSRManifest, ...args: any[]): P;
+    set setManifestData(newManifestData: RoutesList);
+    removeBase(pathname: string): string;
+    /**
+     * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
+     *
+     * If the decoding fails, it logs the error and return the pathname as is.
+     * @param request
+     */
+    getPathnameFromRequest(request: Request): string;
+    /**
+     * Given a `Request`, it returns the `RouteData` that matches its `pathname`. By default, prerendered
+     * routes aren't returned, even if they are matched.
+     *
+     * When `allowPrerenderedRoutes` is `true`, the function returns matched prerendered routes too.
+     * @param request
+     * @param allowPrerenderedRoutes
+     */
+    match(request: Request, allowPrerenderedRoutes?: boolean): RouteData | undefined;
+    private computePathnameFromDomain;
+    private redirectTrailingSlash;
+    render(request: Request, renderOptions?: RenderOptions): Promise<Response>;
+    setCookieHeaders(response: Response): Generator<string, string[], any>;
+    /**
+     * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
+     * For example,
+     * ```ts
+     * for (const cookie_ of App.getSetCookieFromResponse(response)) {
+     *     const cookie: string = cookie_
+     * }
+     * ```
+     * @param response The response to read cookies from.
+     * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
+     */
+    static getSetCookieFromResponse: typeof getSetCookiesFromResponse;
+    /**
+     * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
+     * This also handles pre-rendered /404 or /500 routes
+     */
+    renderError(request: Request, { locals, status, response: originalResponse, skipMiddleware, error, clientAddress, prerenderedErrorPageFetch, }: RenderErrorOptions): Promise<Response>;
+    private mergeResponses;
+    getDefaultStatusCode(routeData: RouteData, pathname: string): number;
+    getManifest(): SSRManifest;
+}
+export {};