astro 4.8.6 → 4.9.0

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/consts.d.ts

@@ -1 +1,2 @@
 export declare const CHUNKS_PATH = "chunks/";
+export declare const CONTENT_PATH = "content/";

package/dist/core/build/consts.js

@@ -1,4 +1,6 @@
 const CHUNKS_PATH = "chunks/";
+const CONTENT_PATH = "content/";
 export {
-  CHUNKS_PATH
+  CHUNKS_PATH,
+  CONTENT_PATH
 };

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/index.js

@@ -129,8 +129,8 @@ class AstroBuilder {
       teardownCompiler: this.teardownCompiler,
       viteConfig
     };
-    const { internals, ssrOutputChunkNames } = await viteBuild(opts);
-    await staticBuild(opts, internals, ssrOutputChunkNames);
+    const { internals, ssrOutputChunkNames, contentFileNames } = await viteBuild(opts);
+    await staticBuild(opts, internals, ssrOutputChunkNames, contentFileNames);
     this.timer.assetsStart = performance.now();
     Object.keys(assets).map((k) => {
       if (!assets[k]) return;

package/dist/core/build/plugins/plugin-content.d.ts

@@ -1,5 +1,5 @@
 import { type BuildInternals } from '../internal.js';
 import type { AstroBuildPlugin } from '../plugin.js';
 import type { StaticBuildOptions } from '../types.js';
-export declare function copyContentToCache(opts: StaticBuildOptions): Promise<void>;
+export declare function copyContentToCache(opts: StaticBuildOptions): Promise<string[]>;
 export declare function pluginContent(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

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

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import fsMod from "node:fs";
 import { fileURLToPath } from "node:url";
+import glob from "fast-glob";
 import pLimit from "p-limit";
 import { normalizePath } from "vite";
 import { CONTENT_RENDER_FLAG, PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
@@ -19,12 +20,12 @@ import {
 } from "../../path.js";
 import { isContentCollectionsCacheEnabled } from "../../util.js";
 import { addRollupInput } from "../add-rollup-input.js";
-import { CHUNKS_PATH } from "../consts.js";
+import { CHUNKS_PATH, CONTENT_PATH } from "../consts.js";
 import {} from "../internal.js";
 import { copyFiles } from "../static-build.js";
 import { encodeName } from "../util.js";
 import { extendManualChunks } from "./util.js";
-const CONTENT_CACHE_DIR = "./content/";
+const CONTENT_CACHE_DIR = "./" + CONTENT_PATH;
 const CONTENT_MANIFEST_FILE = "./manifest.json";
 const CONTENT_MANIFEST_VERSION = 1;
 const virtualEmptyModuleId = `virtual:empty-content`;
@@ -340,7 +341,17 @@ async function copyContentToCache(opts) {
   await fsMod.promises.mkdir(cacheTmp, { recursive: true });
   await copyFiles(distContentRoot, cacheTmp, true);
   await copyFiles(cacheTmp, contentCacheDir);
+  let files = [];
+  await Promise.all([
+    glob(`**/*.{mjs,json}`, {
+      cwd: fileURLToPath(cacheTmp)
+    }).then((f) => files.push(...f.map((file) => CONTENT_PATH + file))),
+    glob(`**/*.{mjs,json}`, {
+      cwd: fileURLToPath(new URL("./" + CHUNKS_PATH, config.outDir))
+    }).then((f) => files.push(...f.map((file) => CHUNKS_PATH + file)))
+  ]);
   await fsMod.promises.rm(cacheTmp, { recursive: true, force: true });
+  return files;
 }
 function pluginContent(opts, internals) {
   const { cacheDir, outDir } = opts.settings.config;

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
   };
 }

package/dist/core/build/static-build.d.ts

@@ -4,8 +4,9 @@ import type { StaticBuildOptions } from './types.js';
 export declare function viteBuild(opts: StaticBuildOptions): Promise<{
     internals: BuildInternals;
     ssrOutputChunkNames: string[];
+    contentFileNames: string[] | undefined;
 }>;
-export declare function staticBuild(opts: StaticBuildOptions, internals: BuildInternals, ssrOutputChunkNames: string[]): Promise<void>;
+export declare function staticBuild(opts: StaticBuildOptions, internals: BuildInternals, ssrOutputChunkNames: string[], contentFileNames?: string[]): Promise<void>;
 export declare function copyFiles(fromFolder: URL, toFolder: URL, includeDotfiles?: boolean): Promise<void[] | undefined>;
 /**
  * This function takes the virtual module name of any page entrypoint and

package/dist/core/build/static-build.js

@@ -75,8 +75,9 @@ async function viteBuild(opts) {
   const ssrOutputs = viteBuildReturnToRollupOutputs(ssrOutput);
   const clientOutputs = viteBuildReturnToRollupOutputs(clientOutput ?? []);
   await runPostBuildHooks(container, ssrOutputs, clientOutputs);
+  let contentFileNames = void 0;
   if (opts.settings.config.experimental.contentCollectionCache) {
-    await copyContentToCache(opts);
+    contentFileNames = await copyContentToCache(opts);
   }
   settings.timer.end("Client build");
   internals.ssrEntryChunk = void 0;
@@ -91,15 +92,15 @@ async function viteBuild(opts) {
       }
     }
   }
-  return { internals, ssrOutputChunkNames };
+  return { internals, ssrOutputChunkNames, contentFileNames };
 }
-async function staticBuild(opts, internals, ssrOutputChunkNames) {
+async function staticBuild(opts, internals, ssrOutputChunkNames, contentFileNames) {
   const { settings } = opts;
   switch (true) {
     case settings.config.output === "static": {
       settings.timer.start("Static generate");
       await generatePages(opts, internals);
-      await cleanServerOutput(opts, ssrOutputChunkNames, internals);
+      await cleanServerOutput(opts, ssrOutputChunkNames, contentFileNames, internals);
       settings.timer.end("Static generate");
       return;
     }
@@ -325,9 +326,9 @@ export const ${e.n} = noop;`;
     removeEmptyDirs(out);
   }
 }
-async function cleanServerOutput(opts, ssrOutputChunkNames, internals) {
+async function cleanServerOutput(opts, ssrOutputChunkNames, contentFileNames, internals) {
   const out = getOutDirWithinCwd(opts.settings.config.outDir);
-  const files = ssrOutputChunkNames.filter((f) => f.endsWith(".mjs"));
+  const files = ssrOutputChunkNames.filter((f) => f.endsWith(".mjs")).concat(contentFileNames ?? []);
   if (internals.manifestFileName) {
     files.push(internals.manifestFileName);
   }