nextjs-cms 0.9.36 → 0.9.37

package/dist/api/lib/serverActions.js

@@ -1,1517 +0,0 @@
-// import 'server-only'
-import fs from 'fs';
-import path from 'path';
-import { Readable } from 'stream';
-import { TRPCError } from '@trpc/server';
-import { and, eq, sql } from 'drizzle-orm';
-import { fileTypeFromBuffer } from 'file-type';
-import { readChunk } from 'read-chunk';
-import sharp from 'sharp';
-import through2 from 'through2';
-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 { AdminPrivilegesTable, AdminsTable, EditorPhotosTable } from '../../db/schema.js';
-import { recordLog } from '../../logging/index.js';
-import { getPluginRoutes } from '../../plugins/loader.js';
-import getString from '../../translations/index.js';
-import { resolveLanguage, resolveMultilingualString } from '../../translations/language-utils.js';
-import { sanitizeFileName, sanitizeFolderOrFileName } from '../../utils/index.js';
-export const isAccessAllowed = async ({ sectionName, role, userId, }) => {
-    /**
-     * Check admin privileges
-     */
-    const _res = await db
-        .select()
-        .from(AdminPrivilegesTable)
-        .where(and(eq(AdminPrivilegesTable.adminId, userId), eq(AdminPrivilegesTable.sectionName, sectionName)))
-        .limit(1);
-    const allowed = _res[0];
-    if (!allowed)
-        return false;
-    if (role) {
-        if (!allowed.operations.includes(role))
-            return false;
-    }
-    return true;
-};
-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 getDocument = async (session, input) => {
-    const { name, sectionName, fieldName } = input;
-    // Sanitize the inputs
-    const sanitizedFolder = sanitizeFolderOrFileName(sectionName);
-    const sanitizedName = sanitizeFileName(name);
-    /**
-     * Check the section and the field name, and get the allowed extensions,
-     *  while also checking if the user has access to the section
-     */
-    const section = await SectionFactory.getSectionForAdmin({
-        name: sanitizedFolder,
-        admin: { id: session.user.id },
-    });
-    /**
-     * If the check fails, throw an error
-     */
-    if (!section?.name) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            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.language),
-        });
-    }
-    const field = fieldConfig.build();
-    /**
-     * If field is not found, throw an error
-     */
-    if (!field || !field.name || !field.extensions || field.extensions.length === 0) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: getString('invalidRequest', session.user.language),
-        });
-    }
-    /**
-     * Split the allowed extensions into an array
-     */
-    const uploadsFolder = (await getCMSConfig()).media.upload.path;
-    const documentAllowedExtensions = field.extensions;
-    const dir = '.documents';
-    const pathToFile = path.join(uploadsFolder, dir, sanitizedFolder, sanitizedName);
-    /**
-     * First, check if the file exists
-     */
-    if (!fs.existsSync(pathToFile)) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: getString('fileNotFound', session.user.language),
-        });
-    }
-    /**
-     * Read the first 4100 bytes of the file
-     */
-    const chunkBuffer = await readChunk(pathToFile, { length: 4100 });
-    /**
-     * Get the file type from the buffer
-     */
-    const fileType = await fileTypeFromBuffer(chunkBuffer);
-    /**
-     * If the file type is invalid, return an error
-     */
-    if (!fileType) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: getString('invalidFileType', session.user.language),
-        });
-    }
-    /**
-     * Check if the file type is allowed
-     */
-    if (!documentAllowedExtensions.includes(fileType.ext)) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: getString('invalidFileType', session.user.language),
-        });
-    }
-    /**
-     * Convert the image to webp format and return a buffer
-     */
-    const buffer = fs.readFileSync(pathToFile);
-    /**
-     * Create a base64 string from the buffer
-     */
-    const base64 = buffer.toString('base64');
-    /**
-     * Return the base64 string with the mime type
-     */
-    return {
-        base64: `data:${fileType.mime};base64,${base64}`,
-        mimeType: fileType.mime,
-    };
-};
-/**
- * Helper function with proper cleanup for converting Node.js stream to Web ReadableStream
- * Uses pull()-based reading for proper backpressure support.
- * @param nodeStream
- * @param sharpInstance
- */
-function nodeStreamToWebStream(nodeStream, sharpInstance) {
-    return new ReadableStream({
-        start() {
-            // Start paused — let pull() drive reading
-            if ('pause' in nodeStream && typeof nodeStream.pause === 'function') {
-                nodeStream.pause();
-            }
-        },
-        pull(controller) {
-            return new Promise((resolve, reject) => {
-                const onData = (chunk) => {
-                    controller.enqueue(new Uint8Array(chunk));
-                    if ('pause' in nodeStream && typeof nodeStream.pause === 'function') {
-                        nodeStream.pause();
-                    }
-                    nodeStream.removeListener('data', onData);
-                    nodeStream.removeListener('error', onError);
-                    resolve();
-                };
-                const onError = (err) => {
-                    controller.error(err);
-                    nodeStream.removeListener('data', onData);
-                    reject(err);
-                };
-                nodeStream.on('data', onData);
-                nodeStream.on('error', onError);
-                nodeStream.once('end', () => {
-                    controller.close();
-                    resolve();
-                });
-                if ('resume' in nodeStream && typeof nodeStream.resume === 'function') {
-                    nodeStream.resume();
-                }
-            });
-        },
-        cancel() {
-            // Proper cleanup sequence
-            sharpInstance.destroy();
-            nodeStream.removeAllListeners();
-            if ('destroy' in nodeStream && typeof nodeStream.destroy === 'function') {
-                nodeStream.destroy();
-            }
-        },
-    });
-}
-export const getPhoto = async (input) => {
-    const { name, folder, isThumb } = input;
-    // Sanitize the inputs
-    const sanitizedFolder = sanitizeFolderOrFileName(folder);
-    const sanitizedName = sanitizeFileName(name);
-    /**
-     * Check the folder name matches a section name in the database
-     * Notice: Maybe we don't need this check because making an sql call for each image is maybe expensive
-     */
-    /*const sectionQuery = await db
-        .select()
-        .from(SectionsTable)
-        .where(eq(SectionsTable.sectionName, sanitizedFolder))
-        .limit(1)
-
-    if (sectionQuery.length === 0) {
-        throw new Error('Invalid folder name')
-    }*/
-    const uploadsFolder = (await getCMSConfig()).media.upload.path;
-    const dir = isThumb ? '.thumbs' : '.photos';
-    const pathToFile = path.join(uploadsFolder, dir, sanitizedFolder, sanitizedName);
-    /**
-     * Disable caching for the image to avoid unlink issues when removing the image
-     */
-    sharp.cache({ files: 0 });
-    sharp.cache(false);
-    /**
-     * Convert the image to webp format and return a buffer
-     */
-    const sharpInstance = sharp(pathToFile);
-    let webpBuffer = await sharpInstance // Load the image
-        .toFormat('webp') // Re-encode the image to webp
-        .withExif({}) // Strip the exif data
-        .toBuffer(); // Return a buffer
-    /**
-     * Destroy the sharp instance to free it from memory
-     */
-    const base64String = webpBuffer.toString('base64');
-    sharpInstance.destroy();
-    /**
-     * Return the base64 string with the mime type
-     */
-    return `data:image/webp;base64,${base64String}`;
-};
-export async function streamPhoto(input) {
-    const { name, folder, isThumb } = input;
-    // Sanitize the inputs
-    const sanitizedFolder = sanitizeFolderOrFileName(folder);
-    const sanitizedName = sanitizeFileName(name);
-    const dir = isThumb ? '.thumbs' : '.photos';
-    const uploadsFolder = (await getCMSConfig()).media.upload.path;
-    const pathToFile = path.join(uploadsFolder, dir, sanitizedFolder, sanitizedName);
-    /**
-     * Disable caching for the image to avoid unlink issues when removing the image
-     */
-    sharp.cache({ files: 0 });
-    sharp.cache(false);
-    // Process all images through Sharp
-    const processedImage = sharp(pathToFile).toFormat('webp').withExif({});
-    /**
-     * Convert Node.js stream to Web ReadableStream
-     * Also, add through2 for proper streaming
-     */
-    const nodeStream = processedImage.pipe(through2());
-    return nodeStreamToWebStream(nodeStream, processedImage);
-}
-export const getVideo = async (session, input) => {
-    throw new Error(getString('useVideoApiRoute', session.user.language));
-};
-export const getAdminPrivileges = async (adminId) => {
-    const rows = await db
-        .select({ sectionName: AdminPrivilegesTable.sectionName })
-        .from(AdminPrivilegesTable)
-        .where(eq(AdminPrivilegesTable.adminId, adminId));
-    return new Set(rows.map((row) => row.sectionName));
-};
-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 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 (section.type === 'has_items' || section.type === 'category') {
-            title = resolveMultilingualString(section.title.section, language, cmsConfig.i18n.fallbackLanguage);
-        }
-        else {
-            title = resolveMultilingualString(section.title, language, cmsConfig.i18n.fallbackLanguage);
-        }
-        privilegesList.push({
-            title,
-            order: section.order || index,
-            sectionName: section.name,
-            sectionType: section.type,
-        });
-    });
-    const pluginPrivileges = new Map();
-    pluginRoutes.forEach((route) => {
-        if (pluginPrivileges.has(route.pluginName))
-            return;
-        pluginPrivileges.set(route.pluginName, {
-            title: resolveMultilingualString(route.title, language, cmsConfig.i18n.fallbackLanguage),
-        });
-    });
-    Array.from(pluginPrivileges.entries()).forEach(([pluginName, meta], index) => {
-        privilegesList.push({
-            title: meta.title,
-            order: sections.length + index,
-            sectionName: pluginName,
-            sectionType: 'plugin',
-        });
-    });
-    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 () => {
-    const admins = await db
-        .select({
-        id: AdminsTable.id,
-        username: AdminsTable.user,
-        avatar: AdminsTable.coverphoto,
-    })
-        .from(AdminsTable);
-    const roles = await db.select().from(AdminPrivilegesTable);
-    /**
-     * Assign the roles to the admins
-     */
-    const adminsWithRoles = [];
-    admins.forEach((admin) => {
-        const adminRoles = roles.filter((role) => role.adminId === admin.id);
-        adminsWithRoles.push({
-            ...admin,
-            roles: adminRoles,
-        });
-    });
-    return adminsWithRoles;
-};
-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 pluginRoutes = await getPluginRoutes();
-    const privilegeSet = await getAdminPrivileges(session.user.id);
-    // Get config and check for dashboard override
-    const cmsConfig = await getCMSConfig();
-    const dashboardOverridePath = cmsConfig.dashboard?.override;
-    // 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 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,
-        };
-    });
-    // Filter out dashboard override from plugin sections (it becomes the dashboard entry)
-    const pluginSections = allowedPluginRoutes
-        .filter((route) => route.path !== dashboardOverridePath)
-        .map((route) => ({
-        title: resolveMultilingualString(route.title, language, cmsConfig.i18n.fallbackLanguage),
-        path: route.path,
-        icon: route.icon ?? '',
-    }));
-    const fixedSections = [
-        /**
-         * Add the dashboard section (points to override if configured)
-         */
-        {
-            title: getString('dashboard', session.user.language),
-            path: dashboardOverridePath ?? '/dashboard',
-            icon: 'home',
-        },
-        /**
-         * Add the plugin sections (excluding dashboard override)
-         */
-        ...pluginSections,
-        ...fixed.map((section) => ({
-            title: getString(section.name, session.user.language),
-            path: `/${section.name}`,
-            icon: section.icon,
-        })),
-    ];
-    return {
-        fixed_sections: fixedSections,
-        cat_sections: categorySectionsItems,
-        has_items_sections: hasItemsSectionItems,
-        simple_sections: simpleSectionItems,
-    };
-};
-/**
- * Return a stream from the disk with proper backpressure handling.
- * Uses Node.js built-in Readable.toWeb() which correctly pauses/resumes
- * the underlying fs stream based on consumer demand.
- * @param {string} path - The location of the file
- * @param options
- * @returns {ReadableStream} A readable stream of the file
- */
-export const streamFile = async (path, options) => {
-    const stream = fs.createReadStream(path, options);
-    return Readable.toWeb(stream);
-};