astro 5.16.5 → 6.0.0-alpha.1

package/dist/content/types-generator.js

@@ -1,18 +1,18 @@
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import colors from "piccolore";
-import { glob } from "tinyglobby";
-import { normalizePath } from "vite";
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import {
+  isRunnableDevEnvironment,
+  normalizePath
+} from "vite";
+import * as z from "zod/v4";
 import { AstroError } from "../core/errors/errors.js";
-import { AstroErrorData, AstroUserError } from "../core/errors/index.js";
+import { AstroErrorData } 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 {
@@ -26,6 +26,7 @@ import {
   getEntryType,
   reloadContentConfigObserver
 } from "./utils.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 async function createContentTypesGenerator({
   contentConfigObserver,
   fs,
@@ -43,27 +44,7 @@ async function createContentTypesGenerator({
   const typeTemplateContent = await fs.promises.readFile(contentPaths.typesTemplate, "utf-8");
   async function init() {
     events.push({ name: "add", entry: contentPaths.config.url });
-    if (settings.config.legacy.collections) {
-      if (!fs.existsSync(contentPaths.contentDir)) {
-        return { typesGenerated: false, reason: "no-content-dir" };
-      }
-      const globResult = await glob("**", {
-        cwd: fileURLToPath(contentPaths.contentDir),
-        absolute: true
-      });
-      for (const fullPath of globResult) {
-        const entryURL = pathToFileURL(fullPath);
-        if (entryURL.href.startsWith(contentPaths.config.url.href)) continue;
-        const stat = fs.statSync(fullPath);
-        if (stat.isFile()) {
-          events.push({ name: "add", entry: entryURL });
-        } else if (stat.isDirectory()) {
-          events.push({ name: "addDir", entry: entryURL });
-        }
-      }
-    }
     await runEvents();
-    return { typesGenerated: true };
   }
   async function handleEvent(event) {
     if (event.name === "addDir" || event.name === "unlinkDir") {
@@ -97,7 +78,11 @@ async function createContentTypesGenerator({
       return { shouldGenerateTypes: false };
     }
     if (fileType === "config") {
-      await reloadContentConfigObserver({ fs, settings, viteServer });
+      await reloadContentConfigObserver({
+        fs,
+        settings,
+        environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro]
+      });
       return { shouldGenerateTypes: true };
     }
     const { entry } = event;
@@ -125,7 +110,7 @@ async function createContentTypesGenerator({
           }
           const collectionInfo2 = collectionEntryMap[collectionKey2];
           if (collectionInfo2.type === "content") {
-            viteServer.hot.send({
+            viteServer.environments.client.hot.send({
               type: "error",
               err: new AstroError({
                 ...AstroErrorData.MixedContentDataCollectionError,
@@ -164,7 +149,7 @@ async function createContentTypesGenerator({
     }
     const collectionInfo = collectionEntryMap[collectionKey];
     if (collectionInfo.type === "data") {
-      viteServer.hot.send({
+      viteServer.environments.client.hot.send({
         type: "error",
         err: new AstroError({
           ...AstroErrorData.MixedContentDataCollectionError,
@@ -222,11 +207,7 @@ async function createContentTypesGenerator({
       entry: pathToFileURL(rawEvent.entry),
       name: rawEvent.name
     };
-    if (settings.config.legacy.collections) {
-      if (!event.entry.pathname.startsWith(contentPaths.contentDir.pathname)) {
-        return;
-      }
-    } else if (contentPaths.config.url.pathname !== event.entry.pathname) {
+    if (contentPaths.config.url.pathname !== event.entry.pathname) {
       return;
     }
     events.push(event);
@@ -263,58 +244,68 @@ async function createContentTypesGenerator({
         logger,
         settings
       });
-      invalidateVirtualMod(viteServer);
+      if (!isRunnableDevEnvironment(viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
+        return;
+      }
+      invalidateVirtualMod(viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]);
     }
   }
   return { init, queueEvent };
 }
-function invalidateVirtualMod(viteServer) {
-  const virtualMod = viteServer.moduleGraph.getModuleById("\0" + VIRTUAL_MODULE_ID);
+function invalidateVirtualMod(environment) {
+  const virtualMod = environment.moduleGraph.getModuleById("\0" + VIRTUAL_MODULE_ID);
   if (!virtualMod) return;
-  viteServer.moduleGraph.invalidateModule(virtualMod);
+  environment.moduleGraph.invalidateModule(virtualMod);
 }
 function normalizeConfigPath(from, to) {
   const configPath = path.relative(from, to).replace(/\.ts$/, ".js");
   const normalizedPath = configPath.replaceAll("\\", "/");
   return `"${isRelativePath(configPath) ? "" : "./"}${normalizedPath}"`;
 }
-const schemaCache = /* @__PURE__ */ new Map();
-async function getContentLayerSchema(collection, collectionKey) {
-  const cached = schemaCache.get(collectionKey);
+const createSchemaResultCache = /* @__PURE__ */ new Map();
+async function getCreateSchemaResult(collection, collectionKey) {
+  const cached = createSchemaResultCache.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;
-    }
+  if (collection?.type === CONTENT_LAYER_TYPE && typeof collection.loader === "object" && !collection.loader.schema && collection.loader.createSchema) {
+    const result = await collection.loader.createSchema();
+    createSchemaResultCache.set(collectionKey, result);
+    return result;
   }
 }
+async function getContentLayerSchema(collection, collectionKey) {
+  if (collection?.type !== CONTENT_LAYER_TYPE || typeof collection.loader === "function") {
+    return;
+  }
+  if (collection.loader.schema) {
+    return collection.loader.schema;
+  }
+  const result = await getCreateSchemaResult(collection, collectionKey);
+  return result?.schema;
+}
 async function typeForCollection(collection, collectionKey) {
   if (collection?.schema) {
-    return `InferEntrySchema<${collectionKey}>`;
+    return { type: `InferEntrySchema<${collectionKey}>` };
   }
-  if (collection?.type === CONTENT_LAYER_TYPE) {
-    const schema = await getContentLayerSchema(collection, collectionKey);
-    if (schema) {
-      try {
-        const zodToTs = await import("zod-to-ts");
-        const ast = zodToTs.zodToTs(schema);
-        return zodToTs.printNode(ast.node);
-      } catch (err) {
-        if (err.message.includes("Cannot find package 'typescript'")) {
-          return "any";
-        }
-        throw err;
-      }
-    }
+  if (!collection?.type || typeof collection.loader === "function") {
+    return { type: "any" };
+  }
+  if (collection.loader.schema) {
+    return { type: `InferLoaderSchema<${collectionKey}>` };
   }
-  return "any";
+  const result = await getCreateSchemaResult(collection, collectionKey);
+  if (!result) {
+    return { type: "any" };
+  }
+  const base = `loaders/${collectionKey.slice(1, -1)}`;
+  return {
+    type: `import("./${base}.js").Entry`,
+    injectedType: {
+      filename: `${base}.ts`,
+      content: result.types
+    }
+  };
 }
 async function writeContentFiles({
   fs,
@@ -327,7 +318,6 @@ async function writeContentFiles({
   logger,
   settings
 }) {
-  let contentTypesStr = "";
   let dataTypesStr = "";
   const collectionSchemasDir = new URL(COLLECTIONS_DIR, settings.dotAstroDir);
   fs.mkdirSync(collectionSchemasDir, { recursive: true });
@@ -342,7 +332,7 @@ async function writeContentFiles({
     const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
     const collection = collectionEntryMap[collectionKey];
     if (collectionConfig?.type && collection.type !== "unknown" && collectionConfig.type !== CONTENT_LAYER_TYPE && collection.type !== collectionConfig.type) {
-      viteServer.hot.send({
+      viteServer.environments.client.hot.send({
         type: "error",
         err: new AstroError({
           ...AstroErrorData.ContentCollectionTypeMismatchError,
@@ -359,86 +349,28 @@ async function writeContentFiles({
       });
       return;
     }
-    const resolvedType = collection.type === "unknown" ? (
-      // Add empty / unknown collections to the data type map by default
-      // This ensures `getCollection('empty-collection')` doesn't raise a type error
-      collectionConfig?.type ?? "data"
-    ) : collection.type;
-    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, {
+    const { type: dataType, injectedType } = await typeForCollection(
+      collectionConfig,
+      collectionKey
+    );
+    if (injectedType) {
+      if (settings.injectedTypes.some((t) => t.filename === CONTENT_TYPES_FILE)) {
+        const url = new URL(injectedType.filename, settings.dotAstroDir);
+        await fs.promises.mkdir(path.dirname(fileURLToPath(url)), { recursive: true });
+        await fs.promises.writeFile(url, injectedType.content, "utf-8");
+      } else {
+        settings.injectedTypes.push(injectedType);
+      }
+    }
+    dataTypesStr += `${collectionKey}: Record<string, {
   id: string;
-  slug: string;
-  body: string;
+  body?: string;
   collection: ${collectionKey};
   data: ${dataType};
-  render(): Render[".md"];
-}>;
-`;
-          break;
-        }
-        contentTypesStr += `${collectionKey}: {
-`;
-        for (const entryKey of collectionEntryKeys) {
-          const entryMetadata = collection.entries[entryKey];
-          const renderType = `{ render(): Render[${JSON.stringify(
-            path.extname(JSON.parse(entryKey))
-          )}] }`;
-          const slugType = JSON.stringify(entryMetadata.slug);
-          contentTypesStr += `${entryKey}: {
-	id: ${entryKey};
-  slug: ${slugType};
-  body: string;
-  collection: ${collectionKey};
-  data: ${dataType}
-} & ${renderType};
-`;
-        }
-        contentTypesStr += `};
-`;
-        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;
-  ${legacyTypes}  collection: ${collectionKey};
-  data: ${dataType};
   rendered?: RenderedContent;
   filePath?: string;
 }>;
 `;
-        break;
-      case "data":
-        if (collectionEntryKeys.length === 0) {
-          dataTypesStr += `${collectionKey}: Record<string, {
-  id: string;
-  collection: ${collectionKey};
-  data: ${dataType};
-}>;
-`;
-        } else {
-          dataTypesStr += `${collectionKey}: {
-`;
-          for (const entryKey of collectionEntryKeys) {
-            dataTypesStr += `${entryKey}: {
-	id: ${entryKey};
-  collection: ${collectionKey};
-  data: ${dataType}
-};
-`;
-          }
-          dataTypesStr += `};
-`;
-        }
-        break;
-    }
     if (collectionConfig && (collectionConfig.schema || await getContentLayerSchema(collectionConfig, collectionKey))) {
       await generateJSONSchema(fs, collectionConfig, collectionKey, collectionSchemasDir, logger);
       contentCollectionsMap[collectionKey] = collection;
@@ -453,7 +385,13 @@ async function writeContentFiles({
       const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
       const key = JSON.parse(collectionKey);
       contentCollectionManifest.collections.push({
-        hasSchema: Boolean(collectionConfig?.schema || schemaCache.has(collectionKey)),
+        hasSchema: Boolean(
+          // Is there a user provided schema or
+          collectionConfig?.schema || // Is it a loader object and
+          typeof collectionConfig?.loader !== "function" && // Is it a loader static schema or
+          (collectionConfig?.loader.schema || // is it a loader dynamic schema
+          createSchemaResultCache.has(collectionKey))
+        ),
         name: key
       });
       Object.keys(collection.entries).forEach((entryKey) => {
@@ -479,7 +417,7 @@ async function writeContentFiles({
       typeTemplateContent = contentEntryType.contentModuleTypes + "\n" + typeTemplateContent;
     }
   }
-  typeTemplateContent = typeTemplateContent.replace("// @@CONTENT_ENTRY_MAP@@", contentTypesStr).replace("// @@DATA_ENTRY_MAP@@", dataTypesStr).replace(
+  typeTemplateContent = typeTemplateContent.replace("// @@DATA_ENTRY_MAP@@", dataTypesStr).replace(
     "'@@CONTENT_CONFIG_TYPE@@'",
     contentConfig ? `typeof import(${configPathRelativeToCacheDir})` : "never"
   ).replace(
@@ -513,20 +451,13 @@ async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collec
     });
   }
   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
-      )
+    const schema = z.toJSONSchema(zodSchemaForJson);
+    const schemaStr = JSON.stringify(schema, null, 2);
+    const schemaJsonPath = new URL(
+      `./${collectionKey.replace(/"/g, "")}.schema.json`,
+      collectionSchemasDir
     );
+    await fsMod.promises.writeFile(schemaJsonPath, schemaStr);
   } catch (err) {
     logger.warn(
       "content",