@lupinum/ginko-content 0.1.6 → 0.2.0

package/dist/storage/validation.js

@@ -71,28 +71,19 @@ const collectDerivedReferenceIssues = (references, value, resolveReference, issu
   }
 };
 const internalDocumentFields = /* @__PURE__ */ new Set([
-  "_id",
-  "_file",
-  "_path",
-  "_type",
-  "_collection",
-  "_dir",
-  "_locale",
-  "_canonicalKey",
-  "_partial",
-  "_navigation",
-  "_draft",
-  "_stem",
-  "_extension",
-  "_resolvedLocale",
-  "_requestedLocale",
-  "_fallback",
-  "_availableLocales",
-  "_variantPaths",
-  "_resolvedRefs",
-  "_source",
-  "body",
-  "draft"
+  "id",
+  "file",
+  "path",
+  "type",
+  "collection",
+  "canonicalKey",
+  "partial",
+  "draft",
+  "dir",
+  "locale",
+  "navigationFile",
+  "resolved",
+  "body"
 ]);
 const toUserContentDocument = (document) => {
   const userDocument = {};
@@ -104,7 +95,7 @@ const toUserContentDocument = (document) => {
   return userDocument;
 };
 const validateNavigationDocument = (document) => {
-  if (!document._navigation) {
+  if (!document.navigationFile) {
     return ok(void 0);
   }
   const invalidFields = [];
@@ -129,7 +120,7 @@ const validateNavigationDocument = (document) => {
   if (invalidFields.length) {
     return fail(createContentError(
       "INVALID_NAVIGATION_YAML",
-      document._file || document._id,
+      document.file?.path || document.id,
       "malformed .navigation.yml",
       invalidFields.join("; ")
     ));
@@ -137,13 +128,10 @@ const validateNavigationDocument = (document) => {
   return ok(void 0);
 };
 export const getCanonicalContentId = (document, locales = []) => {
-  if (typeof document.id === "string" && document.id.length) {
-    return document.id;
+  if (typeof document.canonicalKey === "string" && document.canonicalKey.length) {
+    return document.canonicalKey;
   }
-  if (typeof document._canonicalKey === "string" && document._canonicalKey.length) {
-    return document._canonicalKey;
-  }
-  const file = (document._file || "").replace(/^\/+/, "");
+  const file = (document.file?.path || "").replace(/^\/+/, "");
   const parts = file.split("/").filter(Boolean);
   const normalized = parts[0] && locales.includes(parts[0]) ? parts.slice(1) : parts;
   return normalized.join("/").replace(/\.[^.]+$/, "");
@@ -153,10 +141,10 @@ export const validateCollectionDocument = (document, collections = {}) => {
   if (!navigationResult.ok) {
     return navigationResult;
   }
-  if (!document._collection) {
+  if (!document.collection) {
     return ok(document);
   }
-  const collection = getCollectionConfig(document._collection, collections);
+  const collection = getCollectionConfig(document.collection, collections);
   const schema = collection?.schema;
   if (!hasSafeParse(schema)) {
     return ok(document);
@@ -172,7 +160,7 @@ export const validateCollectionDocument = (document, collections = {}) => {
     const path = issue.path?.length ? issue.path.join(".") : "document";
     return `${path}: ${issue.message}`;
   }).join("; ");
-  const message = `Invalid content in ${document._file || document._id}${details ? ` (${details})` : ""}`;
+  const message = `Invalid content in ${document.file?.path || document.id}${details ? ` (${details})` : ""}`;
   if (collection?.strict === false) {
     console.warn(message);
     return ok(document);
@@ -181,32 +169,30 @@ export const validateCollectionDocument = (document, collections = {}) => {
     "SCHEMA_VALIDATION_FAILED",
     message,
     {
-      file: document._file || document._id,
-      collection: document._collection,
+      file: document.file?.path || document.id,
+      collection: document.collection,
       ...details ? { details } : {}
     }
   ));
 };
 export const validateContentGraph = (contents, config) => {
   const locales = config.locales || [];
-  const docs = contents.filter((content) => content && content._path);
-  const routeEntries = docs.filter((content) => !content._partial && !content._navigation);
-  const markdownEntries = routeEntries.filter((content) => content._type === "markdown");
+  const docs = contents.filter((content) => content && content.path);
+  const routeEntries = docs.filter((content) => !content.partial && !content.navigationFile);
+  const markdownEntries = routeEntries.filter((content) => content.type === "markdown");
   const idsByLocale = /* @__PURE__ */ new Map();
   const pathsByLocale = /* @__PURE__ */ new Map();
   const referenceTargets = buildReferenceTargets(routeEntries, locales);
   const targetCollections = /* @__PURE__ */ new Map();
-  const variantsByCanonicalKey = /* @__PURE__ */ new Map();
   const markdownVariantsByCanonicalKey = /* @__PURE__ */ new Map();
-  const explicitIdsByValue = /* @__PURE__ */ new Map();
   const refsByValue = /* @__PURE__ */ new Map();
   for (const document of routeEntries) {
-    const canonicalId = document._canonicalKey || getCanonicalContentId(document, locales);
-    if (!canonicalId || !document._collection) {
+    const canonicalId = document.canonicalKey || getCanonicalContentId(document, locales);
+    if (!canonicalId || !document.collection) {
       continue;
     }
     const collections = targetCollections.get(canonicalId) || /* @__PURE__ */ new Set();
-    collections.add(document._collection);
+    collections.add(document.collection);
     targetCollections.set(canonicalId, collections);
   }
   for (const issue of collectTranslatedSlugValidationIssues(markdownEntries, {
@@ -222,85 +208,44 @@ export const validateContentGraph = (contents, config) => {
     }
     return fail(createContentError("TRANSLATED_SLUG_CONFLICT", issue.file, issue.reason, issue.details));
   }
-  for (const document of routeEntries) {
-    const variantKey = document._canonicalKey || getCanonicalContentId(document, locales);
-    const siblings = variantsByCanonicalKey.get(variantKey) || [];
-    siblings.push(document);
-    variantsByCanonicalKey.set(variantKey, siblings);
-  }
   for (const document of markdownEntries) {
-    const variantKey = document._canonicalKey || getCanonicalContentId(document, locales);
+    const variantKey = document.canonicalKey || getCanonicalContentId(document, locales);
     const siblings = markdownVariantsByCanonicalKey.get(variantKey) || [];
     siblings.push(document);
     markdownVariantsByCanonicalKey.set(variantKey, siblings);
   }
-  for (const [variantKey, variants] of variantsByCanonicalKey.entries()) {
-    const explicitIds = Array.from(new Set(variants.map((document) => typeof document.id === "string" && document.id.length ? document.id : void 0).filter((value) => Boolean(value))));
-    if (explicitIds.length > 1) {
-      return fail(createContentError(
-        "CONFLICTING_REFS",
-        variants[0]?._file || variants[0]?._id || variantKey,
-        `conflicting explicit ids across locale variants for canonical key "${variantKey}"`,
-        explicitIds.join(", ")
-      ));
-    }
-    if (explicitIds.length === 1 && variants.some((document) => document.id !== explicitIds[0])) {
-      return fail(createContentError(
-        "CONFLICTING_REFS",
-        variants[0]?._file || variants[0]?._id || variantKey,
-        `explicit id "${explicitIds[0]}" must be declared consistently across locale variants for canonical key "${variantKey}"`
-      ));
-    }
-  }
-  for (const document of routeEntries) {
-    const explicitId = typeof document.id === "string" && document.id.length ? document.id : void 0;
-    if (!explicitId) {
-      continue;
-    }
-    const variantKey = document._canonicalKey || getCanonicalContentId(document, locales);
-    const previous = explicitIdsByValue.get(explicitId);
-    if (previous && previous.variantKey !== variantKey) {
-      return fail(createContentError(
-        "CONFLICTING_REFS",
-        document._file || document._id,
-        `duplicate explicit id "${explicitId}"`,
-        `conflicts with ${previous.document._file || previous.document._id}`
-      ));
-    }
-    explicitIdsByValue.set(explicitId, { document, variantKey });
-  }
   for (const [variantKey, variants] of markdownVariantsByCanonicalKey.entries()) {
     const explicitRefs = Array.from(new Set(variants.map((document) => typeof document.ref === "string" && document.ref.length ? document.ref : void 0).filter((value) => Boolean(value))));
     if (explicitRefs.length > 1) {
       return fail(createContentError(
         "CONFLICTING_REFS",
-        variants[0]?._file || variants[0]?._id || variantKey,
+        variants[0]?.file?.path || variants[0]?.id || variantKey,
         `conflicting refs across locale variants for canonical key "${variantKey}"`,
         explicitRefs.join(", ")
       ));
     }
   }
   for (const document of routeEntries) {
-    const canonicalId = document._canonicalKey || getCanonicalContentId(document, locales);
-    const localeKey = `${canonicalId}:${document._locale || ""}`;
+    const canonicalId = document.canonicalKey || getCanonicalContentId(document, locales);
+    const localeKey = `${canonicalId}:${document.locale || ""}`;
     if (idsByLocale.has(localeKey)) {
       const previous = idsByLocale.get(localeKey);
       return fail(createContentError(
         "DUPLICATE_CANONICAL_ID",
-        document._file || document._id,
-        `duplicate canonical id "${canonicalId}" for locale "${document._locale || "default"}"`,
-        `conflicts with ${previous._file || previous._id}`
+        document.file?.path || document.id,
+        `duplicate canonical id "${canonicalId}" for locale "${document.locale || "default"}"`,
+        `conflicts with ${previous.file?.path || previous.id}`
       ));
     }
     idsByLocale.set(localeKey, document);
-    const pathKey = `${document._locale || ""}:${document._path || ""}`;
+    const pathKey = `${document.locale || ""}:${document.path || ""}`;
     if (pathsByLocale.has(pathKey)) {
       const previous = pathsByLocale.get(pathKey);
       return fail(createContentError(
         "DUPLICATE_LOCALIZED_PATH",
-        document._file || document._id,
-        `duplicate localized path "${document._path}" for locale "${document._locale || "default"}"`,
-        `conflicts with ${previous._file || previous._id}`
+        document.file?.path || document.id,
+        `duplicate localized path "${document.path}" for locale "${document.locale || "default"}"`,
+        `conflicts with ${previous.file?.path || previous.id}`
       ));
     }
     pathsByLocale.set(pathKey, document);
@@ -309,7 +254,7 @@ export const validateContentGraph = (contents, config) => {
     if (typeof document.ref !== "undefined" && (typeof document.ref !== "string" || !document.ref.length)) {
       return fail(createContentError(
         "INVALID_REF_VALUE",
-        document._file || document._id,
+        document.file?.path || document.id,
         "ref must be a non-empty string"
       ));
     }
@@ -318,21 +263,21 @@ export const validateContentGraph = (contents, config) => {
       continue;
     }
     const previous = refsByValue.get(ref);
-    if (previous && (previous._canonicalKey || getCanonicalContentId(previous, locales)) !== (document._canonicalKey || getCanonicalContentId(document, locales))) {
+    if (previous && (previous.canonicalKey || getCanonicalContentId(previous, locales)) !== (document.canonicalKey || getCanonicalContentId(document, locales))) {
       return fail(createContentError(
         "CONFLICTING_REFS",
-        document._file || document._id,
+        document.file?.path || document.id,
         `duplicate ref "${ref}"`,
-        `conflicts with ${previous._file || previous._id}`
+        `conflicts with ${previous.file?.path || previous.id}`
       ));
     }
     refsByValue.set(ref, document);
   }
   for (const document of docs) {
-    if (!document._collection) {
+    if (!document.collection) {
       continue;
     }
-    const collection = getCollectionConfig(document._collection, config.collections);
+    const collection = getCollectionConfig(document.collection, config.collections);
     const references = collection?.references;
     const schema = collection?.schema;
     if (!schema && !references) {
@@ -356,7 +301,7 @@ export const validateContentGraph = (contents, config) => {
     }
     const error = createContentError(
       "SCHEMA_VALIDATION_FAILED",
-      document._file || document._id,
+      document.file?.path || document.id,
       "unresolved content references",
       issues.join("; ")
     );

package/dist/testing/provider-contract.d.ts

@@ -1,11 +1,21 @@
-import { type ContentProvider } from '../public/provider';
-export interface SaasProviderFixtureContractSuiteOptions {
+import { type ContentProvider, type ContentProviderCapabilities } from '../public/provider';
+export interface ProviderContractSuiteOptions {
     name: string;
     expectedProviderName: string;
     loadProvider: () => Promise<ContentProvider>;
     createEvent: () => any;
+    /**
+     * The capabilities the provider under test declares. Each capability block
+     * runs its positive assertions only when the matching flag is `true`.
+     * Operation capabilities (`routeBackedCollections`, `navigation`,
+     * `surroundings`, `searchSections`, `sitemap`) and the query sub-capabilities
+     * (`query.limit`/`skip`/`count`) additionally assert the typed provider error
+     * when declared `false`; descriptive flags (`dataCollections`,
+     * `localizedRoutes`, `translatedSlugs`) only gate their positive block.
+     */
+    expectedCapabilities: ContentProviderCapabilities;
     collectNavPaths?: (items: Array<{
-        _path?: string;
+        unprefixedPath?: string;
         children?: any[];
     }>) => string[];
 }
@@ -18,7 +28,7 @@ export interface AuthorDependencyContractOptions {
         key: string;
     }>;
 }
-export declare const runSaasProviderFixtureContractSuite: ({ name, expectedProviderName, loadProvider, createEvent, collectNavPaths }: SaasProviderFixtureContractSuiteOptions) => void;
+export declare const runProviderContractSuite: ({ name, expectedProviderName, loadProvider, createEvent, expectedCapabilities, collectNavPaths }: ProviderContractSuiteOptions) => void;
 export declare const createAuthorDependencyContractProvider: () => {
     fixture: import("./provider-fixture").ProviderFixture;
     provider: ContentProvider & {

package/dist/testing/provider-contract.js

@@ -1,42 +1,53 @@
 import { expect, test } from "vitest";
-import { contentProviderResultMarker } from "../public/provider";
+import { contentProviderResultMarker, toContentProviderNavigationQuery, toContentProviderQuery } from "../public/provider";
 import { createAuthorDependencyProviderFixture, createFixtureContentProvider, createProviderFixtureEvent, getProviderFixtureCacheHint } from "./provider-fixture.js";
 const defaultCollectNavPaths = (items) => items.flatMap((item) => [
-  item._path,
+  item.unprefixedPath,
   ...defaultCollectNavPaths(item.children || [])
 ].filter(Boolean));
 const unwrapProviderResult = (value) => value && typeof value === "object" && value[contentProviderResultMarker] ? value.data : value;
-export const runSaasProviderFixtureContractSuite = ({
+const expectUnsupportedOperation = (run, operation) => expect(Promise.resolve().then(run)).rejects.toMatchObject({
+  statusCode: 400,
+  statusMessage: "unsupported_provider_operation",
+  data: { code: "unsupported_provider_operation", operation }
+});
+const expectUnsupportedQueryShape = (run, field) => expect(Promise.resolve().then(run)).rejects.toMatchObject({
+  statusCode: 400,
+  statusMessage: "unsupported_query_shape",
+  data: { code: "unsupported_query_shape", field }
+});
+export const runProviderContractSuite = ({
   name,
   expectedProviderName,
   loadProvider,
   createEvent,
+  expectedCapabilities,
   collectNavPaths = defaultCollectNavPaths
 }) => {
+  const caps = expectedCapabilities;
   test(`${name} exposes explicit capabilities`, async () => {
     const provider = await loadProvider();
     expect(provider.name).toBe(expectedProviderName);
     expect(provider.capabilities).toMatchObject({
-      routeBackedCollections: true,
-      dataCollections: true,
-      localizedRoutes: true,
-      translatedSlugs: true,
-      navigation: true,
-      surroundings: true,
-      searchSections: true,
-      sitemap: true,
+      ...caps,
       query: {
-        limit: true,
-        skip: true,
-        count: true
+        limit: caps.query.limit,
+        skip: caps.query.skip,
+        count: caps.query.count
       }
     });
-    expect(provider.capabilities.query.operators).toContain("$eq");
-    expect(provider.capabilities.query.operators).toContain("$contains");
+    expect(provider.capabilities.query.operators).toEqual(
+      expect.arrayContaining(caps.query.operators)
+    );
   });
   test(`${name} returns complete localized page and route metadata`, async () => {
     const provider = await loadProvider();
     const event = createEvent();
+    if (!caps.routeBackedCollections) {
+      await expectUnsupportedOperation(() => provider.page?.(event, "docs", "/de/dokumentation/einstieg"), "route-backed pages");
+      await expectUnsupportedOperation(() => provider.routeMeta?.(event, "docs", "/de/dokumentation/einstieg", { locale: "de" }), "route metadata");
+      return;
+    }
     const page = unwrapProviderResult(await provider.page?.(event, "docs", "/de/dokumentation/einstieg"));
     expect(page).toMatchObject({
       title: "Einstieg",
@@ -61,43 +72,62 @@ export const runSaasProviderFixtureContractSuite = ({
         locale: "de"
       })
     });
-  });
-  test(`${name} supports localized page misses without fallback routes`, async () => {
-    const provider = await loadProvider();
     const miss = unwrapProviderResult(await provider.page?.(createEvent(), "docs", "/de/dokumentation/not-found"));
     expect(miss).toBeNull();
   });
   test(`${name} supports list queries with locale, ordering, limit, count, and projection`, async () => {
     const provider = await loadProvider();
-    const response = unwrapProviderResult(await provider.query(createEvent(), {
-      collection: "posts",
-      resolveLocale: { locale: "de", fallback: false },
-      sort: [{ date: -1 }],
-      limit: 1,
-      only: ["title", "_path", "_locale"]
-    }));
-    expect(response.result).toEqual([
-      {
-        title: "Mehrsprachiges Onboarding",
-        _path: "/magazin/mehrsprachiges-onboarding",
-        _locale: "de"
-      }
-    ]);
-    expect(typeof response.total).toBe("number");
-    const countResponse = unwrapProviderResult(await provider.query(createEvent(), {
-      collection: "posts",
-      resolveLocale: { locale: "de", fallback: false },
-      count: true
-    }));
-    expect(countResponse).toEqual({ result: 1 });
+    if (!caps.query.limit) {
+      await expectUnsupportedQueryShape(() => provider.query(createEvent(), toContentProviderQuery({
+        collection: "posts",
+        resolveLocale: { locale: "de", fallback: false },
+        limit: 1
+      })), "limit");
+    } else {
+      const response = unwrapProviderResult(await provider.query(createEvent(), toContentProviderQuery({
+        collection: "posts",
+        resolveLocale: { locale: "de", fallback: false },
+        sort: [{ date: -1 }],
+        limit: 1,
+        only: ["title", "path", "locale"]
+      })));
+      expect(response.result).toEqual([
+        {
+          title: "Mehrsprachiges Onboarding",
+          path: "/magazin/mehrsprachiges-onboarding",
+          locale: "de"
+        }
+      ]);
+      expect(typeof response.total).toBe("number");
+    }
+    if (!caps.query.count) {
+      await expectUnsupportedQueryShape(() => provider.query(createEvent(), toContentProviderQuery({
+        collection: "posts",
+        resolveLocale: { locale: "de", fallback: false },
+        count: true
+      })), "count");
+    } else {
+      const countResponse = unwrapProviderResult(await provider.query(createEvent(), toContentProviderQuery({
+        collection: "posts",
+        resolveLocale: { locale: "de", fallback: false },
+        count: true
+      })));
+      expect(countResponse).toEqual({ result: 1 });
+    }
   });
-  test(`${name} produces navigation, surroundings, search sections, and sitemap entries`, async () => {
+  test(`${name} produces navigation entries`, async () => {
     const provider = await loadProvider();
     const event = createEvent();
+    if (!caps.navigation) {
+      await expectUnsupportedOperation(() => provider.navigation?.(event, "docs", { locale: "de" }), "navigation");
+      const wire = toContentProviderNavigationQuery({ where: { locale: "de" } });
+      await expectUnsupportedOperation(() => provider.navigationQuery?.(event, wire.query, wire.options), "navigation");
+      return;
+    }
     const nav = unwrapProviderResult(await provider.navigation?.(event, "docs", { locale: "de" }));
     expect(collectNavPaths(nav || [])).toContain("/dokumentation/einstieg");
     expect(nav?.[0]).toEqual(expect.objectContaining({
-      _locale: "de",
+      locale: "de",
       ref: expect.any(String),
       stableId: expect.any(String)
     }));
@@ -112,27 +142,54 @@ export const runSaasProviderFixtureContractSuite = ({
       title: expect.any(String),
       description: expect.any(String)
     }));
-    const globalNav = unwrapProviderResult(await provider.navigationQuery?.(event, { where: { _locale: "de" } }));
+    const globalNavWire = toContentProviderNavigationQuery({ where: { locale: "de" } });
+    const globalNav = unwrapProviderResult(await provider.navigationQuery?.(event, globalNavWire.query, globalNavWire.options));
     const globalNavPaths = collectNavPaths(globalNav || []);
     expect(globalNavPaths).toContain("/dokumentation/einstieg");
     expect(globalNavPaths.length).toBeGreaterThan(0);
-    const resolvedLocaleNav = unwrapProviderResult(await provider.navigationQuery?.(event, {
+    const resolvedLocaleNavWire = toContentProviderNavigationQuery({
       collection: "docs",
       resolveLocale: { locale: "de", fallback: false, exact: true }
-    }));
+    });
+    const resolvedLocaleNav = unwrapProviderResult(await provider.navigationQuery?.(event, resolvedLocaleNavWire.query, resolvedLocaleNavWire.options));
     expect(collectNavPaths(resolvedLocaleNav || [])).toContain("/dokumentation/einstieg");
+    expect(JSON.stringify(nav)).not.toContain("Draft Roadmap");
+  });
+  test(`${name} produces surroundings entries`, async () => {
+    const provider = await loadProvider();
+    const event = createEvent();
+    if (!caps.surroundings) {
+      await expectUnsupportedOperation(() => provider.surroundings?.(event, "docs", "/de/dokumentation/einstieg/installation", { locale: "de" }), "surroundings");
+      return;
+    }
     const surround = unwrapProviderResult(await provider.surroundings?.(event, "docs", "/de/dokumentation/einstieg/installation", { locale: "de" }));
     expect(surround).toHaveLength(2);
-    expect(surround?.map((item) => item?._path)).toContain("/dokumentation/einstieg/alltag");
+    expect(surround?.map((item) => item?.unprefixedPath)).toContain("/dokumentation/einstieg/alltag");
+  });
+  test(`${name} produces search sections`, async () => {
+    const provider = await loadProvider();
+    const event = createEvent();
+    if (!caps.searchSections) {
+      await expectUnsupportedOperation(() => provider.searchSections?.(event, "docs", { locale: "de" }), "search sections");
+      return;
+    }
     const sections = unwrapProviderResult(await provider.searchSections?.(event, "docs", { locale: "de" }));
     expect(sections?.some((section) => section.id.startsWith("/de/dokumentation/einstieg") || section.id.startsWith("/dokumentation/einstieg"))).toBe(true);
     expect(JSON.stringify(sections)).not.toContain("Draft Roadmap");
+  });
+  test(`${name} produces sitemap entries`, async () => {
+    const provider = await loadProvider();
+    const event = createEvent();
+    if (!caps.sitemap) {
+      await expectUnsupportedOperation(() => provider.sitemapEntries?.(event, { include: ["docs"] }), "sitemap entries");
+      return;
+    }
     const sitemap = unwrapProviderResult(await provider.sitemapEntries?.(event, { include: ["docs"] }));
     expect(sitemap?.some((entry) => entry.loc.endsWith("/de/dokumentation/einstieg"))).toBe(true);
     expect(JSON.stringify(sitemap)).not.toContain("/docs/draft-roadmap");
-    expect(JSON.stringify(nav)).not.toContain("Draft Roadmap");
   });
   test(`${name} emits cache hints for rendered content`, async () => {
+    if (!caps.routeBackedCollections) return;
     const provider = await loadProvider();
     const event = createEvent();
     await provider.page?.(event, "posts", "/de/magazin/mehrsprachiges-onboarding");
@@ -154,38 +211,34 @@ export const runSaasProviderFixtureContractSuite = ({
     }
   });
   test(`${name} supports data-only collection reads and rejects data-only sitemap access`, async () => {
+    if (!caps.dataCollections) return;
     const provider = await loadProvider();
-    const response = unwrapProviderResult(await provider.query(createEvent(), {
+    const response = unwrapProviderResult(await provider.query(createEvent(), toContentProviderQuery({
       collection: "versions",
       resolveLocale: { locale: "en", fallback: false },
       sort: [{ date: -1 }]
-    }));
+    })));
     expect(response.result[0]?.title).toBe("Launch readiness");
-    await expect(provider.sitemapEntries?.(createEvent(), { include: ["versions"] })).rejects.toMatchObject({
-      statusCode: 400,
-      statusMessage: "data_collection_sitemap_access",
-      data: {
-        code: "data_collection_sitemap_access",
-        collection: "versions"
-      }
-    });
+    if (caps.sitemap) {
+      await expect(provider.sitemapEntries?.(createEvent(), { include: ["versions"] })).rejects.toMatchObject({
+        statusCode: 400,
+        statusMessage: "data_collection_sitemap_access",
+        data: {
+          code: "data_collection_sitemap_access",
+          collection: "versions"
+        }
+      });
+    }
   });
   test(`${name} fails loudly for unsupported query operators and unknown collections`, async () => {
     const provider = await loadProvider();
-    await expect(provider.query(createEvent(), {
+    expect(() => toContentProviderQuery({
       collection: "posts",
       where: { title: { $near: "launch" } }
-    })).rejects.toMatchObject({
-      statusCode: 400,
-      statusMessage: "unsupported_query_operator",
-      data: {
-        code: "unsupported_query_operator",
-        operator: "$near"
-      }
-    });
-    await expect(provider.query(createEvent(), {
+    })).toThrow(/Unsupported content query operator: \$near/);
+    await expect(provider.query(createEvent(), toContentProviderQuery({
       collection: "missing"
-    })).rejects.toMatchObject({
+    }))).rejects.toMatchObject({
       statusCode: 400,
       statusMessage: "unknown_collection",
       data: {

package/dist/testing/provider-fixture.d.ts

@@ -63,5 +63,5 @@ export declare const createProviderFixtureEvent: (options?: ProviderFixtureEvent
 export declare const createFixtureContentProvider: (fixture: ProviderFixture, name?: string) => ContentProvider & {
     cache: ProviderFixtureCacheState;
 };
-export declare const createSaasProviderFixture: () => ProviderFixture;
+export declare const createDefaultProviderFixture: () => ProviderFixture;
 export declare const createAuthorDependencyProviderFixture: () => ProviderFixture;