astro 5.16.5 → 6.0.0-alpha.1

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

@@ -0,0 +1,410 @@
+import { prependForwardSlash, removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { BaseApp } from "../core/app/index.js";
+import { shouldAppendForwardSlash } from "../core/build/util.js";
+import {
+  clientLocalsSymbol,
+  DEFAULT_404_COMPONENT,
+  NOOP_MIDDLEWARE_HEADER,
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY
+} from "../core/constants.js";
+import {
+  MiddlewareNoDataOrNextCalled,
+  MiddlewareNotAResponse,
+  NoMatchingStaticPathFound
+} from "../core/errors/errors-data.js";
+import { createSafeError, isAstroError } from "../core/errors/index.js";
+import { req } from "../core/messages.js";
+import { getProps } from "../core/render/index.js";
+import { createRequest } from "../core/request.js";
+import { redirectTemplate } from "../core/routing/3xx.js";
+import { matchAllRoutes, routeIsRedirect } from "../core/routing/index.js";
+import { isRoute404, isRoute500 } from "../core/routing/match.js";
+import { PERSIST_SYMBOL } from "../core/session.js";
+import { getSortedPreloadedMatches } from "../prerender/routing.js";
+import { recordServerError } from "../vite-plugin-astro-server/error.js";
+import { runWithErrorHandling } from "../vite-plugin-astro-server/index.js";
+import {
+  handle500Response,
+  writeSSRResult,
+  writeWebResponse
+} from "../vite-plugin-astro-server/response.js";
+import { AstroServerPipeline } from "./pipeline.js";
+class AstroServerApp extends BaseApp {
+  settings;
+  logger;
+  loader;
+  manifestData;
+  currentRenderContext = void 0;
+  constructor(manifest, streaming = true, logger, manifestData, loader, settings, getDebugInfo) {
+    super(manifest, streaming, settings, logger, loader, manifestData, getDebugInfo);
+    this.settings = settings;
+    this.logger = logger;
+    this.loader = loader;
+    this.manifestData = manifestData;
+  }
+  static async create(manifest, routesList, logger, loader, settings, getDebugInfo) {
+    return new AstroServerApp(manifest, true, logger, routesList, loader, settings, getDebugInfo);
+  }
+  createPipeline(_streaming, manifest, settings, logger, loader, manifestData, getDebugInfo) {
+    return AstroServerPipeline.create(manifestData, {
+      loader,
+      logger,
+      manifest,
+      settings,
+      getDebugInfo
+    });
+  }
+  async createRenderContext(payload) {
+    this.currentRenderContext = await super.createRenderContext(payload);
+    return this.currentRenderContext;
+  }
+  clearRouteCache() {
+    this.pipeline.clearRouteCache();
+  }
+  async handleRequest({
+    controller,
+    incomingRequest,
+    incomingResponse,
+    isHttps
+  }) {
+    const origin = `${isHttps ? "https" : "http"}://${incomingRequest.headers[":authority"] ?? incomingRequest.headers.host}`;
+    const url = new URL(origin + incomingRequest.url);
+    let pathname;
+    if (this.manifest.trailingSlash === "never" && !incomingRequest.url) {
+      pathname = "";
+    } else {
+      pathname = decodeURI(url.pathname);
+    }
+    url.pathname = removeTrailingForwardSlash(this.manifest.base) + url.pathname;
+    if (url.pathname.endsWith("/") && !shouldAppendForwardSlash(this.manifest.trailingSlash, this.manifest.buildFormat)) {
+      url.pathname = url.pathname.slice(0, -1);
+    }
+    let body = void 0;
+    if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
+      let bytes = [];
+      await new Promise((resolve) => {
+        incomingRequest.on("data", (part) => {
+          bytes.push(part);
+        });
+        incomingRequest.on("end", resolve);
+      });
+      body = Buffer.concat(bytes);
+    }
+    const self = this;
+    await runWithErrorHandling({
+      controller,
+      pathname,
+      async run() {
+        const matchedRoute = await matchRoute(
+          pathname,
+          self.manifestData,
+          self.pipeline,
+          self.manifest
+        );
+        const resolvedPathname = matchedRoute?.resolvedPathname ?? pathname;
+        return await self.handleRoute({
+          matchedRoute,
+          url,
+          pathname: resolvedPathname,
+          body,
+          incomingRequest,
+          incomingResponse
+        });
+      },
+      onError(_err) {
+        const error = createSafeError(_err);
+        if (self.loader) {
+          const { errorWithMetadata } = recordServerError(
+            self.loader,
+            self.manifest,
+            self.logger,
+            error
+          );
+          handle500Response(self.loader, incomingResponse, errorWithMetadata);
+        }
+        return error;
+      }
+    });
+  }
+  async handleRoute({
+    matchedRoute,
+    incomingRequest,
+    incomingResponse,
+    body,
+    url,
+    pathname
+  }) {
+    const timeStart = performance.now();
+    const { logger } = this.pipeline;
+    if (!matchedRoute) {
+      throw new Error("No route matched, and default 404 route was not found.");
+    }
+    let request;
+    let renderContext;
+    let route = matchedRoute.route;
+    const componentInstance = await this.pipeline.getComponentByRoute(route);
+    const locals = Reflect.get(incomingRequest, clientLocalsSymbol);
+    request = createRequest({
+      url,
+      headers: incomingRequest.headers,
+      method: incomingRequest.method,
+      body,
+      logger,
+      isPrerendered: route.prerender,
+      routePattern: route.component
+    });
+    for (const [name, value] of Object.entries(this.settings.config.server.headers ?? {})) {
+      if (value) incomingResponse.setHeader(name, value);
+    }
+    renderContext = await this.createRenderContext({
+      locals,
+      pipeline: this.pipeline,
+      pathname,
+      skipMiddleware: isDefaultPrerendered404(matchedRoute.route),
+      request,
+      routeData: route,
+      clientAddress: incomingRequest.socket.remoteAddress,
+      shouldInjectCspMetaTags: false
+    });
+    let response;
+    let statusCode = 200;
+    let isReroute = false;
+    let isRewrite = false;
+    try {
+      response = await renderContext.render(componentInstance);
+      isReroute = response.headers.has(REROUTE_DIRECTIVE_HEADER);
+      isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
+      const statusCodedMatched = getStatusByMatchedRoute(route);
+      statusCode = isRewrite ? (
+        // Ignore `matchedRoute` status for rewrites
+        response.status
+      ) : (
+        // Our internal noop middleware sets a particular header. If the header isn't present, it means that the user have
+        // their own middleware, so we need to return what the user returns.
+        !response.headers.has(NOOP_MIDDLEWARE_HEADER) && !isReroute ? response.status : statusCodedMatched ?? response.status
+      );
+    } catch (err) {
+      response = await this.renderError(request, {
+        skipMiddleware: false,
+        locals,
+        status: 500,
+        prerenderedErrorPageFetch: fetch,
+        clientAddress: incomingRequest.socket.remoteAddress,
+        error: err
+      });
+      statusCode = 500;
+    } finally {
+      this.currentRenderContext?.session?.[PERSIST_SYMBOL]();
+    }
+    if (isLoggedRequest(pathname)) {
+      const timeEnd = performance.now();
+      logger.info(
+        null,
+        req({
+          url: pathname,
+          method: incomingRequest.method,
+          statusCode,
+          isRewrite,
+          reqTime: timeEnd - timeStart
+        })
+      );
+    }
+    if (statusCode === 404 && // If the body isn't null, that means the user sets the 404 status
+    // but uses the current route to handle the 404
+    response.body === null && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
+      const fourOhFourRoute = await matchRoute(
+        "/404",
+        this.manifestData,
+        this.pipeline,
+        this.manifest
+      );
+      if (fourOhFourRoute) {
+        renderContext = await this.createRenderContext({
+          locals,
+          pipeline: this.pipeline,
+          pathname,
+          skipMiddleware: isDefaultPrerendered404(fourOhFourRoute.route),
+          request,
+          routeData: fourOhFourRoute.route,
+          clientAddress: incomingRequest.socket.remoteAddress,
+          status: 404,
+          shouldInjectCspMetaTags: false
+        });
+        const component = await this.pipeline.preload(
+          fourOhFourRoute.route,
+          fourOhFourRoute.filePath
+        );
+        response = await renderContext.render(component);
+      }
+    }
+    if (isReroute) {
+      response.headers.delete(REROUTE_DIRECTIVE_HEADER);
+    }
+    if (isRewrite) {
+      response.headers.delete(REROUTE_DIRECTIVE_HEADER);
+    }
+    if (route.type === "endpoint") {
+      await writeWebResponse(incomingResponse, response);
+      return;
+    }
+    if (isRewrite) {
+      await writeSSRResult(request, response, incomingResponse);
+      return;
+    }
+    if (response.status < 400 && response.status >= 300) {
+      if (response.status >= 300 && response.status < 400 && routeIsRedirect(route) && !this.settings.config.build.redirects && this.settings.buildOutput === "static") {
+        const location = response.headers.get("location");
+        response = new Response(
+          redirectTemplate({
+            status: response.status,
+            absoluteLocation: location,
+            relativeLocation: location,
+            from: pathname
+          }),
+          {
+            status: 200,
+            headers: {
+              ...response.headers,
+              "content-type": "text/html"
+            }
+          }
+        );
+      }
+      await writeSSRResult(request, response, incomingResponse);
+      return;
+    }
+    if (response.status !== statusCode) {
+      response = new Response(response.body, {
+        status: statusCode,
+        headers: response.headers
+      });
+    }
+    await writeSSRResult(request, response, incomingResponse);
+  }
+  match(request, _allowPrerenderedRoutes) {
+    const url = new URL(request.url);
+    if (this.manifest.assets.has(url.pathname)) return void 0;
+    let pathname = prependForwardSlash(this.removeBase(url.pathname));
+    return this.manifestData.routes.find((route) => {
+      return route.pattern.test(pathname) || route.fallbackRoutes.some((fallbackRoute) => fallbackRoute.pattern.test(pathname));
+    });
+  }
+  async renderError(request, { locals, skipMiddleware = false, error, clientAddress, status }) {
+    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
+      throw error;
+    }
+    const custom500 = getCustom500Route(this.manifestData);
+    if (!custom500) {
+      throw error;
+    }
+    try {
+      const filePath500 = new URL(`./${custom500.component}`, this.manifest.rootDir);
+      const preloaded500Component = await this.pipeline.preload(custom500, filePath500);
+      const renderContext = await this.createRenderContext({
+        locals,
+        pipeline: this.pipeline,
+        pathname: this.getPathnameFromRequest(request),
+        skipMiddleware,
+        request,
+        routeData: custom500,
+        clientAddress,
+        status,
+        shouldInjectCspMetaTags: false
+      });
+      renderContext.props.error = error;
+      const response = await renderContext.render(preloaded500Component);
+      this.logger.error("router", error.stack || error.message);
+      return response;
+    } catch (_err) {
+      if (skipMiddleware === false) {
+        return this.renderError(request, {
+          clientAddress: void 0,
+          prerenderedErrorPageFetch: fetch,
+          status: 500,
+          skipMiddleware: true,
+          error: _err
+        });
+      }
+      throw _err;
+    }
+  }
+}
+function getStatusByMatchedRoute(route) {
+  if (route.route === "/404") return 404;
+  if (route.route === "/500") return 500;
+  return void 0;
+}
+function isDefaultPrerendered404(route) {
+  return route.route === "/404" && route.prerender && route.component === DEFAULT_404_COMPONENT;
+}
+function isLoggedRequest(url) {
+  return url !== "/favicon.ico";
+}
+async function matchRoute(pathname, routesList, pipeline, manifest) {
+  const { logger, routeCache } = pipeline;
+  const matches = matchAllRoutes(pathname, routesList);
+  const preloadedMatches = await getSortedPreloadedMatches({
+    pipeline,
+    matches,
+    manifest
+  });
+  for await (const { route: maybeRoute, filePath } of preloadedMatches) {
+    try {
+      await getProps({
+        mod: await pipeline.preload(maybeRoute, filePath),
+        routeData: maybeRoute,
+        routeCache,
+        pathname,
+        logger,
+        serverLike: pipeline.manifest.serverLike,
+        base: manifest.base,
+        trailingSlash: manifest.trailingSlash
+      });
+      return {
+        route: maybeRoute,
+        filePath,
+        resolvedPathname: pathname
+      };
+    } catch (e) {
+      if (isAstroError(e) && e.title === NoMatchingStaticPathFound.title) {
+        continue;
+      }
+      throw e;
+    }
+  }
+  const altPathname = pathname.replace(/\/index\.html$/, "/").replace(/\.html$/, "");
+  if (altPathname !== pathname) {
+    return await matchRoute(altPathname, routesList, pipeline, manifest);
+  }
+  if (matches.length) {
+    const possibleRoutes = matches.flatMap((route) => route.component);
+    logger.warn(
+      "router",
+      `${NoMatchingStaticPathFound.message(
+        pathname
+      )}
+
+${NoMatchingStaticPathFound.hint(possibleRoutes)}`
+    );
+  }
+  const custom404 = getCustom404Route(routesList);
+  if (custom404) {
+    const filePath = new URL(`./${custom404.component}`, manifest.rootDir);
+    return {
+      route: custom404,
+      filePath,
+      resolvedPathname: pathname
+    };
+  }
+  return void 0;
+}
+function getCustom404Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute404(r.route));
+}
+function getCustom500Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute500(r.route));
+}
+export {
+  AstroServerApp
+};

package/dist/vite-plugin-app/createAstroServerApp.d.ts

@@ -0,0 +1,8 @@
+import type http from 'node:http';
+import { Logger } from '../core/logger/core.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { AstroSettings } from '../types/astro.js';
+import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
+export default function createAstroServerApp(controller: DevServerController, settings: AstroSettings, loader: ModuleLoader, logger?: Logger): Promise<{
+    handler(incomingRequest: http.IncomingMessage, incomingResponse: http.ServerResponse): void;
+}>;

package/dist/vite-plugin-app/createAstroServerApp.js

@@ -0,0 +1,56 @@
+import { manifest } from "virtual:astro:manifest";
+import { routes } from "virtual:astro:routes";
+import { getPackageManager } from "../cli/info/core/get-package-manager.js";
+import { DevDebugInfoProvider } from "../cli/info/infra/dev-debug-info-provider.js";
+import { ProcessNodeVersionProvider } from "../cli/info/infra/process-node-version-provider.js";
+import { ProcessPackageManagerUserAgentProvider } from "../cli/info/infra/process-package-manager-user-agent-provider.js";
+import { StyledDebugInfoFormatter } from "../cli/info/infra/styled-debug-info-formatter.js";
+import { BuildTimeAstroVersionProvider } from "../cli/infra/build-time-astro-version-provider.js";
+import { PassthroughTextStyler } from "../cli/infra/passthrough-text-styler.js";
+import { ProcessOperatingSystemProvider } from "../cli/infra/process-operating-system-provider.js";
+import { TinyexecCommandExecutor } from "../cli/infra/tinyexec-command-executor.js";
+import { Logger } from "../core/logger/core.js";
+import { nodeLogDestination } from "../core/logger/node.js";
+import { AstroServerApp } from "./app.js";
+async function createAstroServerApp(controller, settings, loader, logger) {
+  const actualLogger = logger ?? new Logger({
+    dest: nodeLogDestination,
+    level: settings.logLevel
+  });
+  const routesList = { routes: routes.map((r) => r.routeData) };
+  const debugInfoProvider = new DevDebugInfoProvider({
+    config: settings.config,
+    astroVersionProvider: new BuildTimeAstroVersionProvider(),
+    operatingSystemProvider: new ProcessOperatingSystemProvider(),
+    packageManager: await getPackageManager({
+      packageManagerUserAgentProvider: new ProcessPackageManagerUserAgentProvider(),
+      commandExecutor: new TinyexecCommandExecutor()
+    }),
+    nodeVersionProvider: new ProcessNodeVersionProvider()
+  });
+  const debugInfoFormatter = new StyledDebugInfoFormatter({
+    textStyler: new PassthroughTextStyler()
+  });
+  const debugInfo = debugInfoFormatter.format(await debugInfoProvider.get());
+  const app = await AstroServerApp.create(
+    manifest,
+    routesList,
+    actualLogger,
+    loader,
+    settings,
+    async () => debugInfo
+  );
+  return {
+    handler(incomingRequest, incomingResponse) {
+      app.handleRequest({
+        controller,
+        incomingRequest,
+        incomingResponse,
+        isHttps: loader?.isHttps() ?? false
+      });
+    }
+  };
+}
+export {
+  createAstroServerApp as default
+};

package/dist/vite-plugin-app/index.d.ts

@@ -0,0 +1,3 @@
+import type * as vite from 'vite';
+export declare const ASTRO_DEV_APP_ID = "astro:app";
+export declare function vitePluginApp(): vite.Plugin;

package/dist/vite-plugin-app/index.js

@@ -0,0 +1,16 @@
+const ASTRO_DEV_APP_ID = "astro:app";
+function vitePluginApp() {
+  return {
+    name: "astro:app",
+    async resolveId(id) {
+      if (id === ASTRO_DEV_APP_ID) {
+        const url = new URL("./createAstroServerApp.js", import.meta.url);
+        return await this.resolve(url.toString());
+      }
+    }
+  };
+}
+export {
+  ASTRO_DEV_APP_ID,
+  vitePluginApp
+};

package/dist/{vite-plugin-astro-server → vite-plugin-app}/pipeline.d.ts

@@ -1,28 +1,26 @@
-import type { HeadElements, TryRewriteResult } from '../core/base-pipeline.js';
+import { type HeadElements, Pipeline, type TryRewriteResult } 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';
 import type { AstroSettings, ComponentInstance, RoutesList } from '../types/astro.js';
-import type { RewritePayload } from '../types/public/common.js';
-import type { RouteData, SSRLoadedRenderer, SSRManifest } from '../types/public/internal.js';
-export declare class DevPipeline extends Pipeline {
+import type { RewritePayload, RouteData, SSRLoadedRenderer, SSRManifest } from '../types/public/index.js';
+export declare class AstroServerPipeline extends Pipeline {
     readonly loader: ModuleLoader;
     readonly logger: Logger;
     readonly manifest: SSRManifest;
     readonly settings: AstroSettings;
     readonly getDebugInfo: () => Promise<string>;
-    readonly config: import("../index.js").AstroConfig;
     readonly defaultRoutes: {
         instance: ComponentInstance;
         matchesComponent(filePath: URL): boolean;
         route: string;
         component: string;
     }[];
+    getName(): string;
     renderers: SSRLoadedRenderer[];
     routesList: RoutesList | undefined;
     componentInterner: WeakMap<RouteData, ComponentInstance>;
     private constructor();
-    static create(manifestData: RoutesList, { loader, logger, manifest, settings, getDebugInfo, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings' | 'getDebugInfo'>): DevPipeline;
+    static create(manifestData: RoutesList, { loader, logger, manifest, settings, getDebugInfo, }: Pick<AstroServerPipeline, 'loader' | 'logger' | 'manifest' | 'settings' | 'getDebugInfo'>): AstroServerPipeline;
     headElements(routeData: RouteData): Promise<HeadElements>;
     componentMetadata(routeData: RouteData): Promise<Map<string, import("../types/public/internal.js").SSRComponentMetadata>>;
     preload(routeData: RouteData, filePath: URL): Promise<ComponentInstance>;