@reldens/cms 0.18.0 → 0.19.0

package/lib/cache/cache-manager.js

@@ -67,17 +67,53 @@ class CacheManager
         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){
-            if(!FileHandler.exists(cacheInfo.fullPath)){
-                Logger.debug('File does not exist: '+cacheInfo.fullPath);
-                return true;
+            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];
             }
-            if(!FileHandler.remove(cacheInfo.fullPath)){
-                Logger.error('Failed to delete cache file: '+cacheInfo.fullPath);
-                return false;
+            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;
@@ -87,12 +123,15 @@ class CacheManager
     {
         let cacheByDomains = [];
         if(domain && 'default' !== domain){
-            cacheByDomains.push(this.generateCacheKey(domain, path));
+            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(this.generateCacheKey(cachedDomainFolder, path));
+            cacheByDomains.push({domain: cachedDomainFolder});
         }
         return cacheByDomains;
     }

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

@@ -18,6 +18,8 @@ class CacheRoutesHandler
         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();
     }
 
@@ -42,6 +44,13 @@ class CacheRoutesHandler
                 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;
     }
 
@@ -71,6 +80,20 @@ class CacheRoutesHandler
         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

@@ -76,9 +76,14 @@ 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 routePatchData = {
-            path: sc.get(req.body, 'routePath', this.generateDefaultRoutePath(entityData)),
+            path,
             router: sc.get(req.body, 'routeRouter', 'cmsPages'),
             cache_ttl_seconds: Number(sc.get(req.body, 'routeCacheTtl', 3600)),
             enabled: Number(sc.get(req.body, 'routeEnabled', 1)),
@@ -91,9 +96,12 @@ class CmsPagesRouteManager
         if(!routeResult){
             routeResult = await routesRepository.create(routePatchData);
             if(routeResult){
-                let pagesRepository = this.dataServer.getEntity('cms_pages');
+                let pagesRepository = this.dataServer.getEntity('cmsPages');
                 if(pagesRepository){
-                    await pagesRepository.updateById(cmsPageId, {route_id: routeResult.id});
+                    let pageResult = await pagesRepository.updateById(cmsPageId, {route_id: routeResult.id});
+                    if(!pageResult){
+                        Logger.error('Page could not be updated with route ID.', routeResult);
+                    }
                 }
             }
         }
@@ -105,7 +113,11 @@ class CmsPagesRouteManager
 
     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, '-')

package/lib/frontend.js

@@ -4,9 +4,11 @@
  *
  */
 
+const { TemplateEngine } = require('./template-engine');
+const { Search } = require('./search');
+const { SearchRenderer } = require('./search-renderer');
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
-const { TemplateEngine } = require('./template-engine');
 
 class Frontend
 {
@@ -31,6 +33,24 @@ class Frontend
         this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
         this.templateEngine = false;
         this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.searchPath = sc.get(props, 'searchPath', '/search');
+        this.searchSets = sc.get(props, 'searchSets', false);
+        this.searchConfig = {dataServer: this.dataServer};
+        if(this.searchSets){
+            this.searchConfig.searchSets = this.searchSets;
+        }
+        this.search = new Search(this.searchConfig);
+        this.searchRenderer = new SearchRenderer({
+            renderEngine: this.renderEngine,
+            getPartials: this.getPartialsForDomain.bind(this)
+        });
+        this.metaDefaults = sc.get(props, 'metaDefaults', {
+            locale: 'en',
+            viewport: 'width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes, viewport-fit=cover',
+            meta_robots: 'index,follow',
+            meta_theme_color: '#000000',
+            meta_twitter_card_type: 'summary'
+        });
     }
 
     async initialize()
@@ -61,10 +81,14 @@ class Frontend
             getPartials: this.getPartialsForDomain.bind(this),
             entitiesConfig: this.entitiesConfig
         });
+        this.searchConfig.jsonFieldsParser = this.templateEngine.jsonFieldsParser;
         await this.loadPartials();
         await this.setupDomainTemplates();
         await this.loadEntityAccessRules();
         this.setupStaticAssets();
+        this.app.get(this.searchPath, async (req, res) => {
+            return await this.handleSearchRequest(req, res);
+        });
         this.app.get('*', async (req, res) => {
             return await this.handleRequest(req, res);
         });
@@ -249,12 +273,95 @@ class Frontend
         return false;
     }
 
+    fetchMetaFields(data)
+    {
+        if(!sc.isObject(data) || 0 === Object.keys(data).length){
+            return this.metaDefaults;
+        }
+        let result = Object.assign({}, this.metaDefaults);
+        for(let key of Object.keys(data)){
+            let value = data[key];
+            if(null !== value && '' !== value && 'undefined' !== typeof value){
+                result[key] = value;
+            }
+        }
+        let titleValue = sc.get(result, 'title', '');
+        let metaTitleValue = sc.get(result, 'meta_title', titleValue);
+        if(metaTitleValue && '' !== metaTitleValue){
+            result.meta_title = metaTitleValue;
+        }
+        let metaOgTitleValue = sc.get(result, 'meta_og_title', metaTitleValue);
+        if(metaOgTitleValue && '' !== metaOgTitleValue){
+            result.meta_og_title = metaOgTitleValue;
+        }
+        let metaDescValue = sc.get(result, 'meta_description', '');
+        let metaOgDescValue = sc.get(result, 'meta_og_description', metaDescValue);
+        if(metaOgDescValue && '' !== metaOgDescValue){
+            result.meta_og_description = metaOgDescValue;
+        }
+        let jsonData = sc.get(result, 'json_data', null);
+        if(sc.isString(jsonData)){
+            jsonData = sc.toJson(jsonData, {});
+        }
+        if(!sc.isObject(jsonData)){
+            jsonData = {};
+        }
+        let viewportValue = sc.get(jsonData, 'viewport', this.metaDefaults.viewport);
+        if(viewportValue && '' !== viewportValue){
+            jsonData.viewport = viewportValue;
+        }
+        result.json_data = jsonData;
+        return result;
+    }
+
+    async handleSearchRequest(req, res)
+    {
+        try {
+            let domain = this.getDomainFromRequest(req);
+            let config = this.search.parseSearchParameters(req.query);
+            if(!config){
+                return res.redirect('/?error-message=searchInvalidParameters');
+            }
+            let cacheKey = this.buildCacheKey(req.path, req);
+            if(this.cacheManager && this.cacheManager.isEnabled()){
+                let cachedContent = await this.cacheManager.get(domain, cacheKey);
+                if(cachedContent){
+                    return res.send(cachedContent);
+                }
+            }
+            let searchResults = await this.search.executeSearch(config);
+            if(false === searchResults){
+                return res.redirect('/?error-message=searchExecutionFailed');
+            }
+            let content = await this.renderWithTemplateContent(
+                {
+                    template: config.render.page,
+                    layout: config.render.layout,
+                    content: await this.searchRenderer.renderSearchResults(searchResults, config, domain, req)
+                },
+                Object.assign({}, {
+                    search_query: sc.get(req.query, 'search', ''),
+                    searchConfig: config,
+                    query: req.query
+                }),
+                domain,
+                req
+            );
+            if(this.cacheManager && this.cacheManager.isEnabled()){
+                await this.cacheManager.set(domain, cacheKey, content);
+            }
+            return res.send(content);
+        } catch (error) {
+            Logger.error('Search request handling error: ' + error.message);
+            return res.redirect('/?error-message=searchError');
+        }
+    }
+
     async handleRequest(req, res)
     {
         try {
             let path = req.path;
             let domain = this.getDomainFromRequest(req);
-            this.templateEngine.setCurrentDomain(domain);
             if(this.cacheManager && this.cacheManager.isEnabled()){
                 let cachedContent = await this.cacheManager.get(domain, path);
                 if(cachedContent){
@@ -263,17 +370,17 @@ class Frontend
             }
             let route = await this.findRouteByPath(path, domain);
             if(route){
-                return await this.renderRouteWithCache(route, domain, res, path);
+                return await this.renderRouteWithCache(route, domain, res, path, req);
             }
             let entityResult = await this.findEntityByPath(path);
             if(entityResult){
-                return await this.renderEntityWithCache(entityResult, domain, res, path);
+                return await this.renderEntityWithCache(entityResult, domain, res, path, req);
             }
             let templatePath = this.findTemplateByPath(path, domain);
             if(templatePath){
-                return await this.renderTemplateWithCache(templatePath, domain, res, path);
+                return await this.renderTemplateWithCache(templatePath, domain, res, path, req);
             }
-            return await this.renderNotFound(domain, res);
+            return await this.renderNotFound(domain, res, req);
         } catch (error) {
             Logger.error('Request handling error: '+error.message);
             return res.status(500).send('Internal server error');
@@ -350,57 +457,46 @@ class Frontend
         return this.findTemplatePath(templatePath, domain);
     }
 
-    async renderRouteWithCache(route, domain, res, path)
+    async renderRouteWithCache(route, domain, res, path, req)
     {
-        let renderedContent = await this.generateRouteContent(route, domain);
+        let renderedContent = await this.generateRouteContent(route, domain, req);
         if(!renderedContent){
-            return await this.renderNotFound(domain, res);
+            return await this.renderNotFound(domain, res, req);
         }
         if(this.cacheManager && this.cacheManager.isEnabled()){
-            await this.cacheManager.set(domain, path, renderedContent);
+            let cacheKey = this.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
         }
         return res.send(renderedContent);
     }
 
-    async renderEntityWithCache(entityResult, domain, res, path)
+    async renderEntityWithCache(entityResult, domain, res, path, req)
     {
-        let renderedContent = await this.generateEntityContent(entityResult, domain);
+        let renderedContent = await this.generateEntityContent(entityResult, domain, req);
         if(!renderedContent){
-            return await this.renderNotFound(domain, res);
+            return await this.renderNotFound(domain, res, req);
         }
         if(this.cacheManager && this.cacheManager.isEnabled()){
-            await this.cacheManager.set(domain, path, renderedContent);
+            let cacheKey = this.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
         }
         return res.send(renderedContent);
     }
 
-    async renderTemplateWithCache(templatePath, domain, res, path)
+    async renderTemplateWithCache(templatePath, domain, res, path, req)
     {
-        let renderedContent = await this.generateTemplateContent(templatePath, domain);
+        let renderedContent = await this.generateTemplateContent(templatePath, domain, req);
         if(!renderedContent){
             return res.status(500).send('Template error: '+templatePath);
         }
         if(this.cacheManager && this.cacheManager.isEnabled()){
-            await this.cacheManager.set(domain, path, renderedContent);
+            let cacheKey = this.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
         }
-        let layoutContent = await this.processContentWithLayout({content: renderedContent}, {}, 'default', domain);
-        let pagePath = this.findTemplatePath('page', domain);
-        if(!pagePath){
-            return res.send(layoutContent);
-        }
-        let pageTemplate = FileHandler.readFile(pagePath);
-        if(!pageTemplate){
-            return res.send(layoutContent);
-        }
-        let finalContent = await this.templateEngine.render(
-            pageTemplate,
-            Object.assign({}, {}, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
-            this.getPartialsForDomain(domain)
-        );
-        return res.send(finalContent);
+        return await this.renderWithLayout({content: renderedContent}, {}, 'default', domain, res, req);
     }
 
-    async generateRouteContent(route, domain)
+    async generateRouteContent(route, domain, req)
     {
         if(!route.router){
             return false;
@@ -413,78 +509,56 @@ class Frontend
         if(!content){
             return false;
         }
-        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain);
+        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain, req);
     }
 
-    async generateEntityContent(entityResult, domain)
+    async generateEntityContent(entityResult, domain, req)
     {
-        return await this.renderWithTemplateContent(entityResult.entity, entityResult.entity, domain);
+        return await this.renderWithTemplateContent(entityResult.entity, entityResult.entity, domain, req);
     }
 
-    async generateTemplateContent(templatePath, domain)
+    async generateTemplateContent(templatePath, domain, req)
     {
         let template = FileHandler.readFile(templatePath);
         if(!template){
             Logger.error('Failed to read template: ' + templatePath);
             return false;
         }
-        return await this.templateEngine.render(template, {}, this.getPartialsForDomain(domain));
+        return await this.templateEngine.render(template, {}, this.getPartialsForDomain(domain), domain, req);
     }
 
-    async renderRoute(route, domain, res)
+    async renderRoute(route, domain, res, req)
     {
         if(!route.router){
-            return await this.renderNotFound(domain, res);
+            return await this.renderNotFound(domain, res, req);
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
-            return await this.renderNotFound(domain, res);
+            return await this.renderNotFound(domain, res, req);
         }
         let content = await entity.loadOne({route_id: route.id});
         if(!content){
-            return await this.renderNotFound(domain, res);
+            return await this.renderNotFound(domain, res, req);
         }
-        return await this.renderWithTemplate(content, Object.assign({}, route, content), domain, res);
+        return await this.renderWithTemplate(content, Object.assign({}, route, content), domain, res, req);
     }
 
-    async renderEntity(entityResult, domain, res)
+    async renderWithTemplate(content, data, domain, res, req)
     {
-        return await this.renderWithTemplate(entityResult.entity, entityResult.entity, domain, res);
+        return res.send(await this.renderWithTemplateContent(content, data, domain, req));
     }
 
-    async renderWithTemplate(content, data, domain, res)
+    async renderWithTemplateContent(content, data, domain, req)
     {
-        let templateName = sc.get(content, 'template', '');
-        let layoutName = sc.get(content, 'layout', 'default');
-        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain);
+        let templateName = sc.get(content, 'template', 'page');
         if(!templateName){
             templateName = 'page';
         }
-        let templatePath = this.findTemplatePath(templateName, domain);
-        if(!templatePath){
-            return res.send(layoutContent);
-        }
-        let pageTemplate = FileHandler.readFile(templatePath);
-        if(!pageTemplate){
-            return res.send(layoutContent);
-        }
-        return res.send(
-            await this.templateEngine.render(
-                pageTemplate,
-                Object.assign({}, data, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
-                this.getPartialsForDomain(domain)
-            )
-        );
-    }
-
-    async renderWithTemplateContent(content, data, domain)
-    {
-        let templateName = sc.get(content, 'template', '');
-        let layoutName = sc.get(content, 'layout', 'default');
-        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain);
-        if(!templateName){
-            templateName = 'page';
+        let layoutName = sc.get(content, 'layout', '');
+        if(!layoutName){
+            layoutName = 'default';
         }
+        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain, req);
         let templatePath = this.findTemplatePath(templateName, domain);
         if(!templatePath){
             return layoutContent;
@@ -495,53 +569,31 @@ class Frontend
         }
         return await this.templateEngine.render(
             pageTemplate,
-            Object.assign({}, data, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
-            this.getPartialsForDomain(domain)
+            Object.assign({}, this.fetchMetaFields(data), {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
+            this.getPartialsForDomain(domain),
+            domain,
+            req
         );
     }
 
-    async renderTemplate(templatePath, domain, res)
-    {
-        let content = await this.renderContentWithTemplate(templatePath, {}, domain);
-        if(!content){
-            return res.status(500).send('Template error: '+templatePath);
-        }
-        return await this.renderWithLayout({content}, {}, 'default', domain, res);
-    }
-
-    async renderContentWithTemplate(templatePath, data, domain)
+    async renderContentWithTemplate(templatePath, data, domain, req)
     {
         let template = FileHandler.readFile(templatePath);
         if(!template){
             Logger.error('Failed to read template: ' + templatePath);
             return false;
         }
-        return await this.templateEngine.render(template, data, this.getPartialsForDomain(domain));
+        return await this.templateEngine.render(template, data, this.getPartialsForDomain(domain), domain, req);
     }
 
-    async renderWithLayout(content, data, layoutName, domain, res)
+    async renderWithLayout(content, data, layoutName, domain, res, req)
     {
-        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain);
-        let pagePath = this.findTemplatePath('page', domain);
-        if(!pagePath){
-            return res.send(layoutContent);
-        }
-        let pageTemplate = FileHandler.readFile(pagePath);
-        if(!pageTemplate){
-            return res.send(layoutContent);
-        }
-        return res.send(
-            await this.templateEngine.render(
-                pageTemplate,
-                Object.assign({}, data, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
-                this.getPartialsForDomain(domain)
-            )
-        );
+        return res.send(await this.renderWithTemplateContent(content, data, domain, req));
     }
 
-    async processContentWithLayout(content, data, layoutName, domain)
+    async processContentWithLayout(content, data, layoutName, domain, req)
     {
-        let processedContent = await this.processContent(content, data, domain);
+        let processedContent = await this.processContent(content, data, domain, req);
         let layoutPath = this.findLayoutPath(layoutName, domain);
         if(!layoutPath){
             return processedContent;
@@ -553,32 +605,57 @@ class Frontend
         return await this.templateEngine.render(
             layoutTemplate,
             Object.assign({}, data, {content: processedContent}),
-            this.getPartialsForDomain(domain)
+            this.getPartialsForDomain(domain),
+            domain,
+            req
         );
     }
 
-    async processContent(content, data, domain)
+    async processContent(content, data, domain, req)
     {
         let contentText = sc.get(content, 'content', '');
         if(!contentText){
             return '';
         }
-        return await this.templateEngine.render(contentText, data, this.getPartialsForDomain(domain));
+        return await this.templateEngine.render(contentText, data, this.getPartialsForDomain(domain), domain, req);
     }
 
-    async renderNotFound(domain, res)
+    async renderNotFound(domain, res, req)
     {
         let notFoundPath = this.findTemplatePath('404', domain);
         if(notFoundPath){
-            let content = await this.renderContentWithTemplate(notFoundPath, {}, domain);
+            let content = await this.renderContentWithTemplate(notFoundPath, {}, domain, req);
             if(content){
                 res.status(404);
-                return await this.renderWithLayout({content}, {}, 'default', domain, res);
+                return await this.renderWithLayout({content}, {}, 'default', domain, res, req);
             }
         }
         return res.status(404).send('Page not found');
     }
 
+    buildCacheKey(path, req)
+    {
+        if(!req || !req.query){
+            return path;
+        }
+        for(let key of Object.keys(req.query)){
+            if(key.endsWith('-key')){
+                let queryString = '';
+                for(let qKey of Object.keys(req.query)){
+                    queryString += (queryString ? '&' : '') + qKey + '=' + req.query[qKey];
+                }
+                let hash = 0;
+                for(let i = 0; i < queryString.length; i++){
+                    let char = queryString.charCodeAt(i);
+                    hash = ((hash << 5) - hash) + char;
+                    hash = hash & hash;
+                }
+                return path + '_' + Math.abs(hash);
+            }
+        }
+        return path;
+    }
+
 }
 
 module.exports.Frontend = Frontend;