@reldens/cms 0.19.0 → 0.21.0

package/lib/manager.js

@@ -5,7 +5,7 @@
  */
 
 const { TemplatesList } = require('./templates-list');
-const { AdminTranslations } = require('./admin-translations');
+const { DefaultTranslations } = require('./admin-manager/default-translations');
 const { AdminTemplatesLoader } = require('./admin-templates-loader');
 const { AdminManagerValidator } = require('./admin-manager-validator');
 const { MimeTypes } = require('./mime-types');
@@ -18,6 +18,7 @@ const { CmsPagesRouteManager } = require('./cms-pages-route-manager');
 const { Installer } = require('./installer');
 const { Frontend } = require('./frontend');
 const { CacheManager } = require('./cache/cache-manager');
+const { TemplateReloader } = require('./template-reloader');
 const { EventsManagerSingleton, Logger, sc } = require('@reldens/utils');
 const { DriversMap } = require('@reldens/storage');
 const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
@@ -34,6 +35,7 @@ class Manager
         this.installLockPath = FileHandler.joinPaths(this.projectRoot, 'install.lock');
         dotenv.config({path: this.envFilePath});
         this.config = this.loadConfigFromEnv();
+        this.adminTranslations = sc.get(props, 'adminTranslations', {});
         this.adminEntities = sc.get(props, 'adminEntities', {});
         this.rawRegisteredEntities = sc.get(props, 'rawRegisteredEntities', {});
         this.entitiesTranslations = sc.get(props, 'entitiesTranslations', {});
@@ -60,6 +62,7 @@ class Manager
         this.siteKeyMapping = sc.get(props, 'siteKeyMapping', sc.toJson(process.env.RELDENS_SITE_KEY_MAPPING));
         this.templateExtensions = sc.get(props, 'templateExtensions', ['.html', '.template']);
         this.cache = sc.get(props, 'cache', false);
+        this.reloadTime = sc.get(props, 'reloadTime', 0);
         this.app = sc.get(props, 'app', false);
         this.appServer = sc.get(props, 'appServer', false);
         this.dataServer = sc.get(props, 'dataServer', false);
@@ -67,14 +70,8 @@ class Manager
         this.frontend = sc.get(props, 'frontend', false);
         this.renderEngine = sc.get(props, 'renderEngine', mustache);
         this.prismaClient = sc.get(props, 'prismaClient', false);
-        this.developmentPatterns = sc.get(props, 'developmentPatterns', [
-            'localhost',
-            '127.0.0.1',
-            '.local',
-            '.test',
-            '.dev',
-            '.staging'
-        ]);
+        this.defaultDevelopmentPatterns = ['localhost', '127.0.0.1', '.local', '.test', '.dev'];
+        this.developmentPatterns = sc.get(props, 'developmentPatterns', this.defaultDevelopmentPatterns);
         this.developmentEnvironments = sc.get(props, 'developmentEnvironments', ['development', 'dev', 'test']);
         this.developmentPorts = sc.get(props, 'developmentPorts', [3000, 8080, 8081]);
         this.developmentMultiplier = sc.get(props, 'developmentMultiplier', 10);
@@ -83,6 +80,14 @@ class Manager
         this.appServerFactory = new AppServerFactory();
         this.adminEntitiesGenerator = new AdminEntitiesGenerator();
         this.cacheManager = new CacheManager({projectRoot: this.projectRoot, enabled: this.cache});
+        this.templateReloader = new TemplateReloader({
+            reloadTime: this.reloadTime,
+            events: this.events,
+            adminTemplatesLoader: AdminTemplatesLoader,
+            mappedAdminTemplates: this.mappedAdminTemplates,
+            templatesPath: FileHandler.joinPaths(this.projectRoot, 'templates'),
+            templateExtensions: this.templateExtensions
+        });
         this.installer = new Installer({
             projectRoot: this.projectRoot,
             prismaClient: this.prismaClient,
@@ -411,8 +416,12 @@ class Manager
                 return passwordResult;
             };
         }
+        this.templateReloader.trackTemplateFiles(this.mappedAdminTemplates);
         let adminFilesContents = await AdminTemplatesLoader.fetchAdminFilesContents(this.mappedAdminTemplates);
-        let translations = AdminTranslations.appendTranslations(this.entitiesTranslations || {});
+        let translations = sc.deepMergeProperties(
+            sc.deepMergeProperties({}, DefaultTranslations),
+            sc.deepMergeProperties(this.entitiesTranslations, this.adminTranslations)
+        );
         this.events.emit('reldens.manager.initializeAdminManager', {
             manager: this,
             authenticationCallback,
@@ -430,7 +439,7 @@ class Manager
             renderCallback: this.renderCallback.bind(this),
             secret: this.config.adminSecret,
             rootPath: this.config.adminPath,
-            translations: translations,
+            translations,
             adminFilesContents,
             mimeTypes: this.mimeTypes,
             allowedExtensions: this.allowedExtensions,
@@ -448,6 +457,9 @@ class Manager
             }
         };
         this.adminManager = new AdminManager(adminConfig);
+        this.adminManager.router.checkAndReloadAdminTemplates = async () => {
+            return await this.templateReloader.handleAdminTemplateReload(this.adminManager);
+        };
         await this.adminManager.setupAdmin();
         return true;
     }
@@ -476,6 +488,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,
@@ -484,7 +497,8 @@ class Manager
             siteKeyMapping: this.siteKeyMapping,
             templateExtensions: this.templateExtensions,
             entitiesConfig: this.entitiesConfig,
-            cacheManager: this.cacheManager
+            cacheManager: this.cacheManager,
+            handleFrontendTemplateReload: this.templateReloader.handleFrontendTemplateReload.bind(this.templateReloader)
         });
         return await this.frontend.initialize();
     }

package/lib/search-renderer.js

@@ -35,8 +35,9 @@ class SearchRenderer
                 Logger.error('Search result partial template not found: ' + partialName);
                 continue;
             }
+            let templateData = sc.get(config, 'render.templateData', {});
             if(sc.hasOwn(entityResult, 'pagination')){
-                let entityContent = await this.renderSearchEntityResults(entityResult.results, partialTemplate, domain);
+                let entityContent = await this.renderSearchEntityResults(entityResult.results, partialTemplate, domain, templateData);
                 let totalPages = sc.get(entityResult.pagination, 'totalPages', 1);
                 if(1 < totalPages){
                     let paginationContainer = sc.get(config, 'render.paginationContainer', 'pagedCollection');
@@ -46,22 +47,30 @@ class SearchRenderer
                         hasResults: 0 < entityResult.results.length,
                         noResultsMessage: entityResult.noResultsMessage || 'No results found.'
                     });
-                    renderedContent += this.renderEngine.render(paginationTemplate, paginationData, this.getPartialsForDomain(domain));
+                    renderedContent += this.renderEngine.render(
+                        paginationTemplate,
+                        paginationData,
+                        this.getPartialsForDomain(domain)
+                    );
                     continue;
                 }
                 renderedContent += entityContent;
                 continue;
             }
-            renderedContent += await this.renderSearchEntityResults(entityResult.results, partialTemplate, domain);
+            renderedContent += await this.renderSearchEntityResults(entityResult.results, partialTemplate, domain, templateData);
         }
         return renderedContent;
     }
 
-    async renderSearchEntityResults(results, partialTemplate, domain)
+    async renderSearchEntityResults(results, partialTemplate, domain, templateData = {})
     {
         let renderedContent = '';
+        if(!sc.hasOwn(templateData, 'columnsClass') || '' === templateData.columnsClass){
+            templateData.columnsClass = 'col-lg-6';
+        }
         for(let row of results){
-            renderedContent += this.renderEngine.render(partialTemplate, {row}, this.getPartialsForDomain(domain));
+            let rowData = Object.assign({}, templateData, {row});
+            renderedContent += this.renderEngine.render(partialTemplate, rowData, this.getPartialsForDomain(domain));
         }
         return renderedContent;
     }
@@ -85,8 +94,7 @@ class SearchRenderer
 
     loadPartialTemplate(partialName, domain)
     {
-        let partials = this.getPartialsForDomain(domain);
-        return sc.get(partials, partialName, false);
+        return sc.get(this.getPartialsForDomain(domain), partialName, false);
     }
 
     loadPaginationTemplate(containerName, domain)

package/lib/search-request-handler.js

@@ -0,0 +1,67 @@
+/**
+ *
+ * Reldens - CMS - SearchRequestHandler
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class SearchRequestHandler
+{
+
+    constructor(props)
+    {
+        this.search = sc.get(props, 'search', false);
+        this.searchRenderer = sc.get(props, 'searchRenderer', false);
+        this.contentRenderer = sc.get(props, 'contentRenderer', false);
+        this.requestProcessor = sc.get(props, 'requestProcessor', false);
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+    }
+
+    async handleSearchRequest(req, res)
+    {
+        try {
+            let domain = this.requestProcessor.getDomainFromRequest(req);
+            let config = this.search.parseSearchParameters(req.query);
+            if(!config){
+                return res.redirect('/?error-message=searchInvalidParameters');
+            }
+            let cacheKey = this.requestProcessor.buildCacheKey(req.path, req);
+            if(this.cacheManager && this.cacheManager.isEnabled()){
+                let cachedContent = await this.cacheManager.get(domain, cacheKey);
+                if(cachedContent){
+                    return res.send(cachedContent);
+                }
+            }
+            let searchResults = await this.search.executeSearch(config);
+            if(false === searchResults){
+                return res.redirect('/?error-message=searchExecutionFailed');
+            }
+            let content = await this.contentRenderer.renderWithTemplateContent(
+                {
+                    template: config.render.page,
+                    layout: config.render.layout,
+                    content: await this.searchRenderer.renderSearchResults(searchResults, config, domain, req)
+                },
+                Object.assign({}, {
+                    search_query: sc.get(req.query, 'search', ''),
+                    searchConfig: config,
+                    query: req.query
+                }),
+                domain,
+                req,
+                null
+            );
+            if(this.cacheManager && this.cacheManager.isEnabled()){
+                await this.cacheManager.set(domain, cacheKey, content);
+            }
+            return res.send(content);
+        } catch (error) {
+            Logger.error('Search request handling error: ' + error.message);
+            return res.redirect('/?error-message=searchError');
+        }
+    }
+
+}
+
+module.exports.SearchRequestHandler = SearchRequestHandler;

package/lib/search.js

@@ -38,7 +38,8 @@ class Search
             page: 'page',
             layout: 'search',
             paginationContainer: 'pagedCollection',
-            partial: 'entriesListView'
+            partial: 'entriesListView',
+            templateData: {}
         };
     }
 
@@ -184,6 +185,17 @@ class Search
         if(partial){
             config.render.partial = partial;
         }
+        for(let key of Object.keys(query)){
+            if(!key.startsWith('templateData[')){
+                continue;
+            }
+            let templateMatch = key.match(/templateData\[([^\]]+)\]/);
+            if(!templateMatch){
+                continue;
+            }
+            let templateKey = templateMatch[1];
+            config.render.templateData[templateKey] = query[key];
+        }
         return config;
     }
 

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, enhancedData = {})
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getSingleFieldCollectionRegex())){
@@ -30,20 +40,33 @@ 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,
+                    enhancedData
                 )
             );
         }
         return processedTemplate;
     }
 
-    extractFieldValues(collectionData, fieldName)
+    async extractFieldValues(collectionData, fieldName, domain, req, systemVariables, enhancedData)
     {
         let fieldValues = '';
         for(let row of collectionData){
-            fieldValues += sc.get(row, fieldName, '');
+            let fieldValue = sc.get(row, fieldName, '');
+            if(!fieldValue){
+                continue;
+            }
+            if(!this.processAllTemplateFunctions){
+                fieldValues += fieldValue;
+                continue;
+            }
+            fieldValue = await this.processAllTemplateFunctions(fieldValue, domain, req, systemVariables, enhancedData);
+            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, enhancedData = {})
     {
         let processedTemplate = template;
         let matches = [...template.matchAll(this.getLoopCollectionStartRegex())];
@@ -62,7 +63,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
                     prevPages,
                     nextPages,
                     domain,
-                    req
+                    req,
+                    systemVariables,
+                    enhancedData
                 );
                 if(loopResult){
                     processedTemplate = loopResult;
@@ -76,7 +79,10 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 filtersJson,
                 relationsString,
                 queryOptionsJson,
-                domain
+                domain,
+                req,
+                systemVariables,
+                enhancedData
             );
             if(loopResult){
                 processedTemplate = loopResult;
@@ -92,7 +98,10 @@ class CollectionsTransformer extends CollectionsTransformerBase
         filtersJson,
         relationsString,
         queryOptionsJson,
-        domain
+        domain,
+        req,
+        systemVariables,
+        enhancedData
     ){
         return await this.processCollectionBase(
             template,
@@ -102,7 +111,10 @@ class CollectionsTransformer extends CollectionsTransformerBase
             relationsString,
             queryOptionsJson,
             domain,
-            false
+            false,
+            req,
+            systemVariables,
+            enhancedData
         );
     }
 
@@ -118,7 +130,9 @@ class CollectionsTransformer extends CollectionsTransformerBase
         prevPages,
         nextPages,
         domain,
-        req
+        req,
+        systemVariables,
+        enhancedData
     ){
         if(!req){
             Logger.warning('No request provided for pagination, falling back to regular collection');
@@ -129,7 +143,10 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 filtersJson,
                 relationsString,
                 queryOptionsJson,
-                domain
+                domain,
+                req,
+                systemVariables,
+                enhancedData
             );
         }
         return await this.processCollectionBase(
@@ -146,7 +163,10 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 prevPages,
                 nextPages,
                 req
-            }
+            },
+            req,
+            systemVariables,
+            enhancedData
         );
     }
 
@@ -158,7 +178,10 @@ class CollectionsTransformer extends CollectionsTransformerBase
         relationsString,
         queryOptionsJson,
         domain,
-        paginationOptions
+        paginationOptions,
+        req,
+        systemVariables,
+        enhancedData
     ){
         let startPos = startMatch.index;
         let startEnd = startPos + startMatch[0].length;
@@ -211,13 +234,14 @@ 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, enhancedData);
             finalContent = this.renderEngine.render(
                 1 < paginationData.totalPages
                     ? this.loadPaginationTemplate(paginationOptions.containerName, domain)
                     : '{{&collectionContentForCurrentPage}}',
                 Object.assign(
                     {},
+                    enhancedData,
                     paginationData,
                     {
                         collectionContentForCurrentPage: collectionContent,
@@ -235,7 +259,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 queryOptionsJson,
                 relationsString
             );
-            finalContent = await this.renderCollectionLoop(loopContent, collectionData, domain);
+            finalContent = await this.renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables, enhancedData);
         }
         return template.substring(0, startPos) + finalContent + template.substring(endPos + endMatch[0].length);
     }
@@ -281,36 +305,40 @@ class CollectionsTransformer extends CollectionsTransformerBase
         return '{{&collectionContentForCurrentPage}}';
     }
 
-    async renderCollectionLoop(loopContent, collectionData, domain)
+    async renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables, enhancedData)
     {
         if(!collectionData || 0 === collectionData.length){
-            return this.renderNoResultsMessage(domain);
+            return this.renderNoResultsMessage(domain, enhancedData);
         }
         let renderedContent = '';
         for(let row of collectionData){
-            renderedContent += await this.processPartialsInLoop(loopContent, row, domain);
+            renderedContent += await this.processPartialsInLoop(loopContent, row, domain, req, systemVariables, enhancedData);
         }
         return renderedContent;
     }
 
-    renderNoResultsMessage(domain)
+    renderNoResultsMessage(domain, enhancedData)
     {
         let noResultsTemplate = this.loadPartialTemplate('noResults', domain);
         if(noResultsTemplate){
             return this.renderEngine.render(
                 noResultsTemplate,
-                {
-                    message: 'No results found.',
-                    cssClass: 'no-results',
-                    alertClass: 'alert-info'
-                },
+                Object.assign(
+                    {},
+                    enhancedData,
+                    {
+                        message: 'No results found.',
+                        cssClass: 'no-results',
+                        alertClass: 'alert-info'
+                    }
+                ),
                 this.getPartials(domain)
             );
         }
         return '';
     }
 
-    async processPartialsInLoop(content, rowData, domain)
+    async processPartialsInLoop(content, rowData, domain, req, systemVariables, enhancedData)
     {
         let processedContent = content;
         let partialTags = this.findAllPartialTags(content);
@@ -322,20 +350,26 @@ 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, enhancedData);
+            }
+            let renderData = Object.assign({}, enhancedData);
             if(sc.hasOwn(tag.attributes, 'row')){
-                processedContent = processedContent.substring(0, tag.start)
-                    +this.renderEngine.render(partialContent, {row: rowData}, this.getPartials(domain))
-                    +processedContent.substring(tag.end);
-                continue;
+                renderData.row = rowData;
             }
-            let wrapperTemplate = '{{#vars}}{{> ' + tag.name + '}}{{/vars}}';
-            let renderData = { vars: tag.attributes };
-            let partials = {[tag.name]: partialContent};
-            processedContent = processedContent.substring(0, tag.start) +
-                this.renderEngine.render(wrapperTemplate, renderData, partials) +
-                processedContent.substring(tag.end);
+            for(let key of Object.keys(tag.attributes)){
+                if('row' !== key){
+                    renderData[key] = tag.attributes[key];
+                }
+            }
+            processedContent = processedContent.substring(0, tag.start)
+                +this.renderEngine.render(partialContent, renderData, this.getPartials(domain))
+                +processedContent.substring(tag.end);
+        }
+        if(this.processAllTemplateFunctions){
+            processedContent = await this.processAllTemplateFunctions(processedContent, domain, req, systemVariables, enhancedData);
         }
-        return this.renderEngine.render(processedContent, {row: rowData}, this.getPartials(domain));
+        return this.renderEngine.render(processedContent, Object.assign({}, enhancedData, {row: rowData}), this.getPartials(domain));
     }
 
     getCurrentUrl(req)

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, enhancedData = {})
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getEntityRegex())){
@@ -36,7 +36,10 @@ class EntitiesTransformer
                 match[0],
                 await this.processAllTemplateFunctions(
                     sc.get(await this.fetchEntityForTemplate(tableName, value, field), 'content', ''),
-                    domain
+                    domain,
+                    req,
+                    systemVariables,
+                    enhancedData
                 )
             );
         }