astro 5.0.8 → 5.1.0

package/client.d.ts

@@ -535,3 +535,13 @@ declare module '*?inline' {
 	const src: string;
 	export default src;
 }
+
+declare module '*?url&inline' {
+	const src: string;
+	export default src;
+}
+
+declare module '*?url&no-inline' {
+	const src: string;
+	export default src;
+}

package/dist/actions/plugins.js

@@ -70,13 +70,13 @@ export * from 'astro/actions/runtime/virtual/server.js';`;
       } else {
         code += `
 export * from 'astro/actions/runtime/virtual/client.js';`;
-        code = code.replace(
-          "'/** @TRAILING_SLASH@ **/'",
-          JSON.stringify(
-            shouldAppendForwardSlash(settings.config.trailingSlash, settings.config.build.format)
-          )
-        );
       }
+      code = code.replace(
+        "'/** @TRAILING_SLASH@ **/'",
+        JSON.stringify(
+          shouldAppendForwardSlash(settings.config.trailingSlash, settings.config.build.format)
+        )
+      );
       return code;
     }
   };

package/dist/assets/build/generate.js

@@ -8,7 +8,7 @@ import { AstroErrorData } from "../../core/errors/index.js";
 import { isRemotePath, removeLeadingForwardSlash } from "../../core/path.js";
 import { getConfiguredImageService } from "../internal.js";
 import { isESMImportedImage } from "../utils/imageKind.js";
-import { loadRemoteImage } from "./remote.js";
+import { loadRemoteImage, revalidateRemoteImage } from "./remote.js";
 async function prepareAssetsGenerationEnv(pipeline, totalCount) {
   const { config, logger, settings } = pipeline;
   let useCache = true;
@@ -72,7 +72,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const timeEnd = performance.now();
     const timeChange = getTimeStat(timeStart, timeEnd);
     const timeIncrease = `(+${timeChange})`;
-    const statsText = generationData.cached ? `(reused cache entry)` : `(before: ${generationData.weight.before}kB, after: ${generationData.weight.after}kB)`;
+    const statsText = generationData.cached !== "miss" ? generationData.cached === "hit" ? `(reused cache entry)` : `(revalidated cache entry)` : `(before: ${generationData.weight.before}kB, after: ${generationData.weight.after}kB)`;
     const count = `(${env.count.current}/${env.count.total})`;
     env.logger.info(
       null,
@@ -91,7 +91,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
       if (isLocalImage) {
         await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
         return {
-          cached: true
+          cached: "hit"
         };
       } else {
         const JSONData = JSON.parse(readFileSync(cachedFileURL, "utf-8"));
@@ -104,11 +104,33 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
         if (JSONData.expires > Date.now()) {
           await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
           return {
-            cached: true
+            cached: "hit"
           };
-        } else {
-          await fs.promises.unlink(cachedFileURL);
         }
+        if (JSONData.etag || JSONData.lastModified) {
+          try {
+            const revalidatedData = await revalidateRemoteImage(options.src, {
+              etag: JSONData.etag,
+              lastModified: JSONData.lastModified
+            });
+            if (revalidatedData.data.length) {
+              originalImage = revalidatedData;
+            } else {
+              revalidatedData.data = Buffer.from(JSONData.data, "base64");
+              await writeRemoteCacheFile(cachedFileURL, revalidatedData, env);
+              await fs.promises.writeFile(finalFileURL, revalidatedData.data);
+              return { cached: "revalidated" };
+            }
+          } catch (e) {
+            env.logger.warn(
+              null,
+              `An error was encountered while revalidating a cached remote asset. Proceeding with stale cache. ${e}`
+            );
+            await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
+            return { cached: "hit" };
+          }
+        }
+        await fs.promises.unlink(cachedFileURL);
       }
     } catch (e) {
       if (e.code !== "ENOENT") {
@@ -121,7 +143,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     }
     let resultData = {
       data: void 0,
-      expires: originalImage.expires
+      expires: originalImage.expires,
+      etag: originalImage.etag,
+      lastModified: originalImage.lastModified
     };
     const imageService = await getConfiguredImageService();
     try {
@@ -145,13 +169,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
         if (isLocalImage) {
           await fs.promises.writeFile(cachedFileURL, resultData.data);
         } else {
-          await fs.promises.writeFile(
-            cachedFileURL,
-            JSON.stringify({
-              data: Buffer.from(resultData.data).toString("base64"),
-              expires: resultData.expires
-            })
-          );
+          await writeRemoteCacheFile(cachedFileURL, resultData, env);
         }
       }
     } catch (e) {
@@ -163,7 +181,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
       await fs.promises.writeFile(finalFileURL, resultData.data);
     }
     return {
-      cached: false,
+      cached: "miss",
       weight: {
         // Divide by 1024 to get size in kilobytes
         before: Math.trunc(originalImage.data.byteLength / 1024),
@@ -172,6 +190,24 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     };
   }
 }
+async function writeRemoteCacheFile(cachedFileURL, resultData, env) {
+  try {
+    return await fs.promises.writeFile(
+      cachedFileURL,
+      JSON.stringify({
+        data: Buffer.from(resultData.data).toString("base64"),
+        expires: resultData.expires,
+        etag: resultData.etag,
+        lastModified: resultData.lastModified
+      })
+    );
+  } catch (e) {
+    env.logger.warn(
+      null,
+      `An error was encountered while writing the cache file for a remote asset. Proceeding without caching this asset. Error: ${e}`
+    );
+  }
+}
 function getStaticImageList() {
   if (!globalThis?.astroAsset?.staticImages) {
     return /* @__PURE__ */ new Map();
@@ -180,11 +216,7 @@ function getStaticImageList() {
 }
 async function loadImage(path, env) {
   if (isRemotePath(path)) {
-    const remoteImage = await loadRemoteImage(path);
-    return {
-      data: remoteImage.data,
-      expires: remoteImage.expires
-    };
+    return await loadRemoteImage(path);
   }
   return {
     data: await fs.promises.readFile(getFullImagePath(path, env)),

package/dist/assets/build/remote.d.ts

@@ -1,8 +1,30 @@
 export type RemoteCacheEntry = {
     data: string;
     expires: number;
+    etag?: string;
+    lastModified?: string;
 };
 export declare function loadRemoteImage(src: string): Promise<{
     data: Buffer;
     expires: number;
+    etag: string | undefined;
+    lastModified: string | undefined;
+}>;
+/**
+ * Revalidate a cached remote asset using its entity-tag or modified date.
+ * Uses the [If-None-Match](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match) and [If-Modified-Since](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Modified-Since)
+ * headers to check with the remote server if the cached version of a remote asset is still up to date.
+ * The remote server may respond that the cached asset is still up-to-date if the entity-tag or modification time matches (304 Not Modified), or respond with an updated asset (200 OK)
+ * @param src - url to remote asset
+ * @param revalidationData - an object containing the stored Entity-Tag of the cached asset and/or the Last Modified time
+ * @returns An ImageData object containing the asset data, a new expiry time, and the asset's etag. The data buffer will be empty if the asset was not modified.
+ */
+export declare function revalidateRemoteImage(src: string, revalidationData: {
+    etag?: string;
+    lastModified?: string;
+}): Promise<{
+    data: Buffer;
+    expires: number;
+    etag: string | undefined;
+    lastModified: string | undefined;
 }>;

package/dist/assets/build/remote.js

@@ -11,7 +11,41 @@ async function loadRemoteImage(src) {
   const expires = policy.storable() ? policy.timeToLive() : 0;
   return {
     data: Buffer.from(await res.arrayBuffer()),
-    expires: Date.now() + expires
+    expires: Date.now() + expires,
+    etag: res.headers.get("Etag") ?? void 0,
+    lastModified: res.headers.get("Last-Modified") ?? void 0
+  };
+}
+async function revalidateRemoteImage(src, revalidationData) {
+  const headers = {
+    ...revalidationData.etag && { "If-None-Match": revalidationData.etag },
+    ...revalidationData.lastModified && { "If-Modified-Since": revalidationData.lastModified }
+  };
+  const req = new Request(src, { headers });
+  const res = await fetch(req);
+  if (!res.ok && res.status !== 304) {
+    throw new Error(
+      `Failed to revalidate cached remote image ${src}. The request did not return a 200 OK / 304 NOT MODIFIED response. (received ${res.status} ${res.statusText})`
+    );
+  }
+  const data = Buffer.from(await res.arrayBuffer());
+  if (res.ok && !data.length) {
+    return await loadRemoteImage(src);
+  }
+  const policy = new CachePolicy(
+    webToCachePolicyRequest(req),
+    webToCachePolicyResponse(
+      res.ok ? res : new Response(null, { status: 200, headers: res.headers })
+    )
+    // 304 responses themselves are not cachable, so just pretend to get the refreshed TTL
+  );
+  const expires = policy.storable() ? policy.timeToLive() : 0;
+  return {
+    data,
+    expires: Date.now() + expires,
+    // While servers should respond with the same headers as a 200 response, if they don't we should reuse the stored value
+    etag: res.headers.get("Etag") ?? (res.ok ? void 0 : revalidationData.etag),
+    lastModified: res.headers.get("Last-Modified") ?? (res.ok ? void 0 : revalidationData.lastModified)
   };
 }
 function webToCachePolicyRequest({ url, method, headers: _headers }) {
@@ -38,5 +72,6 @@ function webToCachePolicyResponse({ status, headers: _headers }) {
   };
 }
 export {
-  loadRemoteImage
+  loadRemoteImage,
+  revalidateRemoteImage
 };

package/dist/config/index.d.ts

@@ -1,10 +1,10 @@
 import type { UserConfig as ViteUserConfig, UserConfigFn as ViteUserConfigFn } from 'vite';
-import type { AstroInlineConfig, AstroUserConfig, Locales } from '../types/public/config.js';
+import type { AstroInlineConfig, AstroUserConfig, Locales, SessionDriverName } from '../types/public/config.js';
 /**
  * See the full Astro Configuration API Documentation
  * https://astro.build/config
  */
-export declare function defineConfig<const TLocales extends Locales = never>(config: AstroUserConfig<TLocales>): AstroUserConfig<TLocales>;
+export declare function defineConfig<const TLocales extends Locales = never, const TDriver extends SessionDriverName = never>(config: AstroUserConfig<TLocales, TDriver>): AstroUserConfig<TLocales, TDriver>;
 /**
  * Use Astro to generate a fully resolved Vite config
  */

package/dist/content/content-layer.js

@@ -12,7 +12,8 @@ import {
 import {
   getEntryConfigByExtMap,
   getEntryDataAndImages,
-  globalContentConfigObserver
+  globalContentConfigObserver,
+  safeStringify
 } from "./utils.js";
 class ContentLayer {
   #logger;
@@ -105,16 +106,28 @@ class ContentLayer {
       return;
     }
     logger.info("Syncing content");
+    const {
+      vite: _vite,
+      integrations: _integrations,
+      adapter: _adapter,
+      ...hashableConfig
+    } = this.#settings.config;
+    const astroConfigDigest = safeStringify(hashableConfig);
     const { digest: currentConfigDigest } = contentConfig.config;
     this.#lastConfigDigest = currentConfigDigest;
     let shouldClear = false;
-    const previousConfigDigest = await this.#store.metaStore().get("config-digest");
+    const previousConfigDigest = await this.#store.metaStore().get("content-config-digest");
+    const previousAstroConfigDigest = await this.#store.metaStore().get("astro-config-digest");
     const previousAstroVersion = await this.#store.metaStore().get("astro-version");
+    if (previousAstroConfigDigest && previousAstroConfigDigest !== astroConfigDigest) {
+      logger.info("Astro config changed");
+      shouldClear = true;
+    }
     if (currentConfigDigest && previousConfigDigest !== currentConfigDigest) {
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion !== "5.0.8") {
+    if (previousAstroVersion !== "5.1.0") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -122,11 +135,14 @@ class ContentLayer {
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.0.8") {
-      await this.#store.metaStore().set("astro-version", "5.0.8");
+    if ("5.1.0") {
+      await this.#store.metaStore().set("astro-version", "5.1.0");
     }
     if (currentConfigDigest) {
-      await this.#store.metaStore().set("config-digest", currentConfigDigest);
+      await this.#store.metaStore().set("content-config-digest", currentConfigDigest);
+    }
+    if (astroConfigDigest) {
+      await this.#store.metaStore().set("astro-config-digest", astroConfigDigest);
     }
     await Promise.all(
       Object.entries(contentConfig.config.collections).map(async ([name, collection]) => {

package/dist/content/utils.d.ts

@@ -583,4 +583,5 @@ export declare function posixifyPath(filePath: string): string;
  */
 export declare function posixRelative(from: string, to: string): string;
 export declare function contentModuleToId(fileName: string): string;
+export declare function safeStringify(value: unknown): string;
 export {};

package/dist/content/utils.js

@@ -589,6 +589,27 @@ function contentModuleToId(fileName) {
   params.set(CONTENT_MODULE_FLAG, "true");
   return `${DEFERRED_MODULE}?${params.toString()}`;
 }
+function safeStringifyReplacer(seen) {
+  return function(_key, value) {
+    if (!(value !== null && typeof value === "object")) {
+      return value;
+    }
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const newValue = Array.isArray(value) ? [] : {};
+    for (const [key2, value2] of Object.entries(value)) {
+      newValue[key2] = safeStringifyReplacer(seen)(key2, value2);
+    }
+    seen.delete(value);
+    return newValue;
+  };
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, safeStringifyReplacer(seen));
+}
 export {
   autogenerateCollections,
   contentModuleToId,
@@ -617,5 +638,6 @@ export {
   posixifyPath,
   reloadContentConfigObserver,
   reverseSymlink,
-  safeParseFrontmatter
+  safeParseFrontmatter,
+  safeStringify
 };

package/dist/core/app/index.js

@@ -21,6 +21,7 @@ import { createAssetLink } from "../render/ssr-element.js";
 import { ensure404Route } from "../routing/astro-designed-error-pages.js";
 import { createDefaultRoutes } from "../routing/default.js";
 import { matchRoute } from "../routing/match.js";
+import { PERSIST_SYMBOL } from "../session.js";
 import { AppPipeline } from "./pipeline.js";
 import { deserializeManifest } from "./common.js";
 class App {
@@ -188,6 +189,7 @@ class App {
     const pathname = this.#getPathnameFromRequest(request);
     const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
     let response;
+    let session;
     try {
       const mod = await this.#pipeline.getModuleForRoute(routeData);
       const renderContext = await RenderContext.create({
@@ -199,10 +201,13 @@ class App {
         status: defaultStatus,
         clientAddress
       });
+      session = renderContext.session;
       response = await renderContext.render(await mod.page());
     } catch (err) {
       this.#logger.error(null, err.stack || err.message || String(err));
       return this.#renderError(request, { locals, status: 500, error: err, clientAddress });
+    } finally {
+      session?.[PERSIST_SYMBOL]();
     }
     if (REROUTABLE_STATUS_CODES.includes(response.status) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
       return this.#renderError(request, {
@@ -270,6 +275,7 @@ class App {
         }
       }
       const mod = await this.#pipeline.getModuleForRoute(errorRouteData);
+      let session;
       try {
         const renderContext = await RenderContext.create({
           locals,
@@ -282,6 +288,7 @@ class App {
           props: { error },
           clientAddress
         });
+        session = renderContext.session;
         const response2 = await renderContext.render(await mod.page());
         return this.#mergeResponses(response2, originalResponse);
       } catch {
@@ -294,6 +301,8 @@ class App {
             clientAddress
           });
         }
+      } finally {
+        session?.[PERSIST_SYMBOL]();
       }
     }
     const response = this.#mergeResponses(new Response(null, { status }), originalResponse);

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

@@ -1,7 +1,7 @@
 import type { RoutingStrategies } from '../../i18n/utils.js';
 import type { ComponentInstance, SerializedRouteData } from '../../types/astro.js';
 import type { AstroMiddlewareInstance } from '../../types/public/common.js';
-import type { Locales } from '../../types/public/config.js';
+import type { Locales, ResolvedSessionConfig } from '../../types/public/config.js';
 import type { RouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../types/public/internal.js';
 import type { SinglePageBuiltModule } from '../build/types.js';
 export type ComponentPath = string;
@@ -59,6 +59,7 @@ export type SSRManifest = {
     i18n: SSRManifestI18n | undefined;
     middleware?: () => Promise<AstroMiddlewareInstance> | AstroMiddlewareInstance;
     checkOrigin: boolean;
+    sessionConfig?: ResolvedSessionConfig<any>;
 };
 export type SSRManifestI18n = {
     fallback: Record<string, string> | undefined;

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

@@ -9,6 +9,7 @@ import { encodeKey } from "../../encryption.js";
 import { fileExtension, joinPaths, prependForwardSlash } from "../../path.js";
 import { DEFAULT_COMPONENTS } from "../../routing/default.js";
 import { serializeRouteData } from "../../routing/index.js";
+import { resolveSessionDriver } from "../../session.js";
 import { addRollupInput } from "../add-rollup-input.js";
 import { getOutFile, getOutFolder } from "../common.js";
 import { cssOrder, mergeInlineCss } from "../internal.js";
@@ -17,7 +18,7 @@ const manifestReplace = "@@ASTRO_MANIFEST_REPLACE@@";
 const replaceExp = new RegExp(`['"]${manifestReplace}['"]`, "g");
 const SSR_MANIFEST_VIRTUAL_MODULE_ID = "@astrojs-manifest";
 const RESOLVED_SSR_MANIFEST_VIRTUAL_MODULE_ID = "\0" + SSR_MANIFEST_VIRTUAL_MODULE_ID;
-function vitePluginManifest(_options, internals) {
+function vitePluginManifest(options, internals) {
   return {
     name: "@astro/plugin-build-manifest",
     enforce: "post",
@@ -40,8 +41,12 @@ function vitePluginManifest(_options, internals) {
           `import { deserializeManifest as _deserializeManifest } from 'astro/app'`,
           `import { _privateSetManifestDontUseThis } from 'astro:ssr-manifest'`
         ];
+        const resolvedDriver = await resolveSessionDriver(
+          options.settings.config.experimental?.session?.driver
+        );
         const contents = [
           `const manifest = _deserializeManifest('${manifestReplace}');`,
+          `if (manifest.sessionConfig) manifest.sessionConfig.driverModule = ${resolvedDriver ? `() => import(${JSON.stringify(resolvedDriver)})` : "null"};`,
           `_privateSetManifestDontUseThis(manifest);`
         ];
         const exports = [`export { manifest }`];
@@ -220,7 +225,8 @@ function buildManifest(opts, internals, staticFiles, encodedKey) {
     buildFormat: settings.config.build.format,
     checkOrigin: (settings.config.security?.checkOrigin && settings.buildOutput === "server") ?? false,
     serverIslandNameMap: Array.from(settings.serverIslandNameMap),
-    key: encodedKey
+    key: encodedKey,
+    sessionConfig: settings.config.experimental.session
   };
 }
 export {

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

@@ -218,14 +218,14 @@ ${bgGreen(black(" building client (vite) "))}`);
     envPrefix: viteConfig.envPrefix ?? "PUBLIC_",
     base: settings.config.base
   };
-  await runHookBuildSetup({
+  const updatedViteBuildConfig = await runHookBuildSetup({
     config: settings.config,
     pages: internals.pagesByKeys,
     vite: viteBuildConfig,
     target: "client",
     logger: opts.logger
   });
-  const buildResult = await vite.build(viteBuildConfig);
+  const buildResult = await vite.build(updatedViteBuildConfig);
   return buildResult;
 }
 async function runPostBuildHooks(container, ssrOutputs, clientOutputs) {
@@ -316,7 +316,6 @@ async function ssrMoveAssets(opts) {
   const files = await glob(`**/*`, {
     cwd: fileURLToPath(serverAssets)
   });
-  console.log("FILES2", files);
   if (files.length > 0) {
     await Promise.all(
       files.map(async function moveAsset(filename) {