@reldens/cms 0.18.0 → 0.20.0

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
 {
@@ -17,6 +19,7 @@ class Frontend
         this.appServerFactory = sc.get(props, 'appServerFactory', false);
         this.dataServer = sc.get(props, 'dataServer', false);
         this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.events = sc.get(props, 'events', false);
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
         this.publicPath = FileHandler.joinPaths(this.projectRoot, 'public');
@@ -31,6 +34,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()
@@ -59,12 +80,20 @@ class Frontend
             renderEngine: this.renderEngine,
             dataServer: this.dataServer,
             getPartials: this.getPartialsForDomain.bind(this),
-            entitiesConfig: this.entitiesConfig
+            entitiesConfig: this.entitiesConfig,
+            events: this.events,
+            defaultDomain: this.defaultDomain,
+            projectRoot: this.projectRoot,
+            publicPath: this.publicPath
         });
+        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,31 +278,160 @@ 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,
+                null
+            );
+            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');
+        }
+    }
+
+    normalizePathForRouteSearch(path)
+    {
+        if(!path || '/' === path){
+            return '/';
+        }
+        return path.endsWith('/') ? path.slice(0, -1) : path;
+    }
+
+    async handleRouteRedirect(route, res)
+    {
+        let redirectUrl = sc.get(route, 'redirect_url', null);
+        if(!redirectUrl){
+            return false;
+        }
+        let redirectType = sc.get(route, 'redirect_type', '301');
+        let statusCode = '301' === redirectType ? 301 : 302;
+        return res.redirect(statusCode, redirectUrl);
+    }
+
     async handleRequest(req, res)
     {
         try {
-            let path = req.path;
+            let originalPath = 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);
+                let cachedContent = await this.cacheManager.get(domain, originalPath);
                 if(cachedContent){
                     return res.send(cachedContent);
                 }
             }
-            let route = await this.findRouteByPath(path, domain);
+            let route = await this.findRouteByPath(originalPath, domain);
             if(route){
-                return await this.renderRouteWithCache(route, domain, res, path);
+                let redirectResult = await this.handleRouteRedirect(route, res);
+                if(redirectResult){
+                    return redirectResult;
+                }
+                let normalizedPath = this.normalizePathForRouteSearch(originalPath);
+                let routeFoundWithSlash = originalPath !== normalizedPath && route.path === normalizedPath + '/';
+                if(!originalPath.endsWith('/') && routeFoundWithSlash){
+                    return res.redirect(301, originalPath + '/');
+                }
+                return await this.renderRouteWithCache(route, domain, res, originalPath, req);
+            }
+            let normalizedPath = this.normalizePathForRouteSearch(originalPath);
+            if(originalPath !== normalizedPath){
+                let alternativeRoute = await this.findRouteByPath(normalizedPath + '/', domain);
+                if(alternativeRoute){
+                    let redirectResult = await this.handleRouteRedirect(alternativeRoute, res);
+                    if(redirectResult){
+                        return redirectResult;
+                    }
+                    if(!originalPath.endsWith('/')){
+                        return res.redirect(301, originalPath + '/');
+                    }
+                    return await this.renderRouteWithCache(alternativeRoute, domain, res, originalPath, req);
+                }
             }
-            let entityResult = await this.findEntityByPath(path);
+            if(!originalPath.endsWith('/') && '/' !== originalPath){
+                return res.redirect(301, originalPath + '/');
+            }
+            let entityResult = await this.findEntityByPath(originalPath);
             if(entityResult){
-                return await this.renderEntityWithCache(entityResult, domain, res, path);
+                return await this.renderEntityWithCache(entityResult, domain, res, originalPath, req);
             }
-            let templatePath = this.findTemplateByPath(path, domain);
+            let templatePath = this.findTemplateByPath(originalPath, domain);
             if(templatePath){
-                return await this.renderTemplateWithCache(templatePath, domain, res, path);
+                return await this.renderTemplateWithCache(templatePath, domain, res, originalPath, 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');
@@ -287,8 +445,9 @@ class Frontend
             Logger.error('Routes entity not found in dataServer.');
             return false;
         }
+        let normalizedPath = this.normalizePathForRouteSearch(path);
         let domainFilter = domain || null;
-        let routeFilters = {path, enabled: 1};
+        let routeFilters = {path: normalizedPath, enabled: 1};
         let routes = await routesEntity.load(routeFilters);
         let matchingRoute = false;
         let nullDomain = false;
@@ -304,7 +463,25 @@ class Frontend
         if(matchingRoute){
             return matchingRoute;
         }
-        return nullDomain;
+        if(nullDomain){
+            return nullDomain;
+        }
+        if(normalizedPath !== path){
+            let routeFiltersWithSlash = {path: path, enabled: 1};
+            let routesWithSlash = await routesEntity.load(routeFiltersWithSlash);
+            for(let route of routesWithSlash){
+                if(route.domain === domainFilter){
+                    return route;
+                }
+                if(!route.domain){
+                    nullDomain = route;
+                }
+            }
+            if(nullDomain){
+                return nullDomain;
+            }
+        }
+        return false;
     }
 
     async isEntityAccessible(entityName)
@@ -350,57 +527,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 layoutContent = await this.processContentWithLayout({content: renderedContent}, {}, 'default', domain);
-        let pagePath = this.findTemplatePath('page', domain);
-        if(!pagePath){
-            return res.send(layoutContent);
+            let cacheKey = this.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
         }
-        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 +579,73 @@ 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, route);
     }
 
-    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, null);
     }
 
-    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,
+            null,
+            null
+        );
     }
 
-    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, null));
     }
 
-    async renderWithTemplate(content, data, domain, res)
+    async renderWithTemplateContent(content, data, domain, req, route)
     {
-        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)
-            )
+        let layoutName = sc.get(content, 'layout', '');
+        if(!layoutName){
+            layoutName = 'default';
+        }
+        let currentEntityData = Object.assign({}, content, data);
+        let layoutContent = await this.processContentWithLayout(
+            content,
+            data,
+            layoutName,
+            domain,
+            req,
+            route,
+            currentEntityData
         );
-    }
-
-    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 templatePath = this.findTemplatePath(templateName, domain);
         if(!templatePath){
             return layoutContent;
@@ -495,53 +656,48 @@ 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,
+            route,
+            currentEntityData
         );
     }
 
-    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,
+            null,
+            null
+        );
     }
 
-    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, null));
     }
 
-    async processContentWithLayout(content, data, layoutName, domain)
+    async processContentWithLayout(content, data, layoutName, domain, req, route, currentEntityData)
     {
-        let processedContent = await this.processContent(content, data, domain);
+        let processedContent = await this.processContent(content, data, domain, req, route, currentEntityData);
         let layoutPath = this.findLayoutPath(layoutName, domain);
         if(!layoutPath){
             return processedContent;
@@ -553,32 +709,67 @@ class Frontend
         return await this.templateEngine.render(
             layoutTemplate,
             Object.assign({}, data, {content: processedContent}),
-            this.getPartialsForDomain(domain)
+            this.getPartialsForDomain(domain),
+            domain,
+            req,
+            route,
+            currentEntityData
         );
     }
 
-    async processContent(content, data, domain)
+    async processContent(content, data, domain, req, route, currentEntityData)
     {
         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,
+            route,
+            currentEntityData
+        );
     }
 
-    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;