@lupinum/ginko-content 0.1.0

package/dist/core/query/execute.js

@@ -0,0 +1,304 @@
+import { resolveGraphCanonicalKey, resolveGraphRouteVariant, resolveGraphVariant, resolveLocaleChain, selectGraphDocuments } from "../content/graph.js";
+import { apply, ensureArray, get, omit, sortList, withKeys, withoutKeys } from "./operators.js";
+import { normalizeRouteMounts, routeToContentPathCandidates } from "../content/path.js";
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const includesEntry = (haystack, entry) => typeof haystack === "string" ? haystack.includes(String(entry)) : haystack.includes(entry);
+const compareOperators = {
+  eq: (item, value) => value instanceof RegExp ? value.test(String(item)) : item === value,
+  ne: (item, value) => value instanceof RegExp ? !value.test(String(item)) : item !== value,
+  gt: (item, value) => item > value,
+  gte: (item, value) => item >= value,
+  lt: (item, value) => item < value,
+  lte: (item, value) => item <= value,
+  in: (item, value) => ensureArray(value).some((entry) => Array.isArray(item) ? item.includes(entry) : compareOperators.eq(item, entry)),
+  contains: (item, value) => {
+    const haystack = Array.isArray(item) ? item : String(item);
+    return ensureArray(value).every((entry) => includesEntry(haystack, entry));
+  },
+  containsAny: (item, value) => {
+    const haystack = Array.isArray(item) ? item : String(item);
+    return ensureArray(value).some((entry) => includesEntry(haystack, entry));
+  },
+  icontains: (item, value) => {
+    if (typeof value !== "string") {
+      throw new TypeError("$icontains requires a string condition");
+    }
+    return String(item).toLocaleLowerCase().includes(value.toLocaleLowerCase());
+  },
+  exists: (item, value) => value ? typeof item !== "undefined" : typeof item === "undefined",
+  type: (item, value) => typeof item === String(value),
+  prefix: (item, value) => String(item || "").startsWith(String(value)),
+  regex: (item, value) => {
+    if (value instanceof RegExp) {
+      return value.test(String(item || ""));
+    }
+    const matched = String(value).match(/\/(.*)\/([dgimsuy]*)$/);
+    const regex = matched?.[1] ? new RegExp(matched[1], matched[2] || "") : new RegExp(String(value));
+    return regex.test(String(item || ""));
+  }
+};
+export const evaluateQueryPlanFilter = (item, filter) => {
+  switch (filter.type) {
+    case "true":
+      return true;
+    case "compare":
+      return compareOperators[filter.operator](get(item, filter.field), filter.value);
+    case "and":
+      return filter.clauses.every((clause) => evaluateQueryPlanFilter(item, clause));
+    case "or":
+      return filter.clauses.some((clause) => evaluateQueryPlanFilter(item, clause));
+    case "not":
+      return !evaluateQueryPlanFilter(item, filter.clause);
+  }
+};
+const collectFieldComparisons = (filter, field) => {
+  switch (filter.type) {
+    case "true":
+      return [];
+    case "compare":
+      if (filter.field !== field) {
+        return [];
+      }
+      if (filter.operator === "eq" && typeof filter.value === "string") {
+        return [filter.value];
+      }
+      if (filter.operator === "regex" && filter.value instanceof RegExp) {
+        return [filter.value];
+      }
+      if (filter.operator === "regex" && typeof filter.value === "string") {
+        return [new RegExp(filter.value)];
+      }
+      if (filter.operator === "prefix" && typeof filter.value === "string") {
+        return [new RegExp(`^${escapeRegExp(filter.value)}`)];
+      }
+      return [];
+    case "and":
+      return filter.clauses.flatMap((clause) => collectFieldComparisons(clause, field));
+    case "or":
+    case "not":
+      return [];
+  }
+};
+const applyQueryPlanSort = (matched, plan) => {
+  for (const clause of [...plan.sort].reverse()) {
+    sortList(matched, {
+      [clause.field]: clause.direction,
+      ...clause.locale ? { $locale: clause.locale } : {},
+      ...typeof clause.numeric === "boolean" ? { $numeric: clause.numeric } : {},
+      ...clause.caseFirst ? { $caseFirst: clause.caseFirst } : {},
+      ...clause.sensitivity ? { $sensitivity: clause.sensitivity } : {}
+    });
+  }
+};
+export const applyQueryPlanProjection = (items, plan) => {
+  return apply(withKeys(plan.projection.only))(apply(withoutKeys(plan.projection.without))(items));
+};
+export const finalizeQueryPlanResponse = (matched, plan) => {
+  if (plan.mode === "count") {
+    return {
+      result: matched.length
+    };
+  }
+  const skipped = plan.skip ? matched.slice(plan.skip) : matched;
+  const limited = typeof plan.limit === "number" ? skipped.slice(0, plan.limit) : skipped;
+  const projected = applyQueryPlanProjection(limited, plan);
+  if (plan.mode === "first") {
+    return {
+      ...omit(["skip", "limit", "total"])({
+        result: projected,
+        skip: plan.skip,
+        limit: plan.limit || 0,
+        total: matched.length
+      }),
+      result: projected[0]
+    };
+  }
+  return {
+    result: projected,
+    skip: plan.skip,
+    limit: plan.limit || 0,
+    total: matched.length
+  };
+};
+const findDirConfig = (graph, path, locale) => {
+  if (!path) {
+    return null;
+  }
+  const byLocale = graph.byNavigationPath[path];
+  if (!byLocale) {
+    return null;
+  }
+  if (locale && byLocale[locale]) {
+    return byLocale[locale];
+  }
+  return Object.values(byLocale)[0] || null;
+};
+const withDirConfig = (content, dirConfig) => {
+  if (!content || !dirConfig) {
+    return content;
+  }
+  return {
+    ...content,
+    _dir: {
+      ...dirConfig,
+      ...dirConfig.body
+    }
+  };
+};
+export const executeQueryPlanOnDocuments = (documents, plan) => {
+  const matched = documents.filter((item) => !plan.collection || item?._collection === plan.collection).filter((item) => evaluateQueryPlanFilter(item, plan.filter)).map((item) => ({ ...item }));
+  applyQueryPlanSort(matched, plan);
+  return finalizeQueryPlanResponse(matched, plan);
+};
+const executeStandardPlan = (graph, plan) => {
+  const candidates = selectGraphDocuments(graph, {
+    collection: plan.collection,
+    paths: collectFieldComparisons(plan.filter, "_path")
+  });
+  const matched = candidates.filter((item) => evaluateQueryPlanFilter(item, plan.filter)).map((item) => ({ ...item }));
+  applyQueryPlanSort(matched, plan);
+  return finalizeQueryPlanResponse(matched, plan);
+};
+const executeLocalePlan = (graph, plan, options) => {
+  const requestedLocale = plan.resolveLocale?.locale;
+  const candidates = selectGraphDocuments(graph, {
+    collection: plan.collection,
+    paths: collectFieldComparisons(plan.filter, "_path")
+  });
+  const localeChain = resolveLocaleChain(
+    requestedLocale,
+    options.defaultLocale,
+    requestedLocale ? { [requestedLocale]: plan.resolveLocale?.fallback || options.localeFallback?.[requestedLocale] || [] } : {}
+  );
+  const localeRank = new Map(localeChain.map((locale, index) => [locale, index]));
+  const merged = [];
+  const indexByCanonical = /* @__PURE__ */ new Map();
+  for (const item of candidates.filter((item2) => evaluateQueryPlanFilter(item2, plan.filter))) {
+    if (plan.resolveLocale?.exact && item._locale !== requestedLocale) {
+      continue;
+    }
+    const key = item._canonicalKey || item.id || item._id || item._path;
+    const rank = localeRank.get(item._locale || "") ?? Number.MAX_SAFE_INTEGER;
+    const availableLocales = item._canonicalKey ? Object.keys(graph.byCanonical[item._canonicalKey] || {}) : [item._locale].filter(Boolean);
+    const enriched = {
+      ...item,
+      _requestedLocale: requestedLocale,
+      _resolvedLocale: item._locale,
+      _fallback: item._locale !== requestedLocale,
+      _availableLocales: availableLocales
+    };
+    if (!indexByCanonical.has(key)) {
+      indexByCanonical.set(key, merged.length);
+      merged.push({ rank, item: enriched });
+      continue;
+    }
+    const index = indexByCanonical.get(key);
+    if (rank < merged[index].rank) {
+      merged[index] = { rank, item: enriched };
+    }
+  }
+  const matched = merged.map((entry) => entry.item);
+  applyQueryPlanSort(matched, plan);
+  return finalizeQueryPlanResponse(matched, plan);
+};
+const executeVariantPlan = (graph, plan, options) => {
+  if (!plan.resolveVariant) {
+    return { result: void 0 };
+  }
+  const collectionConfig = plan.collection ? options.collections?.[plan.collection] : void 0;
+  const collectionI18n = collectionConfig?.i18n && typeof collectionConfig.i18n === "object" ? collectionConfig.i18n : void 0;
+  const defaultLocale = collectionI18n?.defaultLocale || options.defaultLocale;
+  const localeFallback = options.localeFallback;
+  const routeMounts = normalizeRouteMounts(collectionConfig?.route, collectionI18n?.locales || [], defaultLocale);
+  const variant = plan.resolveVariant.ref ? (() => {
+    const canonicalKey = resolveGraphCanonicalKey(graph, plan.resolveVariant.ref, plan.collection);
+    if (!canonicalKey) return null;
+    return resolveGraphVariant(graph, canonicalKey, plan.resolveVariant.locale, {
+      defaultLocale,
+      fallback: plan.resolveVariant.fallback,
+      exact: plan.resolveVariant.exact,
+      localeFallback,
+      collection: plan.collection
+    });
+  })() : plan.resolveVariant.route ? (() => {
+    const localeChain = plan.resolveVariant.exact ? plan.resolveVariant.locale ? [plan.resolveVariant.locale] : [] : plan.resolveVariant.fallback?.length ? Array.from(new Set([plan.resolveVariant.locale, ...plan.resolveVariant.fallback].filter(Boolean))) : resolveLocaleChain(plan.resolveVariant.locale, defaultLocale, localeFallback || {});
+    const candidateLocales = localeChain.length ? localeChain : [""];
+    const candidates = routeToContentPathCandidates(
+      plan.resolveVariant.route,
+      plan.resolveVariant.locale,
+      candidateLocales,
+      defaultLocale,
+      routeMounts
+    );
+    for (const candidate of candidates) {
+      const canonicalKey = graph.byRoute[`${candidate.locale}:${candidate.path}`];
+      if (!canonicalKey) {
+        continue;
+      }
+      const resolved = resolveGraphVariant(graph, canonicalKey, plan.resolveVariant.locale, {
+        defaultLocale,
+        fallback: plan.resolveVariant.fallback,
+        exact: plan.resolveVariant.exact,
+        localeFallback,
+        collection: plan.collection
+      });
+      if (resolved) return resolved;
+    }
+    return null;
+  })() : resolveGraphRouteVariant(
+    graph,
+    plan.resolveVariant.path,
+    plan.resolveVariant.locale,
+    {
+      defaultLocale,
+      fallback: plan.resolveVariant.fallback,
+      exact: plan.resolveVariant.exact,
+      localeFallback,
+      collection: plan.collection
+    }
+  );
+  if (!variant) {
+    return { result: void 0 };
+  }
+  const content = graph.byId[variant.contentId];
+  if (plan.collection && content?._collection !== plan.collection) {
+    return { result: void 0 };
+  }
+  const dirConfig = findDirConfig(graph, content?._path, variant.resolvedLocale);
+  const variantPaths = Object.fromEntries(
+    Object.entries(graph.byCanonical[variant.canonicalKey] || {}).map(([locale, entry]) => [locale, entry.path])
+  );
+  const enriched = {
+    ...withDirConfig(content, dirConfig),
+    ...plan.resolveVariant.path ? { _requestedPath: plan.resolveVariant.path } : {},
+    ...plan.resolveVariant.route ? { _requestedRoute: plan.resolveVariant.route } : {},
+    ...plan.resolveVariant.ref ? { _requestedRef: plan.resolveVariant.ref } : {},
+    _requestedLocale: variant.requestedLocale,
+    _resolvedLocale: variant.resolvedLocale,
+    _fallback: variant.fallback,
+    _availableLocales: variant.availableLocales,
+    _variantPaths: variantPaths
+  };
+  const matched = evaluateQueryPlanFilter(enriched, plan.filter) ? [enriched] : [];
+  return finalizeQueryPlanResponse(matched, plan);
+};
+export const executeQueryPlan = (graph, plan, options = {}) => {
+  if (plan.resolveVariant) {
+    return executeVariantPlan(graph, plan, options);
+  }
+  if (plan.resolveLocale?.locale) {
+    return executeLocalePlan(graph, plan, options);
+  }
+  return executeStandardPlan(graph, plan);
+};
+export const resolveQueryPlanVariant = (graph, plan, options = {}) => {
+  if (plan.resolveVariant) {
+    return resolveGraphRouteVariant(graph, plan.resolveVariant.path || plan.resolveVariant.route || "", plan.resolveVariant.locale, {
+      defaultLocale: options.defaultLocale,
+      fallback: plan.resolveVariant.fallback,
+      exact: plan.resolveVariant.exact,
+      localeFallback: options.localeFallback
+    });
+  }
+  return null;
+};

package/dist/core/query/filter

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

package/dist/core/query/filter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Query compiler for the unified query API (ADR-0016).
+ *
+ * `by` selects one document through the graph resolver. `where` filters a
+ * result set. Keeping those paths separate is the public contract.
+ *
+ * Operator names are deliberately close to the internal
+ * `ContentQueryBuilderWhere` shape. Public `$prefix` is kept as `$prefix`
+ * through the transport instead of being exposed as caller-provided regex.
+ */
+import type { ContentSelector, ContentQueryBuilderParams, ContentQueryBuilderWhere, ContentQuerySortFields, LocaleFallback, QueryWhere, SortSpec } from '../../types/query';
+/**
+ * Compile a public `where` object to the internal `where` clause shape.
+ */
+export declare const compileWhere: (where: QueryWhere | undefined) => ContentQueryBuilderWhere | undefined;
+/**
+ * Convert `SortSpec` (e.g. `{ date: -1, title: 1 }`) into the array form the
+ * transport expects.
+ */
+export declare const compileSort: (sort: SortSpec | undefined) => ContentQuerySortFields[] | undefined;
+/**
+ * Normalize `fallback` (string / array / boolean) into the transport shape.
+ * Boolean `true` means "use configured fallbacks"; an explicit string or array
+ * overrides the chain for this query.
+ */
+export declare const compileFallback: (fallback: LocaleFallback | undefined) => boolean | string[] | undefined;
+/**
+ * Top-level compile: build the params payload sent to the transport. This is
+ * the shared pipeline used by every Layer-1 verb.
+ */
+export declare const compileQueryParams: (input: {
+    collection: string;
+    by?: ContentSelector;
+    where?: QueryWhere;
+    sort?: SortSpec;
+    limit?: number;
+    skip?: number;
+    select?: ReadonlyArray<string | number | symbol>;
+    locale?: string;
+    fallback?: LocaleFallback;
+    exact?: boolean;
+}) => ContentQueryBuilderParams;

package/dist/core/query/filter.js

@@ -0,0 +1,118 @@
+import { assertSupportedQueryOperators, SUPPORTED_QUERY_OPERATORS } from "./operators.js";
+import { normalizeContentPath } from "../content/path.js";
+const FIELD_OPERATOR_KEYS = /* @__PURE__ */ new Set([...SUPPORTED_QUERY_OPERATORS, "$nin"]);
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof RegExp) && !(value instanceof Date);
+const isOperatorObject = (value) => {
+  if (!isPlainObject(value)) return false;
+  for (const key of Object.keys(value)) {
+    if (key.startsWith("$") && FIELD_OPERATOR_KEYS.has(key)) return true;
+  }
+  return false;
+};
+const compileFieldOperand = (operand) => {
+  if (operand === void 0) {
+    return void 0;
+  }
+  if (!isPlainObject(operand)) {
+    return operand;
+  }
+  if (isOperatorObject(operand)) {
+    const out = {};
+    for (const [op, value] of Object.entries(operand)) {
+      if (op === "$nin") {
+        out.$not = { $in: value };
+      } else {
+        out[op] = value;
+      }
+    }
+    return out;
+  }
+  return compileWhere(operand);
+};
+export const compileWhere = (where) => {
+  if (!where) return void 0;
+  assertSupportedQueryOperators(where, ["$nin", "$prefix"]);
+  const out = {};
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    if (key === "$and" || key === "$or") {
+      const arr = Array.isArray(value) ? value : [];
+      const compiled = arr.map((part) => compileWhere(part)).filter((part) => Boolean(part && Object.keys(part).length > 0));
+      if (compiled.length) {
+        out[key] = compiled;
+      }
+      continue;
+    }
+    if (key === "$not") {
+      const compiled = compileWhere(value);
+      if (compiled && Object.keys(compiled).length > 0) {
+        out.$not = compiled;
+      }
+      continue;
+    }
+    const targetKey = key === "path" ? "_path" : key;
+    const operand = compileFieldOperand(value);
+    if (operand !== void 0) {
+      ;
+      out[targetKey] = operand;
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
+};
+export const compileSort = (sort) => {
+  if (!sort) return void 0;
+  const fields = Object.entries(sort).map(([field, value]) => {
+    const direction = value === "asc" ? 1 : value === "desc" ? -1 : value;
+    return [field, direction];
+  }).filter(([, v]) => v === 1 || v === -1);
+  if (!fields.length) return void 0;
+  return fields.map(([field, direction]) => ({ [field]: direction }));
+};
+export const compileFallback = (fallback) => {
+  if (fallback === void 0) return void 0;
+  if (typeof fallback === "boolean") return fallback;
+  if (fallback === "default") return ["default"];
+  return Array.isArray(fallback) ? fallback : [fallback];
+};
+export const compileQueryParams = (input) => {
+  const path = input.by && "path" in input.by ? normalizeContentPath(input.by.path) : void 0;
+  const route = input.by && "route" in input.by ? normalizeContentPath(input.by.route) : void 0;
+  const ref = input.by && "ref" in input.by ? input.by.ref : void 0;
+  const where = compileWhere(input.where);
+  const sort = compileSort(input.sort);
+  const fallback = compileFallback(input.fallback);
+  const select = input.select ? input.select.map(String) : void 0;
+  const params = {
+    collection: input.collection,
+    ...where ? { where: [where] } : {},
+    ...sort ? { sort } : {},
+    ...typeof input.limit === "number" ? { limit: input.limit } : {},
+    ...typeof input.skip === "number" ? { skip: input.skip } : {},
+    ...select ? { only: select } : {}
+  };
+  if (input.locale || path || route || ref || fallback !== void 0) {
+    const exact = input.exact ?? (input.locale ? fallback === void 0 || fallback === false : false);
+    params.resolveLocale = {
+      ...input.locale ? { locale: input.locale } : {},
+      ...fallback !== void 0 ? { fallback } : {},
+      ...exact ? { exact: true } : {}
+    };
+  }
+  const useVariantResolver = route || ref || path && (input.locale !== void 0 || fallback !== void 0);
+  if (useVariantResolver) {
+    ;
+    params.resolveVariant = {
+      ...path ? { path } : {},
+      ...route ? { route } : {},
+      ...ref ? { ref } : {},
+      ...input.locale ? { locale: input.locale } : {},
+      ...fallback !== void 0 ? { fallback } : {},
+      ...params.resolveLocale?.exact ? { exact: true } : {}
+    };
+  } else if (path) {
+    const pathClause = { _path: path };
+    const existing = Array.isArray(params.where) ? params.where : params.where ? [params.where] : [];
+    params.where = [...existing, pathClause];
+  }
+  return params;
+};

package/dist/core/query/json

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

package/dist/core/query/json.d.ts

@@ -0,0 +1,2 @@
+export declare function jsonStringify(value: unknown): string;
+export declare function jsonParse(value: string): any;

package/dist/core/query/json.js

@@ -0,0 +1,20 @@
+export function jsonStringify(value) {
+  return JSON.stringify(value, regExpReplacer);
+}
+export function jsonParse(value) {
+  return JSON.parse(value, regExpReviver);
+}
+function regExpReplacer(_key, value) {
+  if (value instanceof RegExp) {
+    return `--REGEX ${value.toString()}`;
+  }
+  return value;
+}
+function regExpReviver(_key, value) {
+  const withOperator = typeof value === "string" && value.match(/^--([A-Z]+) (.+)$/) || [];
+  if (withOperator[1] === "REGEX") {
+    const regex = withOperator[2]?.match(/\/(.*)\/([dgimsuy]*)$/);
+    return regex?.[1] ? new RegExp(regex[1], regex[2] || "") : value;
+  }
+  return value;
+}

package/dist/core/query/lower

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

package/dist/core/query/lower.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lower `ContentQueryBuilderParams` (the public builder's serialized form)
+ * into a `ContentQueryPlan` (the executor's AST — see `./plan.ts`).
+ *
+ * Lowering is the single place we translate user-level shapes (`$eq`,
+ * `$and`, sibling-key-as-`$and`) into the normalized tree the executor
+ * expects. Downstream code only touches the plan.
+ *
+ * The translation is purely syntactic — no graph access, no I/O. It runs
+ * once per `.all()`/`.first()`/`.count()` call.
+ */
+import type { ContentQueryBuilderParams } from '../../types/query';
+import type { ContentQueryPlan } from './plan';
+export declare const lowerQueryPlan: (params: ContentQueryBuilderParams) => ContentQueryPlan;

package/dist/core/query/lower.js

@@ -0,0 +1,121 @@
+import { assertSupportedQueryOperators, SUPPORTED_QUERY_OPERATORS } from "./operators.js";
+const ensureQueryWhereArray = (where) => {
+  return Array.isArray(where) ? [...where] : where ? [where] : [];
+};
+const COMPARISON_OPERATORS = new Set(SUPPORTED_QUERY_OPERATORS);
+const collapse = (type, clauses) => {
+  const filtered = clauses.filter((clause) => clause.type !== "true");
+  if (!filtered.length) {
+    return { type: "true" };
+  }
+  if (filtered.length === 1) {
+    return filtered[0];
+  }
+  return { type, clauses: filtered };
+};
+const lowerFieldCondition = (field, value) => {
+  if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof RegExp)) {
+    const objectValue = value;
+    if ("$options" in objectValue && !("$regex" in objectValue)) {
+      throw new TypeError("Query operator $options requires $regex.");
+    }
+    const clauses = [];
+    for (const [key, nestedValue] of Object.entries(objectValue)) {
+      if (key === "$options") {
+        continue;
+      }
+      if (COMPARISON_OPERATORS.has(key)) {
+        if (key === "$not") {
+          clauses.push({
+            type: "not",
+            clause: lowerFieldCondition(field, nestedValue)
+          });
+          continue;
+        }
+        clauses.push({
+          type: "compare",
+          field,
+          // `key` is gated by the `COMPARISON_OPERATORS` set above; after
+          // stripping the leading `$` it maps 1:1 to a `CompareOperator`.
+          operator: key.slice(1),
+          value: key === "$regex" && typeof objectValue.$options === "string" && !(nestedValue instanceof RegExp) ? new RegExp(String(nestedValue), objectValue.$options) : nestedValue
+        });
+        continue;
+      }
+      clauses.push(lowerFieldCondition(`${field}.${key}`, nestedValue));
+    }
+    return collapse("and", clauses);
+  }
+  return {
+    type: "compare",
+    field,
+    operator: "eq",
+    value
+  };
+};
+const lowerWhereCondition = (condition) => {
+  const clauses = [];
+  for (const [key, value] of Object.entries(condition)) {
+    if (key === "$and") {
+      clauses.push(collapse("and", ensureQueryWhereArray(value).map(lowerWhereCondition)));
+      continue;
+    }
+    if (key === "$or") {
+      clauses.push(collapse("or", ensureQueryWhereArray(value).map(lowerWhereCondition)));
+      continue;
+    }
+    if (key === "$not" && value && typeof value === "object" && !Array.isArray(value) && !(value instanceof RegExp)) {
+      clauses.push({
+        type: "not",
+        clause: lowerWhereCondition(value)
+      });
+      continue;
+    }
+    clauses.push(lowerFieldCondition(key, value));
+  }
+  return collapse("and", clauses);
+};
+const lowerSort = (sort = []) => {
+  return sort.flatMap((option) => {
+    const meta = {
+      locale: option.$locale,
+      numeric: option.$numeric,
+      caseFirst: option.$caseFirst,
+      sensitivity: option.$sensitivity
+    };
+    return Object.entries(option).filter(([key]) => !key.startsWith("$")).map(([field, direction]) => ({
+      field,
+      direction,
+      ...meta
+    }));
+  });
+};
+export const lowerQueryPlan = (params) => {
+  assertSupportedQueryOperators(params.where);
+  const resolveVariant = params.resolveVariant;
+  return {
+    collection: params.collection,
+    filter: collapse("and", ensureQueryWhereArray(params.where).map(lowerWhereCondition)),
+    sort: lowerSort(params.sort),
+    projection: {
+      only: params.only ? [...params.only] : [],
+      without: params.without ? [...params.without] : []
+    },
+    skip: params.skip || 0,
+    limit: params.limit,
+    mode: params.count ? "count" : params.first ? "first" : "all",
+    resolveLocale: params.resolveLocale ? {
+      locale: params.resolveLocale.locale,
+      fallback: Array.isArray(params.resolveLocale.fallback) ? [...params.resolveLocale.fallback] : [],
+      exact: params.resolveLocale.exact
+    } : void 0,
+    resolveVariant: resolveVariant ? {
+      ...resolveVariant.path ? { path: resolveVariant.path } : {},
+      ...resolveVariant.route ? { route: resolveVariant.route } : {},
+      ...resolveVariant.ref ? { ref: resolveVariant.ref } : {},
+      locale: resolveVariant.locale,
+      fallback: Array.isArray(resolveVariant.fallback) ? [...resolveVariant.fallback] : [],
+      exact: resolveVariant.exact
+    } : void 0
+  };
+};

package/dist/core/query/operators

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

package/dist/core/query/operators.d.ts

@@ -0,0 +1,23 @@
+import type { ContentQuerySortOptions } from '../../types/query';
+export declare const get: (obj: Record<string, unknown> | undefined, path: string) => unknown;
+export declare const omit: (keys?: string[]) => <T extends Record<string, unknown>>(obj: T) => Record<string, unknown>;
+export declare const apply: <TInput, TOutput>(fn: (d: TInput) => TOutput) => (data: TInput | TInput[]) => TOutput | TOutput[];
+export declare const detectProperties: (keys: string[]) => {
+    prefixes: string[];
+    properties: string[];
+};
+export declare const withoutKeys: (keys?: string[]) => <T extends Record<string, unknown>>(obj: T | undefined) => Record<string, unknown> | undefined;
+export declare const withKeys: (keys?: string[]) => <T extends Record<string, unknown>>(obj: T | undefined) => Record<string, unknown> | undefined;
+export declare const sortList: <T extends Record<string, unknown>>(data: T[], params: ContentQuerySortOptions) => T[];
+/**
+ * Raise TypeError if value is not an array.
+ */
+export declare function assertArray(value: unknown, message?: string): asserts value is unknown[];
+/**
+ * Ensure result is an array
+ */
+export declare const ensureArray: <T>(value: T) => T extends Array<unknown> ? T : T[];
+export declare const SUPPORTED_QUERY_OPERATORS: readonly ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$contains", "$containsAny", "$icontains", "$exists", "$type", "$regex", "$prefix", "$options", "$not"];
+export declare const containsStandaloneRegexOptions: (value: unknown) => boolean;
+export declare const findUnsupportedQueryOperator: (value: unknown, extraOperators?: readonly string[]) => string | undefined;
+export declare const assertSupportedQueryOperators: (value: unknown, extraOperators?: readonly string[]) => void;