@reldens/cms 0.8.0 → 0.9.0

package/lib/frontend.js

@@ -19,6 +19,10 @@ class Frontend
         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.partialsCache = {};
+        this.domainPartialsCache = new Map();
+        this.domainTemplatesMap = new Map();
         this.error = false;
     }
 
@@ -36,6 +40,8 @@ class Frontend
             Logger.error('Public folder not found: '+this.publicPath);
             return false;
         }
+        await this.loadPartials();
+        await this.setupDomainTemplates();
         this.setupStaticAssets();
         this.app.get('*', async (req, res) => {
             return await this.handleRequest(req, res);
@@ -43,6 +49,101 @@ class Frontend
         return true;
     }
 
+    async loadPartials()
+    {
+        let partialsPath = FileHandler.joinPaths(this.templatesPath, 'partials');
+        FileHandler.createFolder(partialsPath);
+        let partialFiles = FileHandler.getFilesInFolder(partialsPath, this.partialsExtensions);
+        for(let file of partialFiles){
+            let partialName = '';
+            for(let extension of this.partialsExtensions){
+                if(file.endsWith(extension)){
+                    partialName = file.replace(extension, '');
+                    break;
+                }
+            }
+            let partialPath = FileHandler.joinPaths(partialsPath, file);
+            let partialContent = FileHandler.readFile(partialPath);
+            this.partialsCache[partialName] = partialContent.toString();
+        }
+    }
+
+    async loadDomainPartials(domain, domainPath)
+    {
+        let domainPartialsPath = FileHandler.joinPaths(domainPath, 'partials');
+        if(!FileHandler.exists(domainPartialsPath)){
+            return;
+        }
+        let domainPartials = {};
+        let partialFiles = FileHandler.getFilesInFolder(domainPartialsPath, this.partialsExtensions);
+        for(let file of partialFiles){
+            let partialName = '';
+            for(let extension of this.partialsExtensions){
+                if(file.endsWith(extension)){
+                    partialName = file.replace(extension, '');
+                    break;
+                }
+            }
+            let partialPath = FileHandler.joinPaths(domainPartialsPath, file);
+            let partialContent = FileHandler.readFile(partialPath);
+            domainPartials[partialName] = partialContent.toString();
+        }
+        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);
+        }
+    }
+
+    getDomainFromRequest(req)
+    {
+        let host = req.get('host');
+        if(!host){
+            return false;
+        }
+        return host.split(':')[0];
+    }
+
+    getPartialsForDomain(domain)
+    {
+        let domainPartials = this.domainPartialsCache.get(domain);
+        if(!domainPartials){
+            return this.partialsCache;
+        }
+        return Object.assign({}, this.partialsCache, domainPartials);
+    }
+
+    findTemplatePathForDomain(templateName, domain)
+    {
+        if(!domain){
+            return this.getDefaultTemplatePath(templateName);
+        }
+        let domainPath = this.domainTemplatesMap.get(domain);
+        if(!domainPath){
+            return this.getDefaultTemplatePath(templateName);
+        }
+        let domainTemplatePath = FileHandler.joinPaths(domainPath, templateName + '.html');
+        if(!FileHandler.exists(domainTemplatePath)){
+            return this.getDefaultTemplatePath(templateName);
+        }
+        return domainTemplatePath;
+    }
+
+    getDefaultTemplatePath(templateName)
+    {
+        return FileHandler.joinPaths(this.templatesPath, templateName + '.html');
+    }
+
     setupStaticAssets()
     {
         if(!this.app || !this.appServerFactory || !this.publicPath){
@@ -62,10 +163,11 @@ class Frontend
             return res.status(404).send('');
         }
         try {
+            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.renderContentFromRoute(res, route, domain);
             }
             let pathSegments = path.split('/').filter(segment => segment !== '');
             if(0 < pathSegments.length){
@@ -75,17 +177,18 @@ class Frontend
                     return await this.renderContentFromEntity(
                         res,
                         entityResult.entity,
-                        entityResult.entityName
+                        entityResult.entityName,
+                        domain
                     );
                 }
             }
-            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.renderTemplateOnly(res, templatePath, domain);
             }
             Logger.debug('No template found for path: '+path+', rendering 404');
-            return await this.renderNotFoundPage(res);
+            return await this.renderNotFoundPage(res, domain);
         } catch (error) {
             Logger.error('Request handling error: '+error.message);
             return res.status(500).send('Internal server error');
@@ -137,7 +240,7 @@ class Frontend
         };
     }
 
-    findTemplateByPath(path)
+    findTemplateByPath(path, domain)
     {
         if('/' === path){
             path = '/index';
@@ -148,36 +251,36 @@ class Frontend
         templatePath = templatePath.startsWith('/')
             ? templatePath.substring(1)
             : templatePath;
-        let fullPath = FileHandler.joinPaths(this.templatesPath, templatePath + '.html');
+        let fullPath = this.findTemplatePathForDomain(templatePath, domain);
         if(FileHandler.exists(fullPath)){
             return fullPath;
         }
         return false;
     }
 
-    async renderContentFromRoute(res, route)
+    async renderContentFromRoute(res, route, domain)
     {
         if(!route.router || !route.content_id){
             Logger.debug('Route missing router or content_id');
-            return await this.renderNotFoundPage(res);
+            return await this.renderNotFoundPage(res, domain);
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
             Logger.debug('Entity not found: '+route.router);
-            return await this.renderNotFoundPage(res);
+            return await this.renderNotFoundPage(res, domain);
         }
         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);
+            return await this.renderNotFoundPage(res, domain);
         }
         let templateName = content.template || route.router;
-        let templatePath = FileHandler.joinPaths(this.templatesPath, templateName + '.html');
+        let templatePath = this.findTemplatePathForDomain(templateName, domain);
         if(!FileHandler.exists(templatePath)){
-            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
+            templatePath = this.findTemplatePathForDomain('page', domain);
             if(!FileHandler.exists(templatePath)){
                 Logger.debug('Neither template found: '+templateName+'.html nor page.html');
-                return await this.renderNotFoundPage(res);
+                return await this.renderNotFoundPage(res, domain);
             }
         }
         let template = FileHandler.readFile(templatePath).toString();
@@ -186,17 +289,18 @@ class Frontend
             ...content,
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.send(rendered);
     }
 
-    async renderContentFromEntity(res, entity, entityName)
+    async renderContentFromEntity(res, entity, entityName, domain)
     {
-        let templatePath = FileHandler.joinPaths(this.templatesPath, entityName + '.html');
+        let templatePath = this.findTemplatePathForDomain(entityName, domain);
         if(!FileHandler.exists(templatePath)){
-            templatePath = FileHandler.joinPaths(this.templatesPath, 'page.html');
+            templatePath = this.findTemplatePathForDomain('page', domain);
             if(!FileHandler.exists(templatePath)){
-                return await this.renderNotFoundPage(res);
+                return await this.renderNotFoundPage(res, domain);
             }
         }
         let template = FileHandler.readFile(templatePath).toString();
@@ -205,24 +309,26 @@ class Frontend
             title: entity.title || entity.name || entityName,
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.send(rendered);
     }
 
-    async renderTemplateOnly(res, templatePath)
+    async renderTemplateOnly(res, templatePath, domain)
     {
         let template = FileHandler.readFile(templatePath).toString();
         let data = {
             title: 'Page Title',
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.send(rendered);
     }
 
-    async renderNotFoundPage(res)
+    async renderNotFoundPage(res, domain)
     {
-        let templatePath = FileHandler.joinPaths(this.templatesPath, '404.html');
+        let templatePath = this.findTemplatePathForDomain('404', domain);
         if(!FileHandler.exists(templatePath)){
             return res.status(404).send('Page not found');
         }
@@ -231,7 +337,8 @@ class Frontend
             title: '404 - Page Not Found',
             current_year: new Date().getFullYear()
         };
-        let rendered = mustache.render(template, data);
+        let partials = this.getPartialsForDomain(domain);
+        let rendered = mustache.render(template, data, partials);
         return res.status(404).send(rendered);
     }
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.8.0",
+    "version": "0.9.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -32,7 +32,7 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.16.0",
+        "@reldens/server-utils": "^0.17.0",
         "@reldens/storage": "^0.45.0",
         "@reldens/utils": "^0.47.0",
         "dotenv": "^16.5.0",