@reldens/cms 0.8.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,16 +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.error = false;
+        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.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)){
@@ -36,6 +51,9 @@ class Frontend
             Logger.error('Public folder not found: '+this.publicPath);
             return false;
         }
+        await this.loadPartials();
+        await this.setupDomainTemplates();
+        await this.loadEntityAccessRules();
         this.setupStaticAssets();
         this.app.get('*', async (req, res) => {
             return await this.handleRequest(req, res);
@@ -43,6 +61,172 @@ 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.templateExtensions);
+        for(let file of partialFiles){
+            let partialName = this.extractTemplateName(file);
+            if(!partialName){
+                continue;
+            }
+            let partialPath = FileHandler.joinPaths(partialsPath, file);
+            let partialContent = FileHandler.readFile(partialPath);
+            if(!partialContent){
+                Logger.error('Failed to read partial: '+partialPath);
+                continue;
+            }
+            this.partialsCache[partialName] = partialContent;
+        }
+    }
+
+    async loadDomainPartials(domain, domainPath)
+    {
+        let domainPartialsPath = FileHandler.joinPaths(domainPath, 'partials');
+        if(!FileHandler.exists(domainPartialsPath)){
+            return;
+        }
+        let domainPartials = {};
+        let partialFiles = FileHandler.getFilesInFolder(domainPartialsPath, this.templateExtensions);
+        for(let file of partialFiles){
+            let partialName = this.extractTemplateName(file);
+            if(!partialName){
+                continue;
+            }
+            let partialPath = FileHandler.joinPaths(domainPartialsPath, file);
+            let partialContent = FileHandler.readFile(partialPath);
+            if(!partialContent){
+                Logger.error('Failed to read domain partial: '+partialPath);
+                continue;
+            }
+            domainPartials[partialName] = partialContent;
+        }
+        this.domainPartialsCache.set(domain, domainPartials);
+    }
+
+    async setupDomainTemplates()
+    {
+        let domainsPath = FileHandler.joinPaths(this.templatesPath, 'domains');
+        if(!FileHandler.exists(domainsPath)){
+            return;
+        }
+        let domainFolders = FileHandler.fetchSubFoldersList(domainsPath);
+        for(let domain of domainFolders){
+            let domainPath = FileHandler.joinPaths(domainsPath, domain);
+            this.domainTemplatesMap.set(domain, domainPath);
+            await this.loadDomainPartials(domain, domainPath);
+        }
+    }
+
+    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');
+        if(!host){
+            return false;
+        }
+        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 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);
+    }
+
+    findTemplatePath(templateName, domain)
+    {
+        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;
+                    }
+                }
+            }
+        }
+        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 false;
+    }
+
+    findLayoutPath(layoutName, domain)
+    {
+        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()
     {
         if(!this.app || !this.appServerFactory || !this.publicPath){
@@ -57,35 +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);
+                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
-                    );
-                }
+            let entityResult = await this.findEntityByPath(path);
+            if(entityResult){
+                return await this.renderEntity(entityResult, domain, res);
             }
-            let templatePath = this.findTemplateByPath(path);
+            let templatePath = this.findTemplateByPath(path, domain);
             if(templatePath){
-                Logger.debug('Found template for path: '+path+' at: '+templatePath);
-                return await this.renderTemplateOnly(res, templatePath);
+                return await this.renderTemplate(templatePath, domain, res);
             }
-            Logger.debug('No template found for path: '+path+', rendering 404');
-            return await this.renderNotFoundPage(res);
+            return await this.renderNotFound(domain, res);
         } catch (error) {
             Logger.error('Request handling error: '+error.message);
             return res.status(500).send('Internal server error');
@@ -109,130 +280,190 @@ 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)
+    findTemplateByPath(path, domain)
     {
         if('/' === path){
             path = '/index';
         }
-        let templatePath = path.endsWith('/')
-            ? path.slice(0, -1)
-            : path;
-        templatePath = templatePath.startsWith('/')
-            ? templatePath.substring(1)
-            : templatePath;
-        let fullPath = FileHandler.joinPaths(this.templatesPath, templatePath + '.html');
-        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 renderContentFromRoute(res, route)
+    async renderEnhanced(template, data, partials)
+    {
+        return this.renderEngine.render(
+            await this.processCustomTemplateFunctions(template),
+            data,
+            partials
+        );
+    }
+
+    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);
+            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);
+            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);
-        }
-        let templateName = content.template || route.router;
-        let templatePath = FileHandler.joinPaths(this.templatesPath, templateName + '.html');
-        if(!FileHandler.exists(templatePath)){
-            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
-            if(!FileHandler.exists(templatePath)){
-                Logger.debug('Neither template found: '+templateName+'.html nor page.html');
-                return await this.renderNotFoundPage(res);
-            }
+            return await this.renderNotFound(domain, res);
         }
-        let template = FileHandler.readFile(templatePath).toString();
-        let data = {
-            ...route,
-            ...content,
-            current_year: new Date().getFullYear()
-        };
-        let rendered = mustache.render(template, data);
-        return res.send(rendered);
+        return await this.renderWithLayout(
+            content,
+            Object.assign({}, route, content, {currentYear: new Date().getFullYear()}),
+            sc.get(content, 'layout', 'default'),
+            domain,
+            res
+        );
     }
 
-    async renderContentFromEntity(res, entity, entityName)
+    async renderEntity(entityResult, domain, res)
     {
-        let templatePath = FileHandler.joinPaths(this.templatesPath, entityName + '.html');
-        if(!FileHandler.exists(templatePath)){
-            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
-            if(!FileHandler.exists(templatePath)){
-                return await this.renderNotFoundPage(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 = {
-            ...entity,
-            title: entity.title || entity.name || entityName,
-            current_year: new Date().getFullYear()
-        };
-        let rendered = mustache.render(template, data);
-        return res.send(rendered);
+        return await this.renderWithLayout({content}, data, 'default', domain, res);
     }
 
-    async renderTemplateOnly(res, templatePath)
+    async renderContentWithTemplate(templatePath, data, domain)
     {
-        let template = FileHandler.readFile(templatePath).toString();
-        let data = {
-            title: 'Page Title',
-            current_year: new Date().getFullYear()
-        };
-        let rendered = mustache.render(template, data);
-        return res.send(rendered);
+        let template = FileHandler.readFile(templatePath);
+        if(!template){
+            Logger.error('Failed to read template: ' + templatePath);
+            return false;
+        }
+        return await this.renderEnhanced(template, data, this.getPartialsForDomain(domain));
     }
 
-    async renderNotFoundPage(res)
+    async renderWithLayout(content, data, layoutName, domain, res)
     {
-        let templatePath = FileHandler.joinPaths(this.templatesPath, '404.html');
-        if(!FileHandler.exists(templatePath)){
+        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 renderNotFound(domain, res)
+    {
+        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 rendered = mustache.render(template, data);
-        return res.status(404).send(rendered);
+        res.status(404);
+        return await this.renderWithLayout({content}, data, 'default', domain, res);
     }
 
 }