@lupinum/ginko-content 0.1.0

package/dist/runtime/server/navigation.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedContentMeta } from '../../types/content';
+export declare function createNav(contents: ParsedContentMeta[], configs: Record<string, ParsedContentMeta>): import("../../types").NavItem[];

package/dist/runtime/server/navigation.js

@@ -0,0 +1,9 @@
+import { buildNavigation } from "../../features/navigation/build";
+import { getContentRuntimeConfig } from "./runtime-config.js";
+export function createNav(contents, configs) {
+  const { navigation } = getContentRuntimeConfig().public.content;
+  if (navigation === false) {
+    return [];
+  }
+  return buildNavigation(contents, configs, navigation.fields);
+}

package/dist/runtime/server/pagefind

@@ -0,0 +1 @@
+export * from './pagefind.js'

package/dist/runtime/server/pagefind.d.ts

@@ -0,0 +1,2 @@
+import type { ContentSearchIndexRecord } from '../../types/search';
+export declare function writePagefindIndex(records: ContentSearchIndexRecord[], outputPath: string): Promise<void>;

package/dist/runtime/server/pagefind.js

@@ -0,0 +1,30 @@
+export async function writePagefindIndex(records, outputPath) {
+  const { createIndex } = await import("pagefind");
+  const { index } = await createIndex();
+  if (!index) {
+    throw new Error("Failed to initialize Pagefind index");
+  }
+  for (const record of records) {
+    const url = record.anchor ? `${record.path}#${record.anchor}` : record.path;
+    const content = [record.title, ...record.headings, record.content].filter(Boolean).join("\n");
+    const response2 = await index.addCustomRecord({
+      url,
+      content,
+      language: record.locale || "en",
+      meta: {
+        title: record.title,
+        excerpt: record.excerpt,
+        locale: record.locale || "",
+        anchor: record.anchor || "",
+        path: record.path
+      }
+    });
+    if (response2.errors.length) {
+      throw new Error(`Failed to add Pagefind record for ${url}: ${response2.errors.join(", ")}`);
+    }
+  }
+  const response = await index.writeFiles({ outputPath });
+  if (response.errors.length) {
+    throw new Error(`Failed to write Pagefind index: ${response.errors.join(", ")}`);
+  }
+}

package/dist/runtime/server/plugins/cache

@@ -0,0 +1 @@
+export * from './cache.js'

package/dist/runtime/server/plugins/cache.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/cache.js

@@ -0,0 +1,17 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { clearContentCacheHint, getContentCacheHint } from "../cache-hints.js";
+import { getContentCacheAdapter } from "../cache-adapter.js";
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook("render:response", async (_response, { event }) => {
+    const hint = getContentCacheHint(event);
+    if (!hint) {
+      clearContentCacheHint(event);
+      return;
+    }
+    const adapter = await getContentCacheAdapter();
+    if (adapter) {
+      await adapter.apply(event, hint);
+    }
+    clearContentCacheHint(event);
+  });
+});

package/dist/runtime/server/plugins/sitemap

@@ -0,0 +1 @@
+export * from './sitemap.js'

package/dist/runtime/server/plugins/sitemap.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/sitemap.js

@@ -0,0 +1,25 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { getContentRuntimeConfig } from "../runtime-config.js";
+const LEGACY_NUXT_CONTENT_V2_SOURCE = "@nuxt/content@v2:urls";
+const GINKO_SOURCE = "@lupinum/ginko-content:urls";
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook("sitemap:sources", (ctx) => {
+    const runtimeConfig = getContentRuntimeConfig();
+    const sitemap = runtimeConfig.public.content?.sitemap;
+    const apiBaseURL = runtimeConfig.public.content?.api?.baseURL;
+    if (!sitemap || !apiBaseURL) {
+      return;
+    }
+    const fetch = `${apiBaseURL}${sitemap.path || "/sitemap"}`;
+    ctx.sources = ctx.sources.filter((source) => {
+      return source.context?.name !== LEGACY_NUXT_CONTENT_V2_SOURCE && source.context?.name !== GINKO_SOURCE;
+    });
+    ctx.sources.push({
+      context: {
+        name: GINKO_SOURCE
+      },
+      fetch,
+      sourceType: "app"
+    });
+  });
+});

package/dist/runtime/server/preview

@@ -0,0 +1 @@
+export * from './preview.js'

package/dist/runtime/server/preview.d.ts

@@ -0,0 +1 @@
+export { getPreview, isPreview } from '../../integrations/nitro/preview';

package/dist/runtime/server/preview.js

@@ -0,0 +1 @@
+export { getPreview, isPreview } from "../../integrations/nitro/preview";

package/dist/runtime/server/provider-query

@@ -0,0 +1 @@
+export * from './provider-query.js'

package/dist/runtime/server/provider-query.d.ts

@@ -0,0 +1,27 @@
+import type { H3Event } from 'h3';
+import type { ContentCollectionMap } from '@lupinum/ginko-content';
+import type { ParsedContent } from '../../types/content';
+import type { ContentQueryResponse } from '../../types/api';
+import type { CollectionQueryBuilder, ContentQueryBuilderParams, ContentQueryRequest, ResolveContentReferenceOptions } from '../../types/query';
+export declare const normalizeProviderQueryResult: <T>(response: ContentQueryResponse<T> | T[] | T | number | undefined) => T[];
+export declare const resolveProviderContentVariants: (event: H3Event, identity: string, options: ResolveContentReferenceOptions) => Promise<{
+    canonicalKey: any;
+    selected: any;
+    variants: (ParsedContent | import(".").ContentProviderResult<number | ParsedContent | ParsedContent[] | ContentQueryResponse<ParsedContent> | undefined>)[];
+    availableLocales: string[];
+    variantPaths: any;
+    requestedLocale: string | undefined;
+    resolvedLocale: any;
+    fallback: boolean;
+} | null>;
+export declare const createServerProviderQueryFetch: <T = ParsedContent>(event: H3Event) => (query: ContentQueryRequest) => Promise<import(".").MaybeContentProviderResult<number | T | ContentQueryResponse<T> | T[] | undefined>>;
+export declare const createServerContentQuery: <T = ParsedContent>(event: H3Event, query?: string | ContentQueryBuilderParams, ...pathParts: string[]) => import("@lupinum/ginko-content").ContentQueryBuilder<T>;
+export declare function serverQueryCollection<K extends keyof ContentCollectionMap & string>(event: H3Event, collection: K): CollectionQueryBuilder<ContentCollectionMap[K]>;
+export declare function serverQueryCollection<T = ParsedContent>(event: H3Event, collection: string): CollectionQueryBuilder<T>;
+export declare const resolveContentReference: <T = ParsedContent>(event: H3Event, reference: string, options?: ResolveContentReferenceOptions) => Promise<(T & {
+    _requestedLocale?: string;
+    _resolvedLocale?: string;
+    _fallback?: boolean;
+    _availableLocales?: string[];
+    _variantPaths?: Record<string, string>;
+}) | null>;

package/dist/runtime/server/provider-query.js

@@ -0,0 +1,131 @@
+import { joinURL, withLeadingSlash } from "ufo";
+import { createQuery, wrapQueryBuilder } from "../../core/query/builder";
+import { normalizeContentQueryParams } from "../../core/query/params";
+import { normalizeI18nConfig, resolveRuntimeCollectionI18nConfig } from "../../features/localization/config";
+import { normalizeReferenceValue } from "../../core/references/resolve";
+import { getContentRuntimeConfig } from "./runtime-config.js";
+export const normalizeProviderQueryResult = (response) => {
+  if (Array.isArray(response)) {
+    return response;
+  }
+  if (response && typeof response === "object" && "result" in response) {
+    return Array.isArray(response.result) ? response.result : [];
+  }
+  return [];
+};
+const identityMatchesDocument = (document, identity) => {
+  const normalizedIdentity = normalizeReferenceValue(identity);
+  if (!normalizedIdentity) {
+    return false;
+  }
+  return [document._canonicalKey, document._path, document.ref].filter((value) => typeof value === "string").some((value) => normalizeReferenceValue(value) === normalizedIdentity);
+};
+export const resolveProviderContentVariants = async (event, identity, options) => {
+  if (!options.collection) {
+    return null;
+  }
+  const normalizedReference = normalizeReferenceValue(identity);
+  if (!normalizedReference) {
+    return null;
+  }
+  const runtimeContent = getContentRuntimeConfig().content || {};
+  const collectionI18n = resolveRuntimeCollectionI18nConfig(options.collection, runtimeContent);
+  const fallbackLocales = Array.isArray(options.fallback) ? options.fallback : options.fallback && options.locale ? runtimeContent.localeFallback?.[options.locale] || [] : [];
+  const localesToQuery = Array.from(/* @__PURE__ */ new Set([
+    ...options.locale ? [options.locale] : [],
+    ...fallbackLocales,
+    ...collectionI18n?.locales || []
+  ]));
+  const { getContentProvider } = await import("./providers/index.js");
+  const provider = await getContentProvider(event);
+  const baseQuery = {
+    collection: options.collection,
+    only: ["_path", "_canonicalKey", "_locale", "ref", "title", "description", "body"]
+  };
+  const documents = localesToQuery.length ? (await Promise.all(
+    localesToQuery.map(
+      async (locale) => normalizeProviderQueryResult(
+        await provider.query(event, {
+          ...baseQuery,
+          resolveLocale: { locale, exact: true }
+        })
+      )
+    )
+  )).flat() : normalizeProviderQueryResult(await provider.query(event, baseQuery));
+  const matched = documents.find((document) => identityMatchesDocument(document, normalizedReference));
+  const canonicalKey = matched?._canonicalKey;
+  if (!canonicalKey) {
+    return null;
+  }
+  const variants = documents.filter((document) => document._canonicalKey === canonicalKey);
+  if (!variants.length) {
+    return null;
+  }
+  const selectByLocale = (locale) => locale ? variants.find((document) => document._locale === locale) : void 0;
+  const selected = selectByLocale(options.locale) || (!options.exact ? fallbackLocales.map(selectByLocale).find(Boolean) : void 0) || (!options.exact ? selectByLocale(collectionI18n?.defaultLocale || runtimeContent.defaultLocale) : void 0) || (!options.exact ? variants[0] : void 0);
+  if (!selected) {
+    return null;
+  }
+  const availableLocales = Array.from(new Set(variants.map((document) => document._locale).filter(Boolean)));
+  const variantPaths = Object.fromEntries(
+    variants.filter((document) => document._locale && document._path).map((document) => [document._locale, document._path])
+  );
+  return {
+    canonicalKey,
+    selected,
+    variants,
+    availableLocales,
+    variantPaths,
+    requestedLocale: options.locale,
+    resolvedLocale: selected._locale,
+    fallback: Boolean(options.locale && selected._locale && selected._locale !== options.locale)
+  };
+};
+export const createServerProviderQueryFetch = (event) => {
+  return async (query) => {
+    const { getContentProvider } = await import("./providers/index.js");
+    return await (await getContentProvider(event)).query(event, query.params());
+  };
+};
+const getServerCollectionI18n = (collection) => {
+  const config = getContentRuntimeConfig().content;
+  return collection ? resolveRuntimeCollectionI18nConfig(collection, config) : normalizeI18nConfig(config);
+};
+export const createServerContentQuery = (event, query, ...pathParts) => {
+  const config = getContentRuntimeConfig().content;
+  const queryBuilder = createQuery(createServerProviderQueryFetch(event), {
+    initialParams: typeof query !== "string" ? query || {} : {}
+  });
+  let path;
+  if (typeof query === "string") {
+    path = withLeadingSlash(joinURL(query, ...pathParts));
+  }
+  return wrapQueryBuilder(queryBuilder, (params) => {
+    const collectionI18n = getServerCollectionI18n(params.collection);
+    return normalizeContentQueryParams(params, {
+      path,
+      collectionI18n,
+      defaultLocale: config.defaultLocale,
+      localeFallback: config.localeFallback,
+      activeLocale: collectionI18n?.defaultLocale,
+      includeDraftFilter: !import.meta.dev
+    });
+  });
+};
+export function serverQueryCollection(event, collection) {
+  return createServerContentQuery(event, { collection });
+}
+export const resolveContentReference = async (event, reference, options = {}) => {
+  const resolved = await resolveProviderContentVariants(event, reference, options);
+  if (!resolved) {
+    return null;
+  }
+  return {
+    ...resolved.selected,
+    _requestedLocale: resolved.requestedLocale,
+    _resolvedLocale: resolved.resolvedLocale,
+    _fallback: resolved.fallback,
+    _availableLocales: resolved.availableLocales,
+    _variantPaths: resolved.variantPaths
+  };
+};

package/dist/runtime/server/provider-result

@@ -0,0 +1 @@
+export * from './provider-result.js'

package/dist/runtime/server/provider-result.d.ts

@@ -0,0 +1,10 @@
+import type { H3Event } from 'h3';
+import type { ContentProvider, ContentProviderResult, MaybeContentProviderResult } from '../../public/provider';
+export declare const isContentProviderResult: <T = unknown>(value: unknown) => value is ContentProviderResult<T>;
+export declare const unwrapContentProviderResult: <T>(event: H3Event, result: MaybeContentProviderResult<T>) => T;
+/**
+ * External providers may return `{ data, cache }` from any provider method.
+ * Runtime consumers should continue receiving the historical raw data shape,
+ * while the request-local cache collector records the cache hint.
+ */
+export declare const wrapContentProviderCacheResults: (event: H3Event, provider: ContentProvider) => ContentProvider;

package/dist/runtime/server/provider-result.js

@@ -0,0 +1,30 @@
+import { contentProviderResultMarker } from "../../public/provider";
+import { collectContentCacheHint } from "./cache-hints.js";
+const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+export const isContentProviderResult = (value) => isObject(value) && value[contentProviderResultMarker] === true;
+export const unwrapContentProviderResult = (event, result) => {
+  if (isContentProviderResult(result)) {
+    collectContentCacheHint(event, result.cache);
+    return result.data;
+  }
+  return result;
+};
+const wrapProviderMethod = (event, method) => {
+  return (async (...args) => unwrapContentProviderResult(event, await method(...args)));
+};
+export const wrapContentProviderCacheResults = (event, provider) => {
+  const wrapped = {
+    ...provider,
+    query: wrapProviderMethod(event, provider.query)
+  };
+  if (provider.navigationQuery) wrapped.navigationQuery = wrapProviderMethod(event, provider.navigationQuery);
+  if (provider.navigation) wrapped.navigation = wrapProviderMethod(event, provider.navigation);
+  if (provider.surroundings) wrapped.surroundings = wrapProviderMethod(event, provider.surroundings);
+  if (provider.searchSections) wrapped.searchSections = wrapProviderMethod(event, provider.searchSections);
+  if (provider.search) wrapped.search = wrapProviderMethod(event, provider.search);
+  if (provider.siteData) wrapped.siteData = wrapProviderMethod(event, provider.siteData);
+  if (provider.page) wrapped.page = wrapProviderMethod(event, provider.page);
+  if (provider.routeMeta) wrapped.routeMeta = wrapProviderMethod(event, provider.routeMeta);
+  if (provider.sitemapEntries) wrapped.sitemapEntries = wrapProviderMethod(event, provider.sitemapEntries);
+  return wrapped;
+};

package/dist/runtime/server/providers/filesystem

@@ -0,0 +1 @@
+export * from './filesystem.js'

package/dist/runtime/server/providers/filesystem.d.ts

@@ -0,0 +1,2 @@
+import type { ContentProvider } from '../../../public/provider';
+export declare const filesystemProvider: ContentProvider;

package/dist/runtime/server/providers/filesystem.js

@@ -0,0 +1,47 @@
+import { containsStandaloneRegexOptions, SUPPORTED_QUERY_OPERATORS } from "../../../core/query/operators";
+import { executeFilesystemContentQuery } from "../query-executor.js";
+import { resolveContentNavigation } from "../navigation-query.js";
+import {
+  queryFilesystemCollectionItemSurroundings,
+  queryFilesystemCollectionNavigation,
+  queryFilesystemCollectionPage,
+  queryFilesystemCollectionRouteMeta,
+  queryFilesystemCollectionSearchSections
+} from "../collection-helpers.js";
+import { queryFilesystemCollectionsSitemapEntries } from "../sitemap.js";
+export const filesystemProvider = {
+  name: "filesystem",
+  capabilities: {
+    routeBackedCollections: true,
+    dataCollections: true,
+    localizedRoutes: true,
+    translatedSlugs: true,
+    navigation: true,
+    surroundings: true,
+    searchSections: true,
+    sitemap: true,
+    query: {
+      operators: [
+        ...SUPPORTED_QUERY_OPERATORS.filter((operator) => operator !== "$options"),
+        "$and",
+        "$or"
+      ],
+      limit: true,
+      skip: true,
+      count: true
+    }
+  },
+  query: (event, query) => {
+    if (containsStandaloneRegexOptions(query.where)) {
+      throw new TypeError("Query operator $options requires $regex.");
+    }
+    return executeFilesystemContentQuery(event, query);
+  },
+  navigationQuery: (event, query) => resolveContentNavigation(event, query),
+  navigation: (event, collection, options) => queryFilesystemCollectionNavigation(event, collection, options),
+  surroundings: (event, collection, path, options) => queryFilesystemCollectionItemSurroundings(event, collection, path, options),
+  searchSections: (event, collection, options) => queryFilesystemCollectionSearchSections(event, collection, options),
+  page: (event, collection, routeOrPath, options) => queryFilesystemCollectionPage(event, collection, routeOrPath, options),
+  routeMeta: (event, collection, routeOrPath, options) => queryFilesystemCollectionRouteMeta(event, collection, routeOrPath, options),
+  sitemapEntries: (event, options) => queryFilesystemCollectionsSitemapEntries(event, options)
+};

package/dist/runtime/server/providers/index

@@ -0,0 +1 @@
+export * from './index.js'

package/dist/runtime/server/providers/index.d.ts

@@ -0,0 +1,3 @@
+import type { H3Event } from 'h3';
+import type { ContentProvider } from '../../../public/provider';
+export declare const getContentProvider: (event?: H3Event) => Promise<ContentProvider>;

package/dist/runtime/server/providers/index.js

@@ -0,0 +1,190 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+import { loadExternalContentProvider } from "#content/virtual/providers";
+import { createContentProviderError } from "../../../public/provider-errors";
+import { wrapContentProviderCacheResults } from "../provider-result.js";
+const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const requiredCapabilityBooleans = [
+  "routeBackedCollections",
+  "dataCollections",
+  "localizedRoutes",
+  "translatedSlugs",
+  "navigation",
+  "surroundings",
+  "searchSections",
+  "sitemap"
+];
+const assertProviderField = (providerName, condition, field) => {
+  if (!condition) {
+    throw createContentProviderError("provider_module_invalid", `Content provider ${providerName} has an invalid ${field} field.`, {
+      provider: providerName,
+      field
+    });
+  }
+};
+const assertProviderMethod = (providerName, provider, method) => {
+  assertProviderField(providerName, typeof provider[method] === "function", method);
+};
+const findProviderUnsupportedOperator = (value, supportedOperators) => {
+  if (!value || typeof value !== "object") return void 0;
+  if (Array.isArray(value)) {
+    for (const child of value) {
+      const unsupported = findProviderUnsupportedOperator(child, supportedOperators);
+      if (unsupported) return unsupported;
+    }
+    return void 0;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (key.startsWith("$") && !supportedOperators.has(key)) return key;
+    const unsupported = findProviderUnsupportedOperator(child, supportedOperators);
+    if (unsupported) return unsupported;
+  }
+};
+const assertProviderQuerySupported = (provider, query) => {
+  const capabilities = provider.capabilities.query;
+  const unsupportedOperator = findProviderUnsupportedOperator(query.where, new Set(capabilities.operators));
+  if (unsupportedOperator) {
+    throw createContentProviderError("unsupported_query_operator", `${provider.name} does not support query operator: ${unsupportedOperator}`, {
+      provider: provider.name,
+      operator: unsupportedOperator
+    });
+  }
+  if (!capabilities.limit && query.limit !== void 0) {
+    throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support query limits.`, {
+      provider: provider.name,
+      field: "limit"
+    });
+  }
+  if (!capabilities.skip && query.skip !== void 0) {
+    throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support query offsets.`, {
+      provider: provider.name,
+      field: "skip"
+    });
+  }
+  if (!capabilities.count && query.count === true) {
+    throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support count queries.`, {
+      provider: provider.name,
+      field: "count"
+    });
+  }
+};
+const assertProviderOperationSupported = (provider, supported, operation) => {
+  if (!supported) {
+    throw createContentProviderError("unsupported_provider_operation", `${provider.name} does not support ${operation}.`, {
+      provider: provider.name,
+      operation
+    });
+  }
+};
+const enforceProviderCapabilities = (provider) => ({
+  ...provider,
+  query: async (event, query) => {
+    assertProviderQuerySupported(provider, query);
+    return await provider.query(event, query);
+  },
+  navigationQuery: provider.navigationQuery ? async (...args) => {
+    assertProviderOperationSupported(provider, provider.capabilities.navigation, "navigation");
+    return await provider.navigationQuery(...args);
+  } : void 0,
+  navigation: provider.navigation ? async (...args) => {
+    assertProviderOperationSupported(provider, provider.capabilities.navigation, "navigation");
+    return await provider.navigation(...args);
+  } : void 0,
+  surroundings: provider.surroundings ? async (...args) => {
+    assertProviderOperationSupported(provider, provider.capabilities.surroundings, "surroundings");
+    return await provider.surroundings(...args);
+  } : void 0,
+  searchSections: provider.searchSections ? async (...args) => {
+    assertProviderOperationSupported(provider, provider.capabilities.searchSections, "search sections");
+    return await provider.searchSections(...args);
+  } : void 0,
+  page: provider.page ? async (...args) => {
+    assertProviderOperationSupported(provider, provider.capabilities.routeBackedCollections, "route-backed pages");
+    return await provider.page(...args);
+  } : void 0,
+  routeMeta: provider.routeMeta ? async (...args) => {
+    assertProviderOperationSupported(provider, provider.capabilities.routeBackedCollections, "route metadata");
+    return await provider.routeMeta(...args);
+  } : void 0,
+  sitemapEntries: provider.sitemapEntries ? async (...args) => {
+    assertProviderOperationSupported(provider, provider.capabilities.sitemap, "sitemap entries");
+    return await provider.sitemapEntries(...args);
+  } : void 0
+});
+const validateContentProvider = (providerName, provider) => {
+  if (!isObject(provider)) {
+    throw createContentProviderError("provider_module_invalid", `Content provider module for ${providerName} did not export a provider object.`, {
+      provider: providerName
+    });
+  }
+  if (typeof provider.name !== "string") {
+    throw createContentProviderError("provider_module_invalid", `Content provider ${providerName} is missing a string name.`, {
+      provider: providerName,
+      field: "name"
+    });
+  }
+  if (!isObject(provider.capabilities) || !isObject(provider.capabilities.query)) {
+    throw createContentProviderError("provider_module_invalid", `Content provider ${providerName} is missing capabilities.`, {
+      provider: providerName,
+      field: "capabilities"
+    });
+  }
+  for (const key of requiredCapabilityBooleans) {
+    assertProviderField(providerName, typeof provider.capabilities[key] === "boolean", `capabilities.${key}`);
+  }
+  const queryCapabilities = provider.capabilities.query;
+  assertProviderField(
+    providerName,
+    Array.isArray(queryCapabilities.operators) && queryCapabilities.operators.every((operator) => typeof operator === "string"),
+    "capabilities.query.operators"
+  );
+  assertProviderField(providerName, typeof queryCapabilities.limit === "boolean", "capabilities.query.limit");
+  assertProviderField(providerName, typeof queryCapabilities.skip === "boolean", "capabilities.query.skip");
+  assertProviderField(providerName, typeof queryCapabilities.count === "boolean", "capabilities.query.count");
+  assertProviderMethod(providerName, provider, "query");
+  if (provider.capabilities.navigation) {
+    assertProviderMethod(providerName, provider, "navigationQuery");
+    assertProviderMethod(providerName, provider, "navigation");
+  }
+  if (provider.capabilities.surroundings) {
+    assertProviderMethod(providerName, provider, "surroundings");
+  }
+  if (provider.capabilities.searchSections) {
+    assertProviderMethod(providerName, provider, "searchSections");
+  }
+  if (provider.capabilities.sitemap) {
+    assertProviderMethod(providerName, provider, "sitemapEntries");
+  }
+  if (provider.capabilities.routeBackedCollections || provider.capabilities.localizedRoutes) {
+    assertProviderMethod(providerName, provider, "page");
+    assertProviderMethod(providerName, provider, "routeMeta");
+  }
+  return provider;
+};
+export const getContentProvider = async (event) => {
+  const runtime = event ? useRuntimeConfig(event) : useRuntimeConfig();
+  const eventContent = event?.context?.contentRuntime;
+  const provider = eventContent?.provider || runtime.content?.provider || runtime.public?.content?.provider || "filesystem";
+  if (provider === "filesystem") {
+    const { filesystemProvider } = await import("./filesystem.js");
+    const enforced = enforceProviderCapabilities(filesystemProvider);
+    return event ? wrapContentProviderCacheResults(event, enforced) : enforced;
+  }
+  if (typeof provider === "string") {
+    try {
+      const externalProvider = await loadExternalContentProvider(provider);
+      if (externalProvider) {
+        const validated = enforceProviderCapabilities(validateContentProvider(provider, externalProvider));
+        return event ? wrapContentProviderCacheResults(event, validated) : validated;
+      }
+    } catch (error) {
+      if (isObject(error) && error.statusMessage === "provider_module_invalid") {
+        throw error;
+      }
+      throw createContentProviderError("provider_module_missing", `Content provider module for ${provider} could not be loaded.`, {
+        provider,
+        cause: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  throw createContentProviderError("unknown_provider", `Unknown content provider: ${provider}`, { provider });
+};

package/dist/runtime/server/query-api

@@ -0,0 +1 @@
+export * from './query-api.js'

package/dist/runtime/server/query-api.d.ts

@@ -0,0 +1,28 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionHandle } from '../../types/config';
+import type { BacklinksOptions, BacklinksResult, BacklinkSource, ContentVariant, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, VariantsOptions } from '../../types/query';
+import { type ContentQueryContext } from '../query/unified';
+export declare const createServerContentQueryContext: (event: H3Event) => Promise<ContentQueryContext>;
+export declare function resolveOne<const H extends ContentCollectionHandle | string, O extends ResolveOneOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options: O): Promise<ResolveOneResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+export declare function one<const H extends ContentCollectionHandle | string, O extends OneOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options: O): Promise<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>> | null>;
+export declare function many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options?: O): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
+export declare function paginate<const H extends ContentCollectionHandle | string, O extends PaginationOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, options: O): Promise<PaginationResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+export declare function backlinks<const Target extends ContentCollectionHandle | string, const Source extends BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined>(event: H3Event, handle: Target, options: BacklinksOptions<Target, Source, P>): Promise<BacklinksResult<Source, P>>;
+export declare function variants<H extends ContentCollectionHandle | string>(event: H3Event, handle: H, options: VariantsOptions<H>): Promise<Array<ContentVariant<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>>;
+export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(event: H3Event, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+    fields?: Fields;
+}): Promise<ContentTreeItem<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent, Fields>[]>;
+export declare function neighbors<H extends ContentCollectionHandle | string>(event: H3Event, handle: H, options: NeighborsOptions<H>): Promise<NeighborsResult<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>;