@reldens/cms 0.20.0 → 0.23.0

package/lib/frontend/content-renderer.js

@@ -0,0 +1,178 @@
+/**
+ *
+ * Reldens - CMS - Frontend - ContentRenderer
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class ContentRenderer
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.templateEngine = sc.get(props, 'templateEngine', false);
+        this.templateResolver = sc.get(props, 'templateResolver', false);
+        this.templateCache = sc.get(props, 'templateCache', false);
+        this.metaDefaults = sc.get(props, 'metaDefaults', {});
+    }
+
+    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', sc.get(result, 'description', ''));
+        if(metaDescValue && '' !== metaDescValue){
+            result.meta_description = metaDescValue;
+        }
+        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 generateRouteContent(route, domain, req)
+    {
+        if(!route.router){
+            return false;
+        }
+        let entity = this.dataServer.getEntity(route.router);
+        if(!entity){
+            return false;
+        }
+        let content = await entity.loadOneWithRelations({route_id: route.id});
+        if(!content){
+            return false;
+        }
+        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain, req, route);
+    }
+
+    async generateTemplateContent(templatePath, domain, req, data = {})
+    {
+        let template = FileHandler.readFile(templatePath);
+        if(!template){
+            Logger.error('Failed to read template: ' + templatePath);
+            return false;
+        }
+        return await this.templateEngine.render(
+            template,
+            data,
+            this.templateCache.getPartialsForDomain(domain),
+            domain,
+            req,
+            null,
+            null
+        );
+    }
+
+    async renderWithTemplateContent(content, data, domain, req, route)
+    {
+        let templateName = sc.get(content, 'template', 'page');
+        if(!templateName){
+            templateName = 'page';
+        }
+        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
+        );
+        let templatePath = this.templateResolver.findTemplatePath(templateName, domain);
+        if(!templatePath){
+            return layoutContent;
+        }
+        let routerKey = route?.router;
+        let categoryName = currentEntityData?.cms_categories?.name;
+        let siteHandle = this.templateResolver.resolveDomainToSiteKey(domain)
+            + (routerKey ? ' '+routerKey : '')
+            + (categoryName ? ' cat-'+categoryName : '');
+        return await this.generateTemplateContent(
+            templatePath,
+            domain,
+            req,
+            Object.assign(
+                {},
+                this.fetchMetaFields(data),
+                {
+                    content: layoutContent,
+                    siteHandle
+                }
+            )
+        );
+    }
+
+    async processContentWithLayout(content, data, layoutName, domain, req, route, currentEntityData)
+    {
+        let processedContent = await this.processContent(content, data, domain, req, route, currentEntityData);
+        let layoutPath = this.templateResolver.findLayoutPath(layoutName, domain);
+        if(!layoutPath){
+            return processedContent;
+        }
+        return await this.generateTemplateContent(
+            layoutPath,
+            domain,
+            req,
+            Object.assign({}, data, {content: processedContent})
+        );
+    }
+
+    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.templateCache.getPartialsForDomain(domain),
+            domain,
+            req,
+            route,
+            currentEntityData
+        );
+    }
+
+}
+
+module.exports.ContentRenderer = ContentRenderer;

package/lib/frontend/entity-access-manager.js

@@ -0,0 +1,63 @@
+/**
+ *
+ * Reldens - CMS - Frontend - EntityAccessManager
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class EntityAccessManager
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.entityAccessCache = new Map();
+    }
+
+    async loadEntityAccessRules()
+    {
+        let accessEntity = this.dataServer.getEntity('entitiesAccess');
+        if(!accessEntity){
+            Logger.warning('Entities Access not found.');
+            return;
+        }
+        let accessRules = await accessEntity.loadAll();
+        for(let rule of accessRules){
+            this.entityAccessCache.set(rule.entity_name, rule.is_public);
+        }
+    }
+
+    async isEntityAccessible(entityName)
+    {
+        if(this.entityAccessCache.has(entityName)){
+            return this.entityAccessCache.get(entityName);
+        }
+        return false;
+    }
+
+    async findEntityByPath(path)
+    {
+        let pathSegments = path.split('/').filter(segment => '' !== segment);
+        if(2 > pathSegments.length){
+            return false;
+        }
+        let entityName = pathSegments[0];
+        if(!await this.isEntityAccessible(entityName)){
+            return false;
+        }
+        let entityId = pathSegments[1];
+        let entity = this.dataServer.getEntity(entityName);
+        if(!entity){
+            return false;
+        }
+        let loadedEntity = await entity.loadByIdWithRelations(entityId);
+        if(!loadedEntity){
+            return false;
+        }
+        return {entity: loadedEntity, entityName};
+    }
+
+}
+
+module.exports.EntityAccessManager = EntityAccessManager;

package/lib/frontend/request-processor.js

@@ -0,0 +1,128 @@
+/**
+ *
+ * Reldens - CMS - Frontend - RequestProcessor
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class RequestProcessor
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.templateResolver = sc.get(props, 'templateResolver', false);
+        this.domainMapping = sc.get(props, 'domainMapping', {});
+    }
+
+    getDomainFromRequest(req)
+    {
+        let host = req.get('host');
+        if(!host){
+            return false;
+        }
+        return host.split(':')[0];
+    }
+
+    resolveDomainMapping(domain)
+    {
+        if(!domain){
+            return domain;
+        }
+        return sc.get(this.domainMapping, domain, domain);
+    }
+
+    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;
+        res.redirect(statusCode, redirectUrl);
+        return true;
+    }
+
+    async findRouteByPath(path, domain)
+    {
+        let routesEntity = this.dataServer.getEntity('routes');
+        if(!routesEntity){
+            Logger.error('Routes entity not found in dataServer.');
+            return false;
+        }
+        let normalizedPath = this.normalizePathForRouteSearch(path);
+        let resolvedDomain = this.resolveDomainMapping(domain);
+        let domainFilter = resolvedDomain || null;
+        let routeFilters = {path: normalizedPath, enabled: 1};
+        let routes = await routesEntity.load(routeFilters);
+        let matchingRoute = false;
+        let nullDomain = false;
+        for(let route of routes){
+            if(route.domain === domainFilter){
+                matchingRoute = route;
+                break;
+            }
+            if(!route.domain){
+                nullDomain = route;
+            }
+        }
+        if(matchingRoute){
+            return matchingRoute;
+        }
+        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;
+    }
+
+    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.RequestProcessor = RequestProcessor;

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;