@reldens/cms 0.9.0 → 0.10.0

package/lib/frontend.js

@@ -6,7 +6,6 @@
 
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
-const mustache = require('mustache');
 
 class Frontend
 {
@@ -16,20 +15,32 @@ class Frontend
         this.app = sc.get(props, 'app', false);
         this.appServerFactory = sc.get(props, 'appServerFactory', false);
         this.dataServer = sc.get(props, 'dataServer', false);
+        this.renderEngine = sc.get(props, 'renderEngine', false);
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
         this.publicPath = FileHandler.joinPaths(this.projectRoot, 'public');
-        this.partialsExtensions = sc.get(props, 'partialsExtensions', ['.html', '.mustache', '.template']);
+        this.templateExtensions = sc.get(props, 'templateExtensions', ['.html', '.mustache', '.template']);
+        this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
+        this.domainMapping = sc.get(props, 'domainMapping', {});
+        this.siteKeyMapping = sc.get(props, 'siteKeyMapping', {});
         this.partialsCache = {};
         this.domainPartialsCache = new Map();
         this.domainTemplatesMap = new Map();
-        this.error = false;
+        this.entityAccessCache = new Map();
     }
 
     async initialize()
     {
         if(!this.app || !this.dataServer){
-            this.error = 'Missing app or dataServer';
+            Logger.error('Missing app or dataServer');
+            return false;
+        }
+        if(!this.renderEngine){
+            Logger.error('Please, provide a renderEngine, it must contain a "render" method.');
+            return false;
+        }
+        if(!sc.isFunction(this.renderEngine.render)){
+            Logger.error('The provided renderEngine does not contain a "render" method.');
             return false;
         }
         if(!FileHandler.exists(this.templatesPath)){
@@ -42,6 +53,7 @@ class Frontend
         }
         await this.loadPartials();
         await this.setupDomainTemplates();
+        await this.loadEntityAccessRules();
         this.setupStaticAssets();
         this.app.get('*', async (req, res) => {
             return await this.handleRequest(req, res);
@@ -49,22 +61,36 @@ class Frontend
         return true;
     }
 
+    async loadEntityAccessRules()
+    {
+        let accessEntity = this.dataServer.getEntity('cmsEntityAccess');
+        if(!accessEntity){
+            Logger.warning('CMS Entity Access not found.');
+            return;
+        }
+        let accessRules = await accessEntity.loadAll();
+        for(let rule of accessRules){
+            this.entityAccessCache.set(rule.entity_name, rule.is_public);
+        }
+    }
+
     async loadPartials()
     {
         let partialsPath = FileHandler.joinPaths(this.templatesPath, 'partials');
         FileHandler.createFolder(partialsPath);
-        let partialFiles = FileHandler.getFilesInFolder(partialsPath, this.partialsExtensions);
+        let partialFiles = FileHandler.getFilesInFolder(partialsPath, this.templateExtensions);
         for(let file of partialFiles){
-            let partialName = '';
-            for(let extension of this.partialsExtensions){
-                if(file.endsWith(extension)){
-                    partialName = file.replace(extension, '');
-                    break;
-                }
+            let partialName = this.extractTemplateName(file);
+            if(!partialName){
+                continue;
             }
             let partialPath = FileHandler.joinPaths(partialsPath, file);
             let partialContent = FileHandler.readFile(partialPath);
-            this.partialsCache[partialName] = partialContent.toString();
+            if(!partialContent){
+                Logger.error('Failed to read partial: '+partialPath);
+                continue;
+            }
+            this.partialsCache[partialName] = partialContent;
         }
     }
 
@@ -75,18 +101,19 @@ class Frontend
             return;
         }
         let domainPartials = {};
-        let partialFiles = FileHandler.getFilesInFolder(domainPartialsPath, this.partialsExtensions);
+        let partialFiles = FileHandler.getFilesInFolder(domainPartialsPath, this.templateExtensions);
         for(let file of partialFiles){
-            let partialName = '';
-            for(let extension of this.partialsExtensions){
-                if(file.endsWith(extension)){
-                    partialName = file.replace(extension, '');
-                    break;
-                }
+            let partialName = this.extractTemplateName(file);
+            if(!partialName){
+                continue;
             }
             let partialPath = FileHandler.joinPaths(domainPartialsPath, file);
             let partialContent = FileHandler.readFile(partialPath);
-            domainPartials[partialName] = partialContent.toString();
+            if(!partialContent){
+                Logger.error('Failed to read domain partial: '+partialPath);
+                continue;
+            }
+            domainPartials[partialName] = partialContent;
         }
         this.domainPartialsCache.set(domain, domainPartials);
     }
@@ -105,6 +132,16 @@ class Frontend
         }
     }
 
+    extractTemplateName(filename)
+    {
+        for(let extension of this.templateExtensions){
+            if(filename.endsWith(extension)){
+                return filename.replace(extension, '');
+            }
+        }
+        return false;
+    }
+
     getDomainFromRequest(req)
     {
         let host = req.get('host');
@@ -114,34 +151,80 @@ class Frontend
         return host.split(':')[0];
     }
 
+    resolveDomainToFolder(domain)
+    {
+        if(!domain){
+            domain = this.defaultDomain;
+        }
+        return sc.get(this.domainMapping, domain, domain);
+    }
+
+    resolveDomainToSiteKey(domain)
+    {
+        return sc.get(this.siteKeyMapping, this.resolveDomainToFolder(domain), 'default');
+    }
+
     getPartialsForDomain(domain)
     {
-        let domainPartials = this.domainPartialsCache.get(domain);
+        let resolvedDomain = this.resolveDomainToFolder(domain);
+        let domainPartials = this.domainPartialsCache.get(resolvedDomain);
+        if(!domainPartials && this.defaultDomain && resolvedDomain !== this.defaultDomain){
+            domainPartials = this.domainPartialsCache.get(this.defaultDomain);
+        }
         if(!domainPartials){
             return this.partialsCache;
         }
         return Object.assign({}, this.partialsCache, domainPartials);
     }
 
-    findTemplatePathForDomain(templateName, domain)
+    findTemplatePath(templateName, domain)
     {
-        if(!domain){
-            return this.getDefaultTemplatePath(templateName);
-        }
-        let domainPath = this.domainTemplatesMap.get(domain);
-        if(!domainPath){
-            return this.getDefaultTemplatePath(templateName);
+        let resolvedDomain = this.resolveDomainToFolder(domain);
+        if(resolvedDomain){
+            let domainPath = this.domainTemplatesMap.get(resolvedDomain);
+            if(domainPath){
+                let domainTemplatePath = this.findTemplateInPath(templateName, domainPath);
+                if(domainTemplatePath){
+                    return domainTemplatePath;
+                }
+            }
+            if(this.defaultDomain && resolvedDomain !== this.defaultDomain){
+                let defaultDomainPath = this.domainTemplatesMap.get(this.defaultDomain);
+                if(defaultDomainPath){
+                    let defaultTemplatePath = this.findTemplateInPath(templateName, defaultDomainPath);
+                    if(defaultTemplatePath){
+                        return defaultTemplatePath;
+                    }
+                }
+            }
         }
-        let domainTemplatePath = FileHandler.joinPaths(domainPath, templateName + '.html');
-        if(!FileHandler.exists(domainTemplatePath)){
-            return this.getDefaultTemplatePath(templateName);
+        return this.findTemplateInPath(templateName, this.templatesPath);
+    }
+
+    findTemplateInPath(templateName, basePath)
+    {
+        for(let extension of this.templateExtensions){
+            let templatePath = FileHandler.joinPaths(basePath, templateName + extension);
+            if(FileHandler.exists(templatePath)){
+                return templatePath;
+            }
         }
-        return domainTemplatePath;
+        return false;
     }
 
-    getDefaultTemplatePath(templateName)
+    findLayoutPath(layoutName, domain)
     {
-        return FileHandler.joinPaths(this.templatesPath, templateName + '.html');
+        let resolvedDomain = this.resolveDomainToFolder(domain);
+        if(resolvedDomain){
+            let domainPath = this.domainTemplatesMap.get(resolvedDomain);
+            if(domainPath){
+                let domainLayoutPath = this.findTemplateInPath('layouts/' + layoutName, domainPath);
+                if(domainLayoutPath){
+                    return domainLayoutPath;
+                }
+            }
+        }
+        return this.findTemplateInPath('layouts/' + layoutName, this.templatesPath);
     }
 
     setupStaticAssets()
@@ -158,37 +241,22 @@ class Frontend
 
     async handleRequest(req, res)
     {
-        let path = req.path;
-        if('/favicon.ico' === path){
-            return res.status(404).send('');
-        }
         try {
+            let path = req.path;
             let domain = this.getDomainFromRequest(req);
             let route = await this.findRouteByPath(path);
             if(route){
-                Logger.debug('Found route for path: '+path, route);
-                return await this.renderContentFromRoute(res, route, domain);
+                return await this.renderRoute(route, domain, res);
             }
-            let pathSegments = path.split('/').filter(segment => segment !== '');
-            if(0 < pathSegments.length){
-                let entityResult = await this.findEntityByPath(pathSegments);
-                if(entityResult){
-                    Logger.debug('Found entity for path segments: '+pathSegments.join('/'));
-                    return await this.renderContentFromEntity(
-                        res,
-                        entityResult.entity,
-                        entityResult.entityName,
-                        domain
-                    );
-                }
+            let entityResult = await this.findEntityByPath(path);
+            if(entityResult){
+                return await this.renderEntity(entityResult, domain, res);
             }
             let templatePath = this.findTemplateByPath(path, domain);
             if(templatePath){
-                Logger.debug('Found template for path: '+path+' at: '+templatePath);
-                return await this.renderTemplateOnly(res, templatePath, domain);
+                return await this.renderTemplate(templatePath, domain, res);
             }
-            Logger.debug('No template found for path: '+path+', rendering 404');
-            return await this.renderNotFoundPage(res, domain);
+            return await this.renderNotFound(domain, res);
         } catch (error) {
             Logger.error('Request handling error: '+error.message);
             return res.status(500).send('Internal server error');
@@ -212,32 +280,34 @@ class Frontend
         return false;
     }
 
-    async findEntityByPath(pathSegments)
+    async isEntityAccessible(entityName)
+    {
+        if(this.entityAccessCache.has(entityName)){
+            return this.entityAccessCache.get(entityName);
+        }
+        return false;
+    }
+
+    async findEntityByPath(path)
     {
-        if(1 > pathSegments.length){
-            Logger.debug('No path segments provided');
+        let pathSegments = path.split('/').filter(segment => '' !== segment);
+        if(2 > pathSegments.length){
             return false;
         }
         let entityName = pathSegments[0];
-        let entityId = 2 > pathSegments.length ? false : pathSegments[1];
-        if(!entityId){
-            Logger.debug('No entity ID in path segments');
+        if(!await this.isEntityAccessible(entityName)){
             return false;
         }
+        let entityId = pathSegments[1];
         let entity = this.dataServer.getEntity(entityName);
         if(!entity){
-            Logger.debug('Entity not found: '+entityName);
             return false;
         }
         let loadedEntity = await entity.loadById(entityId);
         if(!loadedEntity){
-            Logger.debug('Entity not loaded by ID: '+entityId);
             return false;
         }
-        return {
-            entity: loadedEntity,
-            entityName
-        };
+        return {entity: loadedEntity, entityName};
     }
 
     findTemplateByPath(path, domain)
@@ -245,101 +315,155 @@ class Frontend
         if('/' === path){
             path = '/index';
         }
-        let templatePath = path.endsWith('/')
-            ? path.slice(0, -1)
-            : path;
-        templatePath = templatePath.startsWith('/')
-            ? templatePath.substring(1)
-            : templatePath;
-        let fullPath = this.findTemplatePathForDomain(templatePath, domain);
-        if(FileHandler.exists(fullPath)){
-            return fullPath;
+        let templatePath = path.endsWith('/') ? path.slice(0, -1) : path;
+        templatePath = templatePath.startsWith('/') ? templatePath.substring(1) : templatePath;
+        if('page' === templatePath){
+            return false;
         }
-        return false;
+        return this.findTemplatePath(templatePath, domain);
+    }
+
+    async renderEnhanced(template, data, partials)
+    {
+        return this.renderEngine.render(
+            await this.processCustomTemplateFunctions(template),
+            data,
+            partials
+        );
     }
 
-    async renderContentFromRoute(res, route, domain)
+    async processCustomTemplateFunctions(template)
+    {
+        let entityRegex = /\{\{\s*entity\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]\s*\)\s*\}\}/g;
+        let processedTemplate = template;
+        for(let match of template.matchAll(entityRegex)){
+            let tableName = match[1];
+            let identifier = match[2];
+            let entityData = await this.fetchEntityForTemplate(tableName, identifier);
+            processedTemplate = processedTemplate.replace(match[0], sc.get(entityData, 'content', ''));
+        }
+        return processedTemplate;
+    }
+
+    async fetchEntityForTemplate(tableName, identifier)
+    {
+        let entity = this.dataServer.getEntity(tableName);
+        if(!entity){
+            Logger.warning('Entity not found in dataServer: '+tableName);
+            return {};
+        }
+        let result = await entity.loadOneBy('name', identifier);
+        if(!result){
+            result = await entity.loadById(identifier);
+        }
+        return result || {};
+    }
+
+    async renderRoute(route, domain, res)
     {
         if(!route.router || !route.content_id){
-            Logger.debug('Route missing router or content_id');
-            return await this.renderNotFoundPage(res, domain);
+            return await this.renderNotFound(domain, res);
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
-            Logger.debug('Entity not found: '+route.router);
-            return await this.renderNotFoundPage(res, domain);
+            return await this.renderNotFound(domain, res);
         }
         let content = await entity.loadById(route.content_id);
         if(!content){
-            Logger.debug('Content not found for ID: '+route.content_id+' in entity: '+route.router);
-            return await this.renderNotFoundPage(res, domain);
-        }
-        let templateName = content.template || route.router;
-        let templatePath = this.findTemplatePathForDomain(templateName, domain);
-        if(!FileHandler.exists(templatePath)){
-            templatePath = this.findTemplatePathForDomain('page', domain);
-            if(!FileHandler.exists(templatePath)){
-                Logger.debug('Neither template found: '+templateName+'.html nor page.html');
-                return await this.renderNotFoundPage(res, domain);
-            }
+            return await this.renderNotFound(domain, res);
+        }
+        return await this.renderWithLayout(
+            content,
+            Object.assign({}, route, content, {currentYear: new Date().getFullYear()}),
+            sc.get(content, 'layout', 'default'),
+            domain,
+            res
+        );
+    }
+
+    async renderEntity(entityResult, domain, res)
+    {
+        return await this.renderWithLayout(
+            entityResult.entity,
+            Object.assign({}, entityResult.entity, {currentYear: new Date().getFullYear()}),
+            sc.get(entityResult.entity, 'layout', 'default'),
+            domain,
+            res
+        );
+    }
+
+    async renderTemplate(templatePath, domain, res)
+    {
+        let data = { currentYear: new Date().getFullYear() };
+        let content = await this.renderContentWithTemplate(templatePath, data, domain);
+        if(!content){
+            return res.status(500).send('Template error: '+templatePath);
         }
-        let template = FileHandler.readFile(templatePath).toString();
-        let data = {
-            ...route,
-            ...content,
-            current_year: new Date().getFullYear()
-        };
-        let partials = this.getPartialsForDomain(domain);
-        let rendered = mustache.render(template, data, partials);
-        return res.send(rendered);
+        return await this.renderWithLayout({content}, data, 'default', domain, res);
     }
 
-    async renderContentFromEntity(res, entity, entityName, domain)
+    async renderContentWithTemplate(templatePath, data, domain)
     {
-        let templatePath = this.findTemplatePathForDomain(entityName, domain);
-        if(!FileHandler.exists(templatePath)){
-            templatePath = this.findTemplatePathForDomain('page', domain);
-            if(!FileHandler.exists(templatePath)){
-                return await this.renderNotFoundPage(res, domain);
-            }
+        let template = FileHandler.readFile(templatePath);
+        if(!template){
+            Logger.error('Failed to read template: ' + templatePath);
+            return false;
         }
-        let template = FileHandler.readFile(templatePath).toString();
-        let data = {
-            ...entity,
-            title: entity.title || entity.name || entityName,
-            current_year: new Date().getFullYear()
-        };
-        let partials = this.getPartialsForDomain(domain);
-        let rendered = mustache.render(template, data, partials);
-        return res.send(rendered);
+        return await this.renderEnhanced(template, data, this.getPartialsForDomain(domain));
     }
 
-    async renderTemplateOnly(res, templatePath, domain)
+    async renderWithLayout(content, data, layoutName, domain, res)
     {
-        let template = FileHandler.readFile(templatePath).toString();
-        let data = {
-            title: 'Page Title',
-            current_year: new Date().getFullYear()
-        };
-        let partials = this.getPartialsForDomain(domain);
-        let rendered = mustache.render(template, data, partials);
-        return res.send(rendered);
+        let layoutPath = this.findLayoutPath(layoutName, domain);
+        let layoutContent = '';
+        if(layoutPath){
+            let layoutTemplate = FileHandler.readFile(layoutPath);
+            if(layoutTemplate){
+                layoutContent = await this.renderEnhanced(
+                    layoutTemplate,
+                    Object.assign({}, data, {
+                        content: sc.get(content, 'content', '')
+                    }),
+                    this.getPartialsForDomain(domain)
+                );
+            }
+        }
+        if('' === layoutContent){
+            layoutContent = sc.get(content, 'content', '');
+        }
+        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.renderEnhanced(
+                pageTemplate,
+                Object.assign({}, data, {
+                    content: layoutContent,
+                    siteHandle: this.resolveDomainToSiteKey(domain)
+                }),
+                this.getPartialsForDomain(domain)
+            )
+        );
     }
 
-    async renderNotFoundPage(res, domain)
+    async renderNotFound(domain, res)
     {
-        let templatePath = this.findTemplatePathForDomain('404', domain);
-        if(!FileHandler.exists(templatePath)){
+        let templatePath = this.findTemplatePath('404', domain);
+        if(!templatePath){
+            return res.status(404).send('Page not found');
+        }
+        let data = {title: '404 - Page Not Found', currentYear: new Date().getFullYear()};
+        let content = await this.renderContentWithTemplate(templatePath, data, domain);
+        if(!content){
             return res.status(404).send('Page not found');
         }
-        let template = FileHandler.readFile(templatePath).toString();
-        let data = {
-            title: '404 - Page Not Found',
-            current_year: new Date().getFullYear()
-        };
-        let partials = this.getPartialsForDomain(domain);
-        let rendered = mustache.render(template, data, partials);
-        return res.status(404).send(rendered);
+        res.status(404);
+        return await this.renderWithLayout({content}, data, 'default', domain, res);
     }
 
 }