astro 2.4.4 → 2.5.0

package/dist/content/utils.d.ts

@@ -5,32 +5,78 @@ import type { PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings, ContentEntryType } from '../@types/astro.js';
-export declare const collectionConfigParser: z.ZodObject<{
+import { CONTENT_FLAGS } from './consts.js';
+/**
+ * Amap from a collection + slug to the local file path.
+ * This is used internally to resolve entry imports when using `getEntry()`.
+ * @see `src/content/virtual-mod.mjs`
+ */
+export type ContentLookupMap = {
+    [collectionName: string]: {
+        type: 'content' | 'data';
+        entries: {
+            [lookupId: string]: string;
+        };
+    };
+};
+export declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"content">>>;
     schema: z.ZodOptional<z.ZodAny>;
 }, "strip", z.ZodTypeAny, {
     schema?: any;
+    type: "content";
 }, {
+    type?: "content" | undefined;
     schema?: any;
-}>;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"data">;
+    schema: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    schema?: any;
+    type: "data";
+}, {
+    schema?: any;
+    type: "data";
+}>]>;
 export declare function getDotAstroTypeReference({ root, srcDir }: {
     root: URL;
     srcDir: URL;
 }): string;
 export declare const contentConfigParser: z.ZodObject<{
-    collections: z.ZodRecord<z.ZodString, z.ZodObject<{
+    collections: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"content">>>;
         schema: z.ZodOptional<z.ZodAny>;
     }, "strip", z.ZodTypeAny, {
         schema?: any;
+        type: "content";
     }, {
+        type?: "content" | undefined;
         schema?: any;
-    }>>;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"data">;
+        schema: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        schema?: any;
+        type: "data";
+    }, {
+        schema?: any;
+        type: "data";
+    }>]>>;
 }, "strip", z.ZodTypeAny, {
     collections: Record<string, {
         schema?: any;
+        type: "content";
+    } | {
+        schema?: any;
+        type: "data";
     }>;
 }, {
     collections: Record<string, {
+        type?: "content" | undefined;
         schema?: any;
+    } | {
+        schema?: any;
+        type: "data";
     }>;
 }>;
 export type CollectionConfig = z.infer<typeof collectionConfigParser>;
@@ -39,11 +85,6 @@ type EntryInternal = {
     rawData: string | undefined;
     filePath: string;
 };
-export type EntryInfo = {
-    id: string;
-    slug: string;
-    collection: string;
-};
 export declare const msg: {
     collectionConfigMissing: (collection: string) => string;
 };
@@ -53,26 +94,31 @@ export declare function parseEntrySlug({ id, collection, generatedSlug, frontmat
     generatedSlug: string;
     frontmatterSlug?: unknown;
 }): string;
-export declare function getEntryData(entry: EntryInfo & {
+export declare function getEntryData(entry: {
+    id: string;
+    collection: string;
     unvalidatedData: Record<string, unknown>;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig, pluginContext: PluginContext, settings: AstroSettings): Promise<{
-    [x: string]: unknown;
-}>;
+}, collectionConfig: CollectionConfig, pluginContext: PluginContext, config: AstroConfig): Promise<any>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];
+export declare function getDataEntryExts(settings: Pick<AstroSettings, 'dataEntryTypes'>): string[];
 export declare function getContentEntryConfigByExtMap(settings: Pick<AstroSettings, 'contentEntryTypes'>): Map<string, ContentEntryType>;
-export declare class NoCollectionError extends Error {
-}
-export declare function getEntryInfo(params: Pick<ContentPaths, 'contentDir'> & {
+export declare function getEntryCollectionName({ contentDir, entry, }: Pick<ContentPaths, 'contentDir'> & {
     entry: string | URL;
-    allowFilesOutsideCollection?: true;
-}): EntryInfo;
-export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], experimentalAssets: boolean): 'content' | 'config' | 'ignored' | 'unsupported';
+}): string | undefined;
+export declare function getDataEntryId({ entry, contentDir, collection, }: Pick<ContentPaths, 'contentDir'> & {
+    entry: URL;
+    collection: string;
+}): string;
+export declare function getContentEntryIdAndSlug({ entry, contentDir, collection, }: Pick<ContentPaths, 'contentDir'> & {
+    entry: URL;
+    collection: string;
+}): {
+    id: string;
+    slug: string;
+};
+export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], dataFileExts: string[], experimentalAssets?: boolean): 'content' | 'data' | 'config' | 'ignored' | 'unsupported';
 export declare function hasUnderscoreBelowContentDirectoryPath(fileUrl: URL, contentDir: ContentPaths['contentDir']): boolean;
-/**
- * Match YAML exception handling from Astro core errors
- * @see 'astro/src/core/errors.ts'
- */
 export declare function parseFrontmatter(fileContents: string, filePath: string): matter.GrayMatterFile<string>;
 /**
  * The content config is loaded separately from other `src/` files.
@@ -80,11 +126,18 @@ export declare function parseFrontmatter(fileContents: string, filePath: string)
  * subscribe to changes during dev server updates.
  */
 export declare const globalContentConfigObserver: ContentObservable;
+export declare function hasContentFlag(viteId: string, flag: (typeof CONTENT_FLAGS)[number]): boolean;
 export declare function loadContentConfig({ fs, settings, viteServer, }: {
     fs: typeof fsMod;
     settings: AstroSettings;
     viteServer: ViteDevServer;
 }): Promise<ContentConfig | undefined>;
+export declare function reloadContentConfigObserver({ observer, ...loadContentConfigOpts }: {
+    fs: typeof fsMod;
+    settings: AstroSettings;
+    viteServer: ViteDevServer;
+    observer?: ContentObservable;
+}): Promise<void>;
 type ContentCtx = {
     status: 'init';
 } | {

package/dist/content/utils.js

@@ -7,12 +7,20 @@ import { normalizePath } from "vite";
 import { z } from "zod";
 import { VALID_INPUT_FORMATS } from "../assets/consts.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { formatYAMLException, isYAMLException } from "../core/errors/utils.js";
 import { CONTENT_TYPES_FILE } from "./consts.js";
 import { errorMap } from "./error-map.js";
 import { createImage } from "./runtime-assets.js";
-const collectionConfigParser = z.object({
-  schema: z.any().optional()
-});
+const collectionConfigParser = z.union([
+  z.object({
+    type: z.literal("content").optional().default("content"),
+    schema: z.any().optional()
+  }),
+  z.object({
+    type: z.literal("data"),
+    schema: z.any().optional()
+  })
+]);
 function getDotAstroTypeReference({ root, srcDir }) {
   const { cacheDir } = getContentPaths({ root, srcDir });
   const contentTypesRelativeToSrcDir = normalizePath(
@@ -41,48 +49,60 @@ function parseEntrySlug({
     });
   }
 }
-async function getEntryData(entry, collectionConfig, pluginContext, settings) {
-  let { slug, ...data } = entry.unvalidatedData;
+async function getEntryData(entry, collectionConfig, pluginContext, config) {
+  let data;
+  if (collectionConfig.type === "data") {
+    data = entry.unvalidatedData;
+  } else {
+    const { slug, ...unvalidatedData } = entry.unvalidatedData;
+    data = unvalidatedData;
+  }
   let schema = collectionConfig.schema;
   if (typeof schema === "function") {
-    if (!settings.config.experimental.assets) {
+    if (!config.experimental.assets) {
       throw new Error(
         "The function shape for schema can only be used when `experimental.assets` is enabled."
       );
     }
     schema = schema({
-      image: createImage(settings, pluginContext, entry._internal.filePath)
+      image: createImage({ config }, pluginContext, entry._internal.filePath)
     });
   }
   if (schema) {
-    if (typeof schema === "object" && "shape" in schema && schema.shape.slug) {
+    if (collectionConfig.type === "content" && typeof schema === "object" && "shape" in schema && schema.shape.slug) {
       throw new AstroError({
         ...AstroErrorData.ContentSchemaContainsSlugError,
         message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
       });
     }
+    let formattedError;
     const parsed = await schema.safeParseAsync(entry.unvalidatedData, {
-      errorMap
+      errorMap(error, ctx) {
+        var _a, _b;
+        if (error.code === "custom" && ((_a = error.params) == null ? void 0 : _a.isHoistedAstroError)) {
+          formattedError = (_b = error.params) == null ? void 0 : _b.astroError;
+        }
+        return errorMap(error, ctx);
+      }
     });
     if (parsed.success) {
       data = parsed.data;
     } else {
-      const formattedError = new AstroError({
-        ...AstroErrorData.InvalidContentEntryFrontmatterError,
-        message: AstroErrorData.InvalidContentEntryFrontmatterError.message(
-          entry.collection,
-          entry.id,
-          parsed.error
-        ),
-        location: {
-          file: entry._internal.filePath,
-          line: getFrontmatterErrorLine(
-            entry._internal.rawData,
-            String(parsed.error.errors[0].path[0])
+      if (!formattedError) {
+        formattedError = new AstroError({
+          ...AstroErrorData.InvalidContentEntryFrontmatterError,
+          message: AstroErrorData.InvalidContentEntryFrontmatterError.message(
+            entry.collection,
+            entry.id,
+            parsed.error
           ),
-          column: 0
-        }
-      });
+          location: {
+            file: entry._internal.filePath,
+            line: getYAMLErrorLine(entry._internal.rawData, String(parsed.error.errors[0].path[0])),
+            column: 0
+          }
+        });
+      }
       throw formattedError;
     }
   }
@@ -91,6 +111,9 @@ async function getEntryData(entry, collectionConfig, pluginContext, settings) {
 function getContentEntryExts(settings) {
   return settings.contentEntryTypes.map((t) => t.extensions).flat();
 }
+function getDataEntryExts(settings) {
+  return settings.dataEntryTypes.map((t) => t.extensions).flat();
+}
 function getContentEntryConfigByExtMap(settings) {
   const map = /* @__PURE__ */ new Map();
   for (const entryType of settings.contentEntryTypes) {
@@ -100,39 +123,57 @@ function getContentEntryConfigByExtMap(settings) {
   }
   return map;
 }
-class NoCollectionError extends Error {
+function getEntryCollectionName({
+  contentDir,
+  entry
+}) {
+  const entryPath = typeof entry === "string" ? entry : fileURLToPath(entry);
+  const rawRelativePath = path.relative(fileURLToPath(contentDir), entryPath);
+  const collectionName = path.dirname(rawRelativePath).split(path.sep)[0];
+  const isOutsideCollection = !collectionName || collectionName === "" || collectionName === ".." || collectionName === ".";
+  if (isOutsideCollection) {
+    return void 0;
+  }
+  return collectionName;
 }
-function getEntryInfo({
+function getDataEntryId({
   entry,
   contentDir,
-  allowFilesOutsideCollection = false
+  collection
 }) {
-  const rawRelativePath = path.relative(
-    fileURLToPath(contentDir),
-    typeof entry === "string" ? entry : fileURLToPath(entry)
-  );
-  const rawCollection = path.dirname(rawRelativePath).split(path.sep).shift();
-  const isOutsideCollection = rawCollection === ".." || rawCollection === ".";
-  if (!rawCollection || !allowFilesOutsideCollection && isOutsideCollection)
-    return new NoCollectionError();
-  const rawId = path.relative(rawCollection, rawRelativePath);
-  const rawIdWithoutFileExt = rawId.replace(new RegExp(path.extname(rawId) + "$"), "");
-  const rawSlugSegments = rawIdWithoutFileExt.split(path.sep);
+  const relativePath = getRelativeEntryPath(entry, collection, contentDir);
+  const withoutFileExt = relativePath.replace(new RegExp(path.extname(relativePath) + "$"), "");
+  return withoutFileExt;
+}
+function getContentEntryIdAndSlug({
+  entry,
+  contentDir,
+  collection
+}) {
+  const relativePath = getRelativeEntryPath(entry, collection, contentDir);
+  const withoutFileExt = relativePath.replace(new RegExp(path.extname(relativePath) + "$"), "");
+  const rawSlugSegments = withoutFileExt.split(path.sep);
   const slug = rawSlugSegments.map((segment) => githubSlug(segment)).join("/").replace(/\/index$/, "");
   const res = {
-    id: normalizePath(rawId),
-    slug,
-    collection: normalizePath(rawCollection)
+    id: normalizePath(relativePath),
+    slug
   };
   return res;
 }
-function getEntryType(entryPath, paths, contentFileExts, experimentalAssets) {
+function getRelativeEntryPath(entry, collection, contentDir) {
+  const relativeToContent = path.relative(fileURLToPath(contentDir), fileURLToPath(entry));
+  const relativeToCollection = path.relative(collection, relativeToContent);
+  return relativeToCollection;
+}
+function getEntryType(entryPath, paths, contentFileExts, dataFileExts, experimentalAssets = false) {
   const { ext, base } = path.parse(entryPath);
   const fileUrl = pathToFileURL(entryPath);
   if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir) || isOnIgnoreList(base) || experimentalAssets && isImageAsset(ext)) {
     return "ignored";
   } else if (contentFileExts.includes(ext)) {
     return "content";
+  } else if (dataFileExts.includes(ext)) {
+    return "data";
   } else if (fileUrl.href === paths.config.url.href) {
     return "config";
   } else {
@@ -153,15 +194,19 @@ function hasUnderscoreBelowContentDirectoryPath(fileUrl, contentDir) {
   }
   return false;
 }
-function getFrontmatterErrorLine(rawFrontmatter, frontmatterKey) {
-  if (!rawFrontmatter)
+function getYAMLErrorLine(rawData, objectKey) {
+  if (!rawData)
     return 0;
-  const indexOfFrontmatterKey = rawFrontmatter.indexOf(`
-${frontmatterKey}`);
-  if (indexOfFrontmatterKey === -1)
+  const indexOfObjectKey = rawData.search(
+    // Match key either at the top of the file or after a newline
+    // Ensures matching on top-level object keys only
+    new RegExp(`(
+|^)${objectKey}`)
+  );
+  if (indexOfObjectKey === -1)
     return 0;
-  const frontmatterBeforeKey = rawFrontmatter.substring(0, indexOfFrontmatterKey + 1);
-  const numNewlinesBeforeKey = frontmatterBeforeKey.split("\n").length;
+  const dataBeforeKey = rawData.substring(0, indexOfObjectKey + 1);
+  const numNewlinesBeforeKey = dataBeforeKey.split("\n").length;
   return numNewlinesBeforeKey;
 }
 function parseFrontmatter(fileContents, filePath) {
@@ -169,18 +214,18 @@ function parseFrontmatter(fileContents, filePath) {
     matter.clearCache();
     return matter(fileContents);
   } catch (e) {
-    if (e.name === "YAMLException") {
-      const err = e;
-      err.id = filePath;
-      err.loc = { file: e.id, line: e.mark.line + 1, column: e.mark.column };
-      err.message = e.reason;
-      throw err;
+    if (isYAMLException(e)) {
+      throw formatYAMLException(e);
     } else {
       throw e;
     }
   }
 }
 const globalContentConfigObserver = contentObservable({ status: "init" });
+function hasContentFlag(viteId, flag) {
+  const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
+  return flags.has(flag);
+}
 async function loadContentConfig({
   fs,
   settings,
@@ -191,12 +236,8 @@ async function loadContentConfig({
   if (!contentPaths.config.exists) {
     return void 0;
   }
-  try {
-    const configPathname = fileURLToPath(contentPaths.config.url);
-    unparsedConfig = await viteServer.ssrLoadModule(configPathname);
-  } catch (e) {
-    throw e;
-  }
+  const configPathname = fileURLToPath(contentPaths.config.url);
+  unparsedConfig = await viteServer.ssrLoadModule(configPathname);
   const config = contentConfigParser.safeParse(unparsedConfig);
   if (config.success) {
     return config.data;
@@ -204,6 +245,25 @@ async function loadContentConfig({
     return void 0;
   }
 }
+async function reloadContentConfigObserver({
+  observer = globalContentConfigObserver,
+  ...loadContentConfigOpts
+}) {
+  observer.set({ status: "loading" });
+  try {
+    const config = await loadContentConfig(loadContentConfigOpts);
+    if (config) {
+      observer.set({ status: "loaded", config });
+    } else {
+      observer.set({ status: "does-not-exist" });
+    }
+  } catch (e) {
+    observer.set({
+      status: "error",
+      error: e instanceof Error ? e : new AstroError(AstroErrorData.UnknownContentCollectionError)
+    });
+  }
+}
 function contentObservable(initialCtx) {
   const subscribers = /* @__PURE__ */ new Set();
   let ctx = initialCtx;
@@ -266,7 +326,7 @@ async function getEntrySlug({
   }
   const { slug: frontmatterSlug } = await contentEntryType.getEntryInfo({
     fileUrl,
-    contents: await fs.promises.readFile(fileUrl, "utf-8")
+    contents
   });
   return parseEntrySlug({ generatedSlug, frontmatterSlug, id, collection });
 }
@@ -277,23 +337,27 @@ function getExtGlob(exts) {
   ) : `{${exts.join(",")}}`;
 }
 export {
-  NoCollectionError,
   collectionConfigParser,
   contentConfigParser,
   contentObservable,
   getContentEntryConfigByExtMap,
   getContentEntryExts,
+  getContentEntryIdAndSlug,
   getContentPaths,
+  getDataEntryExts,
+  getDataEntryId,
   getDotAstroTypeReference,
+  getEntryCollectionName,
   getEntryData,
-  getEntryInfo,
   getEntrySlug,
   getEntryType,
   getExtGlob,
   globalContentConfigObserver,
+  hasContentFlag,
   hasUnderscoreBelowContentDirectoryPath,
   loadContentConfig,
   msg,
   parseEntrySlug,
-  parseFrontmatter
+  parseFrontmatter,
+  reloadContentConfigObserver
 };

package/dist/content/vite-plugin-content-imports.js

@@ -4,22 +4,22 @@ import { pathToFileURL } from "url";
 import { AstroErrorData } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/errors.js";
 import { escapeViteEnvReferences, getFileInfo } from "../vite-plugin-utils/index.js";
-import { CONTENT_FLAG } from "./consts.js";
+import { CONTENT_FLAG, DATA_FLAG } from "./consts.js";
 import {
   getContentEntryConfigByExtMap,
   getContentEntryExts,
+  getContentEntryIdAndSlug,
   getContentPaths,
+  getDataEntryExts,
+  getDataEntryId,
+  getEntryCollectionName,
   getEntryData,
-  getEntryInfo,
   getEntryType,
   globalContentConfigObserver,
-  NoCollectionError,
-  parseEntrySlug
+  hasContentFlag,
+  parseEntrySlug,
+  reloadContentConfigObserver
 } from "./utils.js";
-function isContentFlagImport(viteId) {
-  const flags = new URLSearchParams(viteId.split("?")[1]);
-  return flags.has(CONTENT_FLAG);
-}
 function getContentRendererByViteId(viteId, settings) {
   let ext = viteId.split(".").pop();
   if (!ext)
@@ -32,18 +32,47 @@ function getContentRendererByViteId(viteId, settings) {
   return void 0;
 }
 const CHOKIDAR_MODIFIED_EVENTS = ["add", "unlink", "change"];
+const COLLECTION_TYPES_TO_INVALIDATE_ON = ["data", "content", "config"];
 function astroContentImportPlugin({
   fs,
   settings
 }) {
   const contentPaths = getContentPaths(settings.config, fs);
   const contentEntryExts = getContentEntryExts(settings);
+  const dataEntryExts = getDataEntryExts(settings);
   const contentEntryConfigByExt = getContentEntryConfigByExtMap(settings);
+  const dataEntryExtToParser = /* @__PURE__ */ new Map();
+  for (const entryType of settings.dataEntryTypes) {
+    for (const ext of entryType.extensions) {
+      dataEntryExtToParser.set(ext, entryType.getEntryInfo);
+    }
+  }
   const plugins = [
     {
       name: "astro:content-imports",
       async transform(_, viteId) {
-        if (isContentFlagImport(viteId)) {
+        if (hasContentFlag(viteId, DATA_FLAG)) {
+          const fileId = viteId.split("?")[0] ?? viteId;
+          const { id, data, collection, _internal } = await getDataEntryModule({
+            fileId,
+            dataEntryExtToParser,
+            contentPaths,
+            settings,
+            fs,
+            pluginContext: this
+          });
+          const code = escapeViteEnvReferences(`
+export const id = ${JSON.stringify(id)};
+export const collection = ${JSON.stringify(collection)};
+export const data = ${devalue.uneval(data)};
+export const _internal = {
+	type: 'data',
+	filePath: ${JSON.stringify(_internal.filePath)},
+	rawData: ${JSON.stringify(_internal.rawData)},
+};
+`);
+          return code;
+        } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
           const fileId = viteId.split("?")[0];
           const { id, slug, collection, body, data, _internal } = await setContentEntryModuleCache({
             fileId,
@@ -56,6 +85,7 @@ function astroContentImportPlugin({
 						export const body = ${JSON.stringify(body)};
 						export const data = ${devalue.uneval(data)};
 						export const _internal = {
+							type: 'content',
 							filePath: ${JSON.stringify(_internal.filePath)},
 							rawData: ${JSON.stringify(_internal.rawData)},
 						};`);
@@ -64,14 +94,21 @@ function astroContentImportPlugin({
       },
       configureServer(viteServer) {
         viteServer.watcher.on("all", async (event, entry) => {
-          if (CHOKIDAR_MODIFIED_EVENTS.includes(event) && getEntryType(
-            entry,
-            contentPaths,
-            contentEntryExts,
-            settings.config.experimental.assets
-          ) === "config") {
+          if (CHOKIDAR_MODIFIED_EVENTS.includes(event)) {
+            const entryType = getEntryType(
+              entry,
+              contentPaths,
+              contentEntryExts,
+              dataEntryExts,
+              settings.config.experimental.assets
+            );
+            if (!COLLECTION_TYPES_TO_INVALIDATE_ON.includes(entryType))
+              return;
+            if (entryType === "content" || entryType === "data") {
+              await reloadContentConfigObserver({ fs, settings, viteServer });
+            }
             for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
-              if (isContentFlagImport(modUrl) || Boolean(getContentRendererByViteId(modUrl, settings))) {
+              if (hasContentFlag(modUrl, CONTENT_FLAG) || hasContentFlag(modUrl, DATA_FLAG) || Boolean(getContentRendererByViteId(modUrl, settings))) {
                 const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);
                 if (mod) {
                   viteServer.moduleGraph.invalidateModule(mod);
@@ -145,13 +182,12 @@ function astroContentImportPlugin({
       fileUrl: pathToFileURL(fileId),
       contents: rawContents
     });
-    const entryInfoResult = getEntryInfo({
-      entry: pathToFileURL(fileId),
-      contentDir: contentPaths.contentDir
-    });
-    if (entryInfoResult instanceof NoCollectionError)
-      throw entryInfoResult;
-    const { id, slug: generatedSlug, collection } = entryInfoResult;
+    const entry = pathToFileURL(fileId);
+    const { contentDir } = contentPaths;
+    const collection = getEntryCollectionName({ entry, contentDir });
+    if (collection === void 0)
+      throw new AstroError(AstroErrorData.UnknownContentCollectionError);
+    const { id, slug: generatedSlug } = getContentEntryIdAndSlug({ entry, contentDir, collection });
     const _internal = { filePath: fileId, rawData };
     const slug = parseEntrySlug({
       id,
@@ -161,10 +197,10 @@ function astroContentImportPlugin({
     });
     const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
     let data = collectionConfig ? await getEntryData(
-      { id, collection, slug, _internal, unvalidatedData },
+      { id, collection, _internal, unvalidatedData },
       collectionConfig,
       pluginContext,
-      settings
+      settings.config
     ) : unvalidatedData;
     const contentEntryModule = {
       id,
@@ -213,6 +249,55 @@ async function getContentConfigFromGlobal() {
   }
   return contentConfig;
 }
+async function getDataEntryModule({
+  fileId,
+  dataEntryExtToParser,
+  contentPaths,
+  fs,
+  pluginContext,
+  settings
+}) {
+  const contentConfig = await getContentConfigFromGlobal();
+  let rawContents;
+  try {
+    rawContents = await fs.promises.readFile(fileId, "utf-8");
+  } catch (e) {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: `Unexpected error reading entry ${JSON.stringify(fileId)}.`,
+      stack: e instanceof Error ? e.stack : void 0
+    });
+  }
+  const fileExt = extname(fileId);
+  const dataEntryParser = dataEntryExtToParser.get(fileExt);
+  if (!dataEntryParser) {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: `No parser found for data entry ${JSON.stringify(
+        fileId
+      )}. Did you apply an integration for this file type?`
+    });
+  }
+  const { data: unvalidatedData, rawData = "" } = await dataEntryParser({
+    fileUrl: pathToFileURL(fileId),
+    contents: rawContents
+  });
+  const entry = pathToFileURL(fileId);
+  const { contentDir } = contentPaths;
+  const collection = getEntryCollectionName({ entry, contentDir });
+  if (collection === void 0)
+    throw new AstroError(AstroErrorData.UnknownContentCollectionError);
+  const id = getDataEntryId({ entry, contentDir, collection });
+  const _internal = { filePath: fileId, rawData };
+  const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
+  const data = collectionConfig ? await getEntryData(
+    { id, collection, _internal, unvalidatedData },
+    collectionConfig,
+    pluginContext,
+    settings.config
+  ) : unvalidatedData;
+  return { id, collection, data, _internal };
+}
 export {
   astroContentImportPlugin
 };