nextjs-cms 0.9.37 → 0.9.38

package/dist/api/lib/serverActions.js

@@ -0,0 +1,1445 @@
+// import 'server-only'
+import { db } from '../../db/client.js';
+import { AdminPrivilegesTable, AdminsTable, EditorPhotosTable } from '../../db/schema.js';
+import { and, eq, sql } from 'drizzle-orm';
+import { TRPCError } from '@trpc/server';
+import { FieldFactory, SectionFactory } from '../../core/factories/index.js';
+import { SelectField } from '../../core/fields/index.js';
+import { MysqlTableChecker } from '../../core/db/index.js';
+import fs from 'fs';
+import { Readable } from 'stream';
+import path from 'path';
+import { sanitizeFileName, sanitizeFolderOrFileName } from '../../utils/index.js';
+import sharp from 'sharp';
+import { readChunk } from 'read-chunk';
+import { fileTypeFromBuffer } from 'file-type';
+import { getCMSConfig } from '../../core/config/index.js';
+import { resolveLocale } from '../../core/localization/index.js';
+import { getPluginRoutes } from '../../plugins/loader.js';
+import through2 from 'through2';
+import { recordLog } from '../../logging/index.js';
+import getString from '../../translations/index.js';
+import { resolveMultilingualString } from '../../translations/language-utils.js';
+import { resolveLanguage } from '../../translations/language-utils.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;
+};
+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 (typeof section.title === 'string') {
+            title = resolveMultilingualString(section.title, language, cmsConfig.i18n.fallbackLanguage);
+        }
+        else {
+            title = resolveMultilingualString(section.title.section, 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 = [];
+            if (sectionInfo.hasLocalizedFields) {
+                const localesTableName = sectionInfo.localesTableName;
+                const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+                const localeTableExists = localeColumns.length > 0;
+                if (localeTableExists) {
+                    // Simple sections always have itemId = 1
+                    const sectionItemId = 1;
+                    const [rows] = await db.execute(sql `SELECT locale FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId}`);
+                    existingTranslations = rows.map((r) => r.locale);
+                    // Override localized field values with locale-specific data
+                    if (locale && localeResult.resolvedLocale && localeResult.isDefault === false) {
+                        const [localeRows] = await db.execute(sql `SELECT * FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${localeResult.resolvedLocale.code} LIMIT 1`);
+                        const localeRow = localeRows[0] ?? null;
+                        for (const field of sectionInfo.fields) {
+                            if (!field.localized)
+                                continue;
+                            // For select/tags with destinationDb, fetch locale-scoped junction values
+                            const f = field;
+                            if (f.destinationDb && (field.type === 'select' || field.type === 'select_multiple')) {
+                                if (f.db) {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` a JOIN \`${sql.raw(f.db.table)}\` b ON a.\`${sql.raw(f.destinationDb.selectIdentifier)}\` = b.\`${sql.raw(f.db.identifier)}\` WHERE a.\`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND a.\`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: row[f.db.label],
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                                else {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: f.options?.find((opt) => opt.value?.toString() ===
+                                                row[f.destinationDb.selectIdentifier]?.toString())?.label ?? '',
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                            }
+                            else if (f.destinationDb && field.type === 'tags') {
+                                const [_rows] = await db.execute(sql `SELECT \`${sql.raw(f.destinationDb.selectIdentifier)}\` FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                const tags = Array.isArray(_rows)
+                                    ? _rows.map((row) => row[f.destinationDb.selectIdentifier])
+                                    : [];
+                                field.setValue(tags.join(','));
+                            }
+                            else {
+                                // Simple field: override from locale row
+                                field.setValue(localeRow ? (localeRow[field.name] ?? null) : null);
+                            }
+                        }
+                    }
+                }
+            }
+            localizationData = {
+                defaultLocale: localeResult.defaultLocale,
+                currentLocale: localeResult.resolvedLocale ?? localeResult.defaultLocale,
+                existingTranslations,
+                locales: localeResult.availableLocales,
+            };
+        }
+        return {
+            section: {
+                name: sectionInfo.name,
+                title: resolvedTitle,
+                gallery: gallery,
+                variants: sectionInfo.variants,
+                configFile: sectionInfo.configFile,
+            },
+            inputGroups: await fieldsFactory.getGroupedFields(),
+            localization: localizationData,
+        };
+    }
+    catch (err) {
+        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 && section.hasLocalizedFields) {
+            const localesTableName = section.localesTableName;
+            const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+            if (localeColumns.length > 0) {
+                const [localeRows] = await db.execute(sql `SELECT locale FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId}`);
+                const locales = localeRows.map((r) => r.locale);
+                for (const locale of locales) {
+                    const result = await deleteLocaleTranslation(session, sectionName, sectionItemId, locale);
+                    if (result && typeof result === 'object' && 'error' in result) {
+                        return result;
+                    }
+                }
+            }
+        }
+        /**
+         * Grab the file fields to delete the files
+         */
+        const fileFieldConfigs = section.fieldConfigs.filter((fieldConfig) => fieldConfig.type === 'document' || fieldConfig.type === 'photo' || fieldConfig.type === 'video');
+        const uploadsFolder = 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 || !section.hasLocalizedFields) {
+            return {
+                error: {
+                    message: getString('localizationNotEnabledForSection', session.user.language),
+                },
+            };
+        }
+        if (locale === cmsConfig.localization.defaultLocale) {
+            return {
+                error: {
+                    message: getString('cannotDeleteBaseLocaleTranslation', session.user.language),
+                },
+            };
+        }
+        const localesTableName = section.localesTableName;
+        const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+        if (localeColumns.length === 0) {
+            return {
+                error: {
+                    message: getString('localesTableDoesNotExist', session.user.language),
+                },
+            };
+        }
+        // Fetch the locale row before deleting so we can clean up files
+        const [localeRows] = await db.execute(sql `SELECT * FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${locale} LIMIT 1`);
+        const localeRow = localeRows[0] ?? null;
+        const beforeDeleteHook = section.hooks?.beforeDelete;
+        if (beforeDeleteHook && typeof beforeDeleteHook === 'object' && beforeDeleteHook.runForLocales) {
+            await beforeDeleteHook.handler({
+                itemId: sectionItemId,
+                values: localeRow ?? {},
+                section: section,
+                locale,
+            });
+        }
+        // Delete files for localized photo/document/video fields
+        if (localeRow) {
+            const uploadsFolder = cmsConfig.media.upload.path;
+            const localizedFileFields = section.fieldConfigs.filter((f) => f.localized === true && (f.type === 'photo' || f.type === 'document' || f.type === 'video'));
+            for (const field of localizedFileFields) {
+                const value = localeRow[field.name];
+                if (!value)
+                    continue;
+                if (field.type === 'document') {
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.documents', section.name, value));
+                    }
+                    catch (error) {
+                        console.error('Error deleting document', error);
+                    }
+                }
+                else if (field.type === 'video') {
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.videos', section.name, value));
+                    }
+                    catch (error) {
+                        console.error('Error deleting video', error);
+                    }
+                }
+                else {
+                    // photo
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, value));
+                        await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', section.name, value));
+                    }
+                    catch (error) {
+                        console.error('Error deleting photo', error);
+                    }
+                }
+            }
+        }
+        // Delete locale-scoped editor photos for localized rich_text fields
+        const editorPhotos = await db
+            .select()
+            .from(EditorPhotosTable)
+            .where(and(eq(EditorPhotosTable.section, sectionName), eq(EditorPhotosTable.itemId, sectionItemId.toString()), eq(EditorPhotosTable.locale, locale)));
+        if (editorPhotos.length > 0) {
+            const uploadsFolder = cmsConfig.media.upload.path;
+            for (const photo of editorPhotos) {
+                try {
+                    await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, photo.name));
+                }
+                catch (error) {
+                    console.error('Error deleting editor photo', error);
+                }
+            }
+            await db
+                .delete(EditorPhotosTable)
+                .where(and(eq(EditorPhotosTable.section, sectionName), eq(EditorPhotosTable.itemId, sectionItemId.toString()), eq(EditorPhotosTable.locale, locale)));
+        }
+        // Delete locale-scoped junction table rows for localized select/tags fields
+        const localizedJunctionFields = section.fieldConfigs.filter((f) => f.localized === true &&
+            f.destinationDb &&
+            (f.type === 'select' || f.type === 'select_multiple' || f.type === 'tags'));
+        for (const field of localizedJunctionFields) {
+            const destDb = field.destinationDb;
+            if (!destDb)
+                continue;
+            try {
+                await db.execute(sql `DELETE FROM \`${sql.raw(destDb.table)}\` WHERE \`${sql.raw(destDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${locale}`);
+            }
+            catch (error) {
+                console.error(`Error deleting junction table rows for ${field.name}`, error);
+            }
+        }
+        await db.execute(sql `DELETE FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${locale}`);
+        const afterDeleteHook = section.hooks?.afterDelete;
+        if (afterDeleteHook && typeof afterDeleteHook === 'object' && afterDeleteHook.runForLocales) {
+            try {
+                await afterDeleteHook.handler({
+                    itemId: sectionItemId,
+                    values: localeRow ?? {},
+                    section: section,
+                    locale,
+                });
+            }
+            catch (e) {
+                console.error('afterDelete hook failed:', e);
+            }
+        }
+        await recordLog({
+            eventType: 'section.item.locale.delete',
+            actorId: session.user.id,
+            actorUsername: session.user.name,
+            entityType: 'section_item_locale',
+            entityId: sectionItemId,
+            entityLabel: locale,
+            sectionName: section.name,
+            metadata: {
+                locale,
+            },
+        });
+        return true;
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : getString('unknownErrorOccurred', session.user.language);
+        console.error('Error deleting locale translation', err);
+        return {
+            error: {
+                message: getString('deleteLocaleTranslationFailed', session.user.language, { detail: errorMessage }),
+            },
+        };
+    }
+};
+export const createEditPage = async (session, sectionName, sectionItemId, locale) => {
+    /**
+     * Generate the fields for the edit page
+     */
+    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 [items, fields] = await db.execute(sql `select * from \`${sql.raw(tableName)}\` where \`${sql.raw(referenceIdentifierField)}\` = ${sectionItemId}`);
+                const galleryPhotos = items;
+                galleryPhotos?.map((item) => {
+                    galleryItems.push({
+                        referenceId: item[referenceIdentifierField],
+                        photo: item[photoNameField],
+                        meta: item[metaField],
+                    });
+                });
+            }
+        }
+        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 = [];
+            if (sectionInfo.hasLocalizedFields) {
+                const localesTableName = sectionInfo.localesTableName;
+                const localeColumns = await MysqlTableChecker.getColumns(localesTableName);
+                const localeTableExists = localeColumns.length > 0;
+                if (localeTableExists) {
+                    const [rows] = await db.execute(sql `SELECT locale FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId}`);
+                    existingTranslations = rows.map((r) => r.locale);
+                    // Override localized field values with locale-specific data
+                    if (locale && localeResult.resolvedLocale && localeResult.isDefault === false) {
+                        const [localeRows] = await db.execute(sql `SELECT * FROM \`${sql.raw(localesTableName)}\` WHERE parent_id = ${sectionItemId} AND locale = ${localeResult.resolvedLocale.code} LIMIT 1`);
+                        const localeRow = localeRows[0] ?? null;
+                        for (const field of sectionInfo.fields) {
+                            if (!field.localized)
+                                continue;
+                            // For select/tags with destinationDb, fetch locale-scoped junction values
+                            const f = field;
+                            if (f.destinationDb && (field.type === 'select' || field.type === 'select_multiple')) {
+                                if (f.db) {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` a JOIN \`${sql.raw(f.db.table)}\` b ON a.\`${sql.raw(f.destinationDb.selectIdentifier)}\` = b.\`${sql.raw(f.db.identifier)}\` WHERE a.\`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND a.\`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: row[f.db.label],
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                                else {
+                                    const [_rows] = await db.execute(sql `SELECT * FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                    const values = Array.isArray(_rows)
+                                        ? _rows.map((row) => ({
+                                            value: row[f.destinationDb.selectIdentifier],
+                                            label: f.options?.find((opt) => opt.value?.toString() ===
+                                                row[f.destinationDb.selectIdentifier]?.toString())?.label ?? '',
+                                        }))
+                                        : [];
+                                    field.setValue(values);
+                                }
+                            }
+                            else if (f.destinationDb && field.type === 'tags') {
+                                const [_rows] = await db.execute(sql `SELECT \`${sql.raw(f.destinationDb.selectIdentifier)}\` FROM \`${sql.raw(f.destinationDb.table)}\` WHERE \`${sql.raw(f.destinationDb.itemIdentifier)}\` = ${sectionItemId} AND \`locale\` = ${localeResult.resolvedLocale.code}`);
+                                const tags = Array.isArray(_rows)
+                                    ? _rows.map((row) => row[f.destinationDb.selectIdentifier])
+                                    : [];
+                                field.setValue(tags.join(','));
+                            }
+                            else {
+                                // Simple field: override from locale row
+                                field.setValue(localeRow ? (localeRow[field.name] ?? null) : null);
+                            }
+                        }
+                    }
+                }
+            }
+            localizationData = {
+                defaultLocale: localeResult.defaultLocale,
+                currentLocale: localeResult.resolvedLocale ?? localeResult.defaultLocale,
+                existingTranslations,
+                locales: localeResult.availableLocales,
+            };
+        }
+        return {
+            section: {
+                name: sectionInfo.name,
+                title: resolvedTitle,
+                gallery: gallery,
+                variants: sectionInfo.variants,
+                configFile: sectionInfo.configFile,
+            },
+            inputGroups: await fieldsFactory.getGroupedFields(),
+            gallery: galleryItems,
+            localization: localizationData,
+        };
+    }
+    catch (error) {
+        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);
+};