astro 4.6.2 → 4.6.4

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

@@ -10,40 +10,53 @@ import {
   generateLookupMap
 } from "../../../content/vite-plugin-content-virtual-mod.js";
 import { isServerLikeOutput } from "../../../prerender/utils.js";
-import { joinPaths, removeFileExtension, removeLeadingForwardSlash } from "../../path.js";
+import { configPaths } from "../../config/index.js";
+import { emptyDir } from "../../fs/index.js";
+import {
+  appendForwardSlash,
+  joinPaths,
+  removeFileExtension,
+  removeLeadingForwardSlash
+} from "../../path.js";
 import { addRollupInput } from "../add-rollup-input.js";
+import { CHUNKS_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_MANIFEST_FILE = "./manifest.json";
-const CONTENT_MANIFEST_VERSION = 0;
+const CONTENT_MANIFEST_VERSION = 1;
 const virtualEmptyModuleId = `virtual:empty-content`;
 const resolvedVirtualEmptyModuleId = `\0${virtualEmptyModuleId}`;
+const NO_MANIFEST_VERSION = -1;
 function createContentManifest() {
-  return { version: -1, entries: [], serverEntries: [], clientEntries: [] };
+  return {
+    version: NO_MANIFEST_VERSION,
+    entries: [],
+    serverEntries: [],
+    clientEntries: [],
+    lockfiles: "",
+    configs: ""
+  };
 }
-function vitePluginContent(opts, lookupMap, internals) {
+function vitePluginContent(opts, lookupMap, internals, cachedBuildOutput) {
   const { config } = opts.settings;
   const { cacheDir } = config;
   const distRoot = config.outDir;
   const distContentRoot = new URL("./content/", distRoot);
-  const cachedChunks = new URL("./chunks/", opts.settings.config.cacheDir);
-  const distChunks = new URL("./chunks/", opts.settings.config.outDir);
   const contentCacheDir = new URL(CONTENT_CACHE_DIR, cacheDir);
   const contentManifestFile = new URL(CONTENT_MANIFEST_FILE, contentCacheDir);
-  const cache = contentCacheDir;
-  const cacheTmp = new URL("./.tmp/", cache);
+  const cacheTmp = new URL("./.tmp/", contentCacheDir);
   let oldManifest = createContentManifest();
   let newManifest = createContentManifest();
   let entries;
   let injectedEmptyFile = false;
+  let currentManifestState = "valid";
   if (fsMod.existsSync(contentManifestFile)) {
     try {
       const data = fsMod.readFileSync(contentManifestFile, { encoding: "utf8" });
       oldManifest = JSON.parse(data);
-      internals.cachedClientEntries = oldManifest.clientEntries;
     } catch {
     }
   }
@@ -53,6 +66,30 @@ function vitePluginContent(opts, lookupMap, internals) {
       let newOptions = Object.assign({}, options);
       newManifest = await generateContentManifest(opts, lookupMap);
       entries = getEntriesFromManifests(oldManifest, newManifest);
+      currentManifestState = manifestState(oldManifest, newManifest);
+      if (currentManifestState === "valid") {
+        internals.cachedClientEntries = oldManifest.clientEntries;
+      } else {
+        let logReason = "";
+        switch (currentManifestState) {
+          case "config-mismatch":
+            logReason = "Astro config has changed";
+            break;
+          case "lockfile-mismatch":
+            logReason = "Lockfiles have changed";
+            break;
+          case "no-entries":
+            logReason = "No content collections entries cached";
+            break;
+          case "version-mismatch":
+            logReason = "The cache manifest version has changed";
+            break;
+          case "no-manifest":
+            logReason = "No content manifest was found in the cache";
+            break;
+        }
+        opts.logger.info("build", `Cache invalid, rebuilding from source. Reason: ${logReason}.`);
+      }
       for (const { type, entry } of entries.buildFromSource) {
         const fileURL = encodeURI(joinPaths(opts.settings.config.root.toString(), entry));
         const input = fileURLToPath(fileURL);
@@ -62,8 +99,12 @@ function vitePluginContent(opts, lookupMap, internals) {
         }
         newOptions = addRollupInput(newOptions, inputs);
       }
-      if (fsMod.existsSync(cachedChunks)) {
-        await copyFiles(cachedChunks, distChunks, true);
+      if (currentManifestState === "valid") {
+        for (const { cached, dist } of cachedBuildOutput) {
+          if (fsMod.existsSync(cached)) {
+            await copyFiles(cached, dist, true);
+          }
+        }
       }
       if (entries.buildFromSource.length === 0) {
         newOptions = addRollupInput(newOptions, [virtualEmptyModuleId]);
@@ -152,15 +193,17 @@ export default {}`
       ]);
       newManifest.serverEntries = Array.from(serverComponents);
       newManifest.clientEntries = Array.from(clientComponents);
+      const cacheExists = fsMod.existsSync(contentCacheDir);
+      if (cacheExists && currentManifestState !== "valid") {
+        emptyDir(contentCacheDir);
+      }
       await fsMod.promises.mkdir(contentCacheDir, { recursive: true });
       await fsMod.promises.writeFile(contentManifestFile, JSON.stringify(newManifest), {
         encoding: "utf8"
       });
-      const cacheExists = fsMod.existsSync(cache);
-      fsMod.mkdirSync(cache, { recursive: true });
       await fsMod.promises.mkdir(cacheTmp, { recursive: true });
       await copyFiles(distContentRoot, cacheTmp, true);
-      if (cacheExists) {
+      if (cacheExists && currentManifestState === "valid") {
         await copyFiles(contentCacheDir, distContentRoot, false);
       }
       await copyFiles(cacheTmp, contentCacheDir);
@@ -186,11 +229,11 @@ function findEntryFromSrcRelativePath(lookupMap, srcRelativePath) {
   }
 }
 function getEntriesFromManifests(oldManifest, newManifest) {
-  const { version: oldVersion, entries: oldEntries } = oldManifest;
-  const { version: newVersion, entries: newEntries } = newManifest;
+  const { entries: oldEntries } = oldManifest;
+  const { entries: newEntries } = newManifest;
   let entries = { restoreFromCache: [], buildFromSource: [] };
   const newEntryMap = new Map(newEntries);
-  if (oldVersion !== newVersion || oldEntries.length === 0) {
+  if (manifestState(oldManifest, newManifest) !== "valid") {
     entries.buildFromSource = Array.from(newEntryMap.keys());
     return entries;
   }
@@ -206,13 +249,27 @@ function getEntriesFromManifests(oldManifest, newManifest) {
   }
   return entries;
 }
+function manifestState(oldManifest, newManifest) {
+  if (oldManifest.version === NO_MANIFEST_VERSION) {
+    return "no-manifest";
+  }
+  if (oldManifest.version !== newManifest.version) {
+    return "version-mismatch";
+  }
+  if (oldManifest.entries.length === 0) {
+    return "no-entries";
+  }
+  if (oldManifest.lockfiles !== newManifest.lockfiles || newManifest.lockfiles === "") {
+    return "lockfile-mismatch";
+  }
+  if (oldManifest.configs !== newManifest.configs) {
+    return "config-mismatch";
+  }
+  return "valid";
+}
 async function generateContentManifest(opts, lookupMap) {
-  let manifest = {
-    version: CONTENT_MANIFEST_VERSION,
-    entries: [],
-    serverEntries: [],
-    clientEntries: []
-  };
+  let manifest = createContentManifest();
+  manifest.version = CONTENT_MANIFEST_VERSION;
   const limit = pLimit(10);
   const promises = [];
   for (const [collection, { type, entries }] of Object.entries(lookupMap)) {
@@ -227,19 +284,65 @@ async function generateContentManifest(opts, lookupMap) {
       );
     }
   }
+  const [lockfiles, configs] = await Promise.all([
+    lockfilesHash(opts.settings.config.root),
+    configHash(opts.settings.config.root)
+  ]);
+  manifest.lockfiles = lockfiles;
+  manifest.configs = configs;
   await Promise.all(promises);
   return manifest;
 }
-function checksum(data) {
-  return createHash("sha1").update(data).digest("base64");
+async function pushBufferInto(fileURL, buffers) {
+  try {
+    const handle = await fsMod.promises.open(fileURL, "r");
+    const data = await handle.readFile();
+    buffers.push(data);
+    await handle.close();
+  } catch {
+  }
+}
+async function lockfilesHash(root) {
+  const lockfiles = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+  const datas = [];
+  const promises = [];
+  for (const lockfileName of lockfiles) {
+    const fileURL = new URL(`./${lockfileName}`, root);
+    promises.push(pushBufferInto(fileURL, datas));
+  }
+  await Promise.all(promises);
+  return checksum(...datas);
+}
+async function configHash(root) {
+  const configFileNames = configPaths;
+  for (const configPath of configFileNames) {
+    try {
+      const fileURL = new URL(`./${configPath}`, root);
+      const data = await fsMod.promises.readFile(fileURL);
+      const hash = checksum(data);
+      return hash;
+    } catch {
+    }
+  }
+  return checksum(`export default {}`);
+}
+function checksum(...datas) {
+  const hash = createHash("sha1");
+  datas.forEach((data) => hash.update(data));
+  return hash.digest("base64");
 }
 function collectionTypeToFlag(type) {
   const name = type[0].toUpperCase() + type.slice(1);
   return `astro${name}CollectionEntry`;
 }
 function pluginContent(opts, internals) {
-  const cachedChunks = new URL("./chunks/", opts.settings.config.cacheDir);
-  const distChunks = new URL("./chunks/", opts.settings.config.outDir);
+  const { cacheDir, outDir } = opts.settings.config;
+  const chunksFolder = "./" + CHUNKS_PATH;
+  const assetsFolder = "./" + appendForwardSlash(opts.settings.config.build.assets);
+  const cachedBuildOutput = [
+    { cached: new URL(chunksFolder, cacheDir), dist: new URL(chunksFolder, outDir) },
+    { cached: new URL(assetsFolder, cacheDir), dist: new URL(assetsFolder, outDir) }
+  ];
   return {
     targets: ["server"],
     hooks: {
@@ -252,7 +355,7 @@ function pluginContent(opts, internals) {
         }
         const lookupMap = await generateLookupMap({ settings: opts.settings, fs: fsMod });
         return {
-          vitePlugin: vitePluginContent(opts, lookupMap, internals)
+          vitePlugin: vitePluginContent(opts, lookupMap, internals, cachedBuildOutput)
         };
       },
       async "build:post"() {
@@ -262,8 +365,10 @@ function pluginContent(opts, internals) {
         if (isServerLikeOutput(opts.settings.config)) {
           return;
         }
-        if (fsMod.existsSync(distChunks)) {
-          await copyFiles(distChunks, cachedChunks, true);
+        for (const { cached, dist } of cachedBuildOutput) {
+          if (fsMod.existsSync(dist)) {
+            await copyFiles(dist, cached, true);
+          }
         }
       }
     }

package/dist/core/build/plugins/util.d.ts

@@ -1,4 +1,4 @@
-import type { BuildOptions, Plugin as VitePlugin, Rollup } from 'vite';
+import type { BuildOptions, Rollup, Plugin as VitePlugin } from 'vite';
 type OutputOptionsHook = Extract<VitePlugin['outputOptions'], Function>;
 type OutputOptions = Parameters<OutputOptionsHook>[0];
 type ExtendManualChunksHooks = {

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

@@ -6,7 +6,7 @@ export declare function viteBuild(opts: StaticBuildOptions): Promise<{
     ssrOutputChunkNames: string[];
 }>;
 export declare function staticBuild(opts: StaticBuildOptions, internals: BuildInternals, ssrOutputChunkNames: string[]): Promise<void>;
-export declare function copyFiles(fromFolder: URL, toFolder: URL, includeDotfiles?: boolean): 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
  * transforms it to generate a final `.mjs` output file.

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

@@ -21,6 +21,7 @@ import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { routeIsRedirect } from "../redirects/index.js";
 import { getOutDirWithinCwd } from "./common.js";
+import { CHUNKS_PATH } from "./consts.js";
 import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { createPluginContainer } from "./plugin.js";
@@ -146,7 +147,7 @@ async function ssrBuild(opts, internals, input, container) {
           // We need to keep these separate
           chunkFileNames(chunkInfo) {
             const { name } = chunkInfo;
-            let prefix = "chunks/";
+            let prefix = CHUNKS_PATH;
             let suffix = "_[hash].mjs";
             if (isContentCache) {
               prefix += `${buildID}/`;
@@ -345,7 +346,7 @@ async function copyFiles(fromFolder, toFolder, includeDotfiles = false) {
   });
   if (files.length === 0)
     return;
-  await Promise.all(
+  return await Promise.all(
     files.map(async function copyFile(filename) {
       const from = new URL(filename, fromFolder);
       const to = new URL(filename, toFolder);

package/dist/core/config/config.d.ts

@@ -7,6 +7,7 @@ export declare function validateConfig(userConfig: any, root: string, cmd: strin
 /** Convert the generic "yargs" flag object into our own, custom TypeScript object. */
 export declare function resolveFlags(flags: Partial<Flags>): CLIFlags;
 export declare function resolveRoot(cwd?: string | URL): string;
+export declare const configPaths: readonly string[];
 interface ResolveConfigPathOptions {
     root: string;
     configFile?: string;

package/dist/core/config/config.js

@@ -45,15 +45,16 @@ function resolveRoot(cwd) {
   }
   return cwd ? path.resolve(cwd) : process.cwd();
 }
+const configPaths = Object.freeze([
+  "astro.config.mjs",
+  "astro.config.js",
+  "astro.config.ts",
+  "astro.config.mts",
+  "astro.config.cjs",
+  "astro.config.cts"
+]);
 async function search(fsMod, root) {
-  const paths = [
-    "astro.config.mjs",
-    "astro.config.js",
-    "astro.config.ts",
-    "astro.config.mts",
-    "astro.config.cjs",
-    "astro.config.cts"
-  ].map((p) => path.join(root, p));
+  const paths = configPaths.map((p) => path.join(root, p));
   for (const file of paths) {
     if (fsMod.existsSync(file)) {
       return file;
@@ -121,6 +122,7 @@ async function resolveConfig(inlineConfig, command, fsMod = fs) {
   return { userConfig, astroConfig };
 }
 export {
+  configPaths,
   resolveConfig,
   resolveConfigPath,
   resolveFlags,

package/dist/core/config/index.d.ts

@@ -1,4 +1,4 @@
-export { resolveConfig, resolveConfigPath, resolveFlags, resolveRoot } from './config.js';
+export { configPaths, resolveConfig, resolveConfigPath, resolveFlags, resolveRoot, } from './config.js';
 export { createNodeLogger } from './logging.js';
 export { mergeConfig } from './merge.js';
 export type { AstroConfigType } from './schema.js';

package/dist/core/config/index.js

@@ -1,9 +1,16 @@
-import { resolveConfig, resolveConfigPath, resolveFlags, resolveRoot } from "./config.js";
+import {
+  configPaths,
+  resolveConfig,
+  resolveConfigPath,
+  resolveFlags,
+  resolveRoot
+} from "./config.js";
 import { createNodeLogger } from "./logging.js";
 import { mergeConfig } from "./merge.js";
 import { createSettings } from "./settings.js";
 import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
 export {
+  configPaths,
   createNodeLogger,
   createSettings,
   loadTSConfig,