@reldens/cms 0.20.0 → 0.21.0

package/lib/frontend/response-manager.js

@@ -0,0 +1,54 @@
+/**
+ *
+ * Reldens - CMS - Frontend - ResponseManager
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class ResponseManager
+{
+
+    constructor(props)
+    {
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.contentRenderer = sc.get(props, 'contentRenderer', false);
+        this.templateResolver = sc.get(props, 'templateResolver', false);
+        this.requestProcessor = sc.get(props, 'requestProcessor', false);
+    }
+
+    async renderWithCacheHandler(contentGenerator, errorHandler, responseHandler, domain, res, path, req)
+    {
+        let renderedContent = await contentGenerator();
+        if(!renderedContent){
+            return await errorHandler();
+        }
+        if(this.cacheManager && this.cacheManager.isEnabled()){
+            let cacheKey = this.requestProcessor.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
+        }
+        return await responseHandler(renderedContent);
+    }
+
+    async renderNotFound(domain, res, req)
+    {
+        let notFoundPath = this.templateResolver.findTemplatePath('404', domain);
+        if(notFoundPath){
+            let content = await this.contentRenderer.generateTemplateContent(notFoundPath, domain, req, {});
+            if(content){
+                res.status(404);
+                return res.send(await this.contentRenderer.renderWithTemplateContent(
+                    {content},
+                    {meta_title: 'Page not found'},
+                    domain,
+                    req,
+                    null
+                ));
+            }
+        }
+        return res.status(404).send('Page not found');
+    }
+
+}
+
+module.exports.ResponseManager = ResponseManager;

package/lib/frontend/template-cache.js

@@ -0,0 +1,102 @@
+/**
+ *
+ * Reldens - CMS - Frontend - TemplateCache
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class TemplateCache
+{
+
+    constructor(props)
+    {
+        this.templatesPath = sc.get(props, 'templatesPath', '');
+        this.templateExtensions = sc.get(props, 'templateExtensions', ['.html', '.mustache', '.template']);
+        this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
+        this.partialsCache = {};
+        this.domainPartialsCache = new Map();
+        this.domainTemplatesMap = new Map();
+        this.templateResolver = sc.get(props, 'templateResolver', false);
+    }
+
+    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.templateResolver.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.templateResolver.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);
+        }
+    }
+
+    getPartialsForDomain(domain)
+    {
+        let resolvedDomain = this.templateResolver.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);
+    }
+
+    getDomainTemplatesMap()
+    {
+        return this.domainTemplatesMap;
+    }
+
+}
+
+module.exports.TemplateCache = TemplateCache;

package/lib/frontend/template-resolver.js

@@ -0,0 +1,111 @@
+/**
+ *
+ * Reldens - CMS - Frontend - TemplateResolver
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { sc } = require('@reldens/utils');
+
+class TemplateResolver
+{
+
+    constructor(props)
+    {
+        this.templatesPath = sc.get(props, 'templatesPath', '');
+        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.domainTemplatesMap = sc.get(props, 'domainTemplatesMap', new Map());
+    }
+
+    extractTemplateName(filename)
+    {
+        for(let extension of this.templateExtensions){
+            if(filename.endsWith(extension)){
+                return filename.replace(extension, '');
+            }
+        }
+        return false;
+    }
+
+    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');
+    }
+
+    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);
+    }
+
+    findTemplateByPath(path, domain)
+    {
+        if('/' === path){
+            path = '/index';
+        }
+        let templatePath = path.endsWith('/') ? path.slice(0, -1) : path;
+        templatePath = templatePath.startsWith('/') ? templatePath.substring(1) : templatePath;
+        if('page' === templatePath){
+            return false;
+        }
+        return this.findTemplatePath(templatePath, domain);
+    }
+
+}
+
+module.exports.TemplateResolver = TemplateResolver;