astro 5.16.5 → 6.0.0-alpha.1

package/dist/core/base-pipeline.d.ts

@@ -1,11 +1,14 @@
-import type { ZodType } from 'zod';
-import type { ActionAccept, ActionClient } from '../actions/runtime/server.js';
+import type { $ZodType } from 'zod/v4/core';
+import type { ActionAccept, ActionClient } from '../actions/runtime/types.js';
 import type { ComponentInstance } from '../types/astro.js';
 import type { MiddlewareHandler, RewritePayload } from '../types/public/common.js';
 import type { RuntimeMode } from '../types/public/config.js';
 import type { RouteData, SSRActions, SSRLoadedRenderer, SSRManifest, SSRResult } from '../types/public/internal.js';
+import type { ServerIslandMappings } from './app/types.js';
+import type { SinglePageBuiltModule } from './build/types.js';
 import type { Logger } from './logger/core.js';
 import { RouteCache } from './render/route-cache.js';
+import type { SessionDriver } from './session.js';
 /**
  * The `Pipeline` represents the static parts of rendering that do not change between requests.
  * These are mostly known when the server first starts up and do not change.
@@ -21,10 +24,6 @@ export declare abstract class Pipeline {
     readonly runtimeMode: RuntimeMode;
     readonly renderers: SSRLoadedRenderer[];
     readonly resolve: (s: string) => Promise<string>;
-    /**
-     * Based on Astro config's `output` option, `true` if "server" or "hybrid".
-     */
-    readonly serverLike: boolean;
     readonly streaming: boolean;
     /**
      * Used to provide better error messages for `Astro.clientAddress`
@@ -51,18 +50,19 @@ export declare abstract class Pipeline {
         component: string;
     }[];
     readonly actions: (() => Promise<SSRActions> | SSRActions) | undefined;
+    readonly sessionDriver: (() => Promise<{
+        default: SessionDriver | null;
+    }>) | undefined;
+    readonly serverIslands: (() => Promise<ServerIslandMappings> | ServerIslandMappings) | undefined;
     readonly internalMiddleware: MiddlewareHandler[];
     resolvedMiddleware: MiddlewareHandler | undefined;
     resolvedActions: SSRActions | undefined;
+    resolvedSessionDriver: SessionDriver | null | undefined;
     constructor(logger: Logger, manifest: SSRManifest, 
     /**
      * "development" or "production" only
      */
-    runtimeMode: RuntimeMode, renderers: SSRLoadedRenderer[], resolve: (s: string) => Promise<string>, 
-    /**
-     * Based on Astro config's `output` option, `true` if "server" or "hybrid".
-     */
-    serverLike: boolean, streaming: boolean, 
+    runtimeMode: RuntimeMode, renderers: SSRLoadedRenderer[], resolve: (s: string) => Promise<string>, streaming: boolean, 
     /**
      * Used to provide better error messages for `Astro.clientAddress`
      */
@@ -80,7 +80,9 @@ export declare abstract class Pipeline {
         matchesComponent(filePath: URL): boolean;
         route: string;
         component: string;
-    }[], actions?: (() => Promise<SSRActions> | SSRActions) | undefined);
+    }[], actions?: (() => Promise<SSRActions> | SSRActions) | undefined, sessionDriver?: (() => Promise<{
+        default: SessionDriver | null;
+    }>) | undefined, serverIslands?: (() => Promise<ServerIslandMappings> | ServerIslandMappings) | undefined);
     abstract headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
     abstract componentMetadata(routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
     /**
@@ -99,14 +101,20 @@ export declare abstract class Pipeline {
      * @param routeData
      */
     abstract getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    /**
+     * The current name of the pipeline. Useful for debugging
+     */
+    abstract getName(): string;
     /**
      * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
      * it returns a no-op function
      */
     getMiddleware(): Promise<MiddlewareHandler>;
-    setActions(actions: SSRActions): void;
     getActions(): Promise<SSRActions>;
-    getAction(path: string): Promise<ActionClient<unknown, ActionAccept, ZodType>>;
+    getSessionDriver(): Promise<SessionDriver | null>;
+    getServerIslands(): Promise<ServerIslandMappings>;
+    getAction(path: string): Promise<ActionClient<unknown, ActionAccept, $ZodType>>;
+    getModuleForRoute(route: RouteData): Promise<SinglePageBuiltModule>;
 }
 export interface HeadElements extends Pick<SSRResult, 'scripts' | 'styles' | 'links'> {
 }

package/dist/core/base-pipeline.js

@@ -5,16 +5,16 @@ import { ActionNotFoundError } from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
 import { NOOP_MIDDLEWARE_FN } from "./middleware/noop-middleware.js";
 import { sequence } from "./middleware/sequence.js";
+import { RedirectSinglePageBuiltModule } from "./redirects/index.js";
 import { RouteCache } from "./render/route-cache.js";
 import { createDefaultRoutes } from "./routing/default.js";
 class Pipeline {
-  constructor(logger, manifest, runtimeMode, renderers, resolve, serverLike, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest), actions = manifest.actions) {
+  constructor(logger, manifest, runtimeMode, renderers, resolve, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest), actions = manifest.actions, sessionDriver = manifest.sessionDriver, serverIslands = manifest.serverIslandMappings) {
     this.logger = logger;
     this.manifest = manifest;
     this.runtimeMode = runtimeMode;
     this.renderers = renderers;
     this.resolve = resolve;
-    this.serverLike = serverLike;
     this.streaming = streaming;
     this.adapterName = adapterName;
     this.clientDirectives = clientDirectives;
@@ -26,6 +26,8 @@ class Pipeline {
     this.site = site;
     this.defaultRoutes = defaultRoutes;
     this.actions = actions;
+    this.sessionDriver = sessionDriver;
+    this.serverIslands = serverIslands;
     this.internalMiddleware = [];
     if (i18n?.strategy !== "manual") {
       this.internalMiddleware.push(
@@ -36,6 +38,7 @@ class Pipeline {
   internalMiddleware;
   resolvedMiddleware = void 0;
   resolvedActions = void 0;
+  resolvedSessionDriver = void 0;
   /**
    * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
    * it returns a no-op function
@@ -57,17 +60,35 @@ class Pipeline {
       return this.resolvedMiddleware;
     }
   }
-  setActions(actions) {
-    this.resolvedActions = actions;
-  }
   async getActions() {
     if (this.resolvedActions) {
       return this.resolvedActions;
     } else if (this.actions) {
-      return await this.actions();
+      return this.actions();
     }
     return NOOP_ACTIONS_MOD;
   }
+  async getSessionDriver() {
+    if (this.resolvedSessionDriver !== void 0) {
+      return this.resolvedSessionDriver;
+    }
+    if (this.sessionDriver) {
+      const driverModule = await this.sessionDriver();
+      this.resolvedSessionDriver = driverModule?.default || null;
+      return this.resolvedSessionDriver;
+    }
+    this.resolvedSessionDriver = null;
+    return null;
+  }
+  async getServerIslands() {
+    if (this.serverIslands) {
+      return this.serverIslands();
+    }
+    return {
+      serverIslandMap: /* @__PURE__ */ new Map(),
+      serverIslandNameMap: /* @__PURE__ */ new Map()
+    };
+  }
   async getAction(path) {
     const pathKeys = path.split(".").map((key) => decodeURIComponent(key));
     let { server } = await this.getActions();
@@ -92,6 +113,33 @@ class Pipeline {
     }
     return server;
   }
+  async getModuleForRoute(route) {
+    for (const defaultRoute of this.defaultRoutes) {
+      if (route.component === defaultRoute.component) {
+        return {
+          page: () => Promise.resolve(defaultRoute.instance)
+        };
+      }
+    }
+    if (route.type === "redirect") {
+      return RedirectSinglePageBuiltModule;
+    } else {
+      if (this.manifest.pageMap) {
+        const importComponentInstance = this.manifest.pageMap.get(route.component);
+        if (!importComponentInstance) {
+          throw new Error(
+            `Unexpectedly unable to find a component instance for route ${route.route}`
+          );
+        }
+        return await importComponentInstance();
+      } else if (this.manifest.pageModule) {
+        return this.manifest.pageModule;
+      }
+      throw new Error(
+        "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+      );
+    }
+  }
 }
 export {
   Pipeline

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

@@ -0,0 +1,13 @@
+import { BaseApp, type RenderErrorOptions } from '../app/index.js';
+import type { SSRManifest } from '../app/types.js';
+import type { BuildInternals } from './internal.js';
+import { BuildPipeline } from './pipeline.js';
+import type { StaticBuildOptions } from './types.js';
+export declare class BuildApp extends BaseApp<BuildPipeline> {
+    createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
+    setInternals(internals: BuildInternals): void;
+    setOptions(options: StaticBuildOptions): void;
+    getOptions(): StaticBuildOptions;
+    getSettings(): import("../../types/astro.js").AstroSettings;
+    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/build/app.js

@@ -0,0 +1,38 @@
+import { BaseApp } from "../app/index.js";
+import { BuildPipeline } from "./pipeline.js";
+class BuildApp extends BaseApp {
+  createPipeline(_streaming, manifest, ..._args) {
+    return BuildPipeline.create({
+      manifest
+    });
+  }
+  setInternals(internals) {
+    this.pipeline.setInternals(internals);
+  }
+  setOptions(options) {
+    this.pipeline.setOptions(options);
+    this.logger = options.logger;
+  }
+  getOptions() {
+    return this.pipeline.getOptions();
+  }
+  getSettings() {
+    return this.pipeline.getSettings();
+  }
+  async renderError(request, options) {
+    if (options.status === 500) {
+      if (options.response) {
+        return options.response;
+      }
+      throw options.error;
+    } else {
+      return super.renderError(request, {
+        ...options,
+        prerenderedErrorPageFetch: void 0
+      });
+    }
+  }
+}
+export {
+  BuildApp
+};

package/dist/core/build/common.d.ts

@@ -2,7 +2,7 @@ import type { AstroSettings } from '../../types/astro.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
 export declare function getOutFolder(astroSettings: AstroSettings, pathname: string, routeData: RouteData): URL;
-export declare function getOutFile(astroConfig: AstroConfig, outFolder: URL, pathname: string, routeData: RouteData): URL;
+export declare function getOutFile(buildFormat: NonNullable<AstroConfig['build']>['format'], outFolder: URL, pathname: string, routeData: RouteData): URL;
 /**
  * Ensures the `outDir` is within `process.cwd()`. If not it will fallback to `<cwd>/.astro`.
  * This is used for static `ssrBuild` so the output can access node_modules when we import

package/dist/core/build/common.js

@@ -42,7 +42,7 @@ function getOutFolder(astroSettings, pathname, routeData) {
       }
   }
 }
-function getOutFile(astroConfig, outFolder, pathname, routeData) {
+function getOutFile(buildFormat, outFolder, pathname, routeData) {
   const routeType = routeData.type;
   switch (routeType) {
     case "endpoint":
@@ -50,7 +50,7 @@ function getOutFile(astroConfig, outFolder, pathname, routeData) {
     case "page":
     case "fallback":
     case "redirect":
-      switch (astroConfig.build.format) {
+      switch (buildFormat) {
         case "directory": {
           if (STATUS_CODE_PAGES.has(pathname)) {
             const baseName = npath.basename(pathname);

package/dist/core/build/generate.d.ts

@@ -1,3 +1,3 @@
 import { type BuildInternals } from './internal.js';
 import type { StaticBuildOptions } from './types.js';
-export declare function generatePages(options: StaticBuildOptions, internals: BuildInternals): Promise<void>;
+export declare function generatePages(options: StaticBuildOptions, internals: BuildInternals, prerenderOutputDir: URL): Promise<void>;