includio-cms 0.7.2 → 0.13.0

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

@@ -1,31 +1,7 @@
 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 = {};
-    function transformValue(value) {
-        if (typeof value === 'string') {
-            // Transform string to localized object with default language
-            return { [defaultLanguage]: value };
-        }
-        if (Array.isArray(value)) {
-            return value.map(transformValue);
-        }
-        if (value && typeof value === 'object') {
-            const transformed = {};
-            Object.entries(value).forEach(([key, val]) => {
-                transformed[key] = transformValue(val);
-            });
-            return transformed;
-        }
-        return value;
-    }
-    Object.entries(dataValues).forEach(([key, value]) => {
-        result[key] = transformValue(value);
-    });
-    return result;
-}
+import { getEntrySlugPath, getSlugFromEntryData, getEntryPath } from '../../fields/slugResolver.js';
 export const getDbEntries = async (options) => {
     return getCMS().databaseAdapter.getEntries(options);
 };
@@ -50,6 +26,33 @@ export const getDbEntryOrThrow = async (options) => {
 export const countRawEntries = async (options) => {
     return countDbEntries(options);
 };
+/** Helper: group versions by lang into per-lang published/scheduled/draft maps */
+function buildPerLangVersionMaps(versions) {
+    const now = new Date();
+    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) || [];
+        arr.push(v);
+        byLang.set(v.lang, arr);
+    }
+    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;
+        draftVersions[lang] = draft;
+    }
+    return { publishedVersions, scheduledVersions, draftVersions };
+}
 export const getRawEntries = async (options) => {
     const dbEntries = await getDbEntries(options);
     const entries = await Promise.all(dbEntries.map(async (entry) => {
@@ -57,31 +60,14 @@ export const getRawEntries = async (options) => {
             const versions = await getCMS().databaseAdapter.getEntryVersions({
                 entryIds: [entry.id]
             });
-            // Published/scheduled version from entry-level publishedVersionId
-            const publishedOrScheduledVersion = entry.publishedVersionId
-                ? versions.find((v) => v.id === entry.publishedVersionId) || null
-                : null;
-            // Determine if it's published or scheduled based on entry.publishedAt
-            const isScheduled = publishedOrScheduledVersion &&
-                entry.publishedAt &&
-                entry.publishedAt > new Date();
-            const publishedVersion = publishedOrScheduledVersion && !isScheduled
-                ? publishedOrScheduledVersion
-                : null;
-            const scheduledVersion = publishedOrScheduledVersion && isScheduled
-                ? publishedOrScheduledVersion
-                : null;
-            // 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;
+            const { publishedVersions, scheduledVersions, draftVersions } = buildPerLangVersionMaps(versions);
             return {
                 ...entry,
                 collection: getCMS().getBySlug(entry.slug),
                 versions: versions.sort((a, b) => b.versionNumber - a.versionNumber),
-                publishedVersion,
-                scheduledVersion,
-                draftVersion
+                publishedVersions,
+                scheduledVersions,
+                draftVersions
             };
         }
         catch {
@@ -106,60 +92,56 @@ export const getRawEntryOrThrow = async (options) => {
     }
     return entry;
 };
-function getNestedValue(obj, keys) {
-    let current = obj;
-    for (const key of keys) {
-        if (current === null || current === undefined || typeof current !== 'object')
-            return undefined;
-        current = current[key];
-    }
-    return current;
-}
-function matchesDataValues(data, filter, prefix = []) {
-    for (const [key, value] of Object.entries(filter)) {
-        const path = [...prefix, key];
-        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-            if (!matchesDataValues(data, value, path))
-                return false;
-        }
-        else {
-            const actual = getNestedValue(data, path);
-            if (actual !== value)
-                return false;
-        }
-    }
-    return true;
-}
-function matchesDataLike(data, filter, prefix = []) {
-    for (const [key, value] of Object.entries(filter)) {
-        const path = [...prefix, key];
-        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-            if (!matchesDataLike(data, value, path))
-                return false;
-        }
-        else if (typeof value === 'string') {
-            const actual = getNestedValue(data, path);
-            if (typeof actual !== 'string')
-                return false;
-            if (!actual.toLowerCase().includes(value.toLowerCase()))
-                return false;
-        }
-    }
-    return true;
-}
 export const getEntries = async (options = {}) => {
-    const language = options.language || getCMS().languages[0];
+    const cms = getCMS();
+    const language = options.language || cms.languages[0];
     const status = options.status || 'published';
-    const dataValues = options.dataValues
-        ? transformDataValuesToLocalized(options.dataValues, language)
-        : undefined;
-    const dataLike = options.dataLike
-        ? transformDataValuesToLocalized(options.dataLike, language)
-        : undefined;
+    // 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);
+                const slugPath = getEntrySlugPath(entry.slug);
+                const slug = getSlugFromEntryData(version.data, slugPath, language);
+                const _url = slug ? getEntryPath(entry.slug, slug) : undefined;
+                return {
+                    _id: entry.id,
+                    _slug: entry.slug,
+                    _type: entry.type,
+                    _publishedAt: version.publishedAt,
+                    _url,
+                    ...populatedData
+                };
+            }
+            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;
-    // Get entries that match the slug/ids filter
-    const dbEntries = await getCMS().databaseAdapter.getEntries({
+    const dataValues = options.dataValues;
+    const dataLike = options.dataLike;
+    const dataILikeOr = options.dataILikeOr;
+    const dbEntries = await cms.databaseAdapter.getEntries({
         ids,
         slug,
         orderBy: options.orderBy
@@ -167,87 +149,70 @@ export const getEntries = async (options = {}) => {
     if (dbEntries.length === 0) {
         return [];
     }
-    // Filter entries by status at entry level
+    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 filteredEntries = dbEntries.filter((entry) => {
+    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':
-                return entry.publishedVersionId != null && entry.publishedAt != null && entry.publishedAt <= now;
+                picked = sorted.find((v) => v.publishedAt != null && v.publishedAt <= now) || null;
+                break;
             case 'scheduled':
-                return entry.publishedVersionId != null && entry.publishedAt != null && entry.publishedAt > now;
+                picked = sorted.find((v) => v.publishedAt != null && v.publishedAt > now) || null;
+                break;
             case 'draft':
-                return entry.publishedVersionId == null;
+                picked = sorted.find((v) => v.publishedAt == null) || null;
+                break;
             case 'archived':
-                return entry.archivedAt != null;
-            default:
-                return true;
+                picked = sorted[0] || null;
+                break;
         }
-    });
-    if (filteredEntries.length === 0) {
-        return [];
-    }
-    // Build entries map for quick lookup
-    const entriesMap = new Map(filteredEntries.map((entry) => [entry.id, entry]));
-    const entryIds = filteredEntries.map((entry) => entry.id);
-    // For published/scheduled: get the specific published version
-    // For draft: get latest version (highest versionNumber)
-    let versionEntries;
-    if (status === 'published' || status === 'scheduled') {
-        // Get published versions by their IDs
-        const publishedVersionIds = filteredEntries
-            .map((e) => e.publishedVersionId)
-            .filter((id) => id != null);
-        if (publishedVersionIds.length === 0)
-            return [];
-        const versions = await getCMS().databaseAdapter.getEntryVersions({
-            ids: publishedVersionIds
-        });
-        versionEntries = versions
-            .map((v) => {
-            const dbEntry = entriesMap.get(v.entryId);
-            if (!dbEntry)
-                return null;
-            return { version: v, dbEntry };
-        })
-            .filter((e) => e != null);
-    }
-    else {
-        // Draft/archived: get all versions and pick latest
-        const allVersions = await getCMS().databaseAdapter.getEntryVersions({
-            entryIds
-        });
-        const latestByEntry = new Map();
-        for (const version of allVersions) {
-            const dbEntry = entriesMap.get(version.entryId);
-            if (!dbEntry)
-                continue;
-            const existing = latestByEntry.get(version.entryId);
-            if (!existing || version.versionNumber > existing.version.versionNumber) {
-                latestByEntry.set(version.entryId, { version, dbEntry });
-            }
+        if (picked) {
+            versionEntries.push({ version: picked, dbEntry });
         }
-        versionEntries = Array.from(latestByEntry.values());
     }
-    // Re-sort to match original entry order (DB returns sorted by sortOrder, but version fetch may reorder)
     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));
-    // Post-filter: apply dataValues/dataLike on versions
-    if (dataValues) {
-        versionEntries = versionEntries.filter((e) => matchesDataValues(e.version.data, dataValues));
-    }
-    if (dataLike) {
-        versionEntries = versionEntries.filter((e) => matchesDataLike(e.version.data, dataLike));
-    }
-    // Process entries in parallel
     const entries = await Promise.all(versionEntries.map(async ({ version, dbEntry }) => {
         try {
-            const config = getCMS().getBySlug(dbEntry.slug);
+            const config = cms.getBySlug(dbEntry.slug);
+            const fields = getFieldsFromConfig(config);
+            const populatedData = await populateEntryData(version.data, fields, language);
+            const slugPath = getEntrySlugPath(dbEntry.slug);
+            const slug = getSlugFromEntryData(version.data, slugPath, language);
+            const _url = slug ? getEntryPath(dbEntry.slug, slug) : undefined;
             return {
-                ...dbEntry,
-                data: await populateEntryData(version.data, getFieldsFromConfig(config), language),
-                status,
-                publishedAt: dbEntry.publishedAt,
-                populated: true
+                _id: dbEntry.id,
+                _slug: dbEntry.slug,
+                _type: dbEntry.type,
+                _publishedAt: version.publishedAt,
+                _url,
+                ...populatedData
             };
         }
         catch (error) {
@@ -255,7 +220,31 @@ export const getEntries = async (options = {}) => {
             return null;
         }
     }));
-    return entries.filter((e) => e !== 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({
@@ -282,41 +271,38 @@ export const getEntryLabels = async (options) => {
     });
     if (dbEntries.length === 0)
         return [];
-    // Filter by status at entry level
+    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
+    });
     const now = new Date();
     const statusFilter = options.status ?? 'all';
-    const filteredDbEntries = statusFilter === 'all'
-        ? dbEntries
-        : dbEntries.filter((entry) => {
-            if (statusFilter === 'published') {
-                return entry.publishedVersionId != null && entry.publishedAt != null && entry.publishedAt <= now;
-            }
-            // draft
-            return entry.publishedVersionId == null;
-        });
-    if (filteredDbEntries.length === 0)
-        return [];
-    const entryIds = filteredDbEntries.map((e) => e.id);
-    const allVersions = await cms.databaseAdapter.getEntryVersions({ entryIds });
-    const language = cms.languages[0];
     const entryAdminTitle = config.entryAdminTitle;
-    let results = filteredDbEntries.map((entry) => {
-        // Pick published version or latest draft
+    let results = dbEntries.map((entry) => {
         const entryVersions = allVersions.filter((v) => v.entryId === entry.id);
-        const publishedVersion = entry.publishedVersionId
-            ? entryVersions.find((v) => v.id === entry.publishedVersionId)
-            : null;
-        const latestVersion = publishedVersion ??
-            entryVersions.sort((a, b) => b.versionNumber - a.versionNumber)[0] ?? null;
+        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)
+            return null;
+        const latestVersion = publishedVersion ?? sorted[0] ?? null;
         let label = entry.id;
         if (entryAdminTitle && latestVersion) {
             const titleData = latestVersion.data[entryAdminTitle];
-            if (titleData && typeof titleData === 'object') {
-                label = String(titleData[language] || Object.values(titleData)[0] || entry.id);
+            // Data is now flat — titleData is the string directly
+            if (typeof titleData === 'string') {
+                label = titleData || entry.id;
             }
         }
         return { id: entry.id, label };
-    });
+    }).filter((r) => r != null);
     // Post-query search filtering (case-insensitive includes)
     if (options.search) {
         const searchLower = options.search.toLowerCase();
@@ -358,9 +344,18 @@ export const getEntryVersion = async (options) => {
     }
     try {
         const config = getCMS().getBySlug(dbEntry.slug);
+        const fields = getFieldsFromConfig(config);
+        const populatedData = await populateEntryData(dbEntryVersion.data, fields, language);
+        const slugPath = getEntrySlugPath(dbEntry.slug);
+        const entrySlug = getSlugFromEntryData(dbEntryVersion.data, slugPath, language);
+        const _url = entrySlug ? getEntryPath(dbEntry.slug, entrySlug) : undefined;
         return {
-            ...dbEntry,
-            data: await populateEntryData(dbEntryVersion.data, getFieldsFromConfig(config), language)
+            _id: dbEntry.id,
+            _slug: dbEntry.slug,
+            _type: dbEntry.type,
+            _publishedAt: dbEntryVersion.publishedAt,
+            _url,
+            ...populatedData
         };
     }
     catch (error) {

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

@@ -1,11 +1,7 @@
 import type { DbEntry, DbEntryVersion } from '../../../../types/entries.js';
 import z from 'zod';
 export declare const updateEntrySchema: z.ZodObject<{
-    availableLocales: z.ZodOptional<z.ZodArray<z.ZodString>>;
     archivedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
-    publishedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
-    publishedVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    publishedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     sortOrder: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.z.core.$strip>;
 export declare const updateEntry: (id: string, data: Partial<DbEntry>) => Promise<DbEntry>;
@@ -17,8 +13,11 @@ export declare const updateEntryVersionSchema: z.ZodObject<{
 export declare const updateEntryVersion: (id: string, data: Partial<DbEntryVersion>) => Promise<DbEntryVersion>;
 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?: {
+/** Prune old draft versions scoped to (entryId, lang) */
+export declare const pruneOldDraftVersions: (entryId: string, lang: string) => Promise<void>;
+/** Upsert draft version scoped to (entryId, lang) */
+export declare const upsertDraftVersion: (entryId: string, data: Record<string, unknown>, lang: string, options?: {
     skipValidation?: boolean;
 }) => Promise<DbEntryVersion>;
-export declare const unpublishEntry: (entryId: string) => Promise<void>;
+/** Unpublish a specific language version for an entry */
+export declare const unpublishEntryLang: (entryId: string, lang: string) => Promise<void>;

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

@@ -5,11 +5,7 @@ import z from 'zod';
 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(),
-    publishedAt: z.date().nullable().optional(),
-    publishedVersionId: z.string().uuid().nullable().optional(),
-    publishedBy: z.string().nullable().optional(),
     sortOrder: z.number().int().nullable().optional()
 });
 export const updateEntry = async (id, data) => {
@@ -19,21 +15,9 @@ export const updateEntry = async (id, data) => {
     }
     const filteredData = filteredDataParse.data;
     const dataToUpdate = {};
-    if (filteredData.availableLocales !== undefined) {
-        dataToUpdate.availableLocales = filteredData.availableLocales;
-    }
     if (filteredData.archivedAt !== undefined) {
         dataToUpdate.archivedAt = filteredData.archivedAt;
     }
-    if (filteredData.publishedAt !== undefined) {
-        dataToUpdate.publishedAt = filteredData.publishedAt;
-    }
-    if (filteredData.publishedVersionId !== undefined) {
-        dataToUpdate.publishedVersionId = filteredData.publishedVersionId;
-    }
-    if (filteredData.publishedBy !== undefined) {
-        dataToUpdate.publishedBy = filteredData.publishedBy;
-    }
     if (filteredData.sortOrder !== undefined) {
         dataToUpdate.sortOrder = filteredData.sortOrder;
     }
@@ -63,7 +47,10 @@ 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(getFieldsFromConfig(config), languages);
+        // Validate with localized: false — data is flat single-language
+        const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), languages, {
+            localized: false
+        });
         const parsedData = schema.safeParse(filteredData.data);
         if (!parsedData.success) {
             throw Error('Invalid data: ' + parsedData.error.flatten());
@@ -92,28 +79,27 @@ export const updateEntryVersionCommandTypes = [
     'cancel-published'
 ];
 const MAX_DRAFT_VERSIONS = 10;
-export const pruneOldDraftVersions = async (entryId) => {
-    const entry = await getDbEntryOrThrow({ id: entryId });
+/** Prune old draft versions scoped to (entryId, lang) */
+export const pruneOldDraftVersions = async (entryId, lang) => {
     const versions = await getCMS().databaseAdapter.getEntryVersions({
-        entryIds: [entryId]
+        entryIds: [entryId],
+        lang
     });
     // Sort by version number desc
     const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
-    // Published/scheduled version is identified by entry.publishedVersionId
-    const publishedVersionId = entry.publishedVersionId;
-    const draftVersions = sorted.filter((v) => v.id !== publishedVersionId);
-    // Keep published version + up to MAX_DRAFT_VERSIONS drafts
+    // Keep published versions + up to MAX_DRAFT_VERSIONS drafts
+    const draftVersions = sorted.filter((v) => v.publishedAt == null);
     if (draftVersions.length > MAX_DRAFT_VERSIONS) {
         const toDelete = draftVersions.slice(MAX_DRAFT_VERSIONS);
         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
+/** Upsert draft version scoped to (entryId, lang) */
+export const upsertDraftVersion = async (entryId, data, lang, options) => {
+    const versions = await getDbEntryVersions({ entryIds: [entryId], lang });
+    // Sort desc by versionNumber, find latest unpublished draft
     const sorted = versions.sort((a, b) => b.versionNumber - a.versionNumber);
-    const latestDraft = sorted.find((v) => v.id !== entry.publishedVersionId);
+    const latestDraft = sorted.find((v) => v.publishedAt == null);
     if (latestDraft) {
         // Compare data — if identical, skip
         const existingData = JSON.stringify(latestDraft.data);
@@ -132,17 +118,13 @@ export const upsertDraftVersion = async (entryId, data, options) => {
         return updated;
     }
     // No draft exists — create new version
-    return createEntryVersion({ entryId, data }, options);
+    return createEntryVersion({ entryId, lang, data }, options);
 };
-export const unpublishEntry = async (entryId) => {
-    await updateEntry(entryId, {
-        publishedVersionId: null,
-        publishedAt: null,
-        publishedBy: null
-    });
-    // Dual-write: clear version-level publishedAt for backward compat
+/** Unpublish a specific language version for an entry */
+export const unpublishEntryLang = async (entryId, lang) => {
     const versions = await getCMS().databaseAdapter.getEntryVersions({
-        entryIds: [entryId]
+        entryIds: [entryId],
+        lang
     });
     await Promise.all(versions
         .filter((v) => v.publishedAt !== null)