astro 5.9.4 → 5.10.0

package/dist/content/runtime.js

@@ -3,8 +3,9 @@ import { Traverse } from "neotraverse/modern";
 import pLimit from "p-limit";
 import { ZodIssueCode, z } from "zod";
 import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
-import { AstroError, AstroErrorData, AstroUserError } from "../core/errors/index.js";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { prependForwardSlash } from "../core/path.js";
+import { defineCollection as defineCollectionOrig } from "./config.js";
 import {
   createComponent,
   createHeadAndContent,
@@ -15,28 +16,14 @@ import {
   render as serverRender,
   unescapeHTML
 } from "../runtime/server/index.js";
-import { CONTENT_LAYER_TYPE, IMAGE_IMPORT_PREFIX } from "./consts.js";
+import { IMAGE_IMPORT_PREFIX } from "./consts.js";
 import { globalDataStore } from "./data-store.js";
-function getImporterFilename() {
-  const stackLine = new Error().stack?.split("\n")?.[3];
-  if (!stackLine) {
-    return null;
-  }
-  const match = /\/(src\/.*?):\d+:\d+/.exec(stackLine);
-  return match?.[1] ?? null;
-}
-function defineCollection(config) {
-  if ("loader" in config) {
-    if (config.type && config.type !== CONTENT_LAYER_TYPE) {
-      throw new AstroUserError(
-        `Collections that use the Content Layer API must have a \`loader\` defined and no \`type\` set. Check your collection definitions in ${getImporterFilename() ?? "your content config file"}.`
-      );
-    }
-    config.type = CONTENT_LAYER_TYPE;
-  }
-  if (!config.type) config.type = "content";
-  return config;
-}
+import {
+  LiveCollectionCacheHintError,
+  LiveCollectionError,
+  LiveCollectionValidationError,
+  LiveEntryNotFoundError
+} from "./loaders/errors.js";
 function createCollectionToGlobResultMap({
   globResult,
   contentDir
@@ -52,13 +39,57 @@ function createCollectionToGlobResultMap({
   }
   return collectionToGlobResultMap;
 }
+const cacheHintSchema = z.object({
+  tags: z.array(z.string()).optional(),
+  maxAge: z.number().optional()
+});
+async function parseLiveEntry(entry, schema, collection) {
+  try {
+    const parsed = await schema.safeParseAsync(entry.data);
+    if (!parsed.success) {
+      return {
+        error: new LiveCollectionValidationError(collection, entry.id, parsed.error)
+      };
+    }
+    if (entry.cacheHint) {
+      const cacheHint = cacheHintSchema.safeParse(entry.cacheHint);
+      if (!cacheHint.success) {
+        return {
+          error: new LiveCollectionCacheHintError(collection, entry.id, cacheHint.error)
+        };
+      }
+      entry.cacheHint = cacheHint.data;
+    }
+    return {
+      entry: {
+        ...entry,
+        data: parsed.data
+      }
+    };
+  } catch (error) {
+    return {
+      error: new LiveCollectionError(
+        collection,
+        `Unexpected error parsing entry ${entry.id} in collection ${collection}`,
+        error
+      )
+    };
+  }
+}
 function createGetCollection({
   contentCollectionToEntryMap,
   dataCollectionToEntryMap,
   getRenderEntryImport,
-  cacheEntriesByCollection
+  cacheEntriesByCollection,
+  liveCollections
 }) {
   return async function getCollection(collection, filter) {
+    if (collection in liveCollections) {
+      throw new AstroError({
+        ...AstroErrorData.UnknownContentCollectionError,
+        message: `Collection "${collection}" is a live collection. Use getLiveCollection() instead of getCollection().`
+      });
+    }
     const hasFilter = typeof filter === "function";
     const store = await globalDataStore.get();
     let type;
@@ -219,22 +250,35 @@ function emulateLegacyEntry({ legacyId, ...entry }) {
 function createGetEntry({
   getEntryImport,
   getRenderEntryImport,
-  collectionNames
+  collectionNames,
+  liveCollections
 }) {
-  return async function getEntry(collectionOrLookupObject, _lookupId) {
+  return async function getEntry(collectionOrLookupObject, lookup) {
     let collection, lookupId;
     if (typeof collectionOrLookupObject === "string") {
       collection = collectionOrLookupObject;
-      if (!_lookupId)
+      if (!lookup)
         throw new AstroError({
           ...AstroErrorData.UnknownContentCollectionError,
           message: "`getEntry()` requires an entry identifier as the second argument."
         });
-      lookupId = _lookupId;
+      lookupId = lookup;
     } else {
       collection = collectionOrLookupObject.collection;
       lookupId = "id" in collectionOrLookupObject ? collectionOrLookupObject.id : collectionOrLookupObject.slug;
     }
+    if (collection in liveCollections) {
+      throw new AstroError({
+        ...AstroErrorData.UnknownContentCollectionError,
+        message: `Collection "${collection}" is a live collection. Use getLiveEntry() instead of getEntry().`
+      });
+    }
+    if (typeof lookupId === "object") {
+      throw new AstroError({
+        ...AstroErrorData.UnknownContentCollectionError,
+        message: `The entry identifier must be a string. Received object.`
+      });
+    }
     const store = await globalDataStore.get();
     if (store.hasCollection(collection)) {
       const entry2 = store.get(collection, lookupId);
@@ -291,6 +335,136 @@ function createGetEntries(getEntry) {
     return Promise.all(entries.map((e) => getEntry(e)));
   };
 }
+function createGetLiveCollection({
+  liveCollections
+}) {
+  return async function getLiveCollection(collection, filter) {
+    if (!(collection in liveCollections)) {
+      return {
+        error: new LiveCollectionError(
+          collection,
+          `Collection "${collection}" is not a live collection. Use getCollection() instead of getLiveCollection() to load regular content collections.`
+        )
+      };
+    }
+    try {
+      const context = {
+        filter
+      };
+      const response = await liveCollections[collection].loader?.loadCollection?.(context);
+      if (response && "error" in response) {
+        return { error: response.error };
+      }
+      const { schema } = liveCollections[collection];
+      let processedEntries = response.entries;
+      if (schema) {
+        const entryResults = await Promise.all(
+          response.entries.map((entry) => parseLiveEntry(entry, schema, collection))
+        );
+        for (const result of entryResults) {
+          if (result.error) {
+            return { error: result.error };
+          }
+        }
+        processedEntries = entryResults.map((result) => result.entry);
+      }
+      let cacheHint = response.cacheHint;
+      if (cacheHint) {
+        const cacheHintResult = cacheHintSchema.safeParse(cacheHint);
+        if (!cacheHintResult.success) {
+          return {
+            error: new LiveCollectionCacheHintError(collection, void 0, cacheHintResult.error)
+          };
+        }
+        cacheHint = cacheHintResult.data;
+      }
+      if (processedEntries.length > 0) {
+        const entryTags = /* @__PURE__ */ new Set();
+        let minMaxAge;
+        for (const entry of processedEntries) {
+          if (entry.cacheHint) {
+            if (entry.cacheHint.tags) {
+              entry.cacheHint.tags.forEach((tag) => entryTags.add(tag));
+            }
+            if (typeof entry.cacheHint.maxAge === "number") {
+              minMaxAge = minMaxAge === void 0 ? entry.cacheHint.maxAge : Math.min(minMaxAge, entry.cacheHint.maxAge);
+            }
+          }
+        }
+        if (entryTags.size > 0 || minMaxAge !== void 0 || cacheHint) {
+          const mergedCacheHint = {};
+          if (cacheHint?.tags || entryTags.size > 0) {
+            mergedCacheHint.tags = [...cacheHint?.tags || [], ...entryTags];
+          }
+          if (cacheHint?.maxAge !== void 0 || minMaxAge !== void 0) {
+            mergedCacheHint.maxAge = cacheHint?.maxAge !== void 0 && minMaxAge !== void 0 ? Math.min(cacheHint.maxAge, minMaxAge) : cacheHint?.maxAge ?? minMaxAge;
+          }
+          cacheHint = mergedCacheHint;
+        }
+      }
+      return {
+        entries: processedEntries,
+        cacheHint
+      };
+    } catch (error) {
+      return {
+        error: new LiveCollectionError(
+          collection,
+          `Unexpected error loading collection ${collection}`,
+          error
+        )
+      };
+    }
+  };
+}
+function createGetLiveEntry({
+  liveCollections
+}) {
+  return async function getLiveEntry(collection, lookup) {
+    if (!(collection in liveCollections)) {
+      return {
+        error: new LiveCollectionError(
+          collection,
+          `Collection "${collection}" is not a live collection. Use getCollection() instead of getLiveEntry() to load regular content collections.`
+        )
+      };
+    }
+    try {
+      const lookupObject = {
+        filter: typeof lookup === "string" ? { id: lookup } : lookup
+      };
+      let entry = await liveCollections[collection].loader?.loadEntry?.(lookupObject);
+      if (entry && "error" in entry) {
+        return { error: entry.error };
+      }
+      if (!entry) {
+        return {
+          error: new LiveEntryNotFoundError(collection, lookup)
+        };
+      }
+      const { schema } = liveCollections[collection];
+      if (schema) {
+        const result = await parseLiveEntry(entry, schema, collection);
+        if (result.error) {
+          return { error: result.error };
+        }
+        entry = result.entry;
+      }
+      return {
+        entry,
+        cacheHint: entry.cacheHint
+      };
+    } catch (error) {
+      return {
+        error: new LiveCollectionError(
+          collection,
+          `Unexpected error loading entry ${collection} \u2192 ${typeof lookup === "string" ? lookup : JSON.stringify(lookup)}`,
+          error
+        )
+      };
+    }
+  };
+}
 const CONTENT_LAYER_IMAGE_REGEX = /__ASTRO_IMAGE_="([^"]+)"/g;
 async function updateImageReferencesInBody(html, fileName) {
   const { default: imageAssetMap } = await import("astro:asset-imports");
@@ -499,15 +673,31 @@ function createReference({ lookupMap }) {
 function isPropagatedAssetsModule(module) {
   return typeof module === "object" && module != null && "__astroPropagation" in module;
 }
+function defineCollection(config) {
+  if (config.type === "live") {
+    throw new AstroError({
+      ...AstroErrorData.LiveContentConfigError,
+      message: AstroErrorData.LiveContentConfigError.message(
+        "Collections with type `live` must be defined in a `src/live.config.ts` file."
+      )
+    });
+  }
+  return defineCollectionOrig(config);
+}
 export {
+  LiveCollectionCacheHintError,
+  LiveCollectionError,
+  LiveCollectionValidationError,
+  LiveEntryNotFoundError,
   createCollectionToGlobResultMap,
   createGetCollection,
   createGetDataEntryById,
   createGetEntries,
   createGetEntry,
   createGetEntryBySlug,
+  createGetLiveCollection,
+  createGetLiveEntry,
   createReference,
   defineCollection,
-  getImporterFilename,
   renderEntry
 };

package/dist/content/types-generator.js

@@ -6,12 +6,13 @@ import { normalizePath } from "vite";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { AstroError } from "../core/errors/errors.js";
-import { AstroErrorData } from "../core/errors/index.js";
+import { AstroErrorData, AstroUserError } from "../core/errors/index.js";
 import { isRelativePath } from "../core/path.js";
 import {
   COLLECTIONS_DIR,
   CONTENT_LAYER_TYPE,
   CONTENT_TYPES_FILE,
+  LIVE_CONTENT_TYPE,
   VIRTUAL_MODULE_ID
 } from "./consts.js";
 import {
@@ -366,6 +367,10 @@ async function writeContentFiles({
     const collectionEntryKeys = Object.keys(collection.entries).sort();
     const dataType = await typeForCollection(collectionConfig, collectionKey);
     switch (resolvedType) {
+      case LIVE_CONTENT_TYPE:
+        throw new AstroUserError(
+          `Invalid definition for collection ${collectionKey}: Live content collections must be defined in "src/live.config.ts"`
+        );
       case "content":
         if (collectionEntryKeys.length === 0) {
           contentTypesStr += `${collectionKey}: Record<string, {
@@ -468,16 +473,18 @@ async function writeContentFiles({
     settings.dotAstroDir.pathname,
     contentPaths.config.url.pathname
   );
+  const liveConfigPathRelativeToCacheDir = contentPaths.liveConfig?.exists ? normalizeConfigPath(settings.dotAstroDir.pathname, contentPaths.liveConfig.url.pathname) : void 0;
   for (const contentEntryType of contentEntryTypes) {
     if (contentEntryType.contentModuleTypes) {
       typeTemplateContent = contentEntryType.contentModuleTypes + "\n" + typeTemplateContent;
     }
   }
-  typeTemplateContent = typeTemplateContent.replace("// @@CONTENT_ENTRY_MAP@@", contentTypesStr);
-  typeTemplateContent = typeTemplateContent.replace("// @@DATA_ENTRY_MAP@@", dataTypesStr);
-  typeTemplateContent = typeTemplateContent.replace(
+  typeTemplateContent = typeTemplateContent.replace("// @@CONTENT_ENTRY_MAP@@", contentTypesStr).replace("// @@DATA_ENTRY_MAP@@", dataTypesStr).replace(
     "'@@CONTENT_CONFIG_TYPE@@'",
     contentConfig ? `typeof import(${configPathRelativeToCacheDir})` : "never"
+  ).replace(
+    "'@@LIVE_CONTENT_CONFIG_TYPE@@'",
+    liveConfigPathRelativeToCacheDir ? `typeof import(${liveConfigPathRelativeToCacheDir})` : "never"
   );
   if (settings.injectedTypes.some((t) => t.filename === CONTENT_TYPES_FILE)) {
     await fs.promises.writeFile(

package/dist/content/utils.d.ts

@@ -176,6 +176,18 @@ declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
     };
     schema?: any;
     _legacy?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"live">;
+    schema: z.ZodOptional<z.ZodAny>;
+    loader: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "live";
+    loader: (...args: unknown[]) => unknown;
+    schema?: any;
+}, {
+    type: "live";
+    loader: (...args: unknown[]) => unknown;
+    schema?: any;
 }>]>;
 declare const contentConfigParser: z.ZodObject<{
     collections: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
@@ -321,6 +333,18 @@ declare const contentConfigParser: z.ZodObject<{
         };
         schema?: any;
         _legacy?: boolean | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"live">;
+        schema: z.ZodOptional<z.ZodAny>;
+        loader: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: "live";
+        loader: (...args: unknown[]) => unknown;
+        schema?: any;
+    }, {
+        type: "live";
+        loader: (...args: unknown[]) => unknown;
+        schema?: any;
     }>]>>;
 }, "strip", z.ZodTypeAny, {
     collections: Record<string, {
@@ -351,6 +375,10 @@ declare const contentConfigParser: z.ZodObject<{
         };
         schema?: any;
         _legacy?: boolean | undefined;
+    } | {
+        type: "live";
+        loader: (...args: unknown[]) => unknown;
+        schema?: any;
     }>;
 }, {
     collections: Record<string, {
@@ -381,6 +409,10 @@ declare const contentConfigParser: z.ZodObject<{
         };
         schema?: any;
         _legacy?: boolean | undefined;
+    } | {
+        type: "live";
+        loader: (...args: unknown[]) => unknown;
+        schema?: any;
     }>;
 }>;
 export type CollectionConfig = z.infer<typeof collectionConfigParser>;
@@ -484,8 +516,12 @@ export type ContentPaths = {
         exists: boolean;
         url: URL;
     };
+    liveConfig: {
+        exists: boolean;
+        url: URL;
+    };
 };
-export declare function getContentPaths({ srcDir, legacy, root }: Pick<AstroConfig, 'root' | 'srcDir' | 'legacy'>, fs?: typeof fsMod): ContentPaths;
+export declare function getContentPaths({ srcDir, legacy, root, experimental, }: Pick<AstroConfig, 'root' | 'srcDir' | 'legacy' | 'experimental'>, fs?: typeof fsMod): ContentPaths;
 /**
  * Check for slug in content entry frontmatter and validate the type,
  * falling back to the `generatedSlug` if none is found.

package/dist/content/utils.js

@@ -15,6 +15,7 @@ import {
   CONTENT_MODULE_FLAG,
   DEFERRED_MODULE,
   IMAGE_IMPORT_PREFIX,
+  LIVE_CONTENT_TYPE,
   PROPAGATED_ASSET_FLAG
 } from "./consts.js";
 import { glob } from "./loaders/glob.js";
@@ -78,6 +79,11 @@ const collectionConfigParser = z.union([
     ]),
     /** deprecated */
     _legacy: z.boolean().optional()
+  }),
+  z.object({
+    type: z.literal(LIVE_CONTENT_TYPE),
+    schema: z.any().optional(),
+    loader: z.function()
   })
 ]);
 const contentConfigParser = z.object({
@@ -394,7 +400,7 @@ async function autogenerateCollections({
   const dataPattern = globWithUnderscoresIgnored("", dataExts);
   let usesContentLayer = false;
   for (const collectionName of Object.keys(collections)) {
-    if (collections[collectionName]?.type === "content_layer") {
+    if (collections[collectionName]?.type === "content_layer" || collections[collectionName]?.type === "live") {
       usesContentLayer = true;
       continue;
     }
@@ -496,8 +502,14 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({ srcDir, legacy, root }, fs = fsMod) {
-  const configStats = search(fs, srcDir, legacy?.collections);
+function getContentPaths({
+  srcDir,
+  legacy,
+  root,
+  experimental
+}, fs = fsMod) {
+  const configStats = searchConfig(fs, srcDir, legacy?.collections);
+  const liveConfigStats = experimental?.liveContentCollections ? searchLiveConfig(fs, srcDir) : { exists: false, url: new URL("./", srcDir) };
   const pkgBase = new URL("../../", import.meta.url);
   return {
     root: new URL("./", root),
@@ -505,23 +517,32 @@ function getContentPaths({ srcDir, legacy, root }, fs = fsMod) {
     assetsDir: new URL("./assets/", srcDir),
     typesTemplate: new URL("templates/content/types.d.ts", pkgBase),
     virtualModTemplate: new URL("templates/content/module.mjs", pkgBase),
-    config: configStats
+    config: configStats,
+    liveConfig: liveConfigStats
   };
 }
-function search(fs, srcDir, legacy) {
+function searchConfig(fs, srcDir, legacy) {
   const paths = [
     ...legacy ? [] : ["content.config.mjs", "content.config.js", "content.config.mts", "content.config.ts"],
     "content/config.mjs",
     "content/config.js",
     "content/config.mts",
     "content/config.ts"
-  ].map((p) => new URL(`./${p}`, srcDir));
-  for (const file of paths) {
+  ];
+  return search(fs, srcDir, paths);
+}
+function searchLiveConfig(fs, srcDir) {
+  const paths = ["live.config.mjs", "live.config.js", "live.config.mts", "live.config.ts"];
+  return search(fs, srcDir, paths);
+}
+function search(fs, srcDir, paths) {
+  const urls = paths.map((p) => new URL(`./${p}`, srcDir));
+  for (const file of urls) {
     if (fs.existsSync(file)) {
       return { exists: true, url: file };
     }
   }
-  return { exists: false, url: paths[0] };
+  return { exists: false, url: urls[0] };
 }
 async function getEntrySlug({
   id,

package/dist/content/vite-plugin-content-virtual-mod.d.ts

@@ -1,5 +1,5 @@
 import nodeFs from 'node:fs';
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 import type { AstroSettings } from '../types/astro.js';
 interface AstroContentVirtualModPluginParams {
     settings: AstroSettings;

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -4,6 +4,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { dataToEsm } from "@rollup/pluginutils";
 import pLimit from "p-limit";
 import { glob } from "tinyglobby";
+import { normalizePath } from "vite";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
 import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
@@ -52,11 +53,16 @@ function astroContentVirtualModPlugin({
 }) {
   let dataStoreFile;
   let devServer;
+  let liveConfig;
   return {
     name: "astro-content-virtual-mod-plugin",
     enforce: "pre",
     config(_, env) {
       dataStoreFile = getDataStoreFile(settings, env.command === "serve");
+      const contentPaths = getContentPaths(settings.config);
+      if (contentPaths.liveConfig.exists) {
+        liveConfig = normalizePath(fileURLToPath(contentPaths.liveConfig.url));
+      }
     },
     buildStart() {
       if (devServer) {
@@ -64,8 +70,13 @@ function astroContentVirtualModPlugin({
         invalidateDataStore(devServer);
       }
     },
-    async resolveId(id) {
+    async resolveId(id, importer) {
       if (id === VIRTUAL_MODULE_ID) {
+        if (liveConfig && importer && liveConfig === normalizePath(importer)) {
+          return this.resolve("astro/content/config", importer, {
+            skipSelf: true
+          });
+        }
         return RESOLVED_VIRTUAL_MODULE_ID;
       }
       if (id === DATA_STORE_VIRTUAL_ID) {
@@ -202,14 +213,17 @@ async function generateContentEntryFile({
       message: AstroErrorData.ServerOnlyModule.message("astro:content")
     });
   } else {
-    virtualModContents = nodeFs.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("'@@CONTENT_ENTRY_GLOB_PATH@@'", contentEntryGlobResult).replace("'@@DATA_ENTRY_GLOB_PATH@@'", dataEntryGlobResult).replace("'@@RENDER_ENTRY_GLOB_PATH@@'", renderEntryGlobResult).replace("/* @@LOOKUP_MAP_ASSIGNMENT@@ */", `lookupMap = ${JSON.stringify(lookupMap)};`);
+    virtualModContents = nodeFs.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("'@@CONTENT_ENTRY_GLOB_PATH@@'", contentEntryGlobResult).replace("'@@DATA_ENTRY_GLOB_PATH@@'", dataEntryGlobResult).replace("'@@RENDER_ENTRY_GLOB_PATH@@'", renderEntryGlobResult).replace("/* @@LOOKUP_MAP_ASSIGNMENT@@ */", `lookupMap = ${JSON.stringify(lookupMap)};`).replace(
+      "/* @@LIVE_CONTENT_CONFIG@@ */",
+      contentPaths.liveConfig.exists ? (
+        // Dynamic import so it extracts the chunk and avoids a circular import
+        `const liveCollections = (await import(${JSON.stringify(fileURLToPath(contentPaths.liveConfig.url))})).collections;`
+      ) : "const liveCollections = {};"
+    );
   }
   return virtualModContents;
 }
-async function generateLookupMap({
-  settings,
-  fs
-}) {
+async function generateLookupMap({ settings, fs }) {
   const { root } = settings.config;
   const contentPaths = getContentPaths(settings.config);
   const relContentDir = rootRelativePath(root, contentPaths.contentDir, false);