astro 4.13.4 → 4.14.1

package/dist/content/runtime.js

@@ -1,6 +1,8 @@
+import { Traverse } from "neotraverse/modern";
 import pLimit from "p-limit";
-import { ZodIssueCode, string as zodString } from "zod";
-import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { ZodIssueCode, z } from "zod";
+import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
+import { AstroError, AstroErrorData, AstroUserError } from "../core/errors/index.js";
 import { prependForwardSlash } from "../core/path.js";
 import {
   createComponent,
@@ -9,9 +11,21 @@ import {
   renderScriptElement,
   renderTemplate,
   renderUniqueStylesheet,
+  render as serverRender,
   unescapeHTML
 } from "../runtime/server/index.js";
+import { CONTENT_LAYER_TYPE, IMAGE_IMPORT_PREFIX } from "./consts.js";
+import { globalDataStore } from "./data-store.js";
 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 `src/content/config.*`.'"
+      );
+    }
+    config.type = CONTENT_LAYER_TYPE;
+  }
   if (!config.type) config.type = "content";
   return config;
 }
@@ -37,11 +51,29 @@ function createGetCollection({
   cacheEntriesByCollection
 }) {
   return async function getCollection(collection, filter) {
+    const hasFilter = typeof filter === "function";
+    const store = await globalDataStore.get();
     let type;
     if (collection in contentCollectionToEntryMap) {
       type = "content";
     } else if (collection in dataCollectionToEntryMap) {
       type = "data";
+    } else if (store.hasCollection(collection)) {
+      const { default: imageAssetMap } = await import("astro:asset-imports");
+      const result = [];
+      for (const rawEntry of store.values(collection)) {
+        const data = rawEntry.filePath ? updateImageReferencesInData(rawEntry.data, rawEntry.filePath, imageAssetMap) : rawEntry.data;
+        const entry = {
+          ...rawEntry,
+          data,
+          collection
+        };
+        if (hasFilter && !filter(entry)) {
+          continue;
+        }
+        result.push(entry);
+      }
+      return result;
     } else {
       console.warn(
         `The collection ${JSON.stringify(
@@ -85,7 +117,7 @@ function createGetCollection({
       );
       cacheEntriesByCollection.set(collection, entries);
     }
-    if (typeof filter === "function") {
+    if (hasFilter) {
       return entries.filter(filter);
     } else {
       return entries.slice();
@@ -94,9 +126,21 @@ function createGetCollection({
 }
 function createGetEntryBySlug({
   getEntryImport,
-  getRenderEntryImport
+  getRenderEntryImport,
+  collectionNames
 }) {
   return async function getEntryBySlug(collection, slug) {
+    const store = await globalDataStore.get();
+    if (!collectionNames.has(collection)) {
+      if (store.hasCollection(collection)) {
+        throw new AstroError({
+          ...AstroErrorData.GetEntryDeprecationError,
+          message: AstroErrorData.GetEntryDeprecationError.message(collection, "getEntryBySlug")
+        });
+      }
+      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      return void 0;
+    }
     const entryImport = await getEntryImport(collection, slug);
     if (typeof entryImport !== "function") return void 0;
     const entry = await entryImport();
@@ -116,8 +160,22 @@ function createGetEntryBySlug({
     };
   };
 }
-function createGetDataEntryById({ getEntryImport }) {
+function createGetDataEntryById({
+  getEntryImport,
+  collectionNames
+}) {
   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")
+        });
+      }
+      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      return void 0;
+    }
     const lazyImport = await getEntryImport(collection, id);
     if (!lazyImport) throw new Error(`Entry ${collection} \u2192 ${id} was not found.`);
     const entry = await lazyImport();
@@ -130,7 +188,8 @@ function createGetDataEntryById({ getEntryImport }) {
 }
 function createGetEntry({
   getEntryImport,
-  getRenderEntryImport
+  getRenderEntryImport,
+  collectionNames
 }) {
   return async function getEntry(collectionOrLookupObject, _lookupId) {
     let collection, lookupId;
@@ -146,6 +205,26 @@ function createGetEntry({
       collection = collectionOrLookupObject.collection;
       lookupId = "id" in collectionOrLookupObject ? collectionOrLookupObject.id : collectionOrLookupObject.slug;
     }
+    const store = await globalDataStore.get();
+    if (store.hasCollection(collection)) {
+      const entry2 = store.get(collection, lookupId);
+      if (!entry2) {
+        console.warn(`Entry ${collection} \u2192 ${lookupId} was not found.`);
+        return;
+      }
+      if (entry2.filePath) {
+        const { default: imageAssetMap } = await import("astro:asset-imports");
+        entry2.data = updateImageReferencesInData(entry2.data, entry2.filePath, imageAssetMap);
+      }
+      return {
+        ...entry2,
+        collection
+      };
+    }
+    if (!collectionNames.has(collection)) {
+      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      return void 0;
+    }
     const entryImport = await getEntryImport(collection, lookupId);
     if (typeof entryImport !== "function") return void 0;
     const entry = await entryImport();
@@ -179,6 +258,82 @@ function createGetEntries(getEntry) {
     return Promise.all(entries.map((e) => getEntry(e)));
   };
 }
+const CONTENT_LAYER_IMAGE_REGEX = /__ASTRO_IMAGE_="([^"]+)"/g;
+async function updateImageReferencesInBody(html, fileName) {
+  const { default: imageAssetMap } = await import("astro:asset-imports");
+  const imageObjects = /* @__PURE__ */ new Map();
+  const { getImage } = await import("astro:assets");
+  for (const [_full, imagePath] of html.matchAll(CONTENT_LAYER_IMAGE_REGEX)) {
+    try {
+      const decodedImagePath = JSON.parse(imagePath.replaceAll(""", '"'));
+      const id = imageSrcToImportId(decodedImagePath.src, fileName);
+      const imported = imageAssetMap.get(id);
+      if (!id || imageObjects.has(id) || !imported) {
+        continue;
+      }
+      const image = await getImage({ ...decodedImagePath, src: imported });
+      imageObjects.set(imagePath, image);
+    } catch {
+      throw new Error(`Failed to parse image reference: ${imagePath}`);
+    }
+  }
+  return html.replaceAll(CONTENT_LAYER_IMAGE_REGEX, (full, imagePath) => {
+    const image = imageObjects.get(imagePath);
+    if (!image) {
+      return full;
+    }
+    const { index, ...attributes } = image.attributes;
+    return Object.entries({
+      ...attributes,
+      src: image.src,
+      srcset: image.srcSet.attribute
+    }).map(([key, value]) => value ? `${key}=${JSON.stringify(String(value))}` : "").join(" ");
+  });
+}
+function updateImageReferencesInData(data, fileName, imageAssetMap) {
+  return new Traverse(data).map(function(ctx, val) {
+    if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
+      const src = val.replace(IMAGE_IMPORT_PREFIX, "");
+      const id = imageSrcToImportId(src, fileName);
+      if (!id) {
+        ctx.update(src);
+        return;
+      }
+      const imported = imageAssetMap.get(id);
+      if (imported) {
+        ctx.update(imported);
+      } else {
+        ctx.update(src);
+      }
+    }
+  });
+}
+async function renderEntry(entry) {
+  if (entry && "render" in entry) {
+    return entry.render();
+  }
+  if (entry.deferredRender) {
+    try {
+      const { default: contentModules } = await import("astro:content-module-imports");
+      const module = contentModules.get(entry.filePath);
+      const deferredMod = await module();
+      return {
+        Content: deferredMod.Content,
+        headings: deferredMod.getHeadings?.() ?? [],
+        remarkPluginFrontmatter: deferredMod.frontmatter ?? {}
+      };
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  const html = entry?.rendered?.metadata?.imagePaths?.length && entry.filePath ? await updateImageReferencesInBody(entry.rendered.html, entry.filePath) : entry?.rendered?.html;
+  const Content = createComponent(() => serverRender`${unescapeHTML(html)}`);
+  return {
+    Content,
+    headings: entry?.rendered?.metadata?.headings ?? [],
+    remarkPluginFrontmatter: entry?.rendered?.metadata?.frontmatter ?? {}
+  };
+}
 async function render({
   collection,
   id,
@@ -256,31 +411,69 @@ async function render({
 }
 function createReference({ lookupMap }) {
   return function reference(collection) {
-    return zodString().transform((lookupId, ctx) => {
-      const flattenedErrorPath = ctx.path.join(".");
-      if (!lookupMap[collection]) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `**${flattenedErrorPath}:** Reference to ${collection} invalid. Collection does not exist or is empty.`
-        });
-        return;
-      }
-      const { type, entries } = lookupMap[collection];
-      const entry = entries[lookupId];
-      if (!entry) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Expected ${Object.keys(
-            entries
-          ).map((c) => JSON.stringify(c)).join(" | ")}. Received ${JSON.stringify(lookupId)}.`
-        });
-        return;
-      }
-      if (type === "content") {
-        return { slug: lookupId, collection };
+    return z.union([
+      z.string(),
+      z.object({
+        id: z.string(),
+        collection: z.string()
+      }),
+      z.object({
+        slug: z.string(),
+        collection: z.string()
+      })
+    ]).transform(
+      async (lookup, ctx) => {
+        const flattenedErrorPath = ctx.path.join(".");
+        const store = await globalDataStore.get();
+        const collectionIsInStore = store.hasCollection(collection);
+        if (typeof lookup === "object") {
+          if (lookup.collection !== collection) {
+            ctx.addIssue({
+              code: ZodIssueCode.custom,
+              message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Expected ${collection}. Received ${lookup.collection}.`
+            });
+            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) {
+          const entry2 = store.get(collection, lookup);
+          if (!entry2) {
+            ctx.addIssue({
+              code: ZodIssueCode.custom,
+              message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Entry ${lookup} does not exist.`
+            });
+            return;
+          }
+          return { id: lookup, collection };
+        }
+        if (!lookupMap[collection] && store.collections().size === 0) {
+          return { id: lookup, collection };
+        }
+        const { type, entries } = lookupMap[collection];
+        const entry = entries[lookup];
+        if (!entry) {
+          ctx.addIssue({
+            code: ZodIssueCode.custom,
+            message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Expected ${Object.keys(
+              entries
+            ).map((c) => JSON.stringify(c)).join(" | ")}. Received ${JSON.stringify(lookup)}.`
+          });
+          return;
+        }
+        if (type === "content") {
+          return { slug: lookup, collection };
+        }
+        return { id: lookup, collection };
       }
-      return { id: lookupId, collection };
-    });
+    );
   };
 }
 function isPropagatedAssetsModule(module) {
@@ -294,5 +487,6 @@ export {
   createGetEntry,
   createGetEntryBySlug,
   createReference,
-  defineCollection
+  defineCollection,
+  renderEntry
 };

package/dist/content/types-generator.js

@@ -5,10 +5,11 @@ import { bold, cyan } from "kleur/colors";
 import { normalizePath } from "vite";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { printNode, zodToTs } from "zod-to-ts";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { isRelativePath } from "../core/path.js";
-import { CONTENT_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
+import { CONTENT_LAYER_TYPE, CONTENT_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
 import {
   getContentEntryIdAndSlug,
   getContentPaths,
@@ -269,6 +270,36 @@ function normalizeConfigPath(from, to) {
   const normalizedPath = configPath.replaceAll("\\", "/");
   return `"${isRelativePath(configPath) ? "" : "./"}${normalizedPath}"`;
 }
+const schemaCache = /* @__PURE__ */ new Map();
+async function getContentLayerSchema(collection, collectionKey) {
+  const cached = schemaCache.get(collectionKey);
+  if (cached) {
+    return cached;
+  }
+  if (collection?.type === CONTENT_LAYER_TYPE && typeof collection.loader === "object" && collection.loader.schema) {
+    let schema = collection.loader.schema;
+    if (typeof schema === "function") {
+      schema = await schema();
+    }
+    if (schema) {
+      schemaCache.set(collectionKey, await schema);
+      return schema;
+    }
+  }
+}
+async function typeForCollection(collection, collectionKey) {
+  if (collection?.schema) {
+    return `InferEntrySchema<${collectionKey}>`;
+  }
+  if (collection?.type === CONTENT_LAYER_TYPE) {
+    const schema = await getContentLayerSchema(collection, collectionKey);
+    if (schema) {
+      const ast = zodToTs(schema);
+      return printNode(ast.node);
+    }
+  }
+  return "any";
+}
 async function writeContentFiles({
   fs,
   contentPaths,
@@ -292,10 +323,11 @@ async function writeContentFiles({
       entries: {}
     };
   }
+  let contentCollectionsMap = {};
   for (const collectionKey of Object.keys(collectionEntryMap).sort()) {
     const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
     const collection = collectionEntryMap[collectionKey];
-    if (collectionConfig?.type && collection.type !== "unknown" && collection.type !== collectionConfig.type) {
+    if (collectionConfig?.type && collection.type !== "unknown" && collectionConfig.type !== CONTENT_LAYER_TYPE && collection.type !== collectionConfig.type) {
       viteServer.hot.send({
         type: "error",
         err: new AstroError({
@@ -319,7 +351,7 @@ async function writeContentFiles({
       collectionConfig?.type ?? "data"
     ) : collection.type;
     const collectionEntryKeys = Object.keys(collection.entries).sort();
-    const dataType = collectionConfig?.schema ? `InferEntrySchema<${collectionKey}>` : "any";
+    const dataType = await typeForCollection(collectionConfig, collectionKey);
     switch (resolvedType) {
       case "content":
         if (collectionEntryKeys.length === 0) {
@@ -352,6 +384,15 @@ async function writeContentFiles({
 `;
         }
         contentTypesStr += `};
+`;
+        break;
+      case CONTENT_LAYER_TYPE:
+        dataTypesStr += `${collectionKey}: Record<string, {
+  id: string;
+  collection: ${collectionKey};
+  data: ${dataType};
+  rendered?: RenderedContent 
+}>;
 `;
         break;
       case "data":
@@ -377,42 +418,51 @@ async function writeContentFiles({
 `;
         }
         if (collectionConfig?.schema) {
-          let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
-          if (zodSchemaForJson instanceof z.ZodObject) {
-            zodSchemaForJson = zodSchemaForJson.extend({
-              $schema: z.string().optional()
-            });
-          }
-          try {
-            await fs.promises.writeFile(
-              new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
-              JSON.stringify(
-                zodToJsonSchema(zodSchemaForJson, {
-                  name: collectionKey.replace(/"/g, ""),
-                  markdownDescription: true,
-                  errorMessages: true,
-                  // Fix for https://github.com/StefanTerdell/zod-to-json-schema/issues/110
-                  dateStrategy: ["format:date-time", "format:date", "integer"]
-                }),
-                null,
-                2
-              )
-            );
-          } catch (err) {
-            logger.warn(
-              "content",
-              `An error was encountered while creating the JSON schema for the ${collectionKey} collection. Proceeding without it. Error: ${err}`
-            );
-          }
+          await generateJSONSchema(
+            fs,
+            collectionConfig,
+            collectionKey,
+            collectionSchemasDir,
+            logger
+          );
         }
         break;
     }
+    if (settings.config.experimental.contentIntellisense && collectionConfig && (collectionConfig.schema || await getContentLayerSchema(collectionConfig, collectionKey))) {
+      await generateJSONSchema(fs, collectionConfig, collectionKey, collectionSchemasDir, logger);
+      contentCollectionsMap[collectionKey] = collection;
+    }
+  }
+  if (settings.config.experimental.contentIntellisense) {
+    let contentCollectionManifest = {
+      collections: [],
+      entries: {}
+    };
+    Object.entries(contentCollectionsMap).forEach(([collectionKey, collection]) => {
+      const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
+      const key = JSON.parse(collectionKey);
+      contentCollectionManifest.collections.push({
+        hasSchema: Boolean(collectionConfig?.schema || schemaCache.has(collectionKey)),
+        name: key
+      });
+      Object.keys(collection.entries).forEach((entryKey) => {
+        const entryPath = new URL(
+          JSON.parse(entryKey),
+          contentPaths.contentDir + `${key}/`
+        ).toString();
+        contentCollectionManifest.entries[entryPath.toLowerCase()] = key;
+      });
+    });
+    await fs.promises.writeFile(
+      new URL("./collections.json", collectionSchemasDir),
+      JSON.stringify(contentCollectionManifest, null, 2)
+    );
   }
   if (!fs.existsSync(settings.dotAstroDir)) {
     fs.mkdirSync(settings.dotAstroDir, { recursive: true });
   }
   const configPathRelativeToCacheDir = normalizeConfigPath(
-    settings.dotAstroDir.pathname,
+    new URL("astro", settings.dotAstroDir).pathname,
     contentPaths.config.url.pathname
   );
   for (const contentEntryType of contentEntryTypes) {
@@ -426,10 +476,48 @@ async function writeContentFiles({
     "'@@CONTENT_CONFIG_TYPE@@'",
     contentConfig ? `typeof import(${configPathRelativeToCacheDir})` : "never"
   );
-  await fs.promises.writeFile(
-    new URL(CONTENT_TYPES_FILE, settings.dotAstroDir),
-    typeTemplateContent
-  );
+  if (settings.injectedTypes.some((t) => t.filename === CONTENT_TYPES_FILE)) {
+    const filePath = fileURLToPath(new URL(CONTENT_TYPES_FILE, settings.dotAstroDir));
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, typeTemplateContent, "utf-8");
+  } else {
+    settings.injectedTypes.push({
+      filename: CONTENT_TYPES_FILE,
+      content: typeTemplateContent
+    });
+  }
+}
+async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collectionSchemasDir, logger) {
+  let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
+  if (!zodSchemaForJson && collectionConfig.type === CONTENT_LAYER_TYPE) {
+    zodSchemaForJson = await getContentLayerSchema(collectionConfig, collectionKey);
+  }
+  if (zodSchemaForJson instanceof z.ZodObject) {
+    zodSchemaForJson = zodSchemaForJson.extend({
+      $schema: z.string().optional()
+    });
+  }
+  try {
+    await fsMod.promises.writeFile(
+      new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
+      JSON.stringify(
+        zodToJsonSchema(zodSchemaForJson, {
+          name: collectionKey.replace(/"/g, ""),
+          markdownDescription: true,
+          errorMessages: true,
+          // Fix for https://github.com/StefanTerdell/zod-to-json-schema/issues/110
+          dateStrategy: ["format:date-time", "format:date", "integer"]
+        }),
+        null,
+        2
+      )
+    );
+  } catch (err) {
+    logger.warn(
+      "content",
+      `An error was encountered while creating the JSON schema for the ${collectionKey} collection. Proceeding without it. Error: ${err}`
+    );
+  }
 }
 export {
   createContentTypesGenerator