includio-cms 0.1.4 → 0.5.1

package/dist/core/fields/structuredToHtml.js

@@ -0,0 +1,161 @@
+const VOID_TAGS = new Set(['hr', 'br', 'img']);
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function resolveUrl(url, baseUrl) {
+    if (!baseUrl || !url)
+        return url;
+    if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith('//'))
+        return url;
+    return `${baseUrl.replace(/\/$/, '')}${url.startsWith('/') ? '' : '/'}${url}`;
+}
+function renderMarks(text, marks, options) {
+    if (!marks?.length)
+        return escapeHtml(text);
+    let html = escapeHtml(text);
+    for (const mark of marks) {
+        switch (mark.type) {
+            case 'bold':
+                html = `<strong>${html}</strong>`;
+                break;
+            case 'italic':
+                html = `<em>${html}</em>`;
+                break;
+            case 'underline':
+                html = `<u>${html}</u>`;
+                break;
+            case 'strike':
+                html = `<s>${html}</s>`;
+                break;
+            case 'code':
+                html = `<code>${html}</code>`;
+                break;
+            case 'highlight':
+                html = `<mark>${html}</mark>`;
+                break;
+            case 'link': {
+                const attrs = mark.attrs ?? {};
+                const href = resolveUrl(attrs.href ?? '', options.baseUrl);
+                const target = attrs.target;
+                const title = attrs.title;
+                const ariaLabel = attrs['aria-label'];
+                let attrStr = ` href="${escapeHtml(href)}"`;
+                if (target === '_blank') {
+                    attrStr += ` target="_blank" rel="noopener noreferrer"`;
+                }
+                else if (target) {
+                    attrStr += ` target="${escapeHtml(target)}"`;
+                }
+                if (title)
+                    attrStr += ` title="${escapeHtml(title)}"`;
+                if (ariaLabel)
+                    attrStr += ` aria-label="${escapeHtml(ariaLabel)}"`;
+                html = `<a${attrStr}>${html}</a>`;
+                break;
+            }
+        }
+    }
+    return html;
+}
+function renderNode(node, options) {
+    const children = node.content?.map((c) => renderNode(c, options)).join('') ?? '';
+    switch (node.type) {
+        case 'doc':
+            return children;
+        case 'text':
+            return renderMarks(node.text ?? '', node.marks, options);
+        case 'paragraph':
+            return `<p>${children}</p>`;
+        case 'heading': {
+            const level = node.attrs?.level ?? 2;
+            return `<h${level}>${children}</h${level}>`;
+        }
+        case 'blockquote':
+            return `<blockquote>${children}</blockquote>`;
+        case 'bulletList':
+            return `<ul>${children}</ul>`;
+        case 'orderedList':
+            return `<ol>${children}</ol>`;
+        case 'listItem':
+            return `<li>${children}</li>`;
+        case 'codeBlock': {
+            const lang = node.attrs?.language;
+            const langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : '';
+            return `<pre><code${langAttr}>${children}</code></pre>`;
+        }
+        case 'horizontalRule':
+            return '<hr>';
+        case 'hardBreak':
+            return '<br>';
+        case 'figure': {
+            const attrs = node.attrs ?? {};
+            const src = resolveUrl(attrs.src ?? '', options.baseUrl);
+            const alt = escapeHtml(attrs.alt ?? '');
+            const caption = attrs.caption;
+            const width = attrs.width;
+            const height = attrs.height;
+            let imgAttrs = ` src="${escapeHtml(src)}" alt="${alt}"`;
+            if (width)
+                imgAttrs += ` width="${width}"`;
+            if (height)
+                imgAttrs += ` height="${height}"`;
+            let html = `<figure><img${imgAttrs}>`;
+            if (caption)
+                html += `<figcaption>${escapeHtml(caption)}</figcaption>`;
+            html += '</figure>';
+            return html;
+        }
+        case 'image': {
+            const attrs = node.attrs ?? {};
+            const src = resolveUrl(attrs.src ?? '', options.baseUrl);
+            const alt = escapeHtml(attrs.alt ?? '');
+            const width = attrs.width;
+            const height = attrs.height;
+            let imgAttrs = ` src="${escapeHtml(src)}" alt="${alt}"`;
+            if (width)
+                imgAttrs += ` width="${width}"`;
+            if (height)
+                imgAttrs += ` height="${height}"`;
+            return `<img${imgAttrs}>`;
+        }
+        case 'video': {
+            const attrs = node.attrs ?? {};
+            const src = resolveUrl(attrs.src ?? '', options.baseUrl);
+            const poster = attrs.poster;
+            const width = attrs.width;
+            const height = attrs.height;
+            let videoAttrs = ' controls';
+            if (poster)
+                videoAttrs += ` poster="${escapeHtml(resolveUrl(poster, options.baseUrl))}"`;
+            if (width)
+                videoAttrs += ` width="${width}"`;
+            if (height)
+                videoAttrs += ` height="${height}"`;
+            return `<video${videoAttrs}><source src="${escapeHtml(src)}"></video>`;
+        }
+        case 'table':
+            return `<table>${children}</table>`;
+        case 'tableRow':
+            return `<tr>${children}</tr>`;
+        case 'tableCell':
+            return `<td>${children}</td>`;
+        case 'tableHeader':
+            return `<th>${children}</th>`;
+        case 'inlineBlock': {
+            const attrs = node.attrs ?? {};
+            const blockType = attrs.blockType;
+            const blockData = attrs.blockData ?? {};
+            return options.inlineBlock?.(blockType, blockData) ?? '';
+        }
+        default:
+            return children;
+    }
+}
+/** Convert a StructuredContentDoc to an HTML string. */
+export function structuredToHtml(doc, options = {}) {
+    return renderNode(doc, options);
+}

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

@@ -4,6 +4,7 @@ import { entryTypes } from '../../../../types/entries.js';
 import z from 'zod';
 import { getDbEntryOrThrow } from './get.js';
 import { generateZodSchemaFromFields } from '../../../fields/fieldSchemaToTs.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 export const createEntrySchema = z.object({
     slug: z.string(),
     type: z.enum(entryTypes)
@@ -32,7 +33,7 @@ export const createEntryVersion = async (data, options) => {
         const entry = await getDbEntryOrThrow({ id: data.entryId });
         const config = getCMS().getBySlug(entry.slug);
         const languages = getCMS().languages;
-        const schema = generateZodSchemaFromFields(config.fields, languages);
+        const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), languages);
         const parsedData = schema.safeParse(data.data);
         if (!parsedData.success) {
             throw Error('Invalid data: ' + JSON.stringify(parsedData.error.flatten()));

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

@@ -1,5 +1,6 @@
 import { getCMS } from '../../../cms.js';
 import { populateEntryData } from '../../fields/populateEntry.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 // Helper function to transform string values to localized objects
 function transformDataValuesToLocalized(dataValues, defaultLanguage) {
     const result = {};
@@ -70,16 +71,17 @@ export const getRawEntries = async (options) => {
             const scheduledVersion = publishedOrScheduledVersion && isScheduled
                 ? publishedOrScheduledVersion
                 : null;
-            // Draft = latest version by versionNumber
-            const draftVersions = versions
-                .sort((a, b) => b.versionNumber - a.versionNumber);
+            // Draft = latest non-published version by versionNumber
+            const draftVersion = versions
+                .filter((v) => v.id !== entry.publishedVersionId)
+                .sort((a, b) => b.versionNumber - a.versionNumber)[0] || null;
             return {
                 ...entry,
                 collection: getCMS().getBySlug(entry.slug),
                 versions: versions.sort((a, b) => b.versionNumber - a.versionNumber),
                 publishedVersion,
                 scheduledVersion,
-                draftVersion: draftVersions[0] || null
+                draftVersion
             };
         }
         catch {
@@ -92,7 +94,8 @@ export const getRawEntries = async (options) => {
 export const getRawEntry = async (options) => {
     const [entry] = await getRawEntries({
         ...options,
-        ids: options.id ? [options.id] : undefined
+        ids: options.id ? [options.id] : undefined,
+        includeArchived: options.includeArchived
     });
     return entry || null;
 };
@@ -237,7 +240,7 @@ export const getEntries = async (options = {}) => {
             const config = getCMS().getBySlug(dbEntry.slug);
             return {
                 ...dbEntry,
-                data: await populateEntryData(version.data, config.fields, language),
+                data: await populateEntryData(version.data, getFieldsFromConfig(config), language),
                 status,
                 publishedAt: dbEntry.publishedAt,
                 populated: true
@@ -295,7 +298,7 @@ export const getEntryVersion = async (options) => {
         const config = getCMS().getBySlug(dbEntry.slug);
         return {
             ...dbEntry,
-            data: await populateEntryData(dbEntryVersion.data, config.fields, language)
+            data: await populateEntryData(dbEntryVersion.data, getFieldsFromConfig(config), language)
         };
     }
     catch (error) {

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

@@ -17,4 +17,7 @@ export declare const updateEntryVersion: (id: string, data: Partial<DbEntryVersi
 export declare const updateEntryVersionCommandTypes: readonly ["draft", "published-now", "published-scheduled", "cancel-published"];
 export type UpdateEntryVersionCommandType = (typeof updateEntryVersionCommandTypes)[number];
 export declare const pruneOldDraftVersions: (entryId: string) => Promise<void>;
+export declare const upsertDraftVersion: (entryId: string, data: Record<string, unknown>, options?: {
+    skipValidation?: boolean;
+}) => Promise<DbEntryVersion>;
 export declare const unpublishEntry: (entryId: string) => Promise<void>;

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

@@ -1,7 +1,9 @@
 import { getCMS } from '../../../cms.js';
 import { generateZodSchemaFromFields } from '../../../fields/fieldSchemaToTs.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 import z from 'zod';
-import { getDbEntryOrThrow, getDbEntryVersionOrThrow } from './get.js';
+import { getDbEntryOrThrow, getDbEntryVersionOrThrow, getDbEntryVersions } from './get.js';
+import { createEntryVersion } from './create.js';
 export const updateEntrySchema = z.object({
     availableLocales: z.array(z.string()).optional(),
     archivedAt: z.date().nullable().optional(),
@@ -57,7 +59,7 @@ export const updateEntryVersion = async (id, data) => {
         const entry = await getDbEntryOrThrow({ id: version.entryId });
         const config = getCMS().getBySlug(entry.slug);
         const languages = getCMS().languages;
-        const schema = generateZodSchemaFromFields(config.fields, languages);
+        const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), languages);
         const parsedData = schema.safeParse(filteredData.data);
         if (!parsedData.success) {
             throw Error('Invalid data: ' + parsedData.error.flatten());
@@ -102,6 +104,32 @@ export const pruneOldDraftVersions = async (entryId) => {
         await Promise.all(toDelete.map((v) => getCMS().databaseAdapter.deleteEntryVersion({ id: v.id })));
     }
 };
+export const upsertDraftVersion = async (entryId, data, options) => {
+    const entry = await getDbEntryOrThrow({ id: entryId });
+    const versions = await getDbEntryVersions({ entryIds: [entryId] });
+    // Sort desc by versionNumber, find latest non-published draft
+    const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
+    const latestDraft = sorted.find((v) => v.id !== entry.publishedVersionId);
+    if (latestDraft) {
+        // Compare data — if identical, skip
+        const existingData = JSON.stringify(latestDraft.data);
+        const newData = JSON.stringify(data);
+        if (existingData === newData) {
+            return latestDraft;
+        }
+        // Different data — update in place
+        const updated = await getCMS().databaseAdapter.updateEntryVersion({
+            id: latestDraft.id,
+            data: {
+                data: data,
+                createdAt: new Date()
+            }
+        });
+        return updated;
+    }
+    // No draft exists — create new version
+    return createEntryVersion({ entryId, data }, options);
+};
 export const unpublishEntry = async (entryId) => {
     await updateEntry(entryId, {
         publishedVersionId: null,

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

@@ -0,0 +1,15 @@
+import type { SCNode, StructuredContentDoc, SCInlineBlockAttrs } from '../../../types/structured-content.js';
+export interface MediaRef {
+    type: 'image' | 'video';
+    src: string;
+    alt?: string;
+    mediaId?: string;
+}
+/** Extract block-level nodes, optionally filtered by type. */
+export declare function extractBlocks(doc: StructuredContentDoc, type?: string): SCNode[];
+/** Extract inline block nodes, optionally filtered by blockType. */
+export declare function extractInlineBlocks(doc: StructuredContentDoc, blockType?: string): SCInlineBlockAttrs[];
+/** Extract all plain text from doc (useful for excerpts, search indexing). */
+export declare function extractText(doc: StructuredContentDoc): string;
+/** Extract media references from figure/video/image nodes. */
+export declare function extractMediaRefs(doc: StructuredContentDoc): MediaRef[];

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

@@ -0,0 +1,65 @@
+import { walkNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
+/** Extract block-level nodes, optionally filtered by type. */
+export function extractBlocks(doc, type) {
+    const result = [];
+    walkNodes(doc.content, (node) => {
+        if (type ? node.type === type : !['doc', 'text'].includes(node.type)) {
+            result.push(node);
+        }
+    });
+    return result;
+}
+/** Extract inline block nodes, optionally filtered by blockType. */
+export function extractInlineBlocks(doc, blockType) {
+    const result = [];
+    walkNodes(doc.content, (node) => {
+        if (node.type !== 'inlineBlock' || !node.attrs)
+            return;
+        const attrs = node.attrs;
+        if (blockType ? attrs.blockType === blockType : true) {
+            result.push(attrs);
+        }
+    });
+    return result;
+}
+/** Extract all plain text from doc (useful for excerpts, search indexing). */
+export function extractText(doc) {
+    const parts = [];
+    walkNodes(doc.content, (node) => {
+        if (node.type === 'text' && node.text) {
+            parts.push(node.text);
+        }
+        else if (node.type === 'hardBreak') {
+            parts.push('\n');
+        }
+    });
+    return parts.join('');
+}
+/** Extract media references from figure/video/image nodes. */
+export function extractMediaRefs(doc) {
+    const refs = [];
+    walkNodes(doc.content, (node) => {
+        if (node.type === 'figure' || node.type === 'image') {
+            const attrs = node.attrs;
+            if (attrs?.src) {
+                refs.push({
+                    type: 'image',
+                    src: attrs.src,
+                    alt: attrs.alt ?? undefined,
+                    mediaId: attrs['data-media-id'] ?? undefined
+                });
+            }
+        }
+        else if (node.type === 'video') {
+            const attrs = node.attrs;
+            if (attrs?.src) {
+                refs.push({
+                    type: 'video',
+                    src: attrs.src,
+                    mediaId: attrs['data-media-id'] ?? undefined
+                });
+            }
+        }
+    });
+    return refs;
+}

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

@@ -3,6 +3,7 @@ const PUBLIC_URL = env.PUBLIC_URL ?? '';
 import { getCMS } from '../../cms.js';
 import z from 'zod';
 import { getImageStyles } from './utils/imageStyles.js';
+import { extractMediaIds as extractMediaIdsFromDoc, walkMediaNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 export async function resolveMediaFields(data, fields) {
     const mediaIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -39,7 +40,7 @@ export async function resolveMediaFields(data, fields) {
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             // Find the object definition for this item based on its slug
@@ -50,6 +51,17 @@ export async function resolveMediaFields(data, fields) {
                         });
                     }
                     break;
+                case 'content': {
+                    // Content field is localized: { lang: StructuredContentDoc }
+                    if (typeof val === 'object' && val !== null) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                mediaIds.push(...extractMediaIdsFromDoc(doc));
+                            }
+                        }
+                    }
+                    break;
+                }
             }
         }
     };
@@ -178,7 +190,7 @@ export async function resolveMediaFields(data, fields) {
                         data: await resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                case 'blocks':
                     result[field.slug] = await Promise.all(
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     val.map(async (item) => {
@@ -194,6 +206,43 @@ export async function resolveMediaFields(data, fields) {
                         return item;
                     }));
                     break;
+                case 'content': {
+                    // Content field is localized: { lang: StructuredContentDoc }
+                    if (typeof val === 'object' && val !== null) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                const cloned = cloneDoc(doc);
+                                walkMediaNodes(cloned, (node) => {
+                                    const mediaId = node.attrs?.['data-media-id'];
+                                    if (!mediaId)
+                                        return;
+                                    const mediaFile = mediaMap[mediaId];
+                                    if (!mediaFile)
+                                        return;
+                                    node.attrs.src = mediaFile.url;
+                                    if (mediaFile.width)
+                                        node.attrs.width = mediaFile.width;
+                                    if (mediaFile.height)
+                                        node.attrs.height = mediaFile.height;
+                                    if (mediaFile.alt && !node.attrs.alt)
+                                        node.attrs.alt = mediaFile.alt;
+                                    node.attrs._media = {
+                                        data: mediaFile,
+                                        ...(mediaFile.type === 'image' ? { blurDataUrl: mediaFile.blurDataUrl } : {})
+                                    };
+                                });
+                                resolved[lang] = cloned;
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
+                    }
+                    break;
+                }
                 default:
                     result[field.slug] = val;
             }

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

@@ -26,7 +26,7 @@ export async function resolveRelationFields(data, fields, language) {
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             // Find the object definition for this item based on its slug
@@ -78,7 +78,7 @@ export async function resolveRelationFields(data, fields, language) {
                         data: resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                case 'blocks':
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     result[field.slug] = val.map((item) => {
                         // Find the object definition for this item based on its slug

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

@@ -1,4 +1,6 @@
 import { getCMS } from '../../cms.js';
+import { extractEntryIds as extractEntryIdsFromDoc, extractMediaIds as extractMediaIdsFromDoc, cloneDoc, walkLinkMarks, walkInlineBlockNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
+import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
 const ENTRY_ID_RE = /data-entry-id="([0-9a-f-]{36})"/g;
 function extractEntryIds(html) {
     const ids = [];
@@ -7,15 +9,47 @@ function extractEntryIds(html) {
     }
     return ids;
 }
-function resolveHtml(html, entriesMap) {
+function resolveHtml(html, slugMap) {
     return html.replace(/<a\s([^>]*data-entry-id="([0-9a-f-]{36})"[^>]*)>/g, (match, _attrs, id) => {
-        const entryData = entriesMap[id]?.data;
-        const slug = entryData?.seo?.slug;
+        const slug = slugMap[id];
         if (!slug)
             return match;
         return match.replace(/href="[^"]*"/, `href="${slug}"`);
     });
 }
+/** Extract entry IDs from inlineBlock blockData relation fields. */
+function extractEntryIdsFromInlineBlocks(doc) {
+    const ids = [];
+    walkInlineBlockNodes(doc, (node) => {
+        const data = node.attrs?.blockData;
+        if (!data || typeof data !== 'object')
+            return;
+        for (const val of Object.values(data)) {
+            if (typeof val === 'string' && val.length === 36)
+                ids.push(val);
+            if (Array.isArray(val)) {
+                for (const item of val) {
+                    if (typeof item === 'string' && item.length === 36)
+                        ids.push(item);
+                }
+            }
+        }
+    });
+    return ids;
+}
+function resolveContentDoc(doc, slugMap) {
+    const cloned = cloneDoc(doc);
+    walkLinkMarks(cloned, (mark) => {
+        const entryId = mark.attrs?.['data-entry-id'];
+        if (!entryId)
+            return;
+        const slug = slugMap[entryId];
+        if (slug && mark.attrs) {
+            mark.attrs.href = slug;
+        }
+    });
+    return cloned;
+}
 export async function resolveRichtextLinks(data, fields, language) {
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -39,10 +73,22 @@ export async function resolveRichtextLinks(data, fields, language) {
                     }
                     break;
                 }
+                case 'content': {
+                    // Content field is localized: { lang: StructuredContentDoc, ... }
+                    if (typeof val === 'object' && val !== null) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                entriesIds.push(...extractEntryIdsFromDoc(doc));
+                                entriesIds.push(...extractEntryIdsFromInlineBlocks(doc));
+                            }
+                        }
+                    }
+                    break;
+                }
                 case 'object':
                     collectIds(val.data, field.fields);
                     break;
-                case 'array':
+                case 'blocks':
                     if (Array.isArray(val)) {
                         val.forEach((item) => {
                             const objectDef = field.of.find((objDef) => objDef.slug === item.slug);
@@ -71,15 +117,20 @@ export async function resolveRichtextLinks(data, fields, language) {
     const versions = await db.getEntryVersions({
         ids: publishedVersionIds
     });
-    // Build map: entryId → { data: { seo: { slug } } } using raw version data
-    const entriesMap = {};
+    // Build map: entryId → collectionSlug for config lookup
+    const entryConfigSlugMap = {};
+    for (const entry of entries) {
+        entryConfigSlugMap[entry.id] = entry.slug;
+    }
+    // Build map: entryId → resolved slug string
+    const slugMap = {};
     for (const version of versions) {
         const rawData = version.data;
-        const seoRaw = rawData?.seo;
-        const slugField = seoRaw?.slug;
-        const slug = slugField?.[language];
+        const configSlug = entryConfigSlugMap[version.entryId];
+        const slugPath = configSlug ? getEntrySlugPath(configSlug) : 'seo.slug';
+        const slug = getSlugFromEntryData(rawData, slugPath, language);
         if (slug) {
-            entriesMap[version.entryId] = { data: { seo: { slug } } };
+            slugMap[version.entryId] = slug;
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -99,12 +150,28 @@ export async function resolveRichtextLinks(data, fields, language) {
                         const resolved = {};
                         for (const [lang, html] of Object.entries(val)) {
                             resolved[lang] =
-                                typeof html === 'string' ? resolveHtml(html, entriesMap) : html;
+                                typeof html === 'string' ? resolveHtml(html, slugMap) : html;
                         }
                         result[field.slug] = resolved;
                     }
                     else if (typeof val === 'string') {
-                        result[field.slug] = resolveHtml(val, entriesMap);
+                        result[field.slug] = resolveHtml(val, slugMap);
+                    }
+                    break;
+                }
+                case 'content': {
+                    if (typeof val === 'object' && val !== null) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                resolved[lang] = resolveContentDoc(doc, slugMap);
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
                     }
                     break;
                 }
@@ -114,7 +181,7 @@ export async function resolveRichtextLinks(data, fields, language) {
                         data: resolveValues(val.data, field.fields)
                     };
                     break;
-                case 'array':
+                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);