@reldens/cms 0.19.0 → 0.20.0

package/lib/frontend.js

@@ -19,6 +19,7 @@ class Frontend
         this.appServerFactory = sc.get(props, 'appServerFactory', false);
         this.dataServer = sc.get(props, 'dataServer', false);
         this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.events = sc.get(props, 'events', false);
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.templatesPath = FileHandler.joinPaths(this.projectRoot, 'templates');
         this.publicPath = FileHandler.joinPaths(this.projectRoot, 'public');
@@ -79,7 +80,11 @@ class Frontend
             renderEngine: this.renderEngine,
             dataServer: this.dataServer,
             getPartials: this.getPartialsForDomain.bind(this),
-            entitiesConfig: this.entitiesConfig
+            entitiesConfig: this.entitiesConfig,
+            events: this.events,
+            defaultDomain: this.defaultDomain,
+            projectRoot: this.projectRoot,
+            publicPath: this.publicPath
         });
         this.searchConfig.jsonFieldsParser = this.templateEngine.jsonFieldsParser;
         await this.loadPartials();
@@ -345,7 +350,8 @@ class Frontend
                     query: req.query
                 }),
                 domain,
-                req
+                req,
+                null
             );
             if(this.cacheManager && this.cacheManager.isEnabled()){
                 await this.cacheManager.set(domain, cacheKey, content);
@@ -357,28 +363,73 @@ class Frontend
         }
     }
 
+    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;
+        return res.redirect(statusCode, redirectUrl);
+    }
+
     async handleRequest(req, res)
     {
         try {
-            let path = req.path;
+            let originalPath = req.path;
             let domain = this.getDomainFromRequest(req);
             if(this.cacheManager && this.cacheManager.isEnabled()){
-                let cachedContent = await this.cacheManager.get(domain, path);
+                let cachedContent = await this.cacheManager.get(domain, originalPath);
                 if(cachedContent){
                     return res.send(cachedContent);
                 }
             }
-            let route = await this.findRouteByPath(path, domain);
+            let route = await this.findRouteByPath(originalPath, domain);
             if(route){
-                return await this.renderRouteWithCache(route, domain, res, path, req);
+                let redirectResult = await this.handleRouteRedirect(route, res);
+                if(redirectResult){
+                    return redirectResult;
+                }
+                let normalizedPath = this.normalizePathForRouteSearch(originalPath);
+                let routeFoundWithSlash = originalPath !== normalizedPath && route.path === normalizedPath + '/';
+                if(!originalPath.endsWith('/') && routeFoundWithSlash){
+                    return res.redirect(301, originalPath + '/');
+                }
+                return await this.renderRouteWithCache(route, domain, res, originalPath, req);
+            }
+            let normalizedPath = this.normalizePathForRouteSearch(originalPath);
+            if(originalPath !== normalizedPath){
+                let alternativeRoute = await this.findRouteByPath(normalizedPath + '/', domain);
+                if(alternativeRoute){
+                    let redirectResult = await this.handleRouteRedirect(alternativeRoute, res);
+                    if(redirectResult){
+                        return redirectResult;
+                    }
+                    if(!originalPath.endsWith('/')){
+                        return res.redirect(301, originalPath + '/');
+                    }
+                    return await this.renderRouteWithCache(alternativeRoute, domain, res, originalPath, req);
+                }
             }
-            let entityResult = await this.findEntityByPath(path);
+            if(!originalPath.endsWith('/') && '/' !== originalPath){
+                return res.redirect(301, originalPath + '/');
+            }
+            let entityResult = await this.findEntityByPath(originalPath);
             if(entityResult){
-                return await this.renderEntityWithCache(entityResult, domain, res, path, req);
+                return await this.renderEntityWithCache(entityResult, domain, res, originalPath, req);
             }
-            let templatePath = this.findTemplateByPath(path, domain);
+            let templatePath = this.findTemplateByPath(originalPath, domain);
             if(templatePath){
-                return await this.renderTemplateWithCache(templatePath, domain, res, path, req);
+                return await this.renderTemplateWithCache(templatePath, domain, res, originalPath, req);
             }
             return await this.renderNotFound(domain, res, req);
         } catch (error) {
@@ -394,8 +445,9 @@ class Frontend
             Logger.error('Routes entity not found in dataServer.');
             return false;
         }
+        let normalizedPath = this.normalizePathForRouteSearch(path);
         let domainFilter = domain || null;
-        let routeFilters = {path, enabled: 1};
+        let routeFilters = {path: normalizedPath, enabled: 1};
         let routes = await routesEntity.load(routeFilters);
         let matchingRoute = false;
         let nullDomain = false;
@@ -411,7 +463,25 @@ class Frontend
         if(matchingRoute){
             return matchingRoute;
         }
-        return nullDomain;
+        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;
     }
 
     async isEntityAccessible(entityName)
@@ -509,12 +579,12 @@ class Frontend
         if(!content){
             return false;
         }
-        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain, req);
+        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain, req, route);
     }
 
     async generateEntityContent(entityResult, domain, req)
     {
-        return await this.renderWithTemplateContent(entityResult.entity, entityResult.entity, domain, req);
+        return await this.renderWithTemplateContent(entityResult.entity, entityResult.entity, domain, req, null);
     }
 
     async generateTemplateContent(templatePath, domain, req)
@@ -524,7 +594,15 @@ class Frontend
             Logger.error('Failed to read template: ' + templatePath);
             return false;
         }
-        return await this.templateEngine.render(template, {}, this.getPartialsForDomain(domain), domain, req);
+        return await this.templateEngine.render(
+            template,
+            {},
+            this.getPartialsForDomain(domain),
+            domain,
+            req,
+            null,
+            null
+        );
     }
 
     async renderRoute(route, domain, res, req)
@@ -545,10 +623,10 @@ class Frontend
 
     async renderWithTemplate(content, data, domain, res, req)
     {
-        return res.send(await this.renderWithTemplateContent(content, data, domain, req));
+        return res.send(await this.renderWithTemplateContent(content, data, domain, req, null));
     }
 
-    async renderWithTemplateContent(content, data, domain, req)
+    async renderWithTemplateContent(content, data, domain, req, route)
     {
         let templateName = sc.get(content, 'template', 'page');
         if(!templateName){
@@ -558,7 +636,16 @@ class Frontend
         if(!layoutName){
             layoutName = 'default';
         }
-        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain, req);
+        let currentEntityData = Object.assign({}, content, data);
+        let layoutContent = await this.processContentWithLayout(
+            content,
+            data,
+            layoutName,
+            domain,
+            req,
+            route,
+            currentEntityData
+        );
         let templatePath = this.findTemplatePath(templateName, domain);
         if(!templatePath){
             return layoutContent;
@@ -569,10 +656,19 @@ class Frontend
         }
         return await this.templateEngine.render(
             pageTemplate,
-            Object.assign({}, this.fetchMetaFields(data), {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
+            Object.assign(
+                {},
+                this.fetchMetaFields(data),
+                {
+                    content: layoutContent,
+                    siteHandle: this.resolveDomainToSiteKey(domain)
+                }
+            ),
             this.getPartialsForDomain(domain),
             domain,
-            req
+            req,
+            route,
+            currentEntityData
         );
     }
 
@@ -583,17 +679,25 @@ class Frontend
             Logger.error('Failed to read template: ' + templatePath);
             return false;
         }
-        return await this.templateEngine.render(template, data, this.getPartialsForDomain(domain), domain, req);
+        return await this.templateEngine.render(
+            template,
+            data,
+            this.getPartialsForDomain(domain),
+            domain,
+            req,
+            null,
+            null
+        );
     }
 
     async renderWithLayout(content, data, layoutName, domain, res, req)
     {
-        return res.send(await this.renderWithTemplateContent(content, data, domain, req));
+        return res.send(await this.renderWithTemplateContent(content, data, domain, req, null));
     }
 
-    async processContentWithLayout(content, data, layoutName, domain, req)
+    async processContentWithLayout(content, data, layoutName, domain, req, route, currentEntityData)
     {
-        let processedContent = await this.processContent(content, data, domain, req);
+        let processedContent = await this.processContent(content, data, domain, req, route, currentEntityData);
         let layoutPath = this.findLayoutPath(layoutName, domain);
         if(!layoutPath){
             return processedContent;
@@ -607,17 +711,27 @@ class Frontend
             Object.assign({}, data, {content: processedContent}),
             this.getPartialsForDomain(domain),
             domain,
-            req
+            req,
+            route,
+            currentEntityData
         );
     }
 
-    async processContent(content, data, domain, req)
+    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.getPartialsForDomain(domain), domain, req);
+        return await this.templateEngine.render(
+            contentText,
+            data,
+            this.getPartialsForDomain(domain),
+            domain,
+            req,
+            route,
+            currentEntityData
+        );
     }
 
     async renderNotFound(domain, res, req)

package/lib/manager.js

@@ -476,6 +476,7 @@ class Manager
         this.frontend = new Frontend({
             app: this.app,
             dataServer: this.dataServer,
+            events: this.events,
             renderEngine: this.renderEngine,
             projectRoot: this.projectRoot,
             appServerFactory: this.appServerFactory,

package/lib/template-engine/asset-transformer.js

@@ -0,0 +1,41 @@
+/**
+ *
+ * Reldens - CMS - AssetTransformer
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class AssetTransformer
+{
+
+    async transform(template, domain, req, systemVariables)
+    {
+        if(!template){
+            return template;
+        }
+        let currentRequest = sc.get(systemVariables, 'currentRequest', {});
+        let assetPattern = /\[asset\(([^)]+)\)\]/g;
+        let matches = [...template.matchAll(assetPattern)];
+        for(let i = matches.length - 1; i >= 0; i--){
+            let match = matches[i];
+            let assetPath = match[1].replace(/['"]/g, '');
+            let absoluteUrl = this.buildAssetUrl(assetPath, currentRequest);
+            template = template.substring(0, match.index) +
+                absoluteUrl +
+                template.substring(match.index + match[0].length);
+        }
+        return template;
+    }
+
+    buildAssetUrl(assetPath, currentRequest)
+    {
+        if(!assetPath || assetPath.startsWith('http')){
+            return assetPath;
+        }
+        return sc.get(currentRequest, 'baseUrl', '')+'/assets'+(assetPath.startsWith('/') ? assetPath : '/'+assetPath);
+    }
+
+}
+
+module.exports.AssetTransformer = AssetTransformer;

package/lib/template-engine/collections-single-transformer.js

@@ -10,12 +10,22 @@ const { sc } = require('@reldens/utils');
 class CollectionsSingleTransformer extends CollectionsTransformerBase
 {
 
+    constructor(props)
+    {
+        super(props);
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+        this.findAllPartialTags = sc.get(props, 'findAllPartialTags', false);
+        this.loadPartialTemplate = sc.get(props, 'loadPartialTemplate', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
+    }
+
     getSingleFieldCollectionRegex()
     {
         return /<collection\s+([^>]+)\/>/g;
     }
 
-    async transform(template, domain)
+    async transform(template, domain, req, systemVariables)
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getSingleFieldCollectionRegex())){
@@ -30,20 +40,27 @@ class CollectionsSingleTransformer extends CollectionsTransformerBase
             let fieldName = this.extractAttributeValue(tagContent, 'field');
             processedTemplate = processedTemplate.replace(
                 match[0],
-                this.extractFieldValues(
+                await this.extractFieldValues(
                     await this.fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson, relationsString),
-                    fieldName
+                    fieldName,
+                    domain,
+                    req,
+                    systemVariables
                 )
             );
         }
         return processedTemplate;
     }
 
-    extractFieldValues(collectionData, fieldName)
+    async extractFieldValues(collectionData, fieldName, domain, req, systemVariables)
     {
         let fieldValues = '';
         for(let row of collectionData){
-            fieldValues += sc.get(row, fieldName, '');
+            let fieldValue = sc.get(row, fieldName, '');
+            if(fieldValue && this.processAllTemplateFunctions){
+                fieldValue = await this.processAllTemplateFunctions(fieldValue, domain, req, systemVariables);
+            }
+            fieldValues += fieldValue;
         }
         return fieldValues;
     }

package/lib/template-engine/collections-transformer.js

@@ -18,6 +18,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
         this.getPartials = sc.get(props, 'getPartials', false);
         this.findAllPartialTags = sc.get(props, 'findAllPartialTags', false);
         this.loadPartialTemplate = sc.get(props, 'loadPartialTemplate', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
         this.paginationHandler = new PaginationHandler();
     }
 
@@ -31,7 +32,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
         return new RegExp('<\\/collection>');
     }
 
-    async transform(template, domain, req)
+    async transform(template, domain, req, systemVariables)
     {
         let processedTemplate = template;
         let matches = [...template.matchAll(this.getLoopCollectionStartRegex())];
@@ -62,7 +63,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
                     prevPages,
                     nextPages,
                     domain,
-                    req
+                    req,
+                    systemVariables
                 );
                 if(loopResult){
                     processedTemplate = loopResult;
@@ -76,7 +78,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 filtersJson,
                 relationsString,
                 queryOptionsJson,
-                domain
+                domain,
+                req,
+                systemVariables
             );
             if(loopResult){
                 processedTemplate = loopResult;
@@ -92,7 +96,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
         filtersJson,
         relationsString,
         queryOptionsJson,
-        domain
+        domain,
+        req,
+        systemVariables
     ){
         return await this.processCollectionBase(
             template,
@@ -102,7 +108,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
             relationsString,
             queryOptionsJson,
             domain,
-            false
+            false,
+            req,
+            systemVariables
         );
     }
 
@@ -118,7 +126,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
         prevPages,
         nextPages,
         domain,
-        req
+        req,
+        systemVariables
     ){
         if(!req){
             Logger.warning('No request provided for pagination, falling back to regular collection');
@@ -129,7 +138,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 filtersJson,
                 relationsString,
                 queryOptionsJson,
-                domain
+                domain,
+                req,
+                systemVariables
             );
         }
         return await this.processCollectionBase(
@@ -146,7 +157,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 prevPages,
                 nextPages,
                 req
-            }
+            },
+            req,
+            systemVariables
         );
     }
 
@@ -158,7 +171,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
         relationsString,
         queryOptionsJson,
         domain,
-        paginationOptions
+        paginationOptions,
+        req,
+        systemVariables
     ){
         let startPos = startMatch.index;
         let startEnd = startPos + startMatch[0].length;
@@ -211,7 +226,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
                     this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
                 );
             }
-            let collectionContent = await this.renderCollectionLoop(loopContent, collectionData, domain);
+            let collectionContent = await this.renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables);
             finalContent = this.renderEngine.render(
                 1 < paginationData.totalPages
                     ? this.loadPaginationTemplate(paginationOptions.containerName, domain)
@@ -235,7 +250,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 queryOptionsJson,
                 relationsString
             );
-            finalContent = await this.renderCollectionLoop(loopContent, collectionData, domain);
+            finalContent = await this.renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables);
         }
         return template.substring(0, startPos) + finalContent + template.substring(endPos + endMatch[0].length);
     }
@@ -281,14 +296,14 @@ class CollectionsTransformer extends CollectionsTransformerBase
         return '{{&collectionContentForCurrentPage}}';
     }
 
-    async renderCollectionLoop(loopContent, collectionData, domain)
+    async renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables)
     {
         if(!collectionData || 0 === collectionData.length){
             return this.renderNoResultsMessage(domain);
         }
         let renderedContent = '';
         for(let row of collectionData){
-            renderedContent += await this.processPartialsInLoop(loopContent, row, domain);
+            renderedContent += await this.processPartialsInLoop(loopContent, row, domain, req, systemVariables);
         }
         return renderedContent;
     }
@@ -310,7 +325,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
         return '';
     }
 
-    async processPartialsInLoop(content, rowData, domain)
+    async processPartialsInLoop(content, rowData, domain, req, systemVariables)
     {
         let processedContent = content;
         let partialTags = this.findAllPartialTags(content);
@@ -322,6 +337,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 processedContent = processedContent.substring(0, tag.start)+''+processedContent.substring(tag.end);
                 continue;
             }
+            if(this.processAllTemplateFunctions){
+                partialContent = await this.processAllTemplateFunctions(partialContent, domain, req, systemVariables);
+            }
             if(sc.hasOwn(tag.attributes, 'row')){
                 processedContent = processedContent.substring(0, tag.start)
                     +this.renderEngine.render(partialContent, {row: rowData}, this.getPartials(domain))
@@ -335,6 +353,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 this.renderEngine.render(wrapperTemplate, renderData, partials) +
                 processedContent.substring(tag.end);
         }
+        if(this.processAllTemplateFunctions){
+            processedContent = await this.processAllTemplateFunctions(processedContent, domain, req, systemVariables);
+        }
         return this.renderEngine.render(processedContent, {row: rowData}, this.getPartials(domain));
     }
 

package/lib/template-engine/date-transformer.js

@@ -0,0 +1,53 @@
+/**
+ *
+ * Reldens - CMS - DateTransformer
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class DateTransformer
+{
+
+    constructor(props)
+    {
+        this.defaultFormat = sc.get(props, 'defaultFormat', 'Y-m-d H:i:s');
+    }
+
+    async transform(template, domain, req, systemVariables)
+    {
+        if(!template){
+            return template;
+        }
+        let datePattern = /\[date\(([^)]*)\)\]/g;
+        let matches = [...template.matchAll(datePattern)];
+        for(let i = matches.length - 1; i >= 0; i--){
+            let match = matches[i];
+            let args = match[1] ? match[1].split(',').map(arg => arg.trim().replace(/['"]/g, '')) : [];
+            let dateValue = args[0] || '';
+            let formatValue = args[1] || this.defaultFormat;
+            let formattedDate = this.formatDate(dateValue, formatValue);
+            template = template.substring(0, match.index) +
+                formattedDate +
+                template.substring(match.index + match[0].length);
+        }
+        return template;
+    }
+
+    formatDate(dateValue, format)
+    {
+        let date;
+        if(!dateValue || '' === dateValue || 'now' === dateValue.toLowerCase()){
+            date = new Date();
+        } else {
+            date = new Date(dateValue);
+            if(isNaN(date.getTime())){
+                date = new Date();
+            }
+        }
+        return sc.formatDate(date, format);
+    }
+
+}
+
+module.exports.DateTransformer = DateTransformer;

package/lib/template-engine/entities-transformer.js

@@ -21,7 +21,7 @@ class EntitiesTransformer
         return /<entity\s+name="([^"]+)"(?:\s+field="([^"]+)"\s+value="([^"]+)"|\s+id="([^"]+)")?\s*\/?>/g;
     }
 
-    async transform(template, domain)
+    async transform(template, domain, req, systemVariables)
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getEntityRegex())){
@@ -36,7 +36,9 @@ class EntitiesTransformer
                 match[0],
                 await this.processAllTemplateFunctions(
                     sc.get(await this.fetchEntityForTemplate(tableName, value, field), 'content', ''),
-                    domain
+                    domain,
+                    req,
+                    systemVariables
                 )
             );
         }

package/lib/template-engine/partials-transformer.js

@@ -13,9 +13,10 @@ class PartialsTransformer
     {
         this.renderEngine = sc.get(props, 'renderEngine', false);
         this.getPartials = sc.get(props, 'getPartials', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
     }
 
-    async transform(template, domain)
+    async transform(template, domain, req, systemVariables)
     {
         let processedTemplate = template;
         let partialTags = this.findAllPartialTags(template);
@@ -27,6 +28,9 @@ class PartialsTransformer
                 processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
                 continue;
             }
+            if(this.processAllTemplateFunctions){
+                partialContent = await this.processAllTemplateFunctions(partialContent, domain, req, systemVariables);
+            }
             let wrapperTemplate = '{{#vars}}{{> ' + tag.name + '}}{{/vars}}';
             let renderData = { vars: tag.attributes };
             let partials = {[tag.name]: partialContent};