includio-cms 0.16.0 → 0.19.0

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(),

package/dist/core/server/fields/populateEntry.d.ts

@@ -1,3 +1,11 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function populateEntryData(data: EntryData, fields: Field[], language: string, entryId?: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+/**
+ * Internal populate chain: relations → urls → media → richtext → custom → shop → typography orphans.
+ * Carries `ctx` (locale, status, depth, visited, populate config, current entryId) so every nested
+ * field resolver can cascade locale + recursion guards consistently.
+ *
+ * Not part of the public API. Userland uses `resolveEntry`/`resolveEntries`.
+ */
+export declare function _populate(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/populateEntry.js

@@ -5,11 +5,8 @@ import { resolveUrlFields } from './resolveUrlFields.js';
 import { resolveTypographyOrphans } from './resolveTypographyOrphans.js';
 import { getCMS } from '../../cms.js';
 import { resolveShopFields } from '../../../shop/server/populate.js';
-async function resolveCustomFields(data, fields) {
-    // Check if any custom fields exist before accessing CMS
-    const hasCustom = fields.some((f) => f.type === 'custom' ||
-        f.type === 'object' ||
-        f.type === 'blocks');
+async function resolveCustomFields(data, fields, ctx) {
+    const hasCustom = fields.some((f) => f.type === 'custom' || f.type === 'object' || f.type === 'blocks');
     if (!hasCustom)
         return data;
     let cms;
@@ -26,13 +23,14 @@ async function resolveCustomFields(data, fields) {
             case 'custom': {
                 const def = cms.customFields.get(field.fieldType);
                 if (def?.populateResolver && val != null) {
-                    result[field.slug] = await def.populateResolver(val, field);
+                    // Plugin populateResolver receives ctx as 3rd arg (breaking in 0.17.0; plugin API @experimental)
+                    result[field.slug] = await def.populateResolver(val, field, ctx);
                 }
                 break;
             }
             case 'object':
                 if (val && typeof val === 'object') {
-                    result[field.slug] = await resolveCustomFields(val, field.fields);
+                    result[field.slug] = await resolveCustomFields(val, field.fields, ctx);
                 }
                 break;
             case 'blocks':
@@ -40,7 +38,7 @@ async function resolveCustomFields(data, fields) {
                     result[field.slug] = await Promise.all(val.map(async (item) => {
                         const blockDef = field.of.find((d) => d.slug === item._slug);
                         if (blockDef) {
-                            return await resolveCustomFields(item, blockDef.fields);
+                            return await resolveCustomFields(item, blockDef.fields, ctx);
                         }
                         return item;
                     }));
@@ -50,14 +48,20 @@ async function resolveCustomFields(data, fields) {
     }
     return result;
 }
-export async function populateEntryData(data, fields, language, entryId) {
-    let populatedData = await resolveRelationFields(data, fields, language);
-    populatedData = await resolveUrlFields(populatedData, fields, language);
-    populatedData = await resolveMediaFields(populatedData, fields);
-    populatedData = await resolveRichtextLinks(populatedData, fields, language);
-    populatedData = (await resolveCustomFields(populatedData, fields));
-    populatedData = (await resolveShopFields(populatedData, fields, entryId));
-    // Typography orphan fix — enabled by default, opt-out via config
+/**
+ * Internal populate chain: relations → urls → media → richtext → custom → shop → typography orphans.
+ * Carries `ctx` (locale, status, depth, visited, populate config, current entryId) so every nested
+ * field resolver can cascade locale + recursion guards consistently.
+ *
+ * Not part of the public API. Userland uses `resolveEntry`/`resolveEntries`.
+ */
+export async function _populate(data, fields, ctx) {
+    let populated = await resolveRelationFields(data, fields, ctx);
+    populated = await resolveUrlFields(populated, fields, ctx);
+    populated = await resolveMediaFields(populated, fields);
+    populated = await resolveRichtextLinks(populated, fields, ctx);
+    populated = (await resolveCustomFields(populated, fields, ctx));
+    populated = (await resolveShopFields(populated, fields, ctx));
     let fixOrphans = true;
     try {
         fixOrphans = getCMS().typographyConfig.fixOrphans !== false;
@@ -66,7 +70,7 @@ export async function populateEntryData(data, fields, language, entryId) {
         // CMS not initialized — keep default
     }
     if (fixOrphans) {
-        populatedData = resolveTypographyOrphans(populatedData, fields);
+        populated = resolveTypographyOrphans(populated, fields);
     }
-    return populatedData;
+    return populated;
 }

package/dist/core/server/fields/resolveRelationFields.d.ts

@@ -1,3 +1,4 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function resolveRelationFields(data: EntryData, fields: Field[], language: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+export declare function resolveRelationFields(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/resolveRelationFields.js

@@ -1,53 +1,72 @@
 import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
-import z from 'zod';
-export async function resolveRelationFields(data, fields, language) {
+import { getCMS } from '../../cms.js';
+import { getFieldsFromConfig } from '../../fields/layoutUtils.js';
+import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './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;
+    }
+}
+export async function resolveRelationFields(data, fields, ctx) {
     const entriesIds = [];
+    const optedOutFields = new Set();
+    // Collect ids skipping fields opted out at top level (raw passthrough).
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const collectIds = (value, fields) => {
+    const collectIds = (value, fields, topLevel) => {
         for (const field of fields) {
             const val = value?.[field.slug];
             if (val == null)
                 continue;
+            if (topLevel && ctx.populate.fields?.[field.slug] === false) {
+                optedOutFields.add(field.slug);
+                continue;
+            }
             switch (field.type) {
                 case 'relation': {
                     if (field.multiple && Array.isArray(val)) {
-                        val.forEach((id) => {
-                            if (z.string().uuid().safeParse(id).success) {
+                        for (const id of val) {
+                            if (typeof id === 'string')
                                 entriesIds.push(id);
-                            }
-                        });
+                        }
                     }
                     else if (typeof val === 'string') {
-                        if (z.string().uuid().safeParse(val).success) {
-                            entriesIds.push(val);
-                        }
+                        entriesIds.push(val);
                     }
                     break;
                 }
                 case 'object':
-                    collectIds(val, field.fields);
+                    collectIds(val, field.fields, false);
                     break;
                 case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                             if (objectDef) {
-                                collectIds(item, objectDef.fields);
+                                collectIds(item, objectDef.fields, false);
                             }
                         });
                     }
                     break;
                 case 'content': {
                     const cf = field;
-                    // Content is now a single doc, not Record<lang, doc>
-                    if (val && typeof val === 'object' && val.type === 'doc' && cf.inlineBlocks?.length) {
+                    if (val &&
+                        typeof val === 'object' &&
+                        val.type === 'doc' &&
+                        cf.inlineBlocks?.length) {
                         walkInlineBlockNodes(val, (node) => {
                             const bd = node.attrs?.blockData;
                             if (!bd || typeof bd !== 'object')
                                 return;
                             const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
                             if (def)
-                                collectIds(bd, def.fields);
+                                collectIds(bd, def.fields, false);
                         });
                     }
                     break;
@@ -55,20 +74,97 @@ export async function resolveRelationFields(data, fields, language) {
             }
         }
     };
-    collectIds(data, fields);
+    collectIds(data, fields, true);
     if (entriesIds.length === 0)
         return data;
-    // Import getEntries dynamically to avoid circular dependency
-    const { getEntries } = await import('../entries/operations/get.js');
-    // Get fully populated entries
-    const entries = await getEntries({
-        ids: entriesIds,
-        language
-    });
-    const entriesMap = Object.fromEntries(entries.map((e) => [e._id, e]));
+    // Filter: don't fetch already-visited (cycle) or beyond maxDepth — those stay raw IDs
+    const overDepth = ctx.depth >= ctx.maxDepth;
+    const fetchableIds = overDepth
+        ? []
+        : [...new Set(entriesIds)].filter((id) => !ctx.visited.has(id));
+    const cms = getCMS();
+    // entriesMap: id → Entry (populated) | null (fetched but missing version/missing entry).
+    // Absent key = id was NOT fetched (cycle, max depth, top-level opt-out) → falls back to raw id.
+    const entriesMap = {};
+    if (fetchableIds.length > 0) {
+        const dbEntries = await cms.databaseAdapter.getEntries({ ids: fetchableIds });
+        const aliveDbEntries = dbEntries.filter((e) => e.archivedAt == null);
+        const aliveIds = new Set(aliveDbEntries.map((e) => e.id));
+        // Strict: missing entry / archived → null in nested
+        for (const id of fetchableIds) {
+            if (!aliveIds.has(id))
+                entriesMap[id] = null;
+        }
+        if (aliveDbEntries.length > 0) {
+            const versions = await cms.databaseAdapter.getEntryVersions({
+                entryIds: aliveDbEntries.map((e) => e.id),
+                lang: ctx.locale
+            });
+            const versionsByEntry = new Map();
+            for (const v of versions) {
+                const arr = versionsByEntry.get(v.entryId) ?? [];
+                arr.push(v);
+                versionsByEntry.set(v.entryId, arr);
+            }
+            // Lazy import to avoid static circular dep with populateEntry → resolveRelationFields
+            const { _populate } = await import('./populateEntry.js');
+            await Promise.all(aliveDbEntries.map(async (dbEntry) => {
+                const vs = versionsByEntry.get(dbEntry.id) ?? [];
+                const picked = pickVersion(vs, ctx.status);
+                if (!picked) {
+                    entriesMap[dbEntry.id] = null; // strict: missing version in locale → null
+                    return;
+                }
+                let config;
+                try {
+                    config = cms.getBySlug(dbEntry.slug);
+                }
+                catch {
+                    entriesMap[dbEntry.id] = null;
+                    return;
+                }
+                const nestedFields = getFieldsFromConfig(config);
+                const nestedCtx = {
+                    locale: ctx.locale,
+                    status: ctx.status,
+                    depth: ctx.depth + 1,
+                    maxDepth: ctx.maxDepth,
+                    visited: new Set([...ctx.visited, dbEntry.id]),
+                    populate: ctx.populate,
+                    entryId: dbEntry.id
+                };
+                try {
+                    const populated = await _populate(picked.data, nestedFields, nestedCtx);
+                    const slugPath = getEntrySlugPath(dbEntry.slug);
+                    const slugValue = getSlugFromEntryData(picked.data, slugPath, ctx.locale);
+                    const _url = slugValue ? getEntryPath(dbEntry.slug, slugValue) : undefined;
+                    entriesMap[dbEntry.id] = {
+                        _id: dbEntry.id,
+                        _slug: dbEntry.slug,
+                        _type: dbEntry.type,
+                        _publishedAt: picked.publishedAt,
+                        _url,
+                        ...(config.type === 'collection' && config.orderable
+                            ? { _sortOrder: dbEntry.sortOrder }
+                            : {}),
+                        ...populated
+                    };
+                }
+                catch (error) {
+                    console.error(`[CMS] Failed to populate nested entry ${dbEntry.id} (${dbEntry.slug}):`, error);
+                }
+            }));
+        }
+    }
+    const resolveRefId = (id) => {
+        // Has key (even if value is null) → use mapped value (Entry | null)
+        if (Object.prototype.hasOwnProperty.call(entriesMap, id))
+            return entriesMap[id];
+        // Not fetched (cycle, max depth, top-level opt-out) → raw ID
+        return id;
+    };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const resolveValues = (value, fields) => {
-        // Start with a copy of all original data to preserve non-field properties
+    const resolveValues = (value, fields, topLevel) => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const result = { ...value };
         for (const field of fields) {
@@ -77,33 +173,43 @@ export async function resolveRelationFields(data, fields, language) {
                 result[field.slug] = val;
                 continue;
             }
+            // Per-field opt-out at top level → raw passthrough
+            if (topLevel && optedOutFields.has(field.slug)) {
+                result[field.slug] = val;
+                continue;
+            }
             switch (field.type) {
                 case 'relation': {
                     if (field.multiple && Array.isArray(val)) {
-                        result[field.slug] = val.map((id) => entriesMap[id] ?? null);
+                        result[field.slug] = val.map((id) => typeof id === 'string' ? resolveRefId(id) : id);
+                    }
+                    else if (typeof val === 'string') {
+                        result[field.slug] = resolveRefId(val);
                     }
                     else {
-                        result[field.slug] = entriesMap[val] ?? null;
+                        result[field.slug] = val;
                     }
                     break;
                 }
                 case 'object':
-                    result[field.slug] = resolveValues(val, field.fields);
+                    result[field.slug] = resolveValues(val, field.fields, false);
                     break;
                 case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
                         const objectDef = field.of.find((objDef) => objDef.slug === item._slug);
                         if (objectDef) {
-                            return resolveValues(item, objectDef.fields);
+                            return resolveValues(item, objectDef.fields, false);
                         }
                         return item;
                     });
                     break;
                 case 'content': {
                     const cf = field;
-                    // Content is now a single doc, not Record<lang, doc>
-                    if (val && typeof val === 'object' && val.type === 'doc' && cf.inlineBlocks?.length) {
+                    if (val &&
+                        typeof val === 'object' &&
+                        val.type === 'doc' &&
+                        cf.inlineBlocks?.length) {
                         const cloned = cloneDoc(val);
                         walkInlineBlockNodes(cloned, (node) => {
                             const bd = node.attrs?.blockData;
@@ -112,7 +218,7 @@ export async function resolveRelationFields(data, fields, language) {
                             const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
                             if (!def)
                                 return;
-                            node.attrs.blockData = resolveValues(bd, def.fields);
+                            node.attrs.blockData = resolveValues(bd, def.fields, false);
                         });
                         result[field.slug] = cloned;
                     }
@@ -124,5 +230,5 @@ export async function resolveRelationFields(data, fields, language) {
         }
         return result;
     };
-    return resolveValues(data, fields);
+    return resolveValues(data, fields, true);
 }

package/dist/core/server/fields/resolveRichtextLinks.d.ts

@@ -1,3 +1,4 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function resolveRichtextLinks(data: EntryData, fields: Field[], language: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+export declare function resolveRichtextLinks(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/resolveRichtextLinks.js

@@ -34,7 +34,8 @@ function resolveContentDoc(doc, slugMap) {
     });
     return cloned;
 }
-export async function resolveRichtextLinks(data, fields, language) {
+export async function resolveRichtextLinks(data, fields, ctx) {
+    const language = ctx.locale;
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const collectIds = (value, fields) => {

package/dist/core/server/fields/resolveUrlFields.d.ts

@@ -1,3 +1,4 @@
 import type { EntryData, PopulatedEntryData } from '../../../types/entries.js';
 import type { Field } from '../../../types/fields.js';
-export declare function resolveUrlFields(data: EntryData, fields: Field[], language?: string): Promise<PopulatedEntryData>;
+import type { PopulateCtx } from '../entries/operations/resolveEntry.js';
+export declare function resolveUrlFields(data: EntryData, fields: Field[], ctx: PopulateCtx): Promise<PopulatedEntryData>;

package/dist/core/server/fields/resolveUrlFields.js

@@ -1,6 +1,6 @@
 import { urlFieldDataSchema, urlFieldDataWithRelationSchema } from '../../../schemas/field/url.js';
 import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
-import { getDbEntries, getDbEntryVersions } from '../entries/operations/get.js';
+import { _getDbEntries, _getDbEntryVersions } from '../entries/operations/get.js';
 import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from './slugResolver.js';
 import { isExternalUrl, mergeRel } from '../../fields/urlUtils.js';
 const FLAT_KEY = '_flat';
@@ -34,7 +34,8 @@ function applyExternalAutoDetect(resolvedUrl, extras) {
         }
     }
 }
-export async function resolveUrlFields(data, fields, language) {
+export async function resolveUrlFields(data, fields, ctx) {
+    const language = ctx.locale;
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const collectIds = (value, fields) => {
@@ -102,12 +103,12 @@ export async function resolveUrlFields(data, fields, language) {
     collectIds(data, fields);
     const slugMap = {};
     if (entriesIds.length > 0) {
-        // Use raw DB calls to avoid recursive populateEntryData → resolveUrlFields loop
-        const dbEntries = await getDbEntries({ ids: entriesIds });
+        // Use raw DB calls to avoid recursive _populate → resolveUrlFields loop
+        const dbEntries = await _getDbEntries({ ids: entriesIds });
         const entryIds = dbEntries.map((e) => e.id);
         if (entryIds.length > 0) {
             // Get published versions for the target language
-            const versions = await getDbEntryVersions({
+            const versions = await _getDbEntryVersions({
                 entryIds,
                 lang: language
             });