@lupinum/ginko-content 0.1.2 → 0.1.4

package/dist/runtime/query/backlinks.js

@@ -0,0 +1,90 @@
+import { normalizeReferenceValue } from "../../core/references/resolve";
+import { collectTopLevelReferenceFields } from "../../core/references/schema";
+import { ensureCollectionName } from "./handles.js";
+const backlinkSources = (value) => Array.isArray(value) ? [...value] : [value];
+const isBacklinkFieldMap = (value) => {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const resolveExplicitBacklinkFields = (fields, sourceName) => {
+  if (Array.isArray(fields)) {
+    return fields.filter((field) => typeof field === "string" && field.length > 0);
+  }
+  if (!isBacklinkFieldMap(fields)) {
+    return [];
+  }
+  const sourceFields = fields?.[sourceName];
+  return Array.isArray(sourceFields) ? sourceFields.filter((field) => typeof field === "string" && field.length > 0) : [];
+};
+const inferBacklinkFields = (source, targetCollection, runtime) => {
+  if (typeof source === "string") {
+    const references = runtime?.collections?.[source]?.references;
+    return [
+      ...references?.[targetCollection] || [],
+      ...references?.["*"] || []
+    ];
+  }
+  return collectTopLevelReferenceFields(source.schema, targetCollection);
+};
+const targetReferenceCandidates = (doc) => {
+  const values = [
+    doc.ref,
+    doc.id,
+    doc._canonicalKey,
+    doc._path,
+    doc._path ? doc.path : void 0,
+    doc._path ? doc.canonicalPath : void 0
+  ].filter((value) => typeof value === "string" && value.length > 0).flatMap((value) => [value, normalizeReferenceValue(value)]).filter(Boolean);
+  return Array.from(new Set(values));
+};
+const backlinkWhere = (fields, candidates) => {
+  const clauses = fields.map((field) => ({
+    [field]: { $in: candidates }
+  }));
+  return clauses.length ? { $or: clauses } : void 0;
+};
+const createMissingBacklinkFieldsError = (sourceCollection, targetCollection) => new Error(
+  `Cannot infer backlink fields from "${sourceCollection}" to "${targetCollection}". Declare fields.relation('${targetCollection}') / fields.relations('${targetCollection}') in ${sourceCollection}.schema, or pass fields explicitly.`
+);
+export async function resolveBacklinks(context, one, many, targetHandle, options) {
+  const targetCollection = ensureCollectionName(targetHandle);
+  const target = await one(context, targetHandle, {
+    by: options.by,
+    ...options.locale ? { locale: options.locale } : {},
+    ...options.fallback !== void 0 ? { fallback: options.fallback } : {}
+  });
+  if (!target) {
+    return [];
+  }
+  const candidates = targetReferenceCandidates(target);
+  if (!candidates.length) {
+    return [];
+  }
+  const sources = backlinkSources(options.from);
+  const results = await Promise.all(sources.map(async (source) => {
+    const sourceName = ensureCollectionName(source);
+    const fields = [
+      .../* @__PURE__ */ new Set([
+        ...resolveExplicitBacklinkFields(options.fields, sourceName),
+        ...inferBacklinkFields(source, targetCollection, context.runtime)
+      ])
+    ];
+    if (!fields.length) {
+      throw createMissingBacklinkFieldsError(sourceName, targetCollection);
+    }
+    const where = backlinkWhere(fields, candidates);
+    if (!where) {
+      return [];
+    }
+    return await many(context, source, {
+      where,
+      sort: options.sort,
+      limit: options.limit,
+      skip: options.skip,
+      ...options.locale ? { locale: options.locale } : {},
+      ...options.fallback !== void 0 ? { fallback: options.fallback } : {},
+      select: options.select,
+      populate: options.populate
+    });
+  }));
+  return results.flat();
+}

package/dist/runtime/query/context

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

package/dist/runtime/query/context.d.ts

@@ -0,0 +1,20 @@
+import type { NavItem } from '../../types/content';
+import type { ContentQueryResponse } from '../../types/api';
+import type { ContentQueryBuilderParams } from '../../types/query';
+export interface RuntimeContentConfig {
+    locales?: string[];
+    defaultLocale?: string;
+    collections?: Record<string, {
+        i18n?: boolean | {
+            locales?: string[];
+            defaultLocale?: string;
+        };
+        route?: string | Record<string, string>;
+        references?: Record<string, string[]>;
+    }>;
+}
+export type ContentQueryEndpoint = 'query' | 'navigation';
+export interface ContentQueryContext {
+    runtime: RuntimeContentConfig;
+    transport: <T>(endpoint: ContentQueryEndpoint, params: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T> | T | T[] | NavItem[] | null>;
+}

package/dist/runtime/query/documents

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

package/dist/runtime/query/documents.d.ts

@@ -0,0 +1,6 @@
+import type { ContentCollectionHandle } from '../../types/config';
+import type { DocumentFromHandle, LocalizedDoc, ManyOptions, OneOptions, PopulateFromOptions, PopulateSpec, PopulatedDocument, ResolveOneOptions, ResolveOneResult } from '../../types/query';
+import type { ContentQueryContext } from './context';
+export declare function resolveDocument<const H extends ContentCollectionHandle | string, O extends ResolveOneOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, one: typeof resolveDocumentOnly, handle: H, options: O): Promise<ResolveOneResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+export declare function resolveDocumentOnly<const H extends ContentCollectionHandle | string, O extends OneOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, handle: H, options: O): Promise<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>> | null>;
+export declare function resolveManyDocuments<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, one: typeof resolveDocumentOnly, handle: H, options?: O): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;

package/dist/runtime/query/documents.js

@@ -0,0 +1,98 @@
+import { compileQueryParams } from "../../core/query/filter";
+import { isNotFoundError } from "./errors.js";
+import { ensureCollectionName } from "./handles.js";
+import { decorateLocalizedDocument } from "./localized-docs.js";
+import { resolveFallback } from "./locale-options.js";
+import { populateDocument, selectWithPopulate, validatePopulateSpec } from "./populate.js";
+import { unwrapListResponse, unwrapOneResponse } from "./responses.js";
+const explainResolution = (collection, requestedBy, normalizedBy, requestedLocale, requestedFallback, doc) => {
+  const resolvedLocale = doc?.resolved?.locale || doc?.locale;
+  return {
+    requested: {
+      collection,
+      by: requestedBy,
+      ...requestedLocale ? { locale: requestedLocale } : {},
+      ...requestedFallback !== void 0 ? { fallback: requestedFallback } : {}
+    },
+    normalized: {
+      by: normalizedBy
+    },
+    matched: {
+      found: Boolean(doc),
+      collection,
+      ...doc?.path ? { path: doc.path } : {},
+      ...doc?.canonicalPath ? { canonicalPath: doc.canonicalPath } : {},
+      ...doc?.ref ? { ref: doc.ref } : {},
+      ...resolvedLocale ? { locale: resolvedLocale } : {}
+    },
+    fallback: {
+      used: Boolean(requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale),
+      ...requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale ? { locale: resolvedLocale } : {}
+    }
+  };
+};
+export async function resolveDocument(context, one, handle, options) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  validatePopulateSpec(handle, collection, runtime, options.populate);
+  const by = options.by;
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    by,
+    locale: options.locale,
+    fallback,
+    select: selectWithPopulate(options.select, options.populate)
+  });
+  params.first = true;
+  let response;
+  try {
+    response = await context.transport("query", params);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      const explain2 = explainResolution(collection, options.by, by, options.locale, options.fallback, null);
+      return { doc: null, explain: explain2 };
+    }
+    throw error;
+  }
+  const unwrapped = unwrapOneResponse(response);
+  const doc = Array.isArray(unwrapped) ? unwrapped[0] ?? null : unwrapped ?? null;
+  const decorated = decorateLocalizedDocument(doc, collection, runtime, options.locale);
+  const populated = decorated ? await populateDocument(context, one, decorated, options.populate, options.locale, options.fallback) : null;
+  const explain = explainResolution(collection, options.by, by, options.locale, options.fallback, decorated);
+  return {
+    doc: populated,
+    explain
+  };
+}
+export async function resolveDocumentOnly(context, handle, options) {
+  const result = await resolveDocument(context, resolveDocumentOnly, handle, options);
+  return result.doc;
+}
+export async function resolveManyDocuments(context, one, handle, options = {}) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  validatePopulateSpec(handle, collection, runtime, options.populate);
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    where: options.where,
+    sort: options.sort,
+    limit: options.limit,
+    skip: options.skip,
+    locale: options.locale,
+    fallback,
+    select: selectWithPopulate(options.select, options.populate)
+  });
+  let response;
+  try {
+    response = await context.transport("query", params);
+  } catch (error) {
+    if (isNotFoundError(error)) return [];
+    throw error;
+  }
+  const list = unwrapListResponse(response);
+  const decorated = list.map((doc) => decorateLocalizedDocument(doc, collection, runtime, options.locale)).filter((doc) => Boolean(doc));
+  const populated = await Promise.all(decorated.map((doc) => populateDocument(context, one, doc, options.populate, options.locale, options.fallback)));
+  return populated;
+}

package/dist/runtime/query/errors

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

package/dist/runtime/query/errors.d.ts

@@ -0,0 +1 @@
+export declare const isNotFoundError: (error: unknown) => boolean;

package/dist/runtime/query/errors.js

@@ -0,0 +1,4 @@
+export const isNotFoundError = (error) => {
+  const statusCode = error?.statusCode ?? error?.response?.status;
+  return statusCode === 404;
+};

package/dist/runtime/query/handles

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

package/dist/runtime/query/handles.d.ts

@@ -0,0 +1,2 @@
+import type { ContentCollectionHandle } from '../../types/config';
+export declare const ensureCollectionName: <H extends ContentCollectionHandle | string>(handle: H) => string;

package/dist/runtime/query/handles.js

@@ -0,0 +1,7 @@
+export const ensureCollectionName = (handle) => {
+  if (typeof handle === "string") return handle;
+  if (!handle || typeof handle !== "object" || typeof handle.name !== "string") {
+    throw new TypeError("query API: expected a string collection name or a collection handle from defineContentConfig({ collections }). Use useContentPage('docs') or config.collections.docs.");
+  }
+  return handle.name;
+};

package/dist/runtime/query/locale-options

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

package/dist/runtime/query/locale-options.d.ts

@@ -0,0 +1,5 @@
+import type { LocaleFallback } from '../../types/query';
+import type { RuntimeContentConfig } from './context';
+export declare const collectionDefaultLocale: (collection: string, runtime: RuntimeContentConfig | undefined) => string | undefined;
+export declare const collectionLocales: (collection: string, runtime: RuntimeContentConfig | undefined) => string[];
+export declare const resolveFallback: (fallback: LocaleFallback | undefined, collection: string, runtime: RuntimeContentConfig | undefined) => Exclude<LocaleFallback, "default"> | undefined;

package/dist/runtime/query/locale-options.js

@@ -0,0 +1,14 @@
+export const collectionDefaultLocale = (collection, runtime) => {
+  const collectionI18n = runtime?.collections?.[collection]?.i18n;
+  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
+  return collectionDefault || runtime?.defaultLocale;
+};
+export const collectionLocales = (collection, runtime) => {
+  const collectionI18n = runtime?.collections?.[collection]?.i18n;
+  const collectionLocales2 = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.locales : void 0;
+  return collectionLocales2?.length ? collectionLocales2 : runtime?.locales || [];
+};
+export const resolveFallback = (fallback, collection, runtime) => {
+  if (fallback !== "default") return fallback;
+  return collectionDefaultLocale(collection, runtime);
+};

package/dist/runtime/query/localized-docs

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

package/dist/runtime/query/localized-docs.d.ts

@@ -0,0 +1,17 @@
+import type { ParsedContent } from '../../types/content';
+import type { LocalizedDoc } from '../../types/query';
+import type { RuntimeContentConfig } from './context';
+/**
+ * Decorate a raw parsed document with route metadata and locale paths.
+ *
+ * `localizePageResult` already attaches `path`, `canonicalPath`, `locale`,
+ * `defaultLocale`, `variants`, and `localePaths`. This helper additionally
+ * fills non-translated locales with fallback paths so app switchers can render
+ * all configured languages without another query.
+ */
+export declare const decorateLocalizedDocument: <T extends ParsedContent & Record<string, unknown>>(doc: T | null, collection: string, runtime: RuntimeContentConfig | undefined, requestedLocale?: string) => LocalizedDoc<T> | null;
+export declare const isCollectionRouteRoot: (path: string, collection: string, runtime: RuntimeContentConfig | undefined) => boolean;
+export declare const isNavigationRootPath: (path: string, flat: Array<{
+    path: string;
+    item: unknown;
+}>) => boolean;

package/dist/runtime/query/localized-docs.js

@@ -0,0 +1,44 @@
+import { decorateLocalePathsWithFallbacks, localizePageResult } from "../../features/localization/results";
+import { normalizeContentPath, normalizeRouteMounts } from "../../features/localization/path";
+const collectionLocaleConfig = (collection, runtime) => {
+  const collectionConfig = runtime?.collections?.[collection];
+  const collectionI18n = collectionConfig?.i18n;
+  const collectionLocales = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.locales : void 0;
+  const collectionDefault = collectionI18n && typeof collectionI18n === "object" ? collectionI18n.defaultLocale : void 0;
+  const locales = collectionLocales?.length ? collectionLocales : runtime?.locales?.length ? runtime.locales : [];
+  const defaultLocale = collectionDefault || runtime?.defaultLocale;
+  const routeMounts = normalizeRouteMounts(collectionConfig?.route, locales, defaultLocale);
+  return {
+    locales,
+    defaultLocale,
+    routeMounts,
+    hasLocaleConfig: Boolean(locales.length || defaultLocale)
+  };
+};
+export const decorateLocalizedDocument = (doc, collection, runtime, requestedLocale) => {
+  if (!doc) return null;
+  const { locales, defaultLocale, routeMounts, hasLocaleConfig } = collectionLocaleConfig(collection, runtime);
+  const page = hasLocaleConfig ? doc : {
+    ...doc,
+    _locale: "",
+    _resolvedLocale: void 0,
+    _requestedLocale: void 0,
+    _variantPaths: void 0,
+    _availableLocales: []
+  };
+  const result = localizePageResult(page, hasLocaleConfig ? requestedLocale : void 0, defaultLocale, locales, routeMounts);
+  const fallbackLocale = doc._resolvedLocale || requestedLocale || defaultLocale;
+  result.localePaths = decorateLocalePathsWithFallbacks(result.localePaths, locales, fallbackLocale, defaultLocale, routeMounts);
+  return result;
+};
+const collectionRouteRoots = (collection, runtime) => {
+  const { routeMounts } = collectionLocaleConfig(collection, runtime);
+  return new Set(Object.values(routeMounts || {}).map((value) => normalizeContentPath(value)));
+};
+export const isCollectionRouteRoot = (path, collection, runtime) => collectionRouteRoots(collection, runtime).has(normalizeContentPath(path));
+const isAncestorRoutePath = (path, childPath) => {
+  const normalized = normalizeContentPath(path);
+  const child = normalizeContentPath(childPath);
+  return normalized === "/" ? child !== "/" : child.startsWith(`${normalized}/`);
+};
+export const isNavigationRootPath = (path, flat) => Boolean(flat[0]?.path && isAncestorRoutePath(path, flat[0].path));

package/dist/runtime/query/navigation

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

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

@@ -0,0 +1,22 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionHandle } from '../../types/config';
+import type { ContentTreeItem, LocalizedContentDocument, NeighborsOptions, NeighborsResult, OneOptions, TreeOptions } from '../../types/query';
+import type { ContentQueryContext } from './context';
+export declare const navigationSelectFields: (fields?: ReadonlyArray<string> | undefined) => string[];
+type OneResolver = <H extends ContentCollectionHandle | string>(context: ContentQueryContext, handle: H, options: OneOptions<H>) => Promise<LocalizedContentDocument<ParsedContent> | null>;
+type TreeResolver = <H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+    fields?: Fields;
+}) => Promise<unknown[]>;
+export declare function resolveTree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+    fields?: Fields;
+}): Promise<ContentTreeItem<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent, Fields>[]>;
+export declare function resolveNeighbors<H extends ContentCollectionHandle | string>(context: ContentQueryContext, one: OneResolver, tree: TreeResolver, handle: H, options: NeighborsOptions<H>): Promise<NeighborsResult<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>;
+export {};

package/dist/runtime/query/navigation.js

@@ -0,0 +1,73 @@
+import { compileQueryParams } from "../../core/query/filter";
+import { ensureCollectionName } from "./handles.js";
+import { isCollectionRouteRoot, isNavigationRootPath } from "./localized-docs.js";
+import { resolveFallback } from "./locale-options.js";
+const NAVIGATION_INTERNAL_FIELDS = [
+  "_id",
+  "_path",
+  "_file",
+  "_canonicalKey",
+  "_locale",
+  "_draft",
+  "navigation",
+  "title"
+];
+export const navigationSelectFields = (fields = []) => [
+  .../* @__PURE__ */ new Set([...NAVIGATION_INTERNAL_FIELDS, ...fields])
+];
+export async function resolveTree(context, handle, options = {}) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    where: options.where,
+    sort: options.sort,
+    locale: options.locale,
+    fallback,
+    select: navigationSelectFields(options.fields),
+    exact: options.fallback === void 0 ? false : void 0
+  });
+  const response = await context.transport("navigation", params);
+  const list = Array.isArray(response) ? response : Array.isArray(response?.result) ? response.result : [];
+  return list;
+}
+export async function resolveNeighbors(context, one, tree, handle, options) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  const seed = await one(context, handle, {
+    by: options.by,
+    locale: options.locale,
+    fallback: options.fallback ?? true
+  });
+  if (!seed) return { prev: null, next: null };
+  const fullTree = await tree(context, handle, {
+    locale: options.locale,
+    fallback: options.fallback,
+    fields: options.fields
+  });
+  const flat = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      const n = node;
+      if (n.path || n._path) {
+        flat.push({ path: n.path || n._path || "", item: node });
+      }
+      if (Array.isArray(n.children)) walk(n.children);
+    }
+  };
+  walk(fullTree);
+  const targetPath = seed.path;
+  const idx = flat.findIndex((entry) => entry.path === targetPath);
+  if (idx === -1 && (isCollectionRouteRoot(targetPath, collection, runtime) || isNavigationRootPath(targetPath, flat))) {
+    return {
+      prev: null,
+      next: flat[0]?.item ?? null
+    };
+  }
+  if (idx === -1) return { prev: null, next: null };
+  return {
+    prev: flat[idx - 1]?.item ?? null,
+    next: flat[idx + 1]?.item ?? null
+  };
+}

package/dist/runtime/query/pagination

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

package/dist/runtime/query/pagination.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionHandle } from '../../types/config';
+import type { DocumentFromHandle, LocalizedDoc, OneOptions, PaginationOptions, PaginationResult, PopulateFromOptions, PopulateSpec, PopulatedDocument } from '../../types/query';
+import type { ContentQueryContext } from './context';
+type OneResolver = <H extends ContentCollectionHandle | string>(context: ContentQueryContext, handle: H, options: OneOptions<H>) => Promise<LocalizedDoc<ParsedContent> | null>;
+export declare function resolvePagination<const H extends ContentCollectionHandle | string, O extends PaginationOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, one: OneResolver, handle: H, options: O): Promise<PaginationResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+export {};

package/dist/runtime/query/pagination.js

@@ -0,0 +1,78 @@
+import { compileQueryParams } from "../../core/query/filter";
+import { decorateLocalizedDocument } from "./localized-docs.js";
+import { ensureCollectionName } from "./handles.js";
+import { resolveFallback } from "./locale-options.js";
+import { populateDocument, selectWithPopulate, validatePopulateSpec } from "./populate.js";
+import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "./public-limits.js";
+import { unwrapCountResponse, unwrapFindResponse } from "./responses.js";
+import { isNotFoundError } from "./errors.js";
+const normalizePositiveInteger = (value, fallback) => {
+  const number = typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : fallback;
+  return Math.max(1, number);
+};
+export async function resolvePagination(context, one, handle, options) {
+  const collection = ensureCollectionName(handle);
+  const runtime = context.runtime;
+  validatePopulateSpec(handle, collection, runtime, options.populate);
+  const requestedPage = normalizePositiveInteger(options.page, 1);
+  const limit = Math.min(normalizePositiveInteger(options.limit, 10), MAX_PUBLIC_QUERY_LIMIT);
+  const skip = Math.min((requestedPage - 1) * limit, MAX_PUBLIC_QUERY_SKIP);
+  const page = Math.floor(skip / limit) + 1;
+  const fallback = resolveFallback(options.fallback, collection, runtime);
+  const params = compileQueryParams({
+    collection,
+    where: options.where,
+    sort: options.sort,
+    limit,
+    skip,
+    locale: options.locale,
+    fallback,
+    select: selectWithPopulate(options.select, options.populate)
+  });
+  const countParams = compileQueryParams({
+    collection,
+    where: options.where,
+    locale: options.locale,
+    fallback
+  });
+  countParams.count = true;
+  let response;
+  try {
+    response = await context.transport("query", params);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return {
+        data: [],
+        page,
+        limit,
+        total: 0,
+        pageCount: 0,
+        hasNext: false,
+        hasPrev: page > 1,
+        nextPage: null,
+        prevPage: page > 1 ? page - 1 : null
+      };
+    }
+    throw error;
+  }
+  const envelope = unwrapFindResponse(response);
+  let total = envelope.total;
+  if (!envelope.hasTotal) {
+    const countResponse = await context.transport("query", countParams);
+    total = unwrapCountResponse(countResponse) ?? envelope.total;
+  }
+  const decorated = envelope.result.map((doc) => decorateLocalizedDocument(doc, collection, runtime, options.locale)).filter((doc) => Boolean(doc));
+  const populated = await Promise.all(decorated.map((doc) => populateDocument(context, one, doc, options.populate, options.locale, options.fallback)));
+  const pageCount = total > 0 ? Math.ceil(total / limit) : 0;
+  return {
+    data: populated,
+    page,
+    limit,
+    total,
+    pageCount,
+    hasNext: page < pageCount,
+    hasPrev: page > 1,
+    nextPage: page < pageCount ? page + 1 : null,
+    prevPage: page > 1 ? page - 1 : null
+  };
+}

package/dist/runtime/query/populate

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

package/dist/runtime/query/populate.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionHandle } from '../../types/config';
+import type { LocaleFallback, LocalizedDoc, OneOptions, PopulateSpec, PopulatedDocument } from '../../types/query';
+import type { ContentQueryContext, RuntimeContentConfig } from './context';
+export declare const validatePopulateSpec: (source: ContentCollectionHandle | string, sourceCollection: string, runtime: RuntimeContentConfig | undefined, populate: PopulateSpec | undefined) => void;
+type PopulateReferenceResolver = (context: ContentQueryContext, target: ContentCollectionHandle | string, options: OneOptions<ContentCollectionHandle | string>) => Promise<unknown>;
+export declare const populateDocument: <T extends ParsedContent, P extends PopulateSpec | undefined>(context: ContentQueryContext, resolveReference: PopulateReferenceResolver, doc: LocalizedDoc<T>, populate: P, locale: string | undefined, fallback: LocaleFallback | undefined) => Promise<LocalizedDoc<PopulatedDocument<T, P>>>;
+export declare const selectWithPopulate: (select: ReadonlyArray<string> | undefined, populate: PopulateSpec | undefined) => string[] | undefined;
+export {};