includio-cms 0.16.0 → 0.18.0

package/dist/core/server/entries/operations/get.js

@@ -1,15 +1,14 @@
 import { getCMS } from '../../../cms.js';
 import { getAtPath } from '../../../../admin/utils/objectPath.js';
-import { populateEntryData } from '../../fields/populateEntry.js';
 import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from '../../fields/slugResolver.js';
-export const getDbEntries = async (options) => {
+export const _getDbEntries = async (options) => {
     return getCMS().databaseAdapter.getEntries(options);
 };
-export const countDbEntries = async (options) => {
+export const _countDbEntries = async (options) => {
     return getCMS().databaseAdapter.countEntries(options);
 };
-export const getDbEntry = async (options) => {
+export const _getDbEntry = async (options) => {
     const { id, ...rest } = options;
     const [entry] = await getCMS().databaseAdapter.getEntries({
         ...rest,
@@ -17,15 +16,15 @@ export const getDbEntry = async (options) => {
     });
     return entry || null;
 };
-export const getDbEntryOrThrow = async (options) => {
-    const entry = await getDbEntry(options);
+export const _getDbEntryOrThrow = async (options) => {
+    const entry = await _getDbEntry(options);
     if (!entry) {
         throw new Error('Entry not found');
     }
     return entry;
 };
-export const countRawEntries = async (options) => {
-    return countDbEntries(options);
+export const _countRawEntries = async (options) => {
+    return _countDbEntries(options);
 };
 /** Helper: group versions by lang into per-lang published/scheduled/draft maps */
 function buildPerLangVersionMaps(versions) {
@@ -33,7 +32,6 @@ function buildPerLangVersionMaps(versions) {
     const publishedVersions = {};
     const scheduledVersions = {};
     const draftVersions = {};
-    // Group versions by lang
     const byLang = new Map();
     for (const v of versions) {
         const arr = byLang.get(v.lang) || [];
@@ -42,11 +40,8 @@ function buildPerLangVersionMaps(versions) {
     }
     for (const [lang, langVersions] of byLang) {
         const sorted = langVersions.sort((a, b) => b.versionNumber - a.versionNumber);
-        // Find latest published (publishedAt <= now)
         const published = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
-        // Find scheduled (publishedAt > now)
         const scheduled = sorted.find((v) => v.publishedAt != null && v.publishedAt > now) || null;
-        // Draft = latest version without publishedAt, or latest version newer than published
         const draft = sorted.find((v) => v.publishedAt == null) || null;
         publishedVersions[lang] = published;
         scheduledVersions[lang] = scheduled;
@@ -54,8 +49,8 @@ function buildPerLangVersionMaps(versions) {
     }
     return { publishedVersions, scheduledVersions, draftVersions };
 }
-export const getRawEntries = async (options) => {
-    const dbEntries = await getDbEntries(options);
+export const _getRawEntries = async (options) => {
+    const dbEntries = await _getDbEntries(options);
     const entries = await Promise.all(dbEntries.map(async (entry) => {
         try {
             const versions = await getCMS().databaseAdapter.getEntryVersions({
@@ -78,203 +73,31 @@ export const getRawEntries = async (options) => {
     }));
     return entries.filter((e) => e !== null);
 };
-export const getRawEntry = async (options) => {
-    const [entry] = await getRawEntries({
+export const _getRawEntry = async (options) => {
+    const [entry] = await _getRawEntries({
         ...options,
         ids: options.id ? [options.id] : undefined,
         includeArchived: options.includeArchived
     });
     return entry || null;
 };
-export const getRawEntryOrThrow = async (options) => {
-    const entry = await getRawEntry(options);
-    if (!entry) {
-        throw new Error('Entry not found');
-    }
-    return entry;
-};
-export const getEntries = async (options = {}) => {
-    const cms = getCMS();
-    const language = options.language || cms.languages[0];
-    const status = options.status || 'published';
-    // Fast path: DB-level pagination when limit/offset provided and adapter supports it
-    if (options.limit != null && cms.databaseAdapter.getPaginatedEntries) {
-        const rows = await cms.databaseAdapter.getPaginatedEntries({
-            slug: options.slug,
-            ids: options.ids,
-            language,
-            status,
-            dataValues: options.dataValues,
-            dataLike: options.dataLike,
-            dataILikeOr: options.dataILikeOr,
-            orderBy: options.orderBy,
-            dataOrderBy: options.dataOrderBy,
-            limit: options.limit,
-            offset: options.offset ?? 0
-        });
-        const entries = await Promise.all(rows.map(async ({ entry, version }) => {
-            try {
-                const config = cms.getBySlug(entry.slug);
-                const fields = getFieldsFromConfig(config);
-                const populatedData = await populateEntryData(version.data, fields, language, entry.id);
-                const slugPath = getEntrySlugPath(entry.slug);
-                const slug = getSlugFromEntryData(version.data, slugPath, language);
-                const _url = slug ? getEntryPath(entry.slug, slug) : undefined;
-                const result = {
-                    _id: entry.id,
-                    _slug: entry.slug,
-                    _type: entry.type,
-                    _publishedAt: version.publishedAt,
-                    _url,
-                    ...populatedData
-                };
-                if (config.type === 'collection' && config.orderable) {
-                    result._sortOrder = entry.sortOrder;
-                }
-                return result;
-            }
-            catch (error) {
-                console.error(`[CMS] Failed to populate entry ${entry.id} (${entry.slug}):`, error);
-                return null;
-            }
-        }));
-        return entries.filter((e) => e !== null);
-    }
-    // Slow path: in-memory pagination (backward compat)
-    const ids = options.ids;
-    const slug = options.slug;
-    const dataValues = options.dataValues;
-    const dataLike = options.dataLike;
-    const dataILikeOr = options.dataILikeOr;
-    const dbEntries = await cms.databaseAdapter.getEntries({
-        ids,
-        slug,
-        orderBy: options.orderBy
-    });
-    if (dbEntries.length === 0) {
-        return [];
-    }
-    const filteredEntries = status === 'archived'
-        ? dbEntries.filter((e) => e.archivedAt != null)
-        : dbEntries.filter((e) => e.archivedAt == null);
-    if (filteredEntries.length === 0) {
-        return [];
-    }
-    const entriesMap = new Map(filteredEntries.map((entry) => [entry.id, entry]));
-    const entryIds = filteredEntries.map((entry) => entry.id);
-    const allVersions = await cms.databaseAdapter.getEntryVersions({
-        entryIds,
-        lang: language,
-        dataValues,
-        dataLike,
-        dataILikeOr
-    });
-    const now = new Date();
-    const versionEntries = [];
-    const versionsByEntry = new Map();
-    for (const v of allVersions) {
-        const arr = versionsByEntry.get(v.entryId) || [];
-        arr.push(v);
-        versionsByEntry.set(v.entryId, arr);
-    }
-    for (const [entryId, versions] of versionsByEntry) {
-        const dbEntry = entriesMap.get(entryId);
-        if (!dbEntry)
-            continue;
-        const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
-        let picked = null;
-        switch (status) {
-            case 'published':
-                picked = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
-                break;
-            case 'scheduled':
-                picked = sorted.find((v) => v.publishedAt != null && v.publishedAt > now) || null;
-                break;
-            case 'draft':
-                picked = sorted.find((v) => v.publishedAt == null) || null;
-                break;
-            case 'archived':
-                picked = sorted[0] || null;
-                break;
-        }
-        if (picked) {
-            versionEntries.push({ version: picked, dbEntry });
-        }
-    }
-    const entryOrder = new Map(filteredEntries.map((e, i) => [e.id, i]));
-    versionEntries.sort((a, b) => (entryOrder.get(a.dbEntry.id) ?? 0) - (entryOrder.get(b.dbEntry.id) ?? 0));
-    const entries = await Promise.all(versionEntries.map(async ({ version, dbEntry }) => {
-        try {
-            const config = cms.getBySlug(dbEntry.slug);
-            const fields = getFieldsFromConfig(config);
-            const populatedData = await populateEntryData(version.data, fields, language, dbEntry.id);
-            const slugPath = getEntrySlugPath(dbEntry.slug);
-            const slug = getSlugFromEntryData(version.data, slugPath, language);
-            const _url = slug ? getEntryPath(dbEntry.slug, slug) : undefined;
-            const result = {
-                _id: dbEntry.id,
-                _slug: dbEntry.slug,
-                _type: dbEntry.type,
-                _publishedAt: version.publishedAt,
-                _url,
-                ...populatedData
-            };
-            if (config.type === 'collection' && config.orderable) {
-                result._sortOrder = dbEntry.sortOrder;
-            }
-            return result;
-        }
-        catch (error) {
-            console.error(`[CMS] Failed to populate entry ${dbEntry.id} (${dbEntry.slug}):`, error);
-            return null;
-        }
-    }));
-    let results = entries.filter((e) => e !== null);
-    if (options.offset)
-        results = results.slice(options.offset);
-    if (options.limit)
-        results = results.slice(0, options.limit);
-    return results;
-};
-export const countEntries = async (options) => {
-    const cms = getCMS();
-    const language = options.language || cms.languages[0];
-    const status = options.status || 'published';
-    if (cms.databaseAdapter.countPaginatedEntries) {
-        return cms.databaseAdapter.countPaginatedEntries({
-            slug: options.slug,
-            ids: options.ids,
-            language,
-            status,
-            dataValues: options.dataValues,
-            dataLike: options.dataLike,
-            dataILikeOr: options.dataILikeOr
-        });
-    }
-    // Fallback: use old getEntries without limit/offset (counts all)
-    const entries = await getEntries({ ...options });
-    return entries.length;
-};
-export const getEntry = async (options = {}) => {
-    const [entry] = await getEntries({
-        ...options,
-        ids: options.id ? [options.id] : undefined
-    });
-    return entry || null;
-};
-export const getEntryOrThrow = async (options = {}) => {
-    const entry = await getEntry(options);
+export const _getRawEntryOrThrow = async (options) => {
+    const entry = await _getRawEntry(options);
     if (!entry) {
         throw new Error('Entry not found');
     }
     return entry;
 };
+/**
+ * Admin helper: returns dropdown labels for collection entries.
+ * Not part of the public resolver API — admin UI use only.
+ */
 export const getEntryLabels = async (options) => {
     const cms = getCMS();
     const config = cms.getBySlug(options.slug);
     if (!config || config.type !== 'collection')
         return [];
-    const dbEntries = await getDbEntries({
+    const dbEntries = await _getDbEntries({
         slug: options.slug,
         ids: options.ids
     });
@@ -282,7 +105,6 @@ export const getEntryLabels = async (options) => {
         return [];
     const entryIds = dbEntries.map((e) => e.id);
     const language = cms.languages[0];
-    // Get versions for default language
     const allVersions = await cms.databaseAdapter.getEntryVersions({
         entryIds,
         lang: language
@@ -290,13 +112,12 @@ export const getEntryLabels = async (options) => {
     const now = new Date();
     const statusFilter = options.status ?? 'all';
     const entryAdminTitle = config.entryAdminTitle;
-    let results = dbEntries.map((entry) => {
+    let results = dbEntries
+        .map((entry) => {
         const entryVersions = allVersions.filter((v) => v.entryId === entry.id);
         const sorted = entryVersions.sort((a, b) => b.versionNumber - a.versionNumber);
-        // Determine status from versions
         const publishedVersion = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
         const hasPublished = publishedVersion != null;
-        // Filter by status
         if (statusFilter === 'published' && !hasPublished)
             return null;
         if (statusFilter === 'draft' && hasPublished)
@@ -310,50 +131,60 @@ export const getEntryLabels = async (options) => {
             }
         }
         return { id: entry.id, label };
-    }).filter((r) => r != null);
-    // Post-query search filtering (case-insensitive includes)
+    })
+        .filter((r) => r != null);
     if (options.search) {
         const searchLower = options.search.toLowerCase();
         results = results.filter((r) => r.label.toLowerCase().includes(searchLower));
     }
     const total = results.length;
-    // Apply limit
     if (options.limit && options.limit > 0) {
         results = results.slice(0, options.limit);
     }
     return results.map((r) => ({ ...r, total }));
 };
-export const getDbEntryVersions = async (options) => {
+export const _getDbEntryVersions = async (options) => {
     return getCMS().databaseAdapter.getEntryVersions(options);
 };
-export const getDbEntryVersion = async (options) => {
-    const [version] = await getDbEntryVersions({
+export const _getDbEntryVersion = async (options) => {
+    const [version] = await _getDbEntryVersions({
         ...options,
         ids: options.id ? [options.id] : undefined
     });
     return version || null;
 };
-export const getDbEntryVersionOrThrow = async (options) => {
-    const version = await getDbEntryVersion(options);
+export const _getDbEntryVersionOrThrow = async (options) => {
+    const version = await _getDbEntryVersion(options);
     if (!version) {
         throw new Error('Entry version not found');
     }
     return version;
 };
+/**
+ * Admin helper: fetches a specific version of an entry by version id and populates it.
+ * Used by version-history admin UI; not part of public resolver API.
+ */
 export const getEntryVersion = async (options) => {
     const language = options.language || getCMS().languages[0];
-    const dbEntryVersion = await getDbEntryVersion({ id: options.id });
-    if (!dbEntryVersion) {
+    const dbEntryVersion = await _getDbEntryVersion({ id: options.id });
+    if (!dbEntryVersion)
         return null;
-    }
-    const dbEntry = await getDbEntry({ id: dbEntryVersion.entryId });
-    if (!dbEntry) {
+    const dbEntry = await _getDbEntry({ id: dbEntryVersion.entryId });
+    if (!dbEntry)
         return null;
-    }
     try {
         const config = getCMS().getBySlug(dbEntry.slug);
         const fields = getFieldsFromConfig(config);
-        const populatedData = await populateEntryData(dbEntryVersion.data, fields, language, dbEntry.id);
+        const { _populate } = await import('../../fields/populateEntry.js');
+        const populatedData = await _populate(dbEntryVersion.data, fields, {
+            locale: language,
+            status: 'published',
+            depth: 0,
+            maxDepth: 5,
+            visited: new Set([dbEntry.id]),
+            populate: {},
+            entryId: dbEntry.id
+        });
         const slugPath = getEntrySlugPath(dbEntry.slug);
         const entrySlug = getSlugFromEntryData(dbEntryVersion.data, slugPath, language);
         const _url = entrySlug ? getEntryPath(dbEntry.slug, entrySlug) : undefined;

package/dist/core/server/entries/operations/resolveEntry.d.ts

@@ -0,0 +1,94 @@
+import type { Entry } from '../../../../types/entries.js';
+/**
+ * Status filter for `resolveEntry`/`resolveEntries`/`countEntries`.
+ * - `published` (default): newest version with `publishedAt <= now`
+ * - `draft`: newest version without `publishedAt`
+ * - `scheduled`: newest version with `publishedAt > now` (use case: countdown to launch)
+ *
+ * `archived` is intentionally excluded from public API (admin uses internal `_getRawEntries`).
+ * @public
+ */
+export type ResolveStatus = 'published' | 'draft' | 'scheduled';
+/**
+ * Recursion + per-field opt-out config for relation population.
+ * @public
+ */
+export type PopulateConfig = {
+    /** Hard cap on relation depth. Default 5. Use `0` to keep all relations as raw IDs. */
+    maxDepth?: number;
+    /** Per-field opt-out. `{ author: false }` keeps `author` as raw ID instead of populated Entry. */
+    fields?: Record<string, false>;
+};
+/**
+ * Internal context passed through the populate chain.
+ * Carries locale/status cascade, recursion guards, and the current entry id (for shop populate).
+ */
+export interface PopulateCtx {
+    locale: string;
+    status: ResolveStatus;
+    depth: number;
+    maxDepth: number;
+    visited: Set<string>;
+    populate: PopulateConfig;
+    entryId: string;
+}
+/** @public */
+export interface ResolveEntryOptions {
+    id?: string;
+    collection?: string;
+    locale?: string;
+    status?: ResolveStatus;
+    populate?: PopulateConfig;
+}
+/** @public */
+export interface ResolveEntriesOptions {
+    collection: string;
+    locale?: string;
+    status?: ResolveStatus;
+    ids?: string[];
+    filter?: {
+        dataValues?: Record<string, unknown>;
+        dataLike?: Record<string, unknown>;
+        dataILikeOr?: Record<string, unknown>;
+    };
+    orderBy?: {
+        column: 'createdAt' | 'updatedAt' | 'sortOrder';
+        direction: 'asc' | 'desc';
+    };
+    dataOrderBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    limit?: number;
+    offset?: number;
+    populate?: PopulateConfig;
+}
+/** @public */
+export type CountEntriesOptions = Omit<ResolveEntriesOptions, 'limit' | 'offset' | 'populate' | 'orderBy' | 'dataOrderBy'>;
+/**
+ * Fetch a single populated Entry.
+ *
+ * - At least one of `id` or `collection` must be provided.
+ * - `locale` defaults to `cms.languages[0]`. Strict — returns `null` when no version exists in the requested locale.
+ * - `status` defaults to `'published'`. See {@link ResolveStatus}.
+ * - `populate` controls relation depth + per-field opt-out. See {@link PopulateConfig}.
+ *
+ * @public
+ */
+export declare function resolveEntry(opts: ResolveEntryOptions): Promise<Entry | null>;
+/**
+ * Fetch a list of populated Entries from a collection (or singleton with multiple instances).
+ *
+ * - `collection` is required.
+ * - `locale` strict (excludes entries without a version in requested locale).
+ * - `filter.{dataValues, dataLike, dataILikeOr}` map onto adapter `getEntryVersions` filters.
+ * - `limit`/`offset` applied after status pick.
+ *
+ * @public
+ */
+export declare function resolveEntries(opts: ResolveEntriesOptions): Promise<Entry[]>;
+/**
+ * Count entries matching the same filters as `resolveEntries`, without populating.
+ * @public
+ */
+export declare function countEntries(opts: CountEntriesOptions): Promise<number>;

package/dist/core/server/entries/operations/resolveEntry.js

@@ -0,0 +1,210 @@
+import { getCMS } from '../../../cms.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
+import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from '../../fields/slugResolver.js';
+function pickVersion(versions, status) {
+    const sorted = versions.slice().sort((a, b) => b.versionNumber - a.versionNumber);
+    const now = new Date();
+    switch (status) {
+        case 'published':
+            return sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) ?? null;
+        case 'draft':
+            return sorted.find((v) => v.publishedAt == null) ?? null;
+        case 'scheduled':
+            return sorted.find((v) => v.publishedAt != null && v.publishedAt > now) ?? null;
+    }
+}
+async function buildEntry(dbEntry, version, ctx) {
+    const cms = getCMS();
+    let config;
+    try {
+        config = cms.getBySlug(dbEntry.slug);
+    }
+    catch {
+        // Orphaned entry — slug removed from config
+        return null;
+    }
+    const fields = getFieldsFromConfig(config);
+    // Lazy import to avoid static circular dep with resolveRelationFields → _populate
+    const { _populate } = await import('../../fields/populateEntry.js');
+    const populated = await _populate(version.data, fields, ctx);
+    const slugPath = getEntrySlugPath(dbEntry.slug);
+    const slugValue = getSlugFromEntryData(version.data, slugPath, ctx.locale);
+    const _url = slugValue ? getEntryPath(dbEntry.slug, slugValue) : undefined;
+    const result = {
+        _id: dbEntry.id,
+        _slug: dbEntry.slug,
+        _type: dbEntry.type,
+        _publishedAt: version.publishedAt,
+        _url,
+        ...populated
+    };
+    if (config.type === 'collection' && config.orderable) {
+        result._sortOrder = dbEntry.sortOrder;
+    }
+    return result;
+}
+/**
+ * Fetch a single populated Entry.
+ *
+ * - At least one of `id` or `collection` must be provided.
+ * - `locale` defaults to `cms.languages[0]`. Strict — returns `null` when no version exists in the requested locale.
+ * - `status` defaults to `'published'`. See {@link ResolveStatus}.
+ * - `populate` controls relation depth + per-field opt-out. See {@link PopulateConfig}.
+ *
+ * @public
+ */
+export async function resolveEntry(opts) {
+    if (!opts.id && !opts.collection) {
+        throw new Error('resolveEntry: must provide id or collection');
+    }
+    const cms = getCMS();
+    const locale = opts.locale ?? cms.languages[0];
+    const status = opts.status ?? 'published';
+    const populate = opts.populate ?? {};
+    const maxDepth = populate.maxDepth ?? 5;
+    const dbOpts = {};
+    if (opts.id)
+        dbOpts.ids = [opts.id];
+    if (opts.collection)
+        dbOpts.slug = opts.collection;
+    const dbEntries = await cms.databaseAdapter.getEntries(dbOpts);
+    const dbEntry = dbEntries.find((e) => e.archivedAt == null) ?? null;
+    if (!dbEntry)
+        return null;
+    if (opts.collection && dbEntry.slug !== opts.collection)
+        return null;
+    const versions = await cms.databaseAdapter.getEntryVersions({
+        entryIds: [dbEntry.id],
+        lang: locale
+    });
+    const picked = pickVersion(versions, status);
+    if (!picked)
+        return null;
+    const ctx = {
+        locale,
+        status,
+        depth: 0,
+        maxDepth,
+        visited: new Set([dbEntry.id]),
+        populate,
+        entryId: dbEntry.id
+    };
+    return buildEntry(dbEntry, picked, ctx);
+}
+/**
+ * Fetch a list of populated Entries from a collection (or singleton with multiple instances).
+ *
+ * - `collection` is required.
+ * - `locale` strict (excludes entries without a version in requested locale).
+ * - `filter.{dataValues, dataLike, dataILikeOr}` map onto adapter `getEntryVersions` filters.
+ * - `limit`/`offset` applied after status pick.
+ *
+ * @public
+ */
+export async function resolveEntries(opts) {
+    if (!opts.collection) {
+        throw new Error('resolveEntries: collection is required');
+    }
+    const cms = getCMS();
+    const locale = opts.locale ?? cms.languages[0];
+    const status = opts.status ?? 'published';
+    const populate = opts.populate ?? {};
+    const maxDepth = populate.maxDepth ?? 5;
+    const dbEntries = await cms.databaseAdapter.getEntries({
+        ids: opts.ids,
+        slug: opts.collection,
+        orderBy: opts.orderBy
+    });
+    if (dbEntries.length === 0)
+        return [];
+    const filtered = dbEntries.filter((e) => e.archivedAt == null);
+    if (filtered.length === 0)
+        return [];
+    const entryIds = filtered.map((e) => e.id);
+    const allVersions = await cms.databaseAdapter.getEntryVersions({
+        entryIds,
+        lang: locale,
+        dataValues: opts.filter?.dataValues,
+        dataLike: opts.filter?.dataLike,
+        dataILikeOr: opts.filter?.dataILikeOr
+    });
+    const versionsByEntry = new Map();
+    for (const v of allVersions) {
+        const arr = versionsByEntry.get(v.entryId) ?? [];
+        arr.push(v);
+        versionsByEntry.set(v.entryId, arr);
+    }
+    const order = new Map(filtered.map((e, i) => [e.id, i]));
+    const picks = [];
+    for (const dbEntry of filtered) {
+        const vs = versionsByEntry.get(dbEntry.id) ?? [];
+        const picked = pickVersion(vs, status);
+        if (picked)
+            picks.push({ version: picked, dbEntry });
+    }
+    picks.sort((a, b) => (order.get(a.dbEntry.id) ?? 0) - (order.get(b.dbEntry.id) ?? 0));
+    const built = await Promise.all(picks.map(async ({ version, dbEntry }) => {
+        const ctx = {
+            locale,
+            status,
+            depth: 0,
+            maxDepth,
+            visited: new Set([dbEntry.id]),
+            populate,
+            entryId: dbEntry.id
+        };
+        try {
+            return await buildEntry(dbEntry, version, ctx);
+        }
+        catch (error) {
+            console.error(`[CMS] Failed to populate entry ${dbEntry.id} (${dbEntry.slug}):`, error);
+            return null;
+        }
+    }));
+    let results = built.filter((e) => e !== null);
+    if (opts.offset)
+        results = results.slice(opts.offset);
+    if (opts.limit)
+        results = results.slice(0, opts.limit);
+    return results;
+}
+/**
+ * Count entries matching the same filters as `resolveEntries`, without populating.
+ * @public
+ */
+export async function countEntries(opts) {
+    if (!opts.collection) {
+        throw new Error('countEntries: collection is required');
+    }
+    const cms = getCMS();
+    const locale = opts.locale ?? cms.languages[0];
+    const status = opts.status ?? 'published';
+    const dbEntries = await cms.databaseAdapter.getEntries({
+        ids: opts.ids,
+        slug: opts.collection
+    });
+    const filtered = dbEntries.filter((e) => e.archivedAt == null);
+    if (filtered.length === 0)
+        return 0;
+    const entryIds = filtered.map((e) => e.id);
+    const allVersions = await cms.databaseAdapter.getEntryVersions({
+        entryIds,
+        lang: locale,
+        dataValues: opts.filter?.dataValues,
+        dataLike: opts.filter?.dataLike,
+        dataILikeOr: opts.filter?.dataILikeOr
+    });
+    const versionsByEntry = new Map();
+    for (const v of allVersions) {
+        const arr = versionsByEntry.get(v.entryId) ?? [];
+        arr.push(v);
+        versionsByEntry.set(v.entryId, arr);
+    }
+    let count = 0;
+    for (const dbEntry of filtered) {
+        const vs = versionsByEntry.get(dbEntry.id) ?? [];
+        if (pickVersion(vs, status))
+            count++;
+    }
+    return count;
+}

package/dist/core/server/entries/operations/update.js

@@ -2,7 +2,7 @@ import { getCMS } from '../../../cms.js';
 import { generateZodSchemaFromFields } from '../../../fields/fieldSchemaToTs.js';
 import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 import z from 'zod';
-import { getDbEntryOrThrow, getDbEntryVersionOrThrow, getDbEntryVersions } from './get.js';
+import { _getDbEntryOrThrow as getDbEntryOrThrow, _getDbEntryVersionOrThrow as getDbEntryVersionOrThrow, _getDbEntryVersions as getDbEntryVersions } from './get.js';
 import { createEntryVersion } from './create.js';
 export const updateEntrySchema = z.object({
     archivedAt: z.date().nullable().optional(),