nextjs-cms 0.8.9 → 0.9.0

package/dist/api/lib/serverActions.js

@@ -14,12 +14,13 @@ import sharp from 'sharp';
 import { readChunk } from 'read-chunk';
 import { fileTypeFromBuffer } from 'file-type';
 import { getCMSConfig } from '../../core/config/index.js';
+import { resolveLocale } from '../../core/localization/index.js';
 import { getPluginRoutes } from '../../plugins/loader.js';
 import through2 from 'through2';
 import { recordLog } from '../../logging/index.js';
 import getString from '../../translations/index.js';
-import { resolveLocalizedString } from '../../translations/localization.js';
-import { resolveLocale } from '../../translations/locale-utils.js';
+import { resolveMultilingualString } from '../../translations/language-utils.js';
+import { resolveLanguage } from '../../translations/language-utils.js';
 export const isAccessAllowed = async ({ sectionName, role, userId, }) => {
     /**
      * Check admin privileges
@@ -57,14 +58,14 @@ export const getDocument = async (session, input) => {
     if (!section?.name) {
         throw new TRPCError({
             code: 'BAD_REQUEST',
-            message: getString('invalidFilePath', session.user.locale),
+            message: getString('invalidFilePath', session.user.language),
         });
     }
     const fieldConfig = section.fields.find((field) => field.name === fieldName);
     if (!fieldConfig || typeof fieldConfig.build !== 'function') {
         throw new TRPCError({
             code: 'BAD_REQUEST',
-            message: getString('invalidRequest', session.user.locale),
+            message: getString('invalidRequest', session.user.language),
         });
     }
     const field = fieldConfig.build();
@@ -74,7 +75,7 @@ export const getDocument = async (session, input) => {
     if (!field || !field.name || !field.extensions || field.extensions.length === 0) {
         throw new TRPCError({
             code: 'BAD_REQUEST',
-            message: getString('invalidRequest', session.user.locale),
+            message: getString('invalidRequest', session.user.language),
         });
     }
     /**
@@ -90,7 +91,7 @@ export const getDocument = async (session, input) => {
     if (!fs.existsSync(pathToFile)) {
         throw new TRPCError({
             code: 'BAD_REQUEST',
-            message: getString('fileNotFound', session.user.locale),
+            message: getString('fileNotFound', session.user.language),
         });
     }
     /**
@@ -107,7 +108,7 @@ export const getDocument = async (session, input) => {
     if (!fileType) {
         throw new TRPCError({
             code: 'BAD_REQUEST',
-            message: getString('invalidFileType', session.user.locale),
+            message: getString('invalidFileType', session.user.language),
         });
     }
     /**
@@ -116,7 +117,7 @@ export const getDocument = async (session, input) => {
     if (!documentAllowedExtensions.includes(fileType.ext)) {
         throw new TRPCError({
             code: 'BAD_REQUEST',
-            message: getString('invalidFileType', session.user.locale),
+            message: getString('invalidFileType', session.user.language),
         });
     }
     /**
@@ -252,8 +253,8 @@ export async function streamPhoto(input) {
     const nodeStream = processedImage.pipe(through2());
     return nodeStreamToWebStream(nodeStream, processedImage);
 }
-export const getVideo = async (input) => {
-    throw new Error(getString('useVideoApiRoute', 'en'));
+export const getVideo = async (session, input) => {
+    throw new Error(getString('useVideoApiRoute', session.user.language));
 };
 export const getAdminPrivileges = async (adminId) => {
     const rows = await db
@@ -266,17 +267,17 @@ export const getAllPrivileges = async (session) => {
     const [sections, pluginRoutes] = await Promise.all([SectionFactory.getSections(), getPluginRoutes()]);
     // Get the locale for resolving localized titles
     const cmsConfig = await getCMSConfig();
-    const locale = resolveLocale(session.user.locale, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+    const language = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
     // First, let's assign the static privileges
     const privilegesList = [];
     // Now, let's add the rest of the privileges to the list
     sections.forEach((section, index) => {
         let title;
         if (typeof section.title === 'string') {
-            title = resolveLocalizedString(section.title, locale, cmsConfig.i18n.fallbackLanguage);
+            title = resolveMultilingualString(section.title, language, cmsConfig.i18n.fallbackLanguage);
         }
         else {
-            title = resolveLocalizedString(section.title.section, locale, cmsConfig.i18n.fallbackLanguage);
+            title = resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage);
         }
         privilegesList.push({
             title,
@@ -290,7 +291,7 @@ export const getAllPrivileges = async (session) => {
         if (pluginPrivileges.has(route.pluginName))
             return;
         pluginPrivileges.set(route.pluginName, {
-            title: resolveLocalizedString(route.title, locale, cmsConfig.i18n.fallbackLanguage),
+            title: resolveMultilingualString(route.title, language, cmsConfig.i18n.fallbackLanguage),
         });
     });
     Array.from(pluginPrivileges.entries()).forEach(([pluginName, meta], index) => {
@@ -301,7 +302,7 @@ export const getAllPrivileges = async (session) => {
             sectionType: 'plugin',
         });
     });
-    privilegesList.push({ title: 'Admins', order: 0, sectionName: 'admins', sectionType: 'static' }, { title: 'Log', order: 2, sectionName: 'log', sectionType: 'static' });
+    privilegesList.push({ title: getString('admins', language), order: 0, sectionName: 'admins', sectionType: 'static' }, { title: getString('log', language), order: 2, sectionName: 'log', sectionType: 'static' });
     return privilegesList;
 };
 export const getAdminsList = async () => {
@@ -326,8 +327,30 @@ export const getAdminsList = async () => {
     });
     return adminsWithRoles;
 };
-export const createSimpleSectionPage = async (session, sectionName) => {
+export const createSimpleSectionPage = async (session, sectionName, locale) => {
     try {
+        const cmsConfig = await getCMSConfig();
+        const localeResult = resolveLocale({
+            localization: cmsConfig.localization,
+            locale,
+        });
+        if (locale && !localeResult.resolvedLocale) {
+            if (localeResult.localizationEnabled === false) {
+                return {
+                    error: {
+                        message: getString('localizationNotEnabledForSection', session.user.language),
+                    },
+                };
+            }
+            return {
+                error: {
+                    message: getString('invalidLocale', session.user.language, {
+                        locale,
+                        locales: localeResult.availableLocales.map((l) => l.code).join(', '),
+                    }),
+                },
+            };
+        }
         /**
          * Let's fetch the section information
          */
@@ -346,41 +369,90 @@ export const createSimpleSectionPage = async (session, sectionName) => {
             };
         }
         await fieldsFactory.generateFields();
-        /**
-         * Let's check for variants
-         */
-        /*const variants = section[0].variants
-        const sectionVariants: { name: string }[] = []
-
-        if (variants && variants.trim() !== '') {
-            /!**
-             * Convert to JSON
-             *!/
-            const variantsJson = JSON.parse(variants)
-
-            /!**
-             * Loop through the variants
-             *!/
-
-            variantsJson.forEach((variant: any) => {
-                const variantName = variant.name
-                const variantInfo = variant.info
-            })
-        }*/
         const sectionInfo = fieldsFactory.sectionInfo;
         const gallery = await sectionInfo.getGallery();
         // Get the locale for resolving localized titles
-        const cmsConfig = await getCMSConfig();
-        const locale = resolveLocale(session.user.locale, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
-        const resolvedTitle = resolveLocalizedString(sectionInfo.title, locale, cmsConfig.i18n.fallbackLanguage);
+        const uiLanguage = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+        const resolvedTitle = resolveMultilingualString(sectionInfo.title, uiLanguage, cmsConfig.i18n.fallbackLanguage);
+        /**
+         * Fetch localization metadata for sections with localized fields
+         */
+        let localizationData = null;
+        if (localeResult.localizationEnabled) {
+            let existingTranslations = [];
+            if (sectionInfo.hasLocalizedFields) {
+                const localesTableName = sectionInfo.localesTableName;
+                const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+                const localeTableExists = localeColumns.length > 0;
+                if (localeTableExists) {
+                    // Simple sections always have itemId = 1
+                    const sectionItemId = 1;
+                    const [rows] = await db.execute(sql `SELECT locale FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId}`);
+                    existingTranslations = rows.map((r) => r.locale);
+                    // Override localized field values with locale-specific data
+                    if (locale && localeResult.resolvedLocale && localeResult.isDefault === false) {
+                        const [localeRows] = await db.execute(sql `SELECT * FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${localeResult.resolvedLocale.code} LIMIT 1`);
+                        const localeRow = localeRows[0] ?? null;
+                        for (const field of sectionInfo.fields) {
+                            if (!field.localized)
+                                continue;
+                            // For select/tags with destinationDb, fetch locale-scoped junction values
+                            const f = field;
+                            if (f.destinationDb && (field.type === 'select' || field.type === 'select_multiple')) {
+                                if (f.db) {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` a JOIN \`${sql.raw(f.db.table)}\` b ON a.\`${sql.raw(f.destinationDb.selectIdentifier)}\` = b.\`${sql.raw(f.db.identifier)}\` WHERE a.\`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND a.\`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: row[f.db.label],
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                                else {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: f.options?.find((opt) => opt.value?.toString() ===
+                                                row[f.destinationDb.selectIdentifier]?.toString())?.label ?? '',
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                            }
+                            else if (f.destinationDb && field.type === 'tags') {
+                                const [_rows] = await db.execute(sql `SELECT \`${sql.raw(f.destinationDb.selectIdentifier)}\` FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                const tags = Array.isArray(_rows)
+                                    ? _rows.map((row) => row[f.destinationDb.selectIdentifier])
+                                    : [];
+                                field.setValue(tags.join(','));
+                            }
+                            else {
+                                // Simple field: override from locale row
+                                field.setValue(localeRow ? (localeRow[field.name] ?? null) : null);
+                            }
+                        }
+                    }
+                }
+            }
+            localizationData = {
+                defaultLocale: localeResult.defaultLocale,
+                currentLocale: localeResult.resolvedLocale ?? localeResult.defaultLocale,
+                existingTranslations,
+                locales: localeResult.availableLocales,
+            };
+        }
         return {
             section: {
                 name: sectionInfo.name,
                 title: resolvedTitle,
                 gallery: gallery,
                 variants: sectionInfo.variants,
+                configFile: sectionInfo.configFile,
             },
             inputGroups: await fieldsFactory.getGroupedFields(),
+            localization: localizationData,
         };
     }
     catch (err) {
@@ -410,7 +482,7 @@ export const deleteSectionItem = async (session, sectionName, sectionItemId, rec
         if (!section) {
             return {
                 error: {
-                    message: getString('sectionNotFound', session.user.locale),
+                    message: getString('sectionNotFound', session.user.language),
                 },
             };
         }
@@ -420,7 +492,7 @@ export const deleteSectionItem = async (session, sectionName, sectionItemId, rec
         if (!columns.includes(identifierFieldName)) {
             return {
                 error: {
-                    message: getString('sectionTableIdentifierNotFound', session.user.locale),
+                    message: getString('sectionTableIdentifierNotFound', session.user.language),
                 },
             };
         }
@@ -435,21 +507,38 @@ export const deleteSectionItem = async (session, sectionName, sectionItemId, rec
          * Run beforeDelete hook before the actual deletion
          */
         if (section.hooks?.beforeDelete) {
-            await section.hooks.beforeDelete({
+            const hook = section.hooks.beforeDelete;
+            const handler = typeof hook === 'function' ? hook : hook.handler;
+            await handler({
                 itemId: sectionItemId,
                 values: sectionItemRow ?? {},
                 section: section,
             });
         }
         /**
-         * Delete the row from the table
+         * Cascade delete translations from the locales table.
+         * Use deleteLocaleTranslation per locale to ensure localized files are cleaned up from disk.
          */
-        await db.execute(sql `delete from \`${sql.raw(tableName)}\` where \`${sql.raw(identifierFieldName)}\` = ${sectionItemId}`);
+        const cmsConfig = await getCMSConfig();
+        if (cmsConfig.localization?.enabled && section.hasLocalizedFields) {
+            const localesTableName = section.localesTableName;
+            const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+            if (localeColumns.length > 0) {
+                const [localeRows] = await db.execute(sql `SELECT locale FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId}`);
+                const locales = localeRows.map((r) => r.locale);
+                for (const locale of locales) {
+                    const result = await deleteLocaleTranslation(session, sectionName, sectionItemId, locale);
+                    if (result && typeof result === 'object' && 'error' in result) {
+                        return result;
+                    }
+                }
+            }
+        }
         /**
          * Grab the file fields to delete the files
          */
         const fileFieldConfigs = section.fieldConfigs.filter((fieldConfig) => fieldConfig.type === 'document' || fieldConfig.type === 'photo' || fieldConfig.type === 'video');
-        const uploadsFolder = (await getCMSConfig()).media.upload.path;
+        const uploadsFolder = cmsConfig.media.upload.path;
         if (sectionItemRow) {
             for (const field of fileFieldConfigs) {
                 // @ts-ignore
@@ -464,6 +553,15 @@ export const deleteSectionItem = async (session, sectionName, sectionItemId, rec
                             console.error('Error deleting document', error);
                         }
                     }
+                    else if (field.type === 'video') {
+                        try {
+                            await fs.promises.unlink(path.join(uploadsFolder, '.videos', section.name, value));
+                        }
+                        catch (error) {
+                            // Log but continue - file may not exist or already deleted
+                            console.error('Error deleting video', error);
+                        }
+                    }
                     else {
                         try {
                             await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, value));
@@ -554,12 +652,18 @@ export const deleteSectionItem = async (session, sectionName, sectionItemId, rec
                 .delete(EditorPhotosTable)
                 .where(and(eq(EditorPhotosTable.section, sectionName), eq(EditorPhotosTable.itemId, sectionItemId)));
         }
+        /**
+         * Delete the row from the table
+         */
+        await db.execute(sql `delete from \`${sql.raw(tableName)}\` where \`${sql.raw(identifierFieldName)}\` = ${sectionItemId}`);
         /**
          * Run afterDelete hook after the deletion
          */
         if (section.hooks?.afterDelete) {
+            const hook = section.hooks.afterDelete;
+            const handler = typeof hook === 'function' ? hook : hook.handler;
             try {
-                await section.hooks.afterDelete({
+                await handler({
                     itemId: sectionItemId,
                     values: sectionItemRow ?? {},
                     section: section,
@@ -600,7 +704,170 @@ export const deleteSectionItem = async (session, sectionName, sectionItemId, rec
         };
     }
 };
-export const createEditPage = async (session, sectionName, sectionItemId) => {
+export const deleteLocaleTranslation = async (session, sectionName, sectionItemId, locale) => {
+    sectionItemId = sectionItemId.toString();
+    try {
+        const _s = (await SectionFactory.getSectionForAdmin({
+            name: sectionName,
+            admin: {
+                id: session.user.id,
+                requiredRole: 'D',
+            },
+        }));
+        const section = _s?.build();
+        if (!section) {
+            return {
+                error: {
+                    message: getString('sectionNotFound', session.user.language),
+                },
+            };
+        }
+        const cmsConfig = await getCMSConfig();
+        if (!cmsConfig.localization?.enabled || !section.hasLocalizedFields) {
+            return {
+                error: {
+                    message: getString('localizationNotEnabledForSection', session.user.language),
+                },
+            };
+        }
+        if (locale === cmsConfig.localization.defaultLocale) {
+            return {
+                error: {
+                    message: getString('cannotDeleteBaseLocaleTranslation', session.user.language),
+                },
+            };
+        }
+        const localesTableName = section.localesTableName;
+        const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+        if (localeColumns.length === 0) {
+            return {
+                error: {
+                    message: getString('localesTableDoesNotExist', session.user.language),
+                },
+            };
+        }
+        // Fetch the locale row before deleting so we can clean up files
+        const [localeRows] = await db.execute(sql `SELECT * FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${locale} LIMIT 1`);
+        const localeRow = localeRows[0] ?? null;
+        const beforeDeleteHook = section.hooks?.beforeDelete;
+        if (beforeDeleteHook && typeof beforeDeleteHook === 'object' && beforeDeleteHook.runForLocales) {
+            await beforeDeleteHook.handler({
+                itemId: sectionItemId,
+                values: localeRow ?? {},
+                section: section,
+                locale,
+            });
+        }
+        // Delete files for localized photo/document/video fields
+        if (localeRow) {
+            const uploadsFolder = cmsConfig.media.upload.path;
+            const localizedFileFields = section.fieldConfigs.filter((f) => f.localized === true && (f.type === 'photo' || f.type === 'document' || f.type === 'video'));
+            for (const field of localizedFileFields) {
+                const value = localeRow[field.name];
+                if (!value)
+                    continue;
+                if (field.type === 'document') {
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.documents', section.name, value));
+                    }
+                    catch (error) {
+                        console.error('Error deleting document', error);
+                    }
+                }
+                else if (field.type === 'video') {
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.videos', section.name, value));
+                    }
+                    catch (error) {
+                        console.error('Error deleting video', error);
+                    }
+                }
+                else {
+                    // photo
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, value));
+                        await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', section.name, value));
+                    }
+                    catch (error) {
+                        console.error('Error deleting photo', error);
+                    }
+                }
+            }
+        }
+        // Delete locale-scoped editor photos for localized rich_text fields
+        const editorPhotos = await db
+            .select()
+            .from(EditorPhotosTable)
+            .where(and(eq(EditorPhotosTable.section, sectionName), eq(EditorPhotosTable.itemId, sectionItemId.toString()), eq(EditorPhotosTable.locale, locale)));
+        if (editorPhotos.length > 0) {
+            const uploadsFolder = cmsConfig.media.upload.path;
+            for (const photo of editorPhotos) {
+                try {
+                    await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, photo.name));
+                }
+                catch (error) {
+                    console.error('Error deleting editor photo', error);
+                }
+            }
+            await db
+                .delete(EditorPhotosTable)
+                .where(and(eq(EditorPhotosTable.section, sectionName), eq(EditorPhotosTable.itemId, sectionItemId.toString()), eq(EditorPhotosTable.locale, locale)));
+        }
+        // Delete locale-scoped junction table rows for localized select/tags fields
+        const localizedJunctionFields = section.fieldConfigs.filter((f) => f.localized === true &&
+            f.destinationDb &&
+            (f.type === 'select' || f.type === 'select_multiple' || f.type === 'tags'));
+        for (const field of localizedJunctionFields) {
+            const destDb = field.destinationDb;
+            if (!destDb)
+                continue;
+            try {
+                await db.execute(sql `DELETE FROM \`${sql.raw(destDb.table)}\` WHERE \`${sql.raw(destDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${locale}`);
+            }
+            catch (error) {
+                console.error(`Error deleting junction table rows for ${field.name}`, error);
+            }
+        }
+        await db.execute(sql `DELETE FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${locale}`);
+        const afterDeleteHook = section.hooks?.afterDelete;
+        if (afterDeleteHook && typeof afterDeleteHook === 'object' && afterDeleteHook.runForLocales) {
+            try {
+                await afterDeleteHook.handler({
+                    itemId: sectionItemId,
+                    values: localeRow ?? {},
+                    section: section,
+                    locale,
+                });
+            }
+            catch (e) {
+                console.error('afterDelete hook failed:', e);
+            }
+        }
+        await recordLog({
+            eventType: 'section.item.locale.delete',
+            actorId: session.user.id,
+            actorUsername: session.user.name,
+            entityType: 'section_item_locale',
+            entityId: sectionItemId,
+            entityLabel: locale,
+            sectionName: section.name,
+            metadata: {
+                locale,
+            },
+        });
+        return true;
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : getString('unknownErrorOccurred', session.user.language);
+        console.error('Error deleting locale translation', err);
+        return {
+            error: {
+                message: getString('deleteLocaleTranslationFailed', session.user.language, { detail: errorMessage }),
+            },
+        };
+    }
+};
+export const createEditPage = async (session, sectionName, sectionItemId, locale) => {
     /**
      * Generate the fields for the edit page
      */
@@ -611,6 +878,28 @@ export const createEditPage = async (session, sectionName, sectionItemId) => {
         itemId: sectionItemId,
     });
     try {
+        const cmsConfig = await getCMSConfig();
+        const localeResult = resolveLocale({
+            localization: cmsConfig.localization,
+            locale,
+        });
+        if (locale && !localeResult.resolvedLocale) {
+            if (localeResult.localizationEnabled === false) {
+                return {
+                    error: {
+                        message: getString('localizationNotEnabledForSection', session.user.language),
+                    },
+                };
+            }
+            return {
+                error: {
+                    message: getString('invalidLocale', session.user.language, {
+                        locale,
+                        locales: localeResult.availableLocales.map((l) => l.code).join(', '),
+                    }),
+                },
+            };
+        }
         await fieldsFactory.initialize();
         await fieldsFactory.generateFields();
         if (fieldsFactory.error) {
@@ -665,23 +954,91 @@ export const createEditPage = async (session, sectionName, sectionItemId) => {
             }
         }
         const sectionInfo = fieldsFactory.sectionInfo;
-        // Get the locale for resolving localized titles
-        const cmsConfig = await getCMSConfig();
-        const locale = resolveLocale(session.user.locale, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+        // Resolve localized titles using the user's language
+        const uiLanguage = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
         const resolvedTitle = {
-            section: resolveLocalizedString(sectionInfo.title.section, locale, cmsConfig.i18n.fallbackLanguage),
-            singular: resolveLocalizedString(sectionInfo.title.singular, locale, cmsConfig.i18n.fallbackLanguage),
-            plural: resolveLocalizedString(sectionInfo.title.plural, locale, cmsConfig.i18n.fallbackLanguage),
+            section: resolveMultilingualString(sectionInfo.title.section, uiLanguage, cmsConfig.i18n.fallbackLanguage),
+            singular: resolveMultilingualString(sectionInfo.title.singular, uiLanguage, cmsConfig.i18n.fallbackLanguage),
+            plural: resolveMultilingualString(sectionInfo.title.plural, uiLanguage, cmsConfig.i18n.fallbackLanguage),
         };
+        /**
+         * Fetch localization metadata for sections with localized fields
+         */
+        let localizationData = null;
+        if (localeResult.localizationEnabled) {
+            let existingTranslations = [];
+            if (sectionInfo.hasLocalizedFields) {
+                const localesTableName = sectionInfo.localesTableName;
+                const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+                const localeTableExists = localeColumns.length > 0;
+                if (localeTableExists) {
+                    const [rows] = await db.execute(sql `SELECT locale FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId}`);
+                    existingTranslations = rows.map((r) => r.locale);
+                    // Override localized field values with locale-specific data
+                    if (locale && localeResult.resolvedLocale && localeResult.isDefault === false) {
+                        const [localeRows] = await db.execute(sql `SELECT * FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${localeResult.resolvedLocale.code} LIMIT 1`);
+                        const localeRow = localeRows[0] ?? null;
+                        for (const field of sectionInfo.fields) {
+                            if (!field.localized)
+                                continue;
+                            // For select/tags with destinationDb, fetch locale-scoped junction values
+                            const f = field;
+                            if (f.destinationDb && (field.type === 'select' || field.type === 'select_multiple')) {
+                                if (f.db) {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` a JOIN \`${sql.raw(f.db.table)}\` b ON a.\`${sql.raw(f.destinationDb.selectIdentifier)}\` = b.\`${sql.raw(f.db.identifier)}\` WHERE a.\`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND a.\`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: row[f.db.label],
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                                else {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: f.options?.find((opt) => opt.value?.toString() ===
+                                                row[f.destinationDb.selectIdentifier]?.toString())?.label ?? '',
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                            }
+                            else if (f.destinationDb && field.type === 'tags') {
+                                const [_rows] = await db.execute(sql `SELECT \`${sql.raw(f.destinationDb.selectIdentifier)}\` FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                const tags = Array.isArray(_rows)
+                                    ? _rows.map((row) => row[f.destinationDb.selectIdentifier])
+                                    : [];
+                                field.setValue(tags.join(','));
+                            }
+                            else {
+                                // Simple field: override from locale row
+                                field.setValue(localeRow ? (localeRow[field.name] ?? null) : null);
+                            }
+                        }
+                    }
+                }
+            }
+            localizationData = {
+                defaultLocale: localeResult.defaultLocale,
+                currentLocale: localeResult.resolvedLocale ?? localeResult.defaultLocale,
+                existingTranslations,
+                locales: localeResult.availableLocales,
+            };
+        }
         return {
             section: {
                 name: sectionInfo.name,
                 title: resolvedTitle,
                 gallery: gallery,
                 variants: sectionInfo.variants,
+                configFile: sectionInfo.configFile,
             },
             inputGroups: await fieldsFactory.getGroupedFields(),
             gallery: galleryItems,
+            localization: localizationData,
         };
     }
     catch (error) {
@@ -745,20 +1102,25 @@ export const createNewPage = async (session, sectionName) => {
         const gallery = await sectionInfo.getGallery();
         // Get the locale for resolving localized titles
         const cmsConfig = await getCMSConfig();
-        const locale = resolveLocale(session.user.locale, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+        const language = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
         const resolvedTitle = {
-            section: resolveLocalizedString(sectionInfo.title.section, locale, cmsConfig.i18n.fallbackLanguage),
-            singular: resolveLocalizedString(sectionInfo.title.singular, locale, cmsConfig.i18n.fallbackLanguage),
-            plural: resolveLocalizedString(sectionInfo.title.plural, locale, cmsConfig.i18n.fallbackLanguage),
+            section: resolveMultilingualString(sectionInfo.title.section, language, cmsConfig.i18n.fallbackLanguage),
+            singular: resolveMultilingualString(sectionInfo.title.singular, language, cmsConfig.i18n.fallbackLanguage),
+            plural: resolveMultilingualString(sectionInfo.title.plural, language, cmsConfig.i18n.fallbackLanguage),
         };
+        const defaultLocale = cmsConfig.localization?.enabled
+            ? (cmsConfig.localization.locales.find((l) => l.code === cmsConfig.localization.defaultLocale) ?? null)
+            : null;
         return {
             section: {
                 name: sectionInfo.name,
                 title: resolvedTitle,
                 gallery: gallery,
                 variants: sectionInfo.variants,
+                configFile: sectionInfo.configFile,
             },
             inputGroups: await fieldsFactory.getGroupedFields(),
+            defaultLocale,
         };
     }
     catch (err) {
@@ -787,7 +1149,7 @@ export const getCategorySectionChildren = async ({ session, id, sectionName, lev
     if (!section) {
         return {
             error: {
-                message: getString('sectionNotFound', session.user.locale),
+                message: getString('sectionNotFound', session.user.language),
             },
         };
     }
@@ -835,7 +1197,7 @@ export const getCategorySection = async (session, sectionName) => {
     if (!section) {
         return {
             error: {
-                message: getString('sectionNotFound', session.user.locale),
+                message: getString('sectionNotFound', session.user.language),
             },
         };
     }
@@ -862,11 +1224,11 @@ export const getCategorySection = async (session, sectionName) => {
     s.setValue(undefined);
     // Get the locale for resolving localized titles (label must be a string for React)
     const cmsConfig = await getCMSConfig();
-    const locale = resolveLocale(session.user.locale, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+    const language = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
     const resolvedTitle = {
-        section: resolveLocalizedString(section.title.section, locale, cmsConfig.i18n.fallbackLanguage),
-        singular: resolveLocalizedString(section.title.singular, locale, cmsConfig.i18n.fallbackLanguage),
-        plural: resolveLocalizedString(section.title.plural, locale, cmsConfig.i18n.fallbackLanguage),
+        section: resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage),
+        singular: resolveMultilingualString(section.title.singular, language, cmsConfig.i18n.fallbackLanguage),
+        plural: resolveMultilingualString(section.title.plural, language, cmsConfig.i18n.fallbackLanguage),
     };
     const categorySectionSelect = {
         options: s.options,
@@ -902,7 +1264,7 @@ export const getBrowsePage = async (session, sectionName, page = 1, q) => {
     if (!section) {
         return {
             error: {
-                message: getString('sectionNotFound', session.user.locale),
+                message: getString('sectionNotFound', session.user.language),
             },
         };
     }
@@ -913,26 +1275,38 @@ export const getBrowsePage = async (session, sectionName, page = 1, q) => {
     const sqlChunks = [];
     const totalRowsSqlChunks = [];
     const sectionSearch = section.search?.searchFields ? section.search?.searchFields.length > 0 : false;
-    sqlChunks.push(sql `select * from ${sql.raw(tableName)}`);
-    totalRowsSqlChunks.push(sql `select count(*) as total from ${sql.raw(tableName)}`);
+    // Check if we need to JOIN _locales for search
+    const cmsConfig = await getCMSConfig();
+    const hasLocalization = !!cmsConfig.localization?.enabled;
+    const hasLocalizedSearchFields = hasLocalization && q && q.trim().length > 0 && section.search?.searchFields?.some((f) => f.localized);
+    const localesTable = hasLocalizedSearchFields ? section.localesTableName : null;
+    if (localesTable) {
+        // Use DISTINCT to avoid duplicate rows from the LEFT JOIN
+        sqlChunks.push(sql `select distinct ${sql.raw(`\`${tableName}\``)}.* from ${sql.raw(`\`${tableName}\``)} left join ${sql.raw(`\`${localesTable}\``)} on ${sql.raw(`\`${localesTable}\``)}.parent_id = ${sql.raw(`\`${tableName}\``)}.${sql.raw(`\`${section.db.identifier.name}\``)}`);
+        totalRowsSqlChunks.push(sql `select count(distinct ${sql.raw(`\`${tableName}\``)}.${sql.raw(`\`${section.db.identifier.name}\``)} ) as total from ${sql.raw(`\`${tableName}\``)} left join ${sql.raw(`\`${localesTable}\``)} on ${sql.raw(`\`${localesTable}\``)}.parent_id = ${sql.raw(`\`${tableName}\``)}.${sql.raw(`\`${section.db.identifier.name}\``)}`);
+    }
+    else {
+        sqlChunks.push(sql `select * from ${sql.raw(`\`${tableName}\``)}`);
+        totalRowsSqlChunks.push(sql `select count(*) as total from ${sql.raw(`\`${tableName}\``)}`);
+    }
     if (q && q.trim().length > 0) {
         if (section.search?.searchFields.length) {
-            let i = 1;
+            const whereParts = [];
+            for (const field of section.search.searchFields) {
+                // Search in main table
+                whereParts.push(sql `${sql.raw(`\`${tableName}\``)}.${sql.raw(`\`${field.name}\``)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
+                // Also search in _locales table for localized fields
+                if (localesTable && field.localized) {
+                    whereParts.push(sql `${sql.raw(`\`${localesTable}\``)}.${sql.raw(`\`${field.name}\``)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
+                }
+            }
             sqlChunks.push(sql `where`);
+            sqlChunks.push(sql.join(whereParts, sql ` or `));
             totalRowsSqlChunks.push(sql `where`);
-            for (const field of section.search?.searchFields) {
-                // sqlChunks.push(sql`${sql.raw(field.name)} like '%${q}%'`)
-                sqlChunks.push(sql `${sql.raw(field.name)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
-                totalRowsSqlChunks.push(sql `${sql.raw(field.name)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
-                if (i === section.search?.searchFields.length)
-                    continue;
-                sqlChunks.push(sql `or`);
-                totalRowsSqlChunks.push(sql `or`);
-                i++;
-            }
+            totalRowsSqlChunks.push(sql.join(whereParts, sql ` or `));
         }
     }
-    sqlChunks.push(sql `ORDER BY \`${sql.raw(orderByFieldName)}\` DESC LIMIT ${limit} OFFSET ${offset}`);
+    sqlChunks.push(sql `ORDER BY ${sql.raw(`\`${tableName}\``)}.${sql.raw(`\`${orderByFieldName}\``)} DESC LIMIT ${limit} OFFSET ${offset}`);
     const finalSql = sql.join(sqlChunks, sql.raw(' '));
     const totalRowsSql = sql.join(totalRowsSqlChunks, sql.raw(' '));
     // Now, let's get the section items from the table
@@ -940,10 +1314,9 @@ export const getBrowsePage = async (session, sectionName, page = 1, q) => {
     const totalCountResult = await db.execute(totalRowsSql);
     const totalCountRows = totalCountResult[0];
     const rows = sectionItems[0];
-    // Get the locale for resolving localized titles
-    const cmsConfig = await getCMSConfig();
-    const locale = resolveLocale(session.user.locale, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
-    const resolvedTitle = resolveLocalizedString(section.title.section, locale, cmsConfig.i18n.fallbackLanguage);
+    // Resolve localized section title for the browse page header
+    const language = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+    const resolvedTitle = resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage);
     return {
         section: {
             // tableName: tableName,
@@ -1001,25 +1374,25 @@ export const getSidebar = async (session) => {
     // Include dashboard override plugin even without explicit privilege
     const allowedPluginRoutes = pluginRoutes.filter(({ pluginName, path }) => privilegeSet.has(pluginName) || path === dashboardOverridePath);
     // Get the locale for resolving localized titles
-    const locale = resolveLocale(session.user.locale, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+    const language = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
     // Let's loop through the sections and add path, icon and title to each section item
     const simpleSectionItems = simple.map((section) => {
         return {
-            title: resolveLocalizedString(section.title, locale, cmsConfig.i18n.fallbackLanguage),
+            title: resolveMultilingualString(section.title, language, cmsConfig.i18n.fallbackLanguage),
             path: `/section/${section.name}`,
             icon: section.icon,
         };
     });
     const hasItemsSectionItems = has_items.map((section) => {
         return {
-            title: resolveLocalizedString(section.title.section, locale, cmsConfig.i18n.fallbackLanguage),
+            title: resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage),
             path: `/${section.name}`,
             icon: section.icon,
         };
     });
     const categorySectionsItems = category.map((section) => {
         return {
-            title: resolveLocalizedString(section.title.section, locale, cmsConfig.i18n.fallbackLanguage),
+            title: resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage),
             path: `/categorized/${section.name}`,
             icon: section.icon,
         };
@@ -1028,7 +1401,7 @@ export const getSidebar = async (session) => {
     const pluginSections = allowedPluginRoutes
         .filter((route) => route.path !== dashboardOverridePath)
         .map((route) => ({
-        title: resolveLocalizedString(route.title, locale, cmsConfig.i18n.fallbackLanguage),
+        title: resolveMultilingualString(route.title, language, cmsConfig.i18n.fallbackLanguage),
         path: route.path,
         icon: route.icon ?? '',
     }));
@@ -1037,7 +1410,7 @@ export const getSidebar = async (session) => {
          * Add the dashboard section (points to override if configured)
          */
         {
-            title: getString('dashboard', session.user.locale),
+            title: getString('dashboard', session.user.language),
             path: dashboardOverridePath ?? '/dashboard',
             icon: 'home',
         },
@@ -1046,7 +1419,7 @@ export const getSidebar = async (session) => {
          */
         ...pluginSections,
         ...fixed.map((section) => ({
-            title: getString(section.name, session.user.locale),
+            title: getString(section.name, session.user.language),
             path: `/${section.name}`,
             icon: section.icon,
         })),