@lupinum/ginko-content 0.1.6 → 0.2.0

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

@@ -1,10 +1,35 @@
 import { joinURL, withLeadingSlash } from "ufo";
 import { createQuery, wrapQueryBuilder } from "../../core/query/builder";
 import { normalizeContentQueryParams } from "../../core/query/params";
+import { containsStandaloneRegexOptions, findUnsupportedQueryOperator } from "../../core/query/operators";
 import { normalizeI18nConfig, resolveRuntimeCollectionI18nConfig } from "../../features/localization/config";
+import { sortLocalesCanonically } from "../../core/content/locale";
 import { normalizeReferenceValue } from "../../core/references/resolve";
 import { getContentRuntimeConfig } from "./runtime-config.js";
 import { createContentProviderError } from "../../public/provider-errors";
+import { toContentProviderQuery } from "../../public/provider-query";
+export { toContentProviderNavigationQuery as createProviderNavigationQuery } from "../../public/provider-query";
+export const createProviderQuery = (params) => {
+  const unsupported = findUnsupportedQueryOperator(params.where);
+  if (unsupported) {
+    throw createContentProviderError("unsupported_query_operator", `Unsupported query operator: ${unsupported}`, {
+      operator: unsupported
+    });
+  }
+  if (containsStandaloneRegexOptions(params.where)) {
+    throw createContentProviderError("unsupported_query_shape", "Query operator $options requires $regex.", {
+      operator: "$options"
+    });
+  }
+  const config = getContentRuntimeConfig().content || {};
+  const normalized = normalizeContentQueryParams(params, {
+    collectionI18n: params.collection ? config.collections?.[params.collection]?.i18n : void 0,
+    defaultLocale: config.defaultLocale,
+    localeFallback: config.localeFallback,
+    includeDraftFilter: false
+  });
+  return toContentProviderQuery(normalized);
+};
 const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isProviderFindResponse = (response) => isObject(response) && Array.isArray(response.result) && typeof response.skip === "number" && typeof response.limit === "number" && typeof response.total === "number";
 export const normalizeProviderQueryResult = (response) => {
@@ -55,7 +80,7 @@ const identityMatchesDocument = (document, identity) => {
   if (!normalizedIdentity) {
     return false;
   }
-  return [document._canonicalKey, document._path, document.ref].filter((value) => typeof value === "string").some((value) => normalizeReferenceValue(value) === normalizedIdentity);
+  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) {
@@ -77,38 +102,43 @@ export const resolveProviderContentVariants = async (event, identity, options) =
   const provider = await getContentProvider(event);
   const baseQuery = {
     collection: options.collection,
-    only: ["_path", "_canonicalKey", "_locale", "ref", "title", "description", "body"]
+    only: ["path", "canonicalKey", "locale", "ref", "title", "description", "body"]
   };
   const documents = localesToQuery.length ? (await Promise.all(
-    localesToQuery.map(
-      async (locale) => normalizeProviderQueryResult(
-        normalizeProviderQueryResponse({
-          ...baseQuery,
-          resolveLocale: { locale, exact: true }
-        }, await provider.query(event, {
-          ...baseQuery,
-          resolveLocale: { locale, exact: true }
-        }), provider.name)
-      )
-    )
-  )).flat() : normalizeProviderQueryResult(normalizeProviderQueryResponse(baseQuery, await provider.query(event, baseQuery), provider.name));
+    localesToQuery.map(async (locale) => {
+      const localeQuery = { ...baseQuery, resolveLocale: { locale, exact: true } };
+      return normalizeProviderQueryResult(
+        normalizeProviderQueryResponse(
+          localeQuery,
+          await provider.query(event, createProviderQuery(localeQuery)),
+          provider.name
+        )
+      );
+    })
+  )).flat() : normalizeProviderQueryResult(normalizeProviderQueryResponse(baseQuery, await provider.query(event, createProviderQuery(baseQuery)), provider.name));
   const matched = documents.find((document) => identityMatchesDocument(document, normalizedReference));
-  const canonicalKey = matched?._canonicalKey;
+  const canonicalKey = matched?.canonicalKey;
   if (!canonicalKey) {
     return null;
   }
-  const variants = documents.filter((document) => document._canonicalKey === canonicalKey);
+  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 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 availableLocales = sortLocalesCanonically(
+    Array.from(new Set(variants.map((document) => document.locale).filter(Boolean))),
+    {
+      defaultLocale: collectionI18n?.defaultLocale || runtimeContent.defaultLocale,
+      locales: collectionI18n?.locales
+    }
+  );
   const variantPaths = Object.fromEntries(
-    variants.filter((document) => document._locale && document._path).map((document) => [document._locale, document._path])
+    variants.filter((document) => document.locale && document.path).map((document) => [document.locale, document.path])
   );
   return {
     canonicalKey,
@@ -117,16 +147,17 @@ export const resolveProviderContentVariants = async (event, identity, options) =
     availableLocales,
     variantPaths,
     requestedLocale: options.locale,
-    resolvedLocale: selected._locale,
-    fallback: Boolean(options.locale && selected._locale && selected._locale !== 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");
     const provider = await getContentProvider(event);
-    const response = await provider.query(event, query.params());
-    return normalizeProviderQueryResponse(query.params(), response, provider.name);
+    const params = query.params();
+    const response = await provider.query(event, createProviderQuery(params));
+    return normalizeProviderQueryResponse(params, response, provider.name);
   };
 };
 const getServerCollectionI18n = (collection) => {
@@ -164,10 +195,13 @@ export const resolveContentReference = async (event, reference, options = {}) =>
   }
   return {
     ...resolved.selected,
-    _requestedLocale: resolved.requestedLocale,
-    _resolvedLocale: resolved.resolvedLocale,
-    _fallback: resolved.fallback,
-    _availableLocales: resolved.availableLocales,
-    _variantPaths: resolved.variantPaths
+    resolved: {
+      ...resolved.selected.resolved || {},
+      requestedLocale: resolved.requestedLocale,
+      locale: resolved.resolvedLocale,
+      fallback: resolved.fallback,
+      availableLocales: resolved.availableLocales,
+      variantPaths: resolved.variantPaths
+    }
   };
 };

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

@@ -1,15 +1,15 @@
 import type { H3Event } from 'h3';
 import type { ContentQueryResponse } from '../../types/api';
 import type { NavItem, ParsedContent } from '../../types/content';
-import type { ContentCollectionItemSurroundingsOptions, ContentCollectionNavigationOptions, ContentCollectionPageOptions, ContentCollectionRouteMetaOptions, ContentCollectionSearchSectionsOptions, ContentPageResult, ContentQueryBuilderParams, ContentRouteMeta, ContentSearchSection, ContentSitemapEntry } from '../../types/query';
+import type { ContentCollectionItemSurroundingsOptions, ContentCollectionNavigationOptions, ContentCollectionPageOptions, ContentCollectionRouteMetaOptions, ContentCollectionSearchSectionsOptions, ContentPageResult, ContentRouteMeta, ContentSearchSection, ContentSitemapEntry } from '../../types/query';
 import type { QueryCollectionsSitemapEntriesOptions } from '../../features/sitemap/query';
-import type { ContentProvider, ContentProviderResult, ContentProviderSiteDataRequest, ContentProviderSiteDataResponse, MaybeContentProviderResult } from '../../public/provider';
+import type { ContentProvider, ContentProviderNavigationOptions, ContentProviderQuery, ContentProviderResult, ContentProviderSiteDataRequest, ContentProviderSiteDataResponse, MaybeContentProviderResult } from '../../public/provider';
 import type { ContentProviderSearchRequest, ContentSearchResult } from '../../types/search';
 export declare const isContentProviderResult: <T = unknown>(value: unknown) => value is ContentProviderResult<T>;
 export declare const unwrapContentProviderResult: <T>(event: H3Event, result: MaybeContentProviderResult<T>) => T;
 export interface RuntimeContentProvider extends Omit<ContentProvider, 'query' | 'navigationQuery' | 'navigation' | 'surroundings' | 'searchSections' | 'search' | 'siteData' | 'page' | 'routeMeta' | 'sitemapEntries'> {
-    query: <T = ParsedContent>(event: H3Event, query: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;
-    navigationQuery?: (event: H3Event, query: ContentQueryBuilderParams) => Promise<NavItem[]>;
+    query: <T = ParsedContent>(event: H3Event, query: ContentProviderQuery) => Promise<ContentQueryResponse<T>>;
+    navigationQuery?: (event: H3Event, query: ContentProviderQuery, options?: ContentProviderNavigationOptions) => Promise<NavItem[]>;
     navigation?: (event: H3Event, collection: string, options?: string[] | ContentCollectionNavigationOptions) => Promise<NavItem[]>;
     surroundings?: (event: H3Event, collection: string, path: string, options?: ContentCollectionItemSurroundingsOptions) => Promise<Array<NavItem | null>>;
     searchSections?: (event: H3Event, collection: string, options?: ContentCollectionSearchSectionsOptions) => Promise<ContentSearchSection[]>;

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

@@ -1,4 +1,4 @@
-import { containsStandaloneRegexOptions, SUPPORTED_QUERY_OPERATORS } from "../../../core/query/operators";
+import { SUPPORTED_QUERY_OPERATORS } from "../../../core/query/operators";
 import { executeFilesystemContentQuery } from "../query-executor.js";
 import { resolveContentNavigation } from "../navigation-query.js";
 import {
@@ -9,7 +9,6 @@ import {
   queryFilesystemCollectionSearchSections
 } from "../collection-helpers.js";
 import { queryFilesystemCollectionsSitemapEntries } from "../sitemap.js";
-import { createContentProviderError } from "../../../public/provider-errors";
 export const filesystemProvider = {
   name: "filesystem",
   capabilities: {
@@ -32,15 +31,8 @@ export const filesystemProvider = {
       count: true
     }
   },
-  query: (event, query) => {
-    if (containsStandaloneRegexOptions(query.where)) {
-      throw createContentProviderError("unsupported_query_shape", "Query operator $options requires $regex.", {
-        operator: "$options"
-      });
-    }
-    return executeFilesystemContentQuery(event, query);
-  },
-  navigationQuery: (event, query) => resolveContentNavigation(event, query),
+  query: (event, query) => executeFilesystemContentQuery(event, query.plan),
+  navigationQuery: (event, query, options) => resolveContentNavigation(event, query, options),
   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),

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

@@ -1,5 +1,22 @@
 import type { H3Event } from 'h3';
-import type { ContentProvider } from '../../../public/provider';
+import { type ContentProvider, type ContentProviderQuery } from '../../../public/provider';
+import type { FilterExpr } from '../../../core/query/plan';
 import { type RuntimeContentProvider } from '../provider-result';
+/**
+ * Derive the operator vocabulary a plan actually exercises by walking its
+ * `FilterExpr` tree (CS-5 trap 3). Only `compare` nodes carry operators; we
+ * recurse through `and`/`or`/`not` to reach every one. Operators are reported
+ * in the builder's `$`-prefixed vocabulary so they compare directly against
+ * `capabilities.query.operators`.
+ */
+export declare const collectPlanFilterOperators: (filter: FilterExpr, operators?: Set<string>) => Set<string>;
+/**
+ * Dev-mode guard: the provider wire is JSON-pure by contract (CS-5). A stray
+ * `RegExp`/`Date` in `plan.filter` would corrupt any provider that serializes
+ * the query, so we fail fast in dev instead of shipping a silently mangled
+ * wire. No-op in production (the walk is not free).
+ */
+export declare const assertJsonPureProviderQuery: (provider: ContentProvider, query: ContentProviderQuery) => void;
+export declare const enforceProviderCapabilities: (provider: ContentProvider) => ContentProvider;
 export declare function getContentProvider(): Promise<ContentProvider>;
 export declare function getContentProvider(event: H3Event): Promise<RuntimeContentProvider>;

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

@@ -1,5 +1,6 @@
 import { useRuntimeConfig } from "nitropack/runtime";
 import { loadExternalContentProvider } from "#content/virtual/providers";
+import { PROVIDER_QUERY_VERSION } from "../../../public/provider";
 import { createContentProviderError } from "../../../public/provider-errors";
 import { wrapContentProviderCacheResults } from "../provider-result.js";
 const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -24,43 +25,91 @@ const assertProviderField = (providerName, condition, 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;
+export const collectPlanFilterOperators = (filter, operators = /* @__PURE__ */ new Set()) => {
+  switch (filter.type) {
+    case "true":
+      break;
+    case "compare":
+      operators.add(`$${filter.operator}`);
+      break;
+    case "and":
+    case "or":
+      for (const clause of filter.clauses) {
+        collectPlanFilterOperators(clause, operators);
+      }
+      break;
+    case "not":
+      collectPlanFilterOperators(filter.clause, operators);
+      break;
+    default:
+      throw new TypeError(`Unknown query filter node: ${filter.type}`);
+  }
+  return operators;
+};
+const findNonJsonValue = (value, path) => {
+  if (value === null || value === void 0) return void 0;
+  const kind = typeof value;
+  if (kind === "string" || kind === "number" || kind === "boolean") return void 0;
+  if (kind === "function" || kind === "bigint" || kind === "symbol") return path;
   if (Array.isArray(value)) {
-    for (const child of value) {
-      const unsupported = findProviderUnsupportedOperator(child, supportedOperators);
-      if (unsupported) return unsupported;
+    for (let index = 0; index < value.length; index += 1) {
+      const offender = findNonJsonValue(value[index], `${path}[${index}]`);
+      if (offender) return offender;
     }
     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;
+  if (kind === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) return path;
+    for (const [key, child] of Object.entries(value)) {
+      const offender = findNonJsonValue(child, `${path}.${key}`);
+      if (offender) return offender;
+    }
+    return void 0;
+  }
+  return path;
+};
+export const assertJsonPureProviderQuery = (provider, query) => {
+  if (!import.meta.dev) return;
+  const offender = findNonJsonValue(query, "query");
+  if (offender) {
+    throw createContentProviderError("provider_query_not_json_pure", `${provider.name} received a non-JSON-pure query at ${offender}. Provider queries must survive JSON.parse(JSON.stringify(query)).`, {
+      provider: provider.name,
+      field: offender
+    });
   }
 };
 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}`, {
+  if (query.v !== PROVIDER_QUERY_VERSION) {
+    throw createContentProviderError("unsupported_query_shape", `${provider.name} received unsupported provider query version: ${String(query.v)}.`, {
       provider: provider.name,
-      operator: unsupportedOperator
+      field: "v"
     });
   }
-  if (!capabilities.limit && query.limit !== void 0) {
+  const capabilities = provider.capabilities.query;
+  const supported = new Set(capabilities.operators);
+  const usedOperators = collectPlanFilterOperators(query.plan.filter);
+  for (const operator of usedOperators) {
+    if (!supported.has(operator)) {
+      throw createContentProviderError("unsupported_query_operator", `${provider.name} does not support query operator: ${operator}`, {
+        provider: provider.name,
+        operator
+      });
+    }
+  }
+  if (!capabilities.limit && query.plan.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) {
+  if (!capabilities.skip && query.plan.skip > 0) {
     throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support query offsets.`, {
       provider: provider.name,
       field: "skip"
     });
   }
-  if (!capabilities.count && query.count === true) {
+  if (!capabilities.count && query.plan.mode === "count") {
     throw createContentProviderError("unsupported_query_shape", `${provider.name} does not support count queries.`, {
       provider: provider.name,
       field: "count"
@@ -75,15 +124,18 @@ const assertProviderOperationSupported = (provider, supported, operation) => {
     });
   }
 };
-const enforceProviderCapabilities = (provider) => ({
+export const enforceProviderCapabilities = (provider) => ({
   ...provider,
   query: async (event, query) => {
+    assertJsonPureProviderQuery(provider, query);
     assertProviderQuerySupported(provider, query);
     return await provider.query(event, query);
   },
-  navigationQuery: provider.navigationQuery ? async (...args) => {
+  navigationQuery: provider.navigationQuery ? async (event, query, options) => {
     assertProviderOperationSupported(provider, provider.capabilities.navigation, "navigation");
-    return await provider.navigationQuery(...args);
+    assertJsonPureProviderQuery(provider, query);
+    assertProviderQuerySupported(provider, query);
+    return await provider.navigationQuery(event, query, options);
   } : void 0,
   navigation: provider.navigation ? async (...args) => {
     assertProviderOperationSupported(provider, provider.capabilities.navigation, "navigation");

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

@@ -1,12 +1,12 @@
 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';
+import type { BacklinksOptions, BacklinksResult, BacklinkSource, ContentVariant, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, OptionsArg, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, VariantsOptions } from '../../types/query';
+import { type ContentQueryContext } from '../../features/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 many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(event: H3Event, handle: H, ...args: OptionsArg<H, 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 {
@@ -14,9 +14,9 @@ export declare function variants<H extends ContentCollectionHandle | string>(eve
         _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'> & {
+export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(event: H3Event, handle: H, ...args: OptionsArg<H, Omit<TreeOptions<H>, 'fields'> & {
     fields?: Fields;
-}): Promise<ContentTreeItem<H extends {
+}>): Promise<ContentTreeItem<H extends {
     __schema: {
         _output: infer O;
     };

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

@@ -7,11 +7,11 @@ import {
   resolveOne as resolveOneWithContext,
   tree as treeWithContext,
   variants as variantsWithContext
-} from "../query/unified.js";
+} from "../../features/query/unified";
 import { getContentProvider } from "./providers/index.js";
 import { createContentProviderError } from "../../public/provider-errors";
 import { getContentRuntimeConfig } from "./runtime-config.js";
-import { normalizeProviderQueryResponse } from "./provider-query.js";
+import { createProviderNavigationQuery, createProviderQuery, normalizeProviderQueryResponse } from "./provider-query.js";
 export const createServerContentQueryContext = async (event) => {
   const provider = await getContentProvider(event);
   return {
@@ -23,9 +23,10 @@ export const createServerContentQueryContext = async (event) => {
             provider: provider.name
           });
         }
-        return await provider.navigationQuery(event, params);
+        const { query, options } = createProviderNavigationQuery(params);
+        return await provider.navigationQuery(event, query, options);
       }
-      return normalizeProviderQueryResponse(params, await provider.query(event, params), provider.name);
+      return normalizeProviderQueryResponse(params, await provider.query(event, createProviderQuery(params)), provider.name);
     }
   };
 };
@@ -35,7 +36,8 @@ export async function resolveOne(event, handle, options) {
 export async function one(event, handle, options) {
   return await oneWithContext(await createServerContentQueryContext(event), handle, options);
 }
-export async function many(event, handle, options = {}) {
+export async function many(event, handle, ...args) {
+  const options = args[0] ?? {};
   return await manyWithContext(await createServerContentQueryContext(event), handle, options);
 }
 export async function paginate(event, handle, options) {
@@ -47,7 +49,8 @@ export async function backlinks(event, handle, options) {
 export async function variants(event, handle, options) {
   return await variantsWithContext(await createServerContentQueryContext(event), handle, options);
 }
-export async function tree(event, handle, options = {}) {
+export async function tree(event, handle, ...args) {
+  const options = args[0] ?? {};
   return await treeWithContext(await createServerContentQueryContext(event), handle, options);
 }
 export async function neighbors(event, handle, options) {

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

@@ -1,5 +1,5 @@
 import { type H3Event } from 'h3';
 import type { ContentQueryResponse } from '../../types/api';
-import type { ContentQueryBuilderParams } from '../../types/query';
-export declare const executeFilesystemContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;
-export declare const executeContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T>>;
+import type { ContentQueryPlan } from '../../core/query/plan';
+export declare const executeFilesystemContentQuery: <T = unknown>(event: H3Event, inputPlan: ContentQueryPlan) => Promise<ContentQueryResponse<T>>;
+export declare const executeContentQuery: <T = unknown>(event: H3Event, inputPlan: ContentQueryPlan) => Promise<ContentQueryResponse<T>>;

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

@@ -1,34 +1,30 @@
 import { createError } from "h3";
-import { lowerQueryPlan } from "../../core/query/lower";
+import { isPlanRegex } from "../../core/query/plan";
 import { executeQueryPlan } from "../../core/query/execute";
 import { ContentError } from "../../core/errors";
-import { normalizeContentQueryParams } from "../../core/query/params";
-import { compileWhere } from "../../core/query/filter";
-import { containsStandaloneRegexOptions, findUnsupportedQueryOperator } from "../../core/query/operators";
 import { withResolvedRefs, withResolvedRefsList } from "../../storage/references";
 import { getContentGraph } from "../../storage/graph";
 import { getContentRuntimeConfig } from "./runtime-config.js";
 import { isPreview } from "../../integrations/nitro/preview";
-import { createContentProviderError } from "../../public/provider-errors";
-import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "../query/public-limits.js";
-const notFound = (query, description = "Could not find document for the given query.") => {
+import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "../../features/query/public-limits";
+const notFound = (plan, description = "Could not find document for the given query.") => {
   throw createError({
     statusMessage: "Document not found!",
     statusCode: 404,
     data: {
       description,
-      query
+      query: plan
     }
   });
 };
 const statusForContentError = {
   INVALID_REF_VALUE: 422
 };
-const toHttpError = (error, query) => createError({
+const toHttpError = (error, plan) => createError({
   statusCode: statusForContentError[error.code] ?? 500,
   statusMessage: error.code,
   message: error.message,
-  data: { code: error.code, context: error.context, query }
+  data: { code: error.code, context: error.context, query: plan }
 });
 const badQuery = (message) => {
   throw createError({
@@ -37,71 +33,59 @@ const badQuery = (message) => {
     message
   });
 };
-const containsPublicRegex = (value) => {
-  if (value instanceof RegExp) {
-    return true;
+const planFilterContainsRegex = (filter) => {
+  switch (filter.type) {
+    case "true":
+      return false;
+    case "compare":
+      return filter.operator === "regex" || isPlanRegex(filter.value);
+    case "and":
+    case "or":
+      return filter.clauses.some(planFilterContainsRegex);
+    case "not":
+      return planFilterContainsRegex(filter.clause);
+    default:
+      throw new TypeError(`Unknown query filter node: ${filter.type}`);
   }
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return value.some(containsPublicRegex);
-  }
-  const record = value;
-  return Object.entries(record).some(([key, child]) => key === "$regex" || containsPublicRegex(child));
 };
-const normalizePublicQuery = (event, query, config) => {
-  if (!query.collection) {
+const andPlanFilters = (base, ...extra) => {
+  const clauses = [base, ...extra].filter((clause) => clause.type !== "true");
+  if (!clauses.length) return { type: "true" };
+  if (clauses.length === 1) return clauses[0];
+  return { type: "and", clauses };
+};
+const applyFilesystemQueryPolicy = (event, plan) => {
+  if (!plan.collection) {
     badQuery("Public content queries must target a collection.");
   }
-  if (containsPublicRegex(query.where)) {
+  if (planFilterContainsRegex(plan.filter)) {
     badQuery("Public content queries do not accept RegExp filters.");
   }
-  if (containsStandaloneRegexOptions(query.where)) {
-    badQuery("Query operator $options requires $regex.");
-  }
   const enforceProductionVisibility = !import.meta.dev && !isPreview(event);
-  const normalized = normalizeContentQueryParams({
-    ...query,
-    limit: typeof query.limit === "number" ? Math.max(0, Math.min(query.limit, MAX_PUBLIC_QUERY_LIMIT)) : query.limit,
-    skip: typeof query.skip === "number" ? Math.max(0, Math.min(query.skip, MAX_PUBLIC_QUERY_SKIP)) : query.skip
-  }, {
-    collectionI18n: query.collection ? config.collections?.[query.collection]?.i18n : void 0,
-    defaultLocale: config.defaultLocale,
-    localeFallback: config.localeFallback,
-    includeDraftFilter: false
-  });
-  if (enforceProductionVisibility) {
-    const where = Array.isArray(normalized.where) ? normalized.where : normalized.where ? [normalized.where] : [];
-    normalized.where = [
-      ...where,
-      { _draft: { $ne: true } },
-      { _partial: { $ne: true } }
-    ];
-  }
-  const normalizedWhere = Array.isArray(normalized.where) ? normalized.where : normalized.where ? [normalized.where] : [];
-  normalized.where = normalizedWhere.map((condition) => compileWhere(condition)).filter((condition) => Boolean(condition));
-  const unsupported = findUnsupportedQueryOperator(normalized.where);
-  if (unsupported) {
-    throw createContentProviderError("unsupported_query_operator", `Unsupported query operator: ${unsupported}`, {
-      operator: unsupported
-    });
-  }
-  return normalized;
+  const filter = enforceProductionVisibility ? andPlanFilters(
+    plan.filter,
+    { type: "compare", field: "draft", operator: "ne", value: true },
+    { type: "compare", field: "partial", operator: "ne", value: true }
+  ) : plan.filter;
+  return {
+    ...plan,
+    filter,
+    limit: typeof plan.limit === "number" ? Math.max(0, Math.min(plan.limit, MAX_PUBLIC_QUERY_LIMIT)) : plan.limit,
+    skip: Math.max(0, Math.min(plan.skip, MAX_PUBLIC_QUERY_SKIP))
+  };
 };
-export const executeFilesystemContentQuery = async (event, inputQuery) => {
+export const executeFilesystemContentQuery = async (event, inputPlan) => {
   const config = getContentRuntimeConfig().content || {};
-  const query = normalizePublicQuery(event, inputQuery, config);
+  const plan = applyFilesystemQueryPolicy(event, inputPlan);
   let graph;
   try {
     graph = await getContentGraph(event);
   } catch (cause) {
     if (cause instanceof ContentError) {
-      throw toHttpError(cause, query);
+      throw toHttpError(cause, plan);
     }
     throw cause;
   }
-  const plan = lowerQueryPlan(query);
   const response = executeQueryPlan(graph, plan, {
     defaultLocale: config.defaultLocale,
     localeFallback: config.localeFallback,
@@ -114,7 +98,7 @@ export const executeFilesystemContentQuery = async (event, inputQuery) => {
   if (plan.mode === "first") {
     const content = response.result;
     if (!content) {
-      notFound(query, plan.resolveVariant ? "Could not find document for the given route variant." : void 0);
+      notFound(plan, plan.resolveVariant ? "Could not find document for the given route variant." : void 0);
     }
     return {
       result: await withResolvedRefs(event, content, requestedLocale)

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

@@ -3,7 +3,7 @@ import type { ParsedContent } from '../../types/content';
 import type { ContentQueryBuilderWhere } from '../../types/query';
 import type { ContentSearchIndexRecord } from '../../types/search';
 export { searchRecords } from '../shared/search';
-type SearchablePage = Pick<ParsedContent, '_path' | '_locale' | 'title' | 'description' | 'body'> & Record<string, unknown>;
+type SearchablePage = Pick<ParsedContent, 'path' | 'locale' | 'title' | 'description' | 'body'> & Record<string, unknown>;
 type RuntimeSearchConfig = {
     search?: {
         collections?: string[];