astro 5.0.0-beta.3 → 5.0.0-beta.4

package/client.d.ts

@@ -19,7 +19,7 @@ interface ImportMeta {
 	 * Astro and Vite expose environment variables through `import.meta.env`. For a complete list of the environment variables available, see the two references below.
 	 *
 	 * - [Astro reference](https://docs.astro.build/en/guides/environment-variables/#default-environment-variables)
-	 * - [Vite reference](https://vitejs.dev/guide/env-and-mode.html#env-variables)
+	 * - [Vite reference](https://vite.dev/guide/env-and-mode.html#env-variables)
 	 */
 	readonly env: ImportMetaEnv;
 }

package/dist/actions/runtime/virtual/get-action.js

@@ -1,7 +1,7 @@
 import { ActionNotFoundError } from "../../../core/errors/errors-data.js";
 import { AstroError } from "../../../core/errors/errors.js";
 async function getAction(path) {
-  const pathKeys = path.replace("/_actions/", "").split(".");
+  const pathKeys = path.replace("/_actions/", "").split(".").map((key) => decodeURIComponent(key));
   let { server: actionLookup } = await import("astro:internal-actions");
   if (actionLookup == null || !(typeof actionLookup === "object")) {
     throw new TypeError(

package/dist/assets/utils/transformToPath.js

@@ -6,7 +6,11 @@ import { isESMImportedImage } from "./imageKind.js";
 function propsToFilename(filePath, transform, hash) {
   let filename = decodeURIComponent(removeQueryString(filePath));
   const ext = extname(filename);
-  filename = basename(filename, ext);
+  if (filePath.startsWith("data:")) {
+    filename = shorthash(filePath);
+  } else {
+    filename = basename(filename, ext);
+  }
   const prefixDirname = isESMImportedImage(transform.src) ? dirname(filePath) : "";
   let outputExt = transform.format ? `.${transform.format}` : ext;
   return decodeURIComponent(`${prefixDirname}/${filename}_${hash}${outputExt}`);

package/dist/content/content-layer.js

@@ -107,10 +107,25 @@ class ContentLayer {
     logger.info("Syncing content");
     const { digest: currentConfigDigest } = contentConfig.config;
     this.#lastConfigDigest = currentConfigDigest;
+    let shouldClear = false;
     const previousConfigDigest = await this.#store.metaStore().get("config-digest");
+    const previousAstroVersion = await this.#store.metaStore().get("astro-version");
     if (currentConfigDigest && previousConfigDigest !== currentConfigDigest) {
-      logger.info("Content config changed, clearing cache");
+      logger.info("Content config changed");
+      shouldClear = true;
+    }
+    if (previousAstroVersion !== "5.0.0-beta.4") {
+      logger.info("Astro version changed");
+      shouldClear = true;
+    }
+    if (shouldClear) {
+      logger.info("Clearing content store");
       this.#store.clearAll();
+    }
+    if ("5.0.0-beta.4") {
+      await this.#store.metaStore().set("astro-version", "5.0.0-beta.4");
+    }
+    if (currentConfigDigest) {
       await this.#store.metaStore().set("config-digest", currentConfigDigest);
     }
     await Promise.all(

package/dist/content/data-store.d.ts

@@ -31,6 +31,8 @@ export interface DataEntry<TData extends Record<string, unknown> = Record<string
      */
     deferredRender?: boolean;
     assetImports?: Array<string>;
+    /** @deprecated */
+    legacyId?: string;
 }
 /**
  * A read-only data store for content collections. This is used to retrieve data from the content layer at runtime.

package/dist/content/loaders/glob.d.ts

@@ -23,3 +23,8 @@ export interface GlobOptions {
  * @param pattern A glob pattern to match files, relative to the content directory.
  */
 export declare function glob(globOptions: GlobOptions): Loader;
+/** @private */
+export declare function glob(globOptions: GlobOptions & {
+    /** @deprecated */
+    _legacy?: true;
+}): Loader;

package/dist/content/loaders/glob.js

@@ -9,7 +9,7 @@ function generateIdDefault({ entry, base, data }) {
   if (data.slug) {
     return data.slug;
   }
-  const entryURL = new URL(entry, base);
+  const entryURL = new URL(encodeURI(entry), base);
   const { slug } = getContentEntryIdAndSlug({
     entry: entryURL,
     contentDir: base,
@@ -41,17 +41,19 @@ function glob(globOptions) {
     load: async ({ config, logger, watcher, parseData, store, generateDigest, entryTypes }) => {
       const renderFunctionByContentType = /* @__PURE__ */ new WeakMap();
       const untouchedEntries = new Set(store.keys());
+      const isLegacy = globOptions._legacy;
+      const emulateLegacyCollections = !config.legacy.collections;
       async function syncData(entry, base, entryType) {
         if (!entryType) {
           logger.warn(`No entry type found for ${entry}`);
           return;
         }
-        const fileUrl = new URL(entry, base);
+        const fileUrl = new URL(encodeURI(entry), base);
         const contents = await fs.readFile(fileUrl, "utf-8").catch((err) => {
           logger.error(`Error reading ${entry}: ${err.message}`);
           return;
         });
-        if (!contents) {
+        if (!contents && contents !== "") {
           logger.warn(`No contents found for ${entry}`);
           return;
         }
@@ -60,6 +62,16 @@ function glob(globOptions) {
           fileUrl
         });
         const id = generateId({ entry, base, data });
+        let legacyId;
+        if (isLegacy) {
+          const entryURL = new URL(encodeURI(entry), base);
+          const legacyOptions = getContentEntryIdAndSlug({
+            entry: entryURL,
+            contentDir: base,
+            collection: ""
+          });
+          legacyId = legacyOptions.id;
+        }
         untouchedEntries.delete(id);
         const existingEntry = store.get(id);
         const digest = generateDigest(contents);
@@ -80,6 +92,11 @@ function glob(globOptions) {
           filePath
         });
         if (entryType.getRenderFunction) {
+          if (isLegacy && data.layout) {
+            logger.error(
+              `The Markdown "layout" field is not supported in content collections in Astro 5. Ignoring layout for ${JSON.stringify(entry)}. Enable "legacy.collections" if you need to use the layout field.`
+            );
+          }
           let render = renderFunctionByContentType.get(entryType);
           if (!render) {
             render = await entryType.getRenderFunction(config);
@@ -104,7 +121,8 @@ function glob(globOptions) {
             filePath: relativePath,
             digest,
             rendered,
-            assetImports: rendered?.metadata?.imagePaths
+            assetImports: rendered?.metadata?.imagePaths,
+            legacyId
           });
         } else if ("contentModuleTypes" in entryType) {
           store.set({
@@ -113,10 +131,11 @@ function glob(globOptions) {
             body,
             filePath: relativePath,
             digest,
-            deferredRender: true
+            deferredRender: true,
+            legacyId
           });
         } else {
-          store.set({ id, data: parsedData, body, filePath: relativePath, digest });
+          store.set({ id, data: parsedData, body, filePath: relativePath, digest, legacyId });
         }
         fileToIdMap.set(filePath, id);
       }
@@ -154,7 +173,7 @@ function glob(globOptions) {
           if (isConfigFile(entry)) {
             return;
           }
-          if (isInContentDir(entry)) {
+          if (!emulateLegacyCollections && isInContentDir(entry)) {
             skippedFiles.push(entry);
             return;
           }
@@ -167,7 +186,9 @@ function glob(globOptions) {
       const skipCount = skippedFiles.length;
       if (skipCount > 0) {
         const patternList = Array.isArray(globOptions.pattern) ? globOptions.pattern.join(", ") : globOptions.pattern;
-        logger.warn(`The glob() loader cannot be used for files in ${bold("src/content")}.`);
+        logger.warn(
+          `The glob() loader cannot be used for files in ${bold("src/content")} when legacy mode is enabled.`
+        );
         if (skipCount > 10) {
           logger.warn(
             `Skipped ${green(skippedFiles.length)} files that matched ${green(patternList)}.`

package/dist/content/mutable-data-store.d.ts

@@ -1,5 +1,5 @@
 import { type PathLike } from 'node:fs';
-import { type DataEntry, ImmutableDataStore, type RenderedContent } from './data-store.js';
+import { type DataEntry, ImmutableDataStore } from './data-store.js';
 /**
  * Extends the DataStore with the ability to change entries and write them to disk.
  * This is kept as a separate class to avoid needing node builtins at runtime, when read-only access is all that is needed.
@@ -34,24 +34,7 @@ export declare class MutableDataStore extends ImmutableDataStore {
 export interface DataStore {
     get: <TData extends Record<string, unknown> = Record<string, unknown>>(key: string) => DataEntry<TData> | undefined;
     entries: () => Array<[id: string, DataEntry]>;
-    set: <TData extends Record<string, unknown>>(opts: {
-        /** The ID of the entry. Must be unique per collection. */
-        id: string;
-        /** The data to store. */
-        data: TData;
-        /** The raw body of the content, if applicable. */
-        body?: string;
-        /** The file path of the content, if applicable. Relative to the site root. */
-        filePath?: string;
-        /** A content digest, to check if the content has changed. */
-        digest?: number | string;
-        /** The rendered content, if applicable. */
-        rendered?: RenderedContent;
-        /**
-         * If an entry is a deferred, its rendering phase is delegated to a virtual module during the runtime phase.
-         */
-        deferredRender?: boolean;
-    }) => boolean;
+    set: <TData extends Record<string, unknown>>(opts: DataEntry<TData>) => boolean;
     values: () => Array<DataEntry>;
     keys: () => Array<string>;
     delete: (key: string) => void;

package/dist/content/mutable-data-store.js

@@ -159,7 +159,17 @@ ${lines.join(",\n")}]);
       entries: () => this.entries(collectionName),
       values: () => this.values(collectionName),
       keys: () => this.keys(collectionName),
-      set: ({ id: key, data, body, filePath, deferredRender, digest, rendered, assetImports }) => {
+      set: ({
+        id: key,
+        data,
+        body,
+        filePath,
+        deferredRender,
+        digest,
+        rendered,
+        assetImports,
+        legacyId
+      }) => {
         if (!key) {
           throw new Error(`ID must be a non-empty string`);
         }
@@ -200,6 +210,9 @@ ${lines.join(",\n")}]);
         if (rendered) {
           entry.rendered = rendered;
         }
+        if (legacyId) {
+          entry.legacyId = legacyId;
+        }
         if (deferredRender) {
           entry.deferredRender = deferredRender;
           if (filePath) {

package/dist/content/runtime.d.ts

@@ -18,10 +18,11 @@ export declare function createGetCollection({ contentCollectionToEntryMap, dataC
     getRenderEntryImport: GetEntryImport;
     cacheEntriesByCollection: Map<string, any[]>;
 }): (collection: string, filter?: (entry: any) => unknown) => Promise<any[]>;
-export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, collectionNames, }: {
+export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, collectionNames, getEntry, }: {
     getEntryImport: GetEntryImport;
     getRenderEntryImport: GetEntryImport;
     collectionNames: Set<string>;
+    getEntry: ReturnType<typeof createGetEntry>;
 }): (collection: string, slug: string) => Promise<{
     id: any;
     slug: any;
@@ -30,10 +31,11 @@ export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImp
     data: any;
     render(): Promise<RenderResult>;
 } | undefined>;
-export declare function createGetDataEntryById({ getEntryImport, collectionNames, }: {
+export declare function createGetDataEntryById({ getEntryImport, collectionNames, getEntry, }: {
     getEntryImport: GetEntryImport;
     collectionNames: Set<string>;
-}): (collection: string, id: string) => Promise<{
+    getEntry: ReturnType<typeof createGetEntry>;
+}): (collection: string, id: string) => Promise<ContentEntryResult | {
     id: any;
     collection: any;
     data: any;
@@ -79,7 +81,11 @@ export declare function renderEntry(entry: DataEntry | {
     render: () => Promise<{
         Content: AstroComponentFactory;
     }>;
-}): Promise<{
+} | (DataEntry & {
+    render: () => Promise<{
+        Content: AstroComponentFactory;
+    }>;
+})): Promise<{
     Content: AstroComponentFactory;
 }>;
 export declare function createReference({ lookupMap }: {
@@ -88,20 +94,20 @@ export declare function createReference({ lookupMap }: {
     id: z.ZodString;
     collection: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    id: string;
     collection: string;
-}, {
     id: string;
+}, {
     collection: string;
+    id: string;
 }>, z.ZodObject<{
     slug: z.ZodString;
     collection: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    collection: string;
     slug: string;
-}, {
     collection: string;
+}, {
     slug: string;
+    collection: string;
 }>]>, {
     id: string;
     collection: string;
@@ -109,10 +115,10 @@ export declare function createReference({ lookupMap }: {
     slug: string;
     collection: string;
 } | undefined, string | {
-    id: string;
     collection: string;
+    id: string;
 } | {
-    collection: string;
     slug: string;
+    collection: string;
 }>;
 export {};

package/dist/content/runtime.js

@@ -71,7 +71,7 @@ function createGetCollection({
         if (hasFilter && !filter(entry)) {
           continue;
         }
-        result.push(entry);
+        result.push(entry.legacyId ? emulateLegacyEntry(entry) : entry);
       }
       return result;
     } else {
@@ -127,18 +127,25 @@ function createGetCollection({
 function createGetEntryBySlug({
   getEntryImport,
   getRenderEntryImport,
-  collectionNames
+  collectionNames,
+  getEntry
 }) {
   return async function getEntryBySlug(collection, slug) {
     const store = await globalDataStore.get();
     if (!collectionNames.has(collection)) {
       if (store.hasCollection(collection)) {
+        const entry2 = await getEntry(collection, slug);
+        if (entry2 && "slug" in entry2) {
+          return entry2;
+        }
         throw new AstroError({
           ...AstroErrorData.GetEntryDeprecationError,
           message: AstroErrorData.GetEntryDeprecationError.message(collection, "getEntryBySlug")
         });
       }
-      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      console.warn(
+        `The collection ${JSON.stringify(collection)} does not exist. Please ensure it is defined in your content config.`
+      );
       return void 0;
     }
     const entryImport = await getEntryImport(collection, slug);
@@ -162,18 +169,18 @@ function createGetEntryBySlug({
 }
 function createGetDataEntryById({
   getEntryImport,
-  collectionNames
+  collectionNames,
+  getEntry
 }) {
   return async function getDataEntryById(collection, id) {
     const store = await globalDataStore.get();
     if (!collectionNames.has(collection)) {
       if (store.hasCollection(collection)) {
-        throw new AstroError({
-          ...AstroErrorData.GetEntryDeprecationError,
-          message: AstroErrorData.GetEntryDeprecationError.message(collection, "getDataEntryById")
-        });
+        return getEntry(collection, id);
       }
-      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      console.warn(
+        `The collection ${JSON.stringify(collection)} does not exist. Please ensure it is defined in your content config.`
+      );
       return void 0;
     }
     const lazyImport = await getEntryImport(collection, id);
@@ -186,6 +193,19 @@ function createGetDataEntryById({
     };
   };
 }
+function emulateLegacyEntry(entry) {
+  const legacyEntry = {
+    ...entry,
+    id: entry.legacyId,
+    slug: entry.id
+  };
+  delete legacyEntry.legacyId;
+  return {
+    ...legacyEntry,
+    // Define separately so the render function isn't included in the object passed to `renderEntry()`
+    render: () => renderEntry(legacyEntry)
+  };
+}
 function createGetEntry({
   getEntryImport,
   getRenderEntryImport,
@@ -214,13 +234,18 @@ function createGetEntry({
       }
       const { default: imageAssetMap } = await import("astro:asset-imports");
       entry2.data = updateImageReferencesInData(entry2.data, entry2.filePath, imageAssetMap);
+      if (entry2.legacyId) {
+        return { ...emulateLegacyEntry(entry2), collection };
+      }
       return {
         ...entry2,
         collection
       };
     }
     if (!collectionNames.has(collection)) {
-      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      console.warn(
+        `The collection ${JSON.stringify(collection)} does not exist. Please ensure it is defined in your content config.`
+      );
       return void 0;
     }
     const entryImport = await getEntryImport(collection, lookupId);
@@ -307,7 +332,10 @@ function updateImageReferencesInData(data, fileName, imageAssetMap) {
   });
 }
 async function renderEntry(entry) {
-  if (entry && "render" in entry) {
+  if (!entry) {
+    throw new AstroError(AstroErrorData.RenderUndefinedEntryError);
+  }
+  if ("render" in entry && !("legacyId" in entry)) {
     return entry.render();
   }
   if (entry.deferredRender) {
@@ -431,13 +459,6 @@ function createReference({ lookupMap }) {
             });
             return;
           }
-          if (!lookupMap[collection] && !collectionIsInStore) {
-            ctx.addIssue({
-              code: ZodIssueCode.custom,
-              message: `**${flattenedErrorPath}:** Reference to ${collection} invalid. Collection does not exist or is empty.`
-            });
-            return;
-          }
           return lookup;
         }
         if (collectionIsInStore) {
@@ -451,7 +472,7 @@ function createReference({ lookupMap }) {
           }
           return { id: lookup, collection };
         }
-        if (!lookupMap[collection] && store.collections().size === 0) {
+        if (!lookupMap[collection] && store.collections().size <= 1) {
           return { id: lookup, collection };
         }
         const { type, entries } = lookupMap[collection];

package/dist/content/types-generator.js

@@ -390,12 +390,13 @@ async function writeContentFiles({
 `;
         break;
       case CONTENT_LAYER_TYPE:
+        const legacyTypes = collectionConfig?._legacy ? 'render(): Render[".md"];\n  slug: string;\n  body: string;\n' : "body?: string;\n";
         dataTypesStr += `${collectionKey}: Record<string, {
   id: string;
-  collection: ${collectionKey};
+  ${legacyTypes}  collection: ${collectionKey};
   data: ${dataType};
   rendered?: RenderedContent;
-  filePath?: string 
+  filePath?: string;
 }>;
 `;
         break;