nextjs-cms 0.9.21 → 0.9.23

package/dist/api/actions/pages.js

@@ -0,0 +1,1215 @@
+import 'server-only';
+import fs from 'fs';
+import path from 'path';
+import { and, eq, sql } from 'drizzle-orm';
+import { getCMSConfig } from '../../core/config/index.js';
+import { MysqlTableChecker } from '../../core/db/index.js';
+import { FieldFactory, SectionFactory } from '../../core/factories/index.js';
+import { SelectField } from '../../core/fields/index.js';
+import { resolveLocale } from '../../core/localization/index.js';
+import { db } from '../../db/client.js';
+import { EditorPhotosTable } from '../../db/schema.js';
+import { recordLog } from '../../logging/index.js';
+import { getPluginNavigation } from '../../plugins/loader.js';
+import getString from '../../translations/index.js';
+import { resolveLanguage, resolveMultilingualString } from '../../translations/language-utils.js';
+import { getAdminPrivileges } from './privileges.js';
+async function deleteGalleryFiles({ uploadsFolder, sectionName, photos, }) {
+    for (const photo of photos) {
+        try {
+            await fs.promises.unlink(path.join(uploadsFolder, '.photos', sectionName, photo));
+            await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', sectionName, photo));
+        }
+        catch (error) {
+            console.error('Error deleting gallery photo', error);
+        }
+    }
+}
+async function deleteLocalizedGalleryRows({ section, gallery, sectionItemId, locale, uploadsFolder, }) {
+    if (!gallery.localized)
+        return;
+    const { tableName, referenceIdentifierField, photoNameField } = gallery.db;
+    const columns = await MysqlTableChecker.getColumns(tableName);
+    if (!columns.includes(referenceIdentifierField) ||
+        !columns.includes(photoNameField) ||
+        !columns.includes('locale')) {
+        return;
+    }
+    const [rows] = await db.execute(sql `SELECT \`${sql.raw(photoNameField)}\` AS photo FROM \`${sql.raw(tableName)}\` WHERE \`${sql.raw(referenceIdentifierField)}\` = ${sectionItemId} AND \`locale\` = ${locale}`);
+    const photos = (rows ?? []).map((row) => row.photo).filter(Boolean);
+    await deleteGalleryFiles({ uploadsFolder, sectionName: section.name, photos });
+    await db.execute(sql `DELETE FROM \`${sql.raw(tableName)}\` WHERE \`${sql.raw(referenceIdentifierField)}\` = ${sectionItemId} AND \`locale\` = ${locale}`);
+}
+function sectionHasLocalizedContent(section) {
+    return section.hasLocalizedContent ?? section.hasLocalizedFields ?? false;
+}
+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
+         */
+        const fieldsFactory = new FieldFactory({
+            type: 'edit',
+            sectionName,
+            session: session,
+            itemId: 1, // itemId is always 1 for simple sections
+        });
+        await fieldsFactory.initialize();
+        if (fieldsFactory.error) {
+            return {
+                error: {
+                    message: fieldsFactory.errorMessage,
+                },
+            };
+        }
+        await fieldsFactory.generateFields();
+        const sectionInfo = fieldsFactory.sectionInfo;
+        const gallery = await sectionInfo.getGallery();
+        // Get the locale for resolving localized titles
+        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 = [];
+            const hasLocalizedContent = sectionHasLocalizedContent(sectionInfo);
+            if (hasLocalizedContent) {
+                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 if (field.type === 'date_range' && typeof f.setRangeValues === 'function') {
+                                f.setRangeValues(localeRow ? (localeRow[f.startName] ?? null) : null, localeRow ? (localeRow[f.endName] ?? null) : null);
+                            }
+                            else {
+                                // Simple field: override from locale row
+                                field.setValue(localeRow ? (localeRow[field.name] ?? null) : null);
+                            }
+                        }
+                    }
+                }
+            }
+            // Show the locale switcher when multiple locales are configured AND either:
+            //   - the section has localized fields (production case), or
+            //   - the app is in development mode (so devs can preview the switcher
+            //     while wiring up localization on a section).
+            // The developer note is rendered in dev-mode only, when the switcher is
+            // visible but the section itself has no localized content yet.
+            const localeSwitcherEnabled = localeResult.availableLocales.length > 1 &&
+                (hasLocalizedContent === true || process.env.NODE_ENV === 'development');
+            const developerNoteEnabled = localeSwitcherEnabled && hasLocalizedContent === false;
+            localizationData = {
+                defaultLocale: localeResult.defaultLocale,
+                currentLocale: localeResult.resolvedLocale ?? localeResult.defaultLocale,
+                existingTranslations,
+                locales: localeResult.availableLocales,
+                localeSwitcherEnabled,
+                developerNoteEnabled,
+            };
+        }
+        return {
+            section: {
+                name: sectionInfo.name,
+                title: resolvedTitle,
+                gallery: gallery,
+                variants: sectionInfo.variants,
+                configFile: sectionInfo.configFile,
+            },
+            inputGroups: await fieldsFactory.getGroupedFields(),
+            localization: localizationData,
+        };
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+        console.error('Error creating section page', err);
+        return {
+            error: {
+                message: `Failed to create section page: ${errorMessage}`,
+            },
+        };
+    }
+};
+export const deleteSectionItem = async (session, sectionName, sectionItemId, recursive, requestMetadata) => {
+    /**
+     * Convert the section item id to string
+     */
+    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 tableName = section.db.table;
+        const identifierFieldName = section.db.identifier.name;
+        const columns = await MysqlTableChecker.getColumns(tableName);
+        if (!columns.includes(identifierFieldName)) {
+            return {
+                error: {
+                    message: getString('sectionTableIdentifierNotFound', session.user.language),
+                },
+            };
+        }
+        /**
+         * Get the section item from the table
+         */
+        const [_v, _f] = await db.execute(sql `select * from ${sql.raw(tableName)} where ${sql.raw(identifierFieldName)} = ${sectionItemId} limit 1`);
+        // @ts-ignore
+        // Bug: this is a bug in drizzle-orm/mysql2
+        const sectionItemRow = _v[0];
+        /**
+         * Run beforeDelete hook before the actual deletion
+         */
+        if (section.hooks?.beforeDelete) {
+            const hook = section.hooks.beforeDelete;
+            const handler = typeof hook === 'function' ? hook : hook.handler;
+            await handler({
+                itemId: sectionItemId,
+                values: sectionItemRow ?? {},
+                section: section,
+            });
+        }
+        /**
+         * Cascade delete translations from the locales table.
+         * Use deleteLocaleTranslation per locale to ensure localized files are cleaned up from disk.
+         */
+        const cmsConfig = await getCMSConfig();
+        if (cmsConfig.localization?.enabled && sectionHasLocalizedContent(section)) {
+            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 = cmsConfig.media.upload.path;
+        if (sectionItemRow) {
+            for (const field of fileFieldConfigs) {
+                // @ts-ignore
+                const value = sectionItemRow[field.name];
+                if (value) {
+                    if (field.type === 'document') {
+                        try {
+                            await fs.promises.unlink(path.join(uploadsFolder, '.documents', section.name, value));
+                        }
+                        catch (error) {
+                            // Log but continue - file may not exist or already deleted
+                            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));
+                            await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', section.name, value));
+                        }
+                        catch (error) {
+                            // Log but continue - file may not exist or already deleted
+                            console.error('Error deleting photo', error);
+                        }
+                    }
+                }
+            }
+        }
+        /**
+         * Delete the rows from the destination table if they exist
+         */
+        const fieldsWithDestinationDbTable = section.fieldConfigs.filter((fieldConfig) => ['select_multiple', 'select', 'tags'].includes(fieldConfig.type));
+        for (const fieldConfig of fieldsWithDestinationDbTable) {
+            const field = fieldConfig.build();
+            if (field.destinationDb) {
+                const columns = await MysqlTableChecker.getColumns(field.destinationDb.table);
+                if (columns.includes(field.destinationDb.selectIdentifier) &&
+                    columns.includes(field.destinationDb.itemIdentifier)) {
+                    await db.execute(sql `delete from ${sql.raw(field.destinationDb.table)} where ${sql.raw(field.destinationDb.itemIdentifier)} = ${sectionItemId}`);
+                }
+            }
+        }
+        /**
+         * Also delete the gallery photos if they exist
+         */
+        const gallery = await section.getGallery();
+        if (gallery) {
+            const { tableName, referenceIdentifierField, photoNameField, metaField } = gallery.db;
+            const columns = await MysqlTableChecker.getColumns(tableName);
+            if (columns.includes(photoNameField) &&
+                columns.includes(referenceIdentifierField) &&
+                columns.includes(metaField)) {
+                /**
+                 * First, get the gallery photos
+                 */
+                const [_v, _f] = await db.execute(sql `select * from \`${sql.raw(tableName)}\` where \`${sql.raw(referenceIdentifierField)}\` = ${sectionItemId}`);
+                // @ts-ignore
+                // Bug: this is a bug in drizzle-orm/mysql2
+                const galleryPhotos = _v;
+                /**
+                 * Delete the photos from disk
+                 */
+                for (const photo of galleryPhotos) {
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, photo[photoNameField]));
+                        await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', section.name, photo[photoNameField]));
+                    }
+                    catch (error) {
+                        // Log but continue - file may not exist or already deleted
+                        console.error('Error deleting photo', error);
+                    }
+                }
+                /**
+                 * Delete the photos from the table
+                 */
+                await db.execute(sql `DELETE FROM ${sql.raw(tableName)} WHERE ${sql.raw(referenceIdentifierField)} = ${sectionItemId}`);
+            }
+        }
+        /**
+         * Check if there are photos in the editor_photos table
+         */
+        const editorPhotos = await db
+            .select()
+            .from(EditorPhotosTable)
+            .where(and(eq(EditorPhotosTable.section, sectionName), eq(EditorPhotosTable.itemId, sectionItemId)));
+        if (editorPhotos.length > 0) {
+            /**
+             * Delete the photos from disk
+             */
+            for (const photo of editorPhotos) {
+                try {
+                    await fs.promises.unlink(path.join(uploadsFolder, '.photos', photo.section, photo.name));
+                }
+                catch (error) {
+                    // Log but continue - file may not exist or already deleted
+                    console.error('Error deleting photo', error);
+                }
+            }
+            /**
+             * Delete the photos from the editor_photos table
+             */
+            await db
+                .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 handler({
+                    itemId: sectionItemId,
+                    values: sectionItemRow ?? {},
+                    section: section,
+                });
+            }
+            catch (error) {
+                console.error('afterDelete hook failed:', error);
+            }
+        }
+        const headingFieldName = section.headingField.name;
+        const entityLabel = headingFieldName && sectionItemRow
+            ? // @ts-ignore
+                String(sectionItemRow[headingFieldName] ?? '')
+            : null;
+        await recordLog({
+            eventType: 'section.item.delete',
+            actorId: session.user.id,
+            actorUsername: session.user.name,
+            entityType: 'section_item',
+            entityId: sectionItemId,
+            entityLabel: entityLabel?.trim() ? entityLabel : null,
+            sectionName: section.name,
+            metadata: {
+                sectionType: section.type,
+                recursive: Boolean(recursive),
+            },
+            requestMetadata,
+        });
+        return true;
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+        console.error('Error deleting section item', err);
+        return {
+            error: {
+                message: `Failed to delete section item: ${errorMessage}`,
+            },
+        };
+    }
+};
+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 || !sectionHasLocalizedContent(section)) {
+            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);
+                    }
+                }
+            }
+        }
+        const gallery = await section.getGallery();
+        if (gallery?.localized) {
+            await deleteLocalizedGalleryRows({
+                section,
+                gallery,
+                sectionItemId,
+                locale,
+                uploadsFolder: cmsConfig.media.upload.path,
+            });
+        }
+        // Delete locale-scoped editor photos for localized rich_text fields.
+        // Uses raw SQL because the `locale` column only exists on the DB table when
+        // localization is enabled; the Drizzle schema no longer declares it.
+        const [editorPhotoRows] = await db.execute(sql `SELECT \`photo\` as \`name\` FROM \`editor_photos\` WHERE \`section\` = ${sectionName} AND \`item_id\` = ${sectionItemId.toString()} AND \`locale\` = ${locale}`);
+        const editorPhotos = editorPhotoRows ?? [];
+        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.execute(sql `DELETE FROM \`editor_photos\` WHERE \`section\` = ${sectionName} AND \`item_id\` = ${sectionItemId.toString()} AND \`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
+     */
+    const fieldsFactory = new FieldFactory({
+        type: 'edit',
+        sectionName,
+        session,
+        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) {
+            return {
+                error: {
+                    message: fieldsFactory.errorMessage,
+                },
+            };
+        }
+        /**
+         * 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
+                })
+            }*/
+        /**
+         * Get the gallery photos
+         * TODO: This is a temp implementation, will be removed once converting the gallery into a field
+         */
+        let galleryItems = [];
+        const gallery = await fieldsFactory.sectionInfo?.getGallery();
+        if (gallery) {
+            const { tableName, referenceIdentifierField, photoNameField, metaField } = gallery.db;
+            const columns = await MysqlTableChecker.getColumns(tableName);
+            if (columns.includes(photoNameField) &&
+                columns.includes(referenceIdentifierField) &&
+                columns.includes(metaField)) {
+                const galleryIsLocalized = gallery.localized === true && localeResult.localizationEnabled;
+                const currentLocale = localeResult.resolvedLocale?.code;
+                const localeFilter = galleryIsLocalized && currentLocale && columns.includes('locale')
+                    ? sql ` AND \`locale\` = ${currentLocale}`
+                    : sql ``;
+                const [items] = await db.execute(sql `select * from \`${sql.raw(tableName)}\` where \`${sql.raw(referenceIdentifierField)}\` = ${sectionItemId}${localeFilter}`);
+                const galleryPhotos = items;
+                galleryPhotos?.map((item) => {
+                    galleryItems.push({
+                        referenceId: item[referenceIdentifierField],
+                        photo: item[photoNameField],
+                        meta: item[metaField],
+                        locale: item.locale,
+                    });
+                });
+            }
+        }
+        const sectionInfo = fieldsFactory.sectionInfo;
+        // Resolve localized titles using the user's language
+        const uiLanguage = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+        const resolvedTitle = {
+            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 = [];
+            const hasLocalizedContent = sectionHasLocalizedContent(sectionInfo);
+            if (hasLocalizedContent) {
+                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 if (field.type === 'date_range' && typeof f.setRangeValues === 'function') {
+                                f.setRangeValues(localeRow ? (localeRow[f.startName] ?? null) : null, localeRow ? (localeRow[f.endName] ?? null) : null);
+                            }
+                            else {
+                                // Simple field: override from locale row
+                                field.setValue(localeRow ? (localeRow[field.name] ?? null) : null);
+                            }
+                        }
+                    }
+                }
+            }
+            // Show the locale switcher when multiple locales are configured AND either:
+            //   - the section has localized fields (production case), or
+            //   - the app is in development mode (so devs can preview the switcher
+            //     while wiring up localization on a section).
+            // The developer note is rendered in dev-mode only, when the switcher is
+            // visible but the section itself has no localized content yet.
+            const localeSwitcherEnabled = localeResult.availableLocales.length > 1 &&
+                (hasLocalizedContent === true || process.env.NODE_ENV === 'development');
+            const developerNoteEnabled = localeSwitcherEnabled && hasLocalizedContent === false;
+            localizationData = {
+                defaultLocale: localeResult.defaultLocale,
+                currentLocale: localeResult.resolvedLocale ?? localeResult.defaultLocale,
+                existingTranslations,
+                locales: localeResult.availableLocales,
+                localeSwitcherEnabled,
+                developerNoteEnabled,
+            };
+        }
+        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) {
+        const errorMessage = error?.errorMessage || (error instanceof Error ? error.message : 'Unknown error occurred');
+        console.error('Error creating edit page', error);
+        return {
+            error: {
+                message: errorMessage,
+            },
+        };
+    }
+};
+export const createNewPage = async (session, sectionName) => {
+    try {
+        const fieldsFactory = new FieldFactory({
+            type: 'new',
+            sectionName,
+            session,
+        });
+        await fieldsFactory.initialize();
+        if (fieldsFactory.error) {
+            return {
+                error: {
+                    message: fieldsFactory.errorMessage,
+                },
+            };
+        }
+        try {
+            await fieldsFactory.generateFields();
+        }
+        catch (err) {
+            // console.error('Error generating fields', err)
+            return {
+                error: {
+                    message: err.message,
+                },
+            };
+        }
+        /**
+         * 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 language = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+        const resolvedTitle = {
+            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) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+        console.error('Error creating new page', err);
+        return {
+            error: {
+                message: errorMessage,
+            },
+        };
+    }
+};
+export const getCategorySectionChildren = async ({ session, id, sectionName, level, }) => {
+    /**
+     * First, level up to get the children (next level)
+     */
+    level++;
+    // Let's fetch the section items and admin privileges for the section
+    const _s = (await SectionFactory.getSectionForAdmin({
+        name: sectionName,
+        admin: {
+            id: session.user.id,
+        },
+    }));
+    const section = _s?.build();
+    if (!section) {
+        return {
+            error: {
+                message: getString('sectionNotFound', session.user.language),
+            },
+        };
+    }
+    /**
+     * Check if new level is allowed in the category section depth
+     */
+    if (level > (section.depth ?? 1)) {
+        /**
+         * This is the last level, return an empty array
+         */
+        return {
+            options: null,
+            parentId: id,
+            level: level,
+        };
+    }
+    /**
+     * Let's get the options for the select input
+     */
+    const selectStatement = sql `select * from \`${sql.raw(section.db.table)}\` WHERE parent_id = ${id} AND level = ${level} ORDER BY \`${sql.raw(section.db.orderByField?.name ? section.db.orderByField?.name : section.db.identifier.name)}\` DESC`;
+    /**
+     * Get the options from the table
+     */
+    const selectOptionsRows = await db.execute(selectStatement);
+    const rows = selectOptionsRows[0];
+    return {
+        options: rows.map((row) => {
+            return {
+                value: row[section.db.identifier.name],
+                label: row[section.headingField.name],
+            };
+        }),
+        parentId: id,
+        level: level++,
+    };
+};
+export const getCategorySection = async (session, sectionName) => {
+    // Let's fetch the section items and admin privileges for the section
+    const section = (await SectionFactory.getSectionForAdmin({
+        name: sectionName,
+        admin: {
+            id: session.user.id,
+        },
+    }));
+    if (!section) {
+        return {
+            error: {
+                message: getString('sectionNotFound', session.user.language),
+            },
+        };
+    }
+    const tableName = section.db.table;
+    /**
+     * Create a select field config for the category section
+     */
+    const s = new SelectField({
+        name: section.name,
+        label: section.title.section,
+        required: false,
+        order: 1,
+        section: section,
+        destinationDb: undefined,
+    });
+    /**
+     * Build the select field to get the options
+     * from database and do all the necessary checks
+     */
+    await s.build();
+    /**
+     * Set the value to undefined
+     */
+    s.setValue(undefined);
+    // Get the locale for resolving localized titles (label must be a string for React)
+    const cmsConfig = await getCMSConfig();
+    const language = resolveLanguage(session.user.language, cmsConfig.i18n.supportedLanguages, cmsConfig.i18n.fallbackLanguage);
+    const resolvedTitle = {
+        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,
+        required: s.required,
+        name: s.name,
+        label: resolvedTitle.section,
+        value: s.value,
+        parentId: undefined,
+        level: 1,
+        depth: section.depth,
+        sectionName: section.name,
+        allowRecursiveDelete: section.allowRecursiveDelete,
+    };
+    return {
+        section: {
+            tableName: tableName,
+            sectionName: section.name,
+            title: resolvedTitle,
+        },
+        data: categorySectionSelect,
+        // publisher: privileges.publisher,
+    };
+};
+export const getBrowsePage = async (session, sectionName, page = 1, q) => {
+    // Let's fetch the section items and admin privileges for the section
+    const _s = (await SectionFactory.getSectionForAdmin({
+        name: sectionName,
+        admin: {
+            id: session.user.id,
+        },
+    }));
+    const section = _s?.build();
+    if (!section) {
+        return {
+            error: {
+                message: getString('sectionNotFound', session.user.language),
+            },
+        };
+    }
+    const limit = 12;
+    const offset = (page - 1) * limit;
+    const tableName = section.db.table;
+    const orderByFieldName = section.db.orderByField?.name || 'created_at';
+    const sqlChunks = [];
+    const totalRowsSqlChunks = [];
+    const sectionSearch = section.search?.searchFields ? section.search?.searchFields.length > 0 : false;
+    // 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) {
+            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`);
+            totalRowsSqlChunks.push(sql.join(whereParts, sql ` or `));
+        }
+    }
+    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
+    const sectionItems = await db.execute(finalSql);
+    const totalCountResult = await db.execute(totalRowsSql);
+    const totalCountRows = totalCountResult[0];
+    const rows = sectionItems[0];
+    // 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,
+            // headingField: section.headingField.name,
+            // identifierField: section.db.identifier.name,
+            // coverPhotoField: section.coverPhotoField?.name,
+            hasSearch: sectionSearch,
+            name: section.name,
+            title: resolvedTitle,
+        },
+        items: rows.map((row) => {
+            // Custom browse page implementation: if browse.fields is configured,
+            // return the specified fields plus default fields (id, headingTitle, coverPhoto, createdAt, createdBy, permission).
+            // NOTE: This is for custom browse page implementations only.
+            // The default CMS browse page component uses the fallback fields below.
+            if (section.browse?.fields && section.browse.fields.length > 0) {
+                const item = {
+                    // Always include default fields
+                    id: row[section.db.identifier.name],
+                    headingTitle: row[section.headingField.name],
+                    coverPhoto: section.coverPhotoField ? row[section.coverPhotoField?.name] : null,
+                    createdAt: row['created_at'],
+                    createdBy: row['created_by'],
+                    permission: row.permission,
+                };
+                // Add configured browse fields
+                for (const field of section.browse.fields) {
+                    item[field.name] = row[field.name] ?? null;
+                }
+                return item;
+            }
+            // Default browse page fields (used by the standard CMS browse page)
+            return {
+                id: row[section.db.identifier.name],
+                headingTitle: row[section.headingField.name],
+                coverPhoto: section.coverPhotoField ? row[section.coverPhotoField?.name] : null,
+                createdAt: row['created_at'],
+                createdBy: row['created_by'],
+                permission: row.permission,
+            };
+        }),
+        totalCount: totalCountRows[0].total,
+    };
+};
+export const getSidebar = async (session) => {
+    // Let's get simple, has_items and categorized sections from the sections table
+    const { simple, has_items, category, fixed } = await SectionFactory.getSectionsForAdmin({
+        admin: { id: session.user.id },
+    });
+    const pluginNav = await getPluginNavigation();
+    const privilegeSet = await getAdminPrivileges(session.user.id);
+    // Get config and check for dashboard override
+    const cmsConfig = await getCMSConfig();
+    const dashboardOverridePath = cmsConfig.dashboard?.override;
+    // Get the locale for resolving localized titles
+    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: resolveMultilingualString(section.title, language, cmsConfig.i18n.fallbackLanguage),
+            path: `/section/${section.name}`,
+            icon: section.icon,
+        };
+    });
+    const hasItemsSectionItems = has_items.map((section) => {
+        return {
+            title: resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage),
+            path: `/${section.name}`,
+            icon: section.icon,
+        };
+    });
+    const categorySectionsItems = category.map((section) => {
+        return {
+            title: resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage),
+            path: `/categorized/${section.name}`,
+            icon: section.icon,
+        };
+    });
+    const pluginSections = [];
+    for (const item of pluginNav) {
+        const allowed = privilegeSet.has(item.pluginName);
+        if (item.kind === 'leaf') {
+            // Allowed if privileged, OR this leaf is the dashboard override (becomes /dashboard).
+            if (item.path === dashboardOverridePath)
+                continue;
+            if (!allowed)
+                continue;
+            pluginSections.push({
+                kind: 'leaf',
+                title: resolveMultilingualString(item.title, language, cmsConfig.i18n.fallbackLanguage),
+                path: item.path,
+                icon: item.icon ?? '',
+            });
+            continue;
+        }
+        if (!allowed)
+            continue;
+        const children = item.children
+            .filter((c) => c.path !== dashboardOverridePath)
+            .map((c) => ({
+            title: resolveMultilingualString(c.title, language, cmsConfig.i18n.fallbackLanguage),
+            path: c.path,
+            icon: c.icon ?? '',
+        }));
+        if (children.length === 0)
+            continue;
+        pluginSections.push({
+            kind: 'group',
+            title: resolveMultilingualString(item.title, language, cmsConfig.i18n.fallbackLanguage),
+            icon: item.icon ?? '',
+            children,
+        });
+    }
+    const fixedSections = [
+        /**
+         * Add the dashboard section (points to override if configured)
+         */
+        {
+            title: getString('dashboard', session.user.language),
+            path: dashboardOverridePath ?? '/dashboard',
+            icon: 'home',
+        },
+        ...fixed.map((section) => ({
+            title: getString(section.name, session.user.language),
+            path: `/${section.name}`,
+            icon: section.icon,
+        })),
+    ];
+    return {
+        fixed_sections: fixedSections,
+        plugin_sections: pluginSections,
+        cat_sections: categorySectionsItems,
+        has_items_sections: hasItemsSectionItems,
+        simple_sections: simpleSectionItems,
+    };
+};