nextjs-cms 0.5.9 → 0.5.11

package/dist/api/lib/serverActions.js

@@ -1,834 +1,834 @@
-// 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.js";
-import { SelectField } from "../../core/fields.js";
-import { MysqlTableChecker } from "../../core/db.js";
-import fs from 'fs';
-import path from 'path';
-import { sanitizeFileName, sanitizeFolderOrFileName } from "../../utils.js";
-import sharp from 'sharp';
-import { readChunk } from 'read-chunk';
-import { fileTypeFromBuffer } from 'file-type';
-import { getCMSConfig } from "../../core/config.js";
-import through2 from 'through2';
-const uploadsFolder = getCMSConfig().files.upload.uploadPath;
-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: 'Invalid file path',
-        });
-    }
-    const fieldConfig = section.fields.find((field) => field.name === fieldName);
-    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: 'Invalid request',
-        });
-    }
-    /**
-     * Split the allowed extensions into an array
-     */
-    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: 'File not found',
-        });
-    }
-    /**
-     * 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: 'Invalid file type',
-        });
-    }
-    /**
-     * Check if the file type is allowed
-     */
-    if (!documentAllowedExtensions.includes(fileType.ext)) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: 'Invalid file type',
-        });
-    }
-    /**
-     * 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
- * @param nodeStream
- * @param sharpInstance
- */
-function nodeStreamToWebStream(nodeStream, sharpInstance) {
-    return new ReadableStream({
-        start(controller) {
-            nodeStream.on('data', (chunk) => {
-                controller.enqueue(new Uint8Array(chunk));
-            });
-            nodeStream.on('end', () => controller.close());
-            nodeStream.on('error', (error) => controller.error(error));
-        },
-        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 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 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 (input) => {
-    throw new Error('Please use the /api/video route');
-};
-export const getAllPrivileges = async () => {
-    const sections = await SectionFactory.getSections();
-    // 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) => {
-        privilegesList.push({
-            title: typeof section.title === 'string' ? section.title : section.title.section,
-            order: section.order || index,
-            sectionName: section.name,
-            sectionType: section.type,
-        });
-    });
-    privilegesList.push({ title: 'Admins', order: 0, sectionName: 'admins', sectionType: 'static' }, { title: 'Emails', order: 1, sectionName: 'emails', sectionType: 'static' }, { title: 'Log', 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) => {
-    try {
-        /**
-         * 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();
-        /**
-         * 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
-            })
-        }*/
-        return {
-            section: fieldsFactory.sectionInfo,
-            inputGroups: fieldsFactory.getGroupedFields(),
-        };
-    }
-    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) => {
-    /**
-     * Convert the section item id to string
-     */
-    sectionItemId = sectionItemId.toString();
-    try {
-        const _s = await SectionFactory.getSectionForAdmin({
-            name: sectionName,
-            admin: {
-                id: session.user.id,
-            },
-        });
-        const section = _s?.build();
-        if (!section) {
-            return {
-                error: {
-                    message: 'Section not found or you do not have access to it',
-                },
-            };
-        }
-        const tableName = section.db.table;
-        const identifierFieldName = section.db.identifier.name;
-        const columns = await MysqlTableChecker.getColumns(tableName);
-        if (!columns.includes(identifierFieldName)) {
-            return {
-                error: {
-                    message: 'Section table identifier field not found',
-                },
-            };
-        }
-        /**
-         * 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];
-        /**
-         * Delete the row from the table
-         */
-        await db.execute(sql `delete from \`${sql.raw(tableName)}\` where \`${sql.raw(identifierFieldName)}\` = ${sectionItemId}`);
-        /**
-         * Grab the file fields to delete the files
-         */
-        const fileFieldConfigs = section.fieldConfigs.filter((fieldConfig) => fieldConfig.type === 'document' || fieldConfig.type === 'photo' || fieldConfig.type === 'video');
-        for (const field of fileFieldConfigs) {
-            // @ts-ignore
-            const value = sectionItemRow[field.name];
-            if (value) {
-                if (field.type === 'document') {
-                    await fs.promises.unlink(path.join(uploadsFolder, '.documents', section.name, value));
-                }
-                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);
-                    }
-                }
-            }
-        }
-        /**
-         * Grab the selectMultiple fields and delete the rows from the destination table
-         */
-        const selectMultipleFields = section.fieldConfigs.filter((fieldConfig) => fieldConfig.type === 'select_multiple');
-        for (const fieldConfig of selectMultipleFields) {
-            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
-         */
-        if (section.gallery) {
-            const { tableName, referenceIdentifierField, photoNameField, metaField } = section.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)));
-        }
-        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 createEditPage = async (session, sectionName, sectionItemId) => {
-    /**
-     * Generate the fields for the edit page
-     */
-    const fieldsFactory = new FieldFactory({
-        type: 'edit',
-        sectionName,
-        session,
-        itemId: sectionItemId,
-    });
-    try {
-        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 = [];
-        if (fieldsFactory.sectionInfo?.gallery) {
-            const { tableName, referenceIdentifierField, photoNameField, metaField } = fieldsFactory.sectionInfo.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],
-                    });
-                });
-            }
-        }
-        return {
-            section: fieldsFactory.sectionInfo,
-            inputGroups: fieldsFactory.getGroupedFields(),
-            gallery: galleryItems,
-        };
-    }
-    catch (error) {
-        const errorMessage = error?.errorMessage || (error instanceof Error ? error.message : 'Unknown error occurred');
-        console.error('Error creating edit page', error);
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            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
-            })
-        }*/
-        return {
-            section: fieldsFactory.sectionInfo,
-            inputGroups: fieldsFactory.getGroupedFields(),
-        };
-    }
-    catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
-        console.error('Error creating new page', err);
-        return {
-            error: {
-                message: `Failed to create new page: ${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: 'Section not found or you do not have access to it',
-            },
-        };
-    }
-    /**
-     * 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) {
-        throw new TRPCError({
-            code: 'NOT_FOUND',
-            message: 'Section not found or you do not have access to it',
-        });
-    }
-    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);
-    const categorySectionSelect = {
-        options: s.options,
-        required: s.required,
-        name: s.name,
-        label: s.label,
-        value: s.value,
-        parentId: undefined,
-        level: 1,
-        depth: section.depth,
-        sectionName: section.name,
-        allowRecursiveDelete: section.allowRecursiveDelete,
-    };
-    return {
-        section: {
-            tableName: tableName,
-            sectionName: section.name,
-            title: section.title,
-        },
-        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: 'Section not found or you do not have access to it',
-            },
-        };
-    }
-    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;
-    sqlChunks.push(sql `select * from ${sql.raw(tableName)}`);
-    totalRowsSqlChunks.push(sql `select count(*) as total from ${sql.raw(tableName)}`);
-    if (q && q.trim().length > 0) {
-        if (section.search?.searchFields.length) {
-            let i = 1;
-            sqlChunks.push(sql `where`);
-            totalRowsSqlChunks.push(sql `where`);
-            for (const field of section.search?.searchFields) {
-                // sqlChunks.push(sql`${sql.raw(field.name)} like '%${q}%'`)
-                sqlChunks.push(sql `${sql.raw(field.name)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
-                totalRowsSqlChunks.push(sql `${sql.raw(field.name)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
-                if (i === section.search?.searchFields.length)
-                    continue;
-                sqlChunks.push(sql `or`);
-                totalRowsSqlChunks.push(sql `or`);
-                i++;
-            }
-        }
-    }
-    sqlChunks.push(sql `ORDER BY \`${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];
-    return {
-        section: {
-            // tableName: tableName,
-            // headingField: section.headingField.name,
-            // identifierField: section.db.identifier.name,
-            // coverPhotoField: section.coverPhotoField?.name,
-            hasSearch: sectionSearch,
-            name: section.name,
-            title: section.title.section,
-        },
-        items: rows.map((row) => {
-            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 },
-    });
-    // Let's loop through the sections and add path, icon and title to each section item
-    const simpleSectionItems = simple.map((section) => {
-        return {
-            title: section.title,
-            path: `/section/${section.name}`,
-            icon: section.icon,
-        };
-    });
-    const hasItemsSectionItems = has_items.map((section) => {
-        return {
-            title: section.title.section,
-            path: `/${section.name}`,
-            icon: section.icon,
-        };
-    });
-    const categorySectionsItems = category.map((section) => {
-        return {
-            title: section.title.section,
-            path: `/categorized/${section.name}`,
-            icon: section.icon,
-        };
-    });
-    return {
-        fixed_sections: [
-            {
-                title: 'Dashboard',
-                path: '/dashboard',
-                icon: 'home',
-            },
-            ...fixed.map((section) => {
-                return {
-                    title: section,
-                    path: `/${section}`,
-                    icon: 'home',
-                };
-            }),
-        ],
-        cat_sections: categorySectionsItems,
-        has_items_sections: hasItemsSectionItems,
-        simple_sections: simpleSectionItems,
-    };
-};
-/**
- * Return a stream from the disk
- * @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 new ReadableStream({
-        start(controller) {
-            // @ts-ignore
-            stream.on('data', (chunk) => controller.enqueue(new Uint8Array(chunk)));
-            stream.on('end', () => controller.close());
-            stream.on('error', (error) => controller.error(error));
-        },
-        cancel() {
-            stream.destroy();
-        },
-    });
-};
+// 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 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 through2 from 'through2';
+const uploadsFolder = getCMSConfig().files.upload.uploadPath;
+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: 'Invalid file path',
+        });
+    }
+    const fieldConfig = section.fields.find((field) => field.name === fieldName);
+    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: 'Invalid request',
+        });
+    }
+    /**
+     * Split the allowed extensions into an array
+     */
+    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: 'File not found',
+        });
+    }
+    /**
+     * 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: 'Invalid file type',
+        });
+    }
+    /**
+     * Check if the file type is allowed
+     */
+    if (!documentAllowedExtensions.includes(fileType.ext)) {
+        throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: 'Invalid file type',
+        });
+    }
+    /**
+     * 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
+ * @param nodeStream
+ * @param sharpInstance
+ */
+function nodeStreamToWebStream(nodeStream, sharpInstance) {
+    return new ReadableStream({
+        start(controller) {
+            nodeStream.on('data', (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            });
+            nodeStream.on('end', () => controller.close());
+            nodeStream.on('error', (error) => controller.error(error));
+        },
+        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 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 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 (input) => {
+    throw new Error('Please use the /api/video route');
+};
+export const getAllPrivileges = async () => {
+    const sections = await SectionFactory.getSections();
+    // 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) => {
+        privilegesList.push({
+            title: typeof section.title === 'string' ? section.title : section.title.section,
+            order: section.order || index,
+            sectionName: section.name,
+            sectionType: section.type,
+        });
+    });
+    privilegesList.push({ title: 'Admins', order: 0, sectionName: 'admins', sectionType: 'static' }, { title: 'Emails', order: 1, sectionName: 'emails', sectionType: 'static' }, { title: 'Log', 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) => {
+    try {
+        /**
+         * 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();
+        /**
+         * 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
+            })
+        }*/
+        return {
+            section: fieldsFactory.sectionInfo,
+            inputGroups: fieldsFactory.getGroupedFields(),
+        };
+    }
+    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) => {
+    /**
+     * Convert the section item id to string
+     */
+    sectionItemId = sectionItemId.toString();
+    try {
+        const _s = await SectionFactory.getSectionForAdmin({
+            name: sectionName,
+            admin: {
+                id: session.user.id,
+            },
+        });
+        const section = _s?.build();
+        if (!section) {
+            return {
+                error: {
+                    message: 'Section not found or you do not have access to it',
+                },
+            };
+        }
+        const tableName = section.db.table;
+        const identifierFieldName = section.db.identifier.name;
+        const columns = await MysqlTableChecker.getColumns(tableName);
+        if (!columns.includes(identifierFieldName)) {
+            return {
+                error: {
+                    message: 'Section table identifier field not found',
+                },
+            };
+        }
+        /**
+         * 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];
+        /**
+         * Delete the row from the table
+         */
+        await db.execute(sql `delete from \`${sql.raw(tableName)}\` where \`${sql.raw(identifierFieldName)}\` = ${sectionItemId}`);
+        /**
+         * Grab the file fields to delete the files
+         */
+        const fileFieldConfigs = section.fieldConfigs.filter((fieldConfig) => fieldConfig.type === 'document' || fieldConfig.type === 'photo' || fieldConfig.type === 'video');
+        for (const field of fileFieldConfigs) {
+            // @ts-ignore
+            const value = sectionItemRow[field.name];
+            if (value) {
+                if (field.type === 'document') {
+                    await fs.promises.unlink(path.join(uploadsFolder, '.documents', section.name, value));
+                }
+                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);
+                    }
+                }
+            }
+        }
+        /**
+         * Grab the selectMultiple fields and delete the rows from the destination table
+         */
+        const selectMultipleFields = section.fieldConfigs.filter((fieldConfig) => fieldConfig.type === 'select_multiple');
+        for (const fieldConfig of selectMultipleFields) {
+            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
+         */
+        if (section.gallery) {
+            const { tableName, referenceIdentifierField, photoNameField, metaField } = section.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)));
+        }
+        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 createEditPage = async (session, sectionName, sectionItemId) => {
+    /**
+     * Generate the fields for the edit page
+     */
+    const fieldsFactory = new FieldFactory({
+        type: 'edit',
+        sectionName,
+        session,
+        itemId: sectionItemId,
+    });
+    try {
+        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 = [];
+        if (fieldsFactory.sectionInfo?.gallery) {
+            const { tableName, referenceIdentifierField, photoNameField, metaField } = fieldsFactory.sectionInfo.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],
+                    });
+                });
+            }
+        }
+        return {
+            section: fieldsFactory.sectionInfo,
+            inputGroups: fieldsFactory.getGroupedFields(),
+            gallery: galleryItems,
+        };
+    }
+    catch (error) {
+        const errorMessage = error?.errorMessage || (error instanceof Error ? error.message : 'Unknown error occurred');
+        console.error('Error creating edit page', error);
+        throw new TRPCError({
+            code: 'BAD_REQUEST',
+            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
+            })
+        }*/
+        return {
+            section: fieldsFactory.sectionInfo,
+            inputGroups: fieldsFactory.getGroupedFields(),
+        };
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+        console.error('Error creating new page', err);
+        return {
+            error: {
+                message: `Failed to create new page: ${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: 'Section not found or you do not have access to it',
+            },
+        };
+    }
+    /**
+     * 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) {
+        throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Section not found or you do not have access to it',
+        });
+    }
+    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);
+    const categorySectionSelect = {
+        options: s.options,
+        required: s.required,
+        name: s.name,
+        label: s.label,
+        value: s.value,
+        parentId: undefined,
+        level: 1,
+        depth: section.depth,
+        sectionName: section.name,
+        allowRecursiveDelete: section.allowRecursiveDelete,
+    };
+    return {
+        section: {
+            tableName: tableName,
+            sectionName: section.name,
+            title: section.title,
+        },
+        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: 'Section not found or you do not have access to it',
+            },
+        };
+    }
+    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;
+    sqlChunks.push(sql `select * from ${sql.raw(tableName)}`);
+    totalRowsSqlChunks.push(sql `select count(*) as total from ${sql.raw(tableName)}`);
+    if (q && q.trim().length > 0) {
+        if (section.search?.searchFields.length) {
+            let i = 1;
+            sqlChunks.push(sql `where`);
+            totalRowsSqlChunks.push(sql `where`);
+            for (const field of section.search?.searchFields) {
+                // sqlChunks.push(sql`${sql.raw(field.name)} like '%${q}%'`)
+                sqlChunks.push(sql `${sql.raw(field.name)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
+                totalRowsSqlChunks.push(sql `${sql.raw(field.name)} LIKE CONCAT('%',${sql `${q.trim()}`},'%')`);
+                if (i === section.search?.searchFields.length)
+                    continue;
+                sqlChunks.push(sql `or`);
+                totalRowsSqlChunks.push(sql `or`);
+                i++;
+            }
+        }
+    }
+    sqlChunks.push(sql `ORDER BY \`${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];
+    return {
+        section: {
+            // tableName: tableName,
+            // headingField: section.headingField.name,
+            // identifierField: section.db.identifier.name,
+            // coverPhotoField: section.coverPhotoField?.name,
+            hasSearch: sectionSearch,
+            name: section.name,
+            title: section.title.section,
+        },
+        items: rows.map((row) => {
+            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 },
+    });
+    // Let's loop through the sections and add path, icon and title to each section item
+    const simpleSectionItems = simple.map((section) => {
+        return {
+            title: section.title,
+            path: `/section/${section.name}`,
+            icon: section.icon,
+        };
+    });
+    const hasItemsSectionItems = has_items.map((section) => {
+        return {
+            title: section.title.section,
+            path: `/${section.name}`,
+            icon: section.icon,
+        };
+    });
+    const categorySectionsItems = category.map((section) => {
+        return {
+            title: section.title.section,
+            path: `/categorized/${section.name}`,
+            icon: section.icon,
+        };
+    });
+    return {
+        fixed_sections: [
+            {
+                title: 'Dashboard',
+                path: '/dashboard',
+                icon: 'home',
+            },
+            ...fixed.map((section) => {
+                return {
+                    title: section,
+                    path: `/${section}`,
+                    icon: 'home',
+                };
+            }),
+        ],
+        cat_sections: categorySectionsItems,
+        has_items_sections: hasItemsSectionItems,
+        simple_sections: simpleSectionItems,
+    };
+};
+/**
+ * Return a stream from the disk
+ * @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 new ReadableStream({
+        start(controller) {
+            // @ts-ignore
+            stream.on('data', (chunk) => controller.enqueue(new Uint8Array(chunk)));
+            stream.on('end', () => controller.close());
+            stream.on('error', (error) => controller.error(error));
+        },
+        cancel() {
+            stream.destroy();
+        },
+    });
+};