@reldens/cms 0.16.0 → 0.19.0

package/lib/admin-translations.js

@@ -21,7 +21,9 @@ class AdminTranslations
                 reldensGithubText: 'Need a new feature?'
                     +' Would you like to contribute with code?'
                     +' Find the source code or create an issue in GitHub',
-                reldensLoading: 'Loading...'
+                reldensLoading: 'Loading...',
+                confirmClearCacheMessage: 'Are you sure you want to clear all cache? This action cannot be undone.',
+                clearCacheWarning: 'This will clear all cached routes and may impact site performance temporarily.'
             },
             labels: {
                 navigation: 'Reldens - CMS',
@@ -32,6 +34,12 @@ class AdminTranslations
                 shuttingDown: 'Server is shutting down in:',
                 submitShutdownLabel: 'Shutdown Server',
                 submitCancelLabel: 'Cancel Server Shutdown',
+                cleanCache: 'Clean Cache',
+                clearAllCache: 'Clear All Cache',
+                confirmClearCache: 'Confirm Clear Cache',
+                warning: 'Warning:',
+                cancel: 'Cancel',
+                confirm: 'Continue',
             }
         };
         for(let i of Object.keys(translations)){

package/lib/cache/add-cache-button-subscriber.js

@@ -0,0 +1,149 @@
+/**
+ *
+ * Reldens - CMS - AddCacheButtonSubscriber
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class AddCacheButtonSubscriber
+{
+
+    constructor(props = {})
+    {
+        this.events = sc.get(props, 'events', false);
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.renderCallback = sc.get(props, 'renderCallback', false);
+        this.cacheCleanButton = sc.get(props, 'cacheCleanButton', '');
+        this.clearAllCacheButton = sc.get(props, 'clearAllCacheButton', '');
+        this.translations = sc.get(props, 'translations', {});
+        this.cacheCleanRoute = sc.get(props, 'cacheCleanRoute', '');
+        this.clearAllCacheRoute = sc.get(props, 'clearAllCacheRoute', '');
+        this.setupEvents();
+    }
+
+    setupEvents()
+    {
+        if(!this.cacheManager){
+            Logger.error('Cache Manager not found on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!this.cacheManager.isEnabled()){
+            Logger.debug('Cache Manager not enabled.');
+            return false;
+        }
+        if(!this.events){
+            Logger.error('Events Manager not found on AddCacheButtonSubscriber.');
+            return false;
+        }
+        //Logger.debug('Listening events PropertiesPopulation.');
+        this.events.on('reldens.adminViewPropertiesPopulation', this.populateViewFields.bind(this));
+        this.events.on('reldens.adminEditPropertiesPopulation', this.populateEditFields.bind(this));
+        this.events.on('reldens.adminListPropertiesPopulation', this.populateListFields.bind(this));
+    }
+
+    async populateViewFields(event)
+    {
+        let cacheButton = await this.generateCacheCleanButton(event);
+        if(!cacheButton){
+            //Logger.info('Missing cache button contents on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!event.renderedViewProperties.extraContentForView){
+            event.renderedViewProperties.extraContentForView = '';
+        }
+        event.renderedViewProperties.extraContentForView += cacheButton;
+        //Logger.debug('Clean cache button ready on view.');
+        return true;
+    }
+
+    async populateEditFields(event)
+    {
+        let cacheButton = await this.generateCacheCleanButton(event);
+        if(!cacheButton){
+            //Logger.info('Missing cache button contents on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!event.renderedEditProperties.extraContentForEdit){
+            event.renderedEditProperties.extraContentForEdit = '';
+        }
+        event.renderedEditProperties.extraContentForEdit += cacheButton;
+        //Logger.debug('Clean cache button ready on edit.');
+        return true;
+    }
+
+    async populateListFields(event)
+    {
+        let clearAllButton = await this.generateClearAllCacheButton(event);
+        if(!clearAllButton){
+            return false;
+        }
+        if(!event.listProperties.extraContentForList){
+            event.listProperties.extraContentForList = '';
+        }
+        event.listProperties.extraContentForList += clearAllButton;
+        return true;
+    }
+
+    async generateCacheCleanButton(event)
+    {
+        if('routes' !== event.driverResource.id()){
+            return false;
+        }
+        if(!event.loadedEntity){
+            Logger.error('Missing loaded entity on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!event.loadedEntity.id){
+            Logger.error('Missing loaded entity ID on AddCacheButtonSubscriber.');
+            return false;
+        }
+        if(!this.cacheCleanButton){
+            Logger.error('Cache clean button template content not found');
+            return '';
+        }
+        if(!this.renderCallback){
+            Logger.error('Render callback not available for cache button');
+            return '';
+        }
+        return await this.renderCallback(
+            this.cacheCleanButton,
+            {
+                cacheCleanRoute: this.cacheCleanRoute,
+                routeId: event.loadedEntity.id,
+                buttonText: sc.get(this.translations.labels, 'cleanCache', 'cleanCache')
+            }
+        );
+    }
+
+    async generateClearAllCacheButton(event)
+    {
+        if('routes' !== event.driverResource.id()){
+            return false;
+        }
+        if(!this.clearAllCacheButton){
+            Logger.error('Clear all cache button template content not found');
+            return '';
+        }
+        if(!this.renderCallback){
+            Logger.error('Render callback not available for clear all cache button');
+            return '';
+        }
+        return await this.renderCallback(
+            this.clearAllCacheButton,
+            {
+                buttonText: sc.get(this.translations.labels, 'clearAllCache', 'clearAllCache'),
+                clearAllCacheRoute: this.clearAllCacheRoute,
+                confirmTitle: sc.get(this.translations.labels, 'confirmClearCache', 'confirmClearCache'),
+                confirmMessage: sc.get(this.translations.messages, 'confirmClearCacheMessage', 'confirmClearCacheMessage'),
+                warningText: sc.get(this.translations.labels, 'warning', 'warning'),
+                warningMessage: sc.get(this.translations.messages, 'clearCacheWarning', 'clearCacheWarning'),
+                cancelText: sc.get(this.translations.labels, 'cancel', 'cancel'),
+                confirmText: sc.get(this.translations.labels, 'confirm', 'confirm')
+            }
+        );
+    }
+
+}
+
+module.exports.AddCacheButtonSubscriber = AddCacheButtonSubscriber;

package/lib/cache/cache-manager.js

@@ -0,0 +1,168 @@
+/**
+ *
+ * Reldens - CMS - CacheManager
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class CacheManager
+{
+
+    constructor(props = {})
+    {
+        this.projectRoot = sc.get(props, 'projectRoot', './');
+        this.cacheBasePath = FileHandler.joinPaths(this.projectRoot, '.reldens_cms_cache');
+        this.enabled = sc.get(props, 'enabled', true);
+    }
+
+    generateCacheKey(domain, path)
+    {
+        let domainFolder = domain || 'default';
+        let pathSegments = path.split('/').filter(segment => '' !== segment);
+        if(0 === pathSegments.length){
+            pathSegments = ['index'];
+        }
+        let fileName = pathSegments.pop() + '.html';
+        let folderPath = FileHandler.joinPaths(this.cacheBasePath, domainFolder, ...pathSegments);
+        return {
+            folderPath,
+            fileName,
+            fullPath: FileHandler.joinPaths(folderPath, fileName)
+        };
+    }
+
+    async get(domain, path)
+    {
+        if(!this.enabled){
+            return false;
+        }
+        let cacheInfo = this.generateCacheKey(domain, path);
+        if(!FileHandler.exists(cacheInfo.fullPath)){
+            return false;
+        }
+        let cachedContent = FileHandler.readFile(cacheInfo.fullPath);
+        if(!cachedContent){
+            Logger.debug('Failed to read cached file: '+cacheInfo.fullPath);
+            return false;
+        }
+        return cachedContent;
+    }
+
+    async set(domain, path, content)
+    {
+        if(!this.enabled){
+            return false;
+        }
+        let cacheInfo = this.generateCacheKey(domain, path);
+        if(!FileHandler.createFolder(cacheInfo.folderPath)){
+            Logger.error('Failed to create cache folder: '+cacheInfo.folderPath);
+            return false;
+        }
+        if(!FileHandler.writeFile(cacheInfo.fullPath, content)){
+            Logger.error('Failed to write cache file: '+cacheInfo.fullPath);
+            return false;
+        }
+        return true;
+    }
+
+    findAllCacheFilesForPath(domain, path)
+    {
+        let cacheInfo = this.generateCacheKey(domain, path);
+        if(!FileHandler.exists(cacheInfo.folderPath)){
+            return [];
+        }
+        let allFiles = FileHandler.readFolder(cacheInfo.folderPath);
+        if(0 === allFiles.length){
+            return [];
+        }
+        let baseFileName = cacheInfo.fileName.replace('.html', '');
+        let matchingFiles = [];
+        for(let file of allFiles){
+            if(file === cacheInfo.fileName){
+                matchingFiles.push(FileHandler.joinPaths(cacheInfo.folderPath, file));
+                continue;
+            }
+            if(file.startsWith(baseFileName + '_') && file.endsWith('.html')){
+                matchingFiles.push(FileHandler.joinPaths(cacheInfo.folderPath, file));
+            }
+        }
+        return matchingFiles;
+    }
+
+    async delete(domain, path)
+    {
+        let cacheByDomains = this.fetchCachePathsByDomain(domain, path);
+        for(let cacheInfo of cacheByDomains){
+            let allCacheFiles = this.findAllCacheFilesForPath(cacheInfo.domain || domain, path);
+            if(0 === allCacheFiles.length){
+                let singleCacheInfo = this.generateCacheKey(cacheInfo.domain || domain, path);
+                if(!FileHandler.exists(singleCacheInfo.fullPath)){
+                    Logger.debug('No cache files found for: '+path);
+                    continue;
+                }
+                allCacheFiles = [singleCacheInfo.fullPath];
+            }
+            for(let cacheFilePath of allCacheFiles){
+                if(!FileHandler.exists(cacheFilePath)){
+                    Logger.debug('File does not exist: '+cacheFilePath);
+                    continue;
+                }
+                if(!FileHandler.remove(cacheFilePath)){
+                    Logger.error('Failed to delete cache file: '+cacheFilePath);
+                    return false;
+                }
+                Logger.debug('Deleted cache file: '+cacheFilePath);
+            }
+        }
+        return true;
+    }
+
+    fetchCachePathsByDomain(domain, path)
+    {
+        let cacheByDomains = [];
+        if(domain && 'default' !== domain){
+            cacheByDomains.push({domain: domain});
+            return cacheByDomains;
+        }
+        if(!FileHandler.exists(this.cacheBasePath)){
+            return cacheByDomains;
+        }
+        let cachedDomainFolders = FileHandler.readFolder(this.cacheBasePath);
+        for(let cachedDomainFolder of cachedDomainFolders) {
+            cacheByDomains.push({domain: cachedDomainFolder});
+        }
+        return cacheByDomains;
+    }
+
+    async clear()
+    {
+        if(!FileHandler.exists(this.cacheBasePath)){
+            return true;
+        }
+        if(!FileHandler.remove(this.cacheBasePath)){
+            Logger.error('Failed to clear cache folder: '+this.cacheBasePath);
+            return false;
+        }
+        return true;
+    }
+
+    isEnabled()
+    {
+        return this.enabled;
+    }
+
+    enable()
+    {
+        this.enabled = true;
+    }
+
+    disable()
+    {
+        this.enabled = false;
+    }
+
+}
+
+module.exports.CacheManager = CacheManager;

package/lib/cache/cache-routes-handler.js

@@ -0,0 +1,99 @@
+/**
+ *
+ * Reldens - CMS - CacheRoutesHandler
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class CacheRoutesHandler
+{
+
+    constructor(props)
+    {
+        this.router = sc.get(props, 'router', false);
+        this.dataServer = sc.get(props, 'dataServer', false);
+        /** @type {CacheManager} **/
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.rootPath = sc.get(props, 'rootPath', '');
+        this.cacheCleanPath = '/cache-clean';
+        this.cacheCleanRoute = this.rootPath+this.cacheCleanPath;
+        this.clearAllCachePath = '/cache-clear-all';
+        this.clearAllCacheRoute = this.rootPath+this.clearAllCachePath;
+        this.setupRoutes();
+    }
+
+    setupRoutes()
+    {
+        if(!this.cacheManager){
+            Logger.error('Cache Manager not found on CacheRoutesHandler.');
+            return false;
+        }
+        if(!this.cacheManager.isEnabled()){
+            Logger.debug('Cache Manager not enabled.');
+            return false;
+        }
+        if(!this.router){
+            Logger.error('Router not found on CacheRoutesHandler.');
+            return false;
+        }
+        this.router.adminRouter.post(
+            this.cacheCleanPath,
+            this.router.isAuthenticated.bind(this.router),
+            async (req, res) => {
+                return await this.processCacheClean(req, res);
+            }
+        );
+        this.router.adminRouter.post(
+            this.clearAllCachePath,
+            this.router.isAuthenticated.bind(this.router),
+            async (req, res) => {
+                return await this.processClearAllCache(req, res);
+            }
+        );
+        return true;
+    }
+
+    async processCacheClean(req, res)
+    {
+        if(!this.cacheManager){
+            return res.json({error: 'Cache manager not available'});
+        }
+        let routeId = sc.get(req.body, 'routeId', '');
+        if(!routeId){
+            return res.json({error: 'Route ID is required'});
+        }
+        let routesEntity = this.dataServer.getEntity('routes');
+        if(!routesEntity){
+            return res.json({error: 'Routes entity not found'});
+        }
+        let route = await routesEntity.loadById(routeId);
+        if(!route){
+            return res.json({error: 'Route not found'});
+        }
+        let domain = sc.get(route, 'domain', '');
+        let path = route.path;
+        let cleanResult = await this.cacheManager.delete(domain, path);
+        if(!cleanResult){
+            return res.json({error: 'Failed to clean cache'});
+        }
+        return res.redirect(this.rootPath+'/routes/view'+'?id='+routeId+'&result=success');
+    }
+
+    async processClearAllCache(req, res)
+    {
+        if(!this.cacheManager){
+            return res.json({error: 'Cache manager not available'});
+        }
+        let clearResult = await this.cacheManager.clear();
+        if(!clearResult){
+            Logger.error('Failed to clear all cache');
+            return res.redirect(this.rootPath+'/routes?result=errorClearAllCache');
+        }
+        Logger.info('All cache cleared successfully');
+        return res.redirect(this.rootPath+'/routes?result=success');
+    }
+
+}
+
+module.exports.CacheRoutesHandler = CacheRoutesHandler;

package/lib/cms-pages-route-manager.js

@@ -26,17 +26,19 @@ class CmsPagesRouteManager
     async populateViewFields(event)
     {
         if('cms_pages' !== event.driverResource.id()){
-            return;
+            return false;
+        }
+        if(!event.loadedEntity || !event.loadedEntity.route_id){
+            event.renderedViewProperties.routePath = '';
+            event.renderedViewProperties.routeDomain = '';
+            return true;
         }
         let routesRepository = this.dataServer.getEntity('routes');
         if(!routesRepository){
             Logger.error('Routes repository not found.');
             return false;
         }
-        let existingRoute = await routesRepository.loadOne({
-            router: 'cmsPages',
-            cms_page_id: Number(event.renderedViewProperties.id)
-        });
+        let existingRoute = await routesRepository.loadById(event.loadedEntity.route_id);
         event.renderedViewProperties.routePath = sc.get(existingRoute, 'path', '');
         event.renderedViewProperties.routeDomain = sc.get(existingRoute, 'domain', '');
         return true;
@@ -45,17 +47,19 @@ class CmsPagesRouteManager
     async populateEditFields(event)
     {
         if('cms_pages' !== event.driverResource.id()){
-            return;
+            return false;
+        }
+        if(!event.loadedEntity || !event.loadedEntity.route_id){
+            event.renderedEditProperties.routePath = '';
+            event.renderedEditProperties.routeDomain = '';
+            return true;
         }
         let routesRepository = this.dataServer.getEntity('routes');
         if(!routesRepository){
             Logger.error('Routes repository not found.');
             return false;
         }
-        let existingRoute = await routesRepository.loadOne({
-            router: 'cmsPages',
-            cms_page_id: Number(event.renderedEditProperties.idValue)
-        });
+        let existingRoute = await routesRepository.loadById(event.loadedEntity.route_id);
         event.renderedEditProperties.routePath = sc.get(existingRoute, 'path', '');
         event.renderedEditProperties.routeDomain = sc.get(existingRoute, 'domain', '');
         return true;
@@ -72,28 +76,48 @@ class CmsPagesRouteManager
             Logger.error('Routes repository not found.');
             return;
         }
+        let path = sc.get(req.body, 'routePath', this.generateDefaultRoutePath(entityData));
+        if(!path || '' === path.trim()){
+            Logger.debug('No valid path available for CMS page route creation. Skipping route management.');
+            return;
+        }
         let cmsPageId = Number(entityData.id);
-        let existingRoute = await routesRepository.loadOne({router: 'cmsPages', cms_page_id: cmsPageId});
-        let patchData = {
-            path: sc.get(req.body, 'routePath', this.generateDefaultRoutePath(entityData)),
+        let routePatchData = {
+            path,
             router: sc.get(req.body, 'routeRouter', 'cmsPages'),
-            cms_page_id: cmsPageId,
             cache_ttl_seconds: Number(sc.get(req.body, 'routeCacheTtl', 3600)),
             enabled: Number(sc.get(req.body, 'routeEnabled', 1)),
             domain: sc.get(req.body, 'routeDomain', null)
         };
-        let result = existingRoute
-            ? await routesRepository.updateById(existingRoute.id, patchData)
-            : await routesRepository.create(patchData);
-        if (!result){
-            Logger.error('Route could not be saved.', patchData, existingRoute);
+        let routeResult = false;
+        if(entityData.route_id){
+            routeResult = await routesRepository.updateById(entityData.route_id, routePatchData);
+        }
+        if(!routeResult){
+            routeResult = await routesRepository.create(routePatchData);
+            if(routeResult){
+                let pagesRepository = this.dataServer.getEntity('cmsPages');
+                if(pagesRepository){
+                    let pageResult = await pagesRepository.updateById(cmsPageId, {route_id: routeResult.id});
+                    if(!pageResult){
+                        Logger.error('Page could not be updated with route ID.', routeResult);
+                    }
+                }
+            }
         }
-        return result;
+        if(!routeResult){
+            Logger.error('Route could not be saved.', routePatchData);
+        }
+        return routeResult;
     }
 
     generateDefaultRoutePath(pageData)
     {
-        return '/' + sc.get(pageData, 'title', 'page').toLowerCase()
+        let title = sc.get(pageData, 'title', '');
+        if(!title || '' === title.trim()){
+            return '';
+        }
+        return '/' + title.toLowerCase()
             .replace(/[^a-z0-9\s-]/g, '')
             .replace(/\s+/g, '-')
             .replace(/-+/g, '-')