astro 4.8.7 → 4.9.1

package/dist/container/index.js

@@ -0,0 +1,234 @@
+import { posix } from "node:path";
+import { validateConfig } from "../core/config/config.js";
+import { ASTRO_CONFIG_DEFAULTS } from "../core/config/schema.js";
+import { Logger } from "../core/logger/core.js";
+import { nodeLogDestination } from "../core/logger/node.js";
+import { removeLeadingForwardSlash } from "../core/path.js";
+import { RenderContext } from "../core/render-context.js";
+import { getParts, getPattern, validateSegment } from "../core/routing/manifest/create.js";
+import { ContainerPipeline } from "./pipeline.js";
+function createManifest(renderers, manifest, middleware) {
+  const defaultMiddleware = (_, next) => {
+    return next();
+  };
+  return {
+    rewritingEnabled: false,
+    trailingSlash: manifest?.trailingSlash ?? ASTRO_CONFIG_DEFAULTS.trailingSlash,
+    buildFormat: manifest?.buildFormat ?? ASTRO_CONFIG_DEFAULTS.build.format,
+    compressHTML: manifest?.compressHTML ?? ASTRO_CONFIG_DEFAULTS.compressHTML,
+    assets: manifest?.assets ?? /* @__PURE__ */ new Set(),
+    assetsPrefix: manifest?.assetsPrefix ?? void 0,
+    entryModules: manifest?.entryModules ?? {},
+    routes: manifest?.routes ?? [],
+    adapterName: "",
+    clientDirectives: manifest?.clientDirectives ?? /* @__PURE__ */ new Map(),
+    renderers: manifest?.renderers ?? renderers,
+    base: manifest?.base ?? ASTRO_CONFIG_DEFAULTS.base,
+    componentMetadata: manifest?.componentMetadata ?? /* @__PURE__ */ new Map(),
+    inlinedScripts: manifest?.inlinedScripts ?? /* @__PURE__ */ new Map(),
+    i18n: manifest?.i18n,
+    checkOrigin: false,
+    middleware: manifest?.middleware ?? middleware ?? defaultMiddleware
+  };
+}
+class experimental_AstroContainer {
+  #pipeline;
+  /**
+   * Internally used to check if the container was created with a manifest.
+   * @private
+   */
+  #withManifest = false;
+  constructor({
+    streaming = false,
+    renderers = [],
+    manifest,
+    resolve
+  }) {
+    this.#pipeline = ContainerPipeline.create({
+      logger: new Logger({
+        level: "info",
+        dest: nodeLogDestination
+      }),
+      manifest: createManifest(renderers, manifest),
+      streaming,
+      serverLike: true,
+      renderers,
+      resolve: async (specifier) => {
+        if (this.#withManifest) {
+          return this.#containerResolve(specifier);
+        } else if (resolve) {
+          return resolve(specifier);
+        }
+        return specifier;
+      }
+    });
+  }
+  async #containerResolve(specifier) {
+    const found = this.#pipeline.manifest.entryModules[specifier];
+    if (found) {
+      return new URL(found, ASTRO_CONFIG_DEFAULTS.build.client).toString();
+    }
+    return found;
+  }
+  /**
+   * Creates a new instance of a container.
+   *
+   * @param {AstroContainerOptions=} containerOptions
+   */
+  static async create(containerOptions = {}) {
+    const { streaming = false, renderers = [] } = containerOptions;
+    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;
+      })
+    );
+    const finalRenderers = loadedRenderers.filter((r) => Boolean(r));
+    return new experimental_AstroContainer({ streaming, renderers: finalRenderers });
+  }
+  // NOTE: we keep this private via TS instead via `#` so it's still available on the surface, so we can play with it.
+  // @ematipico: I plan to use it for a possible integration that could help people
+  static async createFromManifest(manifest) {
+    const config = await validateConfig(ASTRO_CONFIG_DEFAULTS, process.cwd(), "container");
+    const container = new experimental_AstroContainer({
+      manifest
+    });
+    container.#withManifest = true;
+    return container;
+  }
+  #insertRoute({
+    path,
+    componentInstance,
+    params = {},
+    type = "page"
+  }) {
+    const pathUrl = new URL(path, "https://example.com");
+    const routeData = this.#createRoute(pathUrl, params, type);
+    this.#pipeline.manifest.routes.push({
+      routeData,
+      file: "",
+      links: [],
+      styles: [],
+      scripts: []
+    });
+    this.#pipeline.insertRoute(routeData, componentInstance);
+    return routeData;
+  }
+  /**
+   * @description
+   * It renders a component and returns the result as a string.
+   *
+   * ## Example
+   *
+   * ```js
+   * import Card from "../src/components/Card.astro";
+   *
+   * const container = await AstroContainer.create();
+   * const result = await container.renderToString(Card);
+   *
+   * console.log(result); // it's a string
+   * ```
+   *
+   *
+   * @param {AstroComponentFactory} component The instance of the component.
+   * @param {ContainerRenderOptions=} options Possible options to pass when rendering the component.
+   */
+  async renderToString(component, options = {}) {
+    const response = await this.renderToResponse(component, options);
+    return await response.text();
+  }
+  /**
+   * @description
+   * It renders a component and returns the `Response` as result of the rendering phase.
+   *
+   * ## Example
+   *
+   * ```js
+   * import Card from "../src/components/Card.astro";
+   *
+   * const container = await AstroContainer.create();
+   * const response = await container.renderToResponse(Card);
+   *
+   * console.log(response.status); // it's a number
+   * ```
+   *
+   *
+   * @param {AstroComponentFactory} component The instance of the component.
+   * @param {ContainerRenderOptions=} options Possible options to pass when rendering the component.
+   */
+  async renderToResponse(component, options = {}) {
+    const { routeType = "page", slots } = options;
+    const request = options?.request ?? new Request("https://example.com/");
+    const url = new URL(request.url);
+    const componentInstance = routeType === "endpoint" ? component : this.#wrapComponent(component, options.params);
+    const routeData = this.#insertRoute({
+      path: request.url,
+      componentInstance,
+      params: options.params,
+      type: routeType
+    });
+    const renderContext = RenderContext.create({
+      pipeline: this.#pipeline,
+      routeData,
+      status: 200,
+      middleware: this.#pipeline.middleware,
+      request,
+      pathname: url.pathname,
+      locals: options?.locals ?? {}
+    });
+    if (options.params) {
+      renderContext.params = options.params;
+    }
+    return renderContext.render(componentInstance, slots);
+  }
+  #createRoute(url, params, type) {
+    const segments = removeLeadingForwardSlash(url.pathname).split(posix.sep).filter(Boolean).map((s) => {
+      validateSegment(s);
+      return getParts(s, url.pathname);
+    });
+    return {
+      route: url.pathname,
+      component: "",
+      generate(_data) {
+        return "";
+      },
+      params: Object.keys(params),
+      pattern: getPattern(
+        segments,
+        ASTRO_CONFIG_DEFAULTS.base,
+        ASTRO_CONFIG_DEFAULTS.trailingSlash
+      ),
+      prerender: false,
+      segments,
+      type,
+      fallbackRoutes: [],
+      isIndex: false
+    };
+  }
+  /**
+   * If the provided component isn't a default export, the function wraps it in an object `{default: Component }` to mimic the default export.
+   * @param componentFactory
+   * @param params
+   * @private
+   */
+  #wrapComponent(componentFactory, params) {
+    if (params) {
+      return {
+        default: componentFactory,
+        getStaticPaths() {
+          return [{ params }];
+        }
+      };
+    }
+    return { default: componentFactory };
+  }
+}
+export {
+  experimental_AstroContainer
+};

package/dist/container/pipeline.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentInstance, RewritePayload, RouteData, SSRResult } from '../@types/astro.js';
+import { type HeadElements, Pipeline } from '../core/base-pipeline.js';
+export declare class ContainerPipeline extends Pipeline {
+    #private;
+    static create({ logger, manifest, renderers, resolve, serverLike, streaming, }: Pick<ContainerPipeline, 'logger' | 'manifest' | 'renderers' | 'resolve' | 'serverLike' | 'streaming'>): ContainerPipeline;
+    componentMetadata(_routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
+    headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
+    tryRewrite(rewritePayload: RewritePayload): Promise<[RouteData, ComponentInstance]>;
+    insertRoute(route: RouteData, componentInstance: ComponentInstance): void;
+    getComponentByRoute(_routeData: RouteData): Promise<ComponentInstance>;
+}

package/dist/container/pipeline.js

@@ -0,0 +1,96 @@
+import { Pipeline } from "../core/base-pipeline.js";
+import { RouteNotFound } from "../core/errors/errors-data.js";
+import { AstroError } from "../core/errors/index.js";
+import {
+  createModuleScriptElement,
+  createStylesheetElementSet
+} from "../core/render/ssr-element.js";
+class ContainerPipeline extends Pipeline {
+  /**
+   * Internal cache to store components instances by `RouteData`.
+   * @private
+   */
+  #componentsInterner = /* @__PURE__ */ new WeakMap();
+  static create({
+    logger,
+    manifest,
+    renderers,
+    resolve,
+    serverLike,
+    streaming
+  }) {
+    return new ContainerPipeline(
+      logger,
+      manifest,
+      "development",
+      renderers,
+      resolve,
+      serverLike,
+      streaming
+    );
+  }
+  componentMetadata(_routeData) {
+  }
+  headElements(routeData) {
+    const routeInfo = this.manifest.routes.find((route) => route.routeData === routeData);
+    const links = /* @__PURE__ */ new Set();
+    const scripts = /* @__PURE__ */ new Set();
+    const styles = createStylesheetElementSet(routeInfo?.styles ?? []);
+    for (const script of routeInfo?.scripts ?? []) {
+      if ("stage" in script) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.children
+          });
+        }
+      } else {
+        scripts.add(createModuleScriptElement(script));
+      }
+    }
+    return { links, styles, scripts };
+  }
+  async tryRewrite(rewritePayload) {
+    let foundRoute;
+    for (const route of this.manifest.routes) {
+      const routeData = route.routeData;
+      if (rewritePayload instanceof URL) {
+        if (routeData.pattern.test(rewritePayload.pathname)) {
+          foundRoute = routeData;
+          break;
+        }
+      } else if (rewritePayload instanceof Request) {
+        const url = new URL(rewritePayload.url);
+        if (routeData.pattern.test(url.pathname)) {
+          foundRoute = routeData;
+          break;
+        }
+      } else if (routeData.pattern.test(decodeURI(rewritePayload))) {
+        foundRoute = routeData;
+        break;
+      }
+    }
+    if (foundRoute) {
+      const componentInstance = await this.getComponentByRoute(foundRoute);
+      return [foundRoute, componentInstance];
+    } else {
+      throw new AstroError(RouteNotFound);
+    }
+  }
+  insertRoute(route, componentInstance) {
+    this.#componentsInterner.set(route, {
+      page() {
+        return Promise.resolve(componentInstance);
+      },
+      renderers: this.manifest.renderers,
+      onRequest: this.manifest.middleware
+    });
+  }
+  // At the moment it's not used by the container via any public API
+  // @ts-expect-error It needs to be implemented.
+  async getComponentByRoute(_routeData) {
+  }
+}
+export {
+  ContainerPipeline
+};

package/dist/core/app/node.js

@@ -48,7 +48,10 @@ class NodeApp extends App {
       Object.assign(options, makeRequestBody(req));
     }
     const request = new Request(url, options);
-    if (req.socket?.remoteAddress) {
+    const clientIp = req.headers["x-forwarded-for"];
+    if (clientIp) {
+      Reflect.set(request, clientAddressSymbol, clientIp);
+    } else if (req.socket?.remoteAddress) {
       Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
     }
     return request;

package/dist/core/build/generate.js

@@ -91,7 +91,7 @@ ${bgGreen(black(` ${verb} static routes `))}`);
   if (ssr) {
     for (const [pageData, filePath] of pagesToGenerate) {
       if (pageData.route.prerender) {
-        if (config.experimental.i18nDomains) {
+        if (config.i18n?.domains && Object.keys(config.i18n.domains).length > 0) {
           throw new AstroError({
             ...NoPrerenderedRoutesWithDomains,
             message: NoPrerenderedRoutesWithDomains.message(pageData.component)
@@ -210,7 +210,7 @@ async function getPathsForRoute(route, mod, pipeline, builtPaths) {
     const label = staticPaths.length === 1 ? "page" : "pages";
     logger.debug(
       "build",
-      `\u251C\u2500\u2500 ${bold(green("\u2714"))} ${route.component} \u2192 ${magenta(`[${staticPaths.length} ${label}]`)}`
+      `\u251C\u2500\u2500 ${bold(green("\u221A"))} ${route.component} \u2192 ${magenta(`[${staticPaths.length} ${label}]`)}`
     );
     paths = staticPaths.map((staticPath) => {
       try {
@@ -388,7 +388,7 @@ function createBuildManifest(settings, internals, renderers, middleware) {
     buildFormat: settings.config.build.format,
     middleware,
     rewritingEnabled: settings.config.experimental.rewriting,
-    checkOrigin: settings.config.experimental.security?.csrfProtection?.origin ?? false
+    checkOrigin: settings.config.security?.checkOrigin ?? false
   };
 }
 export {

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

@@ -178,7 +178,7 @@ function buildManifest(opts, internals, staticFiles) {
     });
   }
   const i18n = settings.config.i18n;
-  if (settings.config.experimental.i18nDomains && i18n && i18n.domains) {
+  if (i18n && i18n.domains) {
     for (const [locale, domainValue] of Object.entries(i18n.domains)) {
       domainLookupTable[domainValue] = normalizeTheLocale(locale);
     }
@@ -212,7 +212,7 @@ function buildManifest(opts, internals, staticFiles) {
     assets: staticFiles.map(prefixAssetPath),
     i18n: i18nManifest,
     buildFormat: settings.config.build.format,
-    checkOrigin: settings.config.experimental.security?.csrfProtection?.origin ?? false,
+    checkOrigin: settings.config.security?.checkOrigin ?? false,
     rewritingEnabled: settings.config.experimental.rewriting
   };
 }