@reldens/cms 0.20.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;
     }
@@ -485,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/collections-single-transformer.js

@@ -25,7 +25,7 @@ class CollectionsSingleTransformer extends CollectionsTransformerBase
         return /<collection\s+([^>]+)\/>/g;
     }
 
-    async transform(template, domain, req, systemVariables)
+    async transform(template, domain, req, systemVariables, enhancedData = {})
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getSingleFieldCollectionRegex())){
@@ -45,21 +45,27 @@ class CollectionsSingleTransformer extends CollectionsTransformerBase
                     fieldName,
                     domain,
                     req,
-                    systemVariables
+                    systemVariables,
+                    enhancedData
                 )
             );
         }
         return processedTemplate;
     }
 
-    async extractFieldValues(collectionData, fieldName, domain, req, systemVariables)
+    async extractFieldValues(collectionData, fieldName, domain, req, systemVariables, enhancedData)
     {
         let fieldValues = '';
         for(let row of collectionData){
             let fieldValue = sc.get(row, fieldName, '');
-            if(fieldValue && this.processAllTemplateFunctions){
-                fieldValue = await this.processAllTemplateFunctions(fieldValue, domain, req, systemVariables);
+            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

@@ -32,7 +32,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
         return new RegExp('<\\/collection>');
     }
 
-    async transform(template, domain, req, systemVariables)
+    async transform(template, domain, req, systemVariables, enhancedData = {})
     {
         let processedTemplate = template;
         let matches = [...template.matchAll(this.getLoopCollectionStartRegex())];
@@ -64,7 +64,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
                     nextPages,
                     domain,
                     req,
-                    systemVariables
+                    systemVariables,
+                    enhancedData
                 );
                 if(loopResult){
                     processedTemplate = loopResult;
@@ -80,7 +81,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 queryOptionsJson,
                 domain,
                 req,
-                systemVariables
+                systemVariables,
+                enhancedData
             );
             if(loopResult){
                 processedTemplate = loopResult;
@@ -98,7 +100,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
         queryOptionsJson,
         domain,
         req,
-        systemVariables
+        systemVariables,
+        enhancedData
     ){
         return await this.processCollectionBase(
             template,
@@ -110,7 +113,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
             domain,
             false,
             req,
-            systemVariables
+            systemVariables,
+            enhancedData
         );
     }
 
@@ -127,7 +131,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
         nextPages,
         domain,
         req,
-        systemVariables
+        systemVariables,
+        enhancedData
     ){
         if(!req){
             Logger.warning('No request provided for pagination, falling back to regular collection');
@@ -140,7 +145,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 queryOptionsJson,
                 domain,
                 req,
-                systemVariables
+                systemVariables,
+                enhancedData
             );
         }
         return await this.processCollectionBase(
@@ -159,7 +165,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 req
             },
             req,
-            systemVariables
+            systemVariables,
+            enhancedData
         );
     }
 
@@ -173,7 +180,8 @@ class CollectionsTransformer extends CollectionsTransformerBase
         domain,
         paginationOptions,
         req,
-        systemVariables
+        systemVariables,
+        enhancedData
     ){
         let startPos = startMatch.index;
         let startEnd = startPos + startMatch[0].length;
@@ -226,13 +234,14 @@ class CollectionsTransformer extends CollectionsTransformerBase
                     this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
                 );
             }
-            let collectionContent = await this.renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables);
+            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,
@@ -250,7 +259,7 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 queryOptionsJson,
                 relationsString
             );
-            finalContent = await this.renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables);
+            finalContent = await this.renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables, enhancedData);
         }
         return template.substring(0, startPos) + finalContent + template.substring(endPos + endMatch[0].length);
     }
@@ -296,36 +305,40 @@ class CollectionsTransformer extends CollectionsTransformerBase
         return '{{&collectionContentForCurrentPage}}';
     }
 
-    async renderCollectionLoop(loopContent, collectionData, domain, req, systemVariables)
+    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, req, systemVariables);
+            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, req, systemVariables)
+    async processPartialsInLoop(content, rowData, domain, req, systemVariables, enhancedData)
     {
         let processedContent = content;
         let partialTags = this.findAllPartialTags(content);
@@ -338,25 +351,25 @@ class CollectionsTransformer extends CollectionsTransformerBase
                 continue;
             }
             if(this.processAllTemplateFunctions){
-                partialContent = await this.processAllTemplateFunctions(partialContent, domain, req, systemVariables);
+                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;
+            }
+            for(let key of Object.keys(tag.attributes)){
+                if('row' !== key){
+                    renderData[key] = tag.attributes[key];
+                }
             }
-            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);
+            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);
+            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/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, req, systemVariables)
+    async transform(template, domain, req, systemVariables, enhancedData = {})
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getEntityRegex())){
@@ -38,7 +38,8 @@ class EntitiesTransformer
                     sc.get(await this.fetchEntityForTemplate(tableName, value, field), 'content', ''),
                     domain,
                     req,
-                    systemVariables
+                    systemVariables,
+                    enhancedData
                 )
             );
         }

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

@@ -16,7 +16,7 @@ class PartialsTransformer
         this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
     }
 
-    async transform(template, domain, req, systemVariables)
+    async transform(template, domain, req, systemVariables, enhancedData = {})
     {
         let processedTemplate = template;
         let partialTags = this.findAllPartialTags(template);
@@ -29,13 +29,12 @@ class PartialsTransformer
                 continue;
             }
             if(this.processAllTemplateFunctions){
-                partialContent = await this.processAllTemplateFunctions(partialContent, domain, req, systemVariables);
+                partialContent = await this.processAllTemplateFunctions(partialContent, domain, req, systemVariables, enhancedData);
             }
-            let wrapperTemplate = '{{#vars}}{{> ' + tag.name + '}}{{/vars}}';
-            let renderData = { vars: tag.attributes };
-            let partials = {[tag.name]: partialContent};
+            let partialData = Object.assign({}, enhancedData, tag.attributes);
+            let renderedPartial = this.renderEngine.render(partialContent, partialData, {});
             processedTemplate = processedTemplate.substring(0, tag.start) +
-                this.renderEngine.render(wrapperTemplate, renderData, partials) +
+                renderedPartial +
                 processedTemplate.substring(tag.end);
         }
         return processedTemplate;

package/lib/template-engine/system-variables-provider.js

@@ -89,6 +89,7 @@ class SystemVariablesProvider
 
     buildSystemInfo()
     {
+        let date = new Date();
         return {
             projectRoot: this.projectRoot,
             publicPath: this.publicPath,
@@ -96,7 +97,9 @@ class SystemVariablesProvider
             platform: process.platform,
             environment: process.env.NODE_ENV || 'development',
             timestamp: sc.getCurrentDate(),
-            uptime: process.uptime()
+            uptime: process.uptime(),
+            currentDate: sc.formatDate(date),
+            currentYear: sc.formatDate(date, 'Y')
         };
     }
 

package/lib/template-engine.js

@@ -59,7 +59,8 @@ class TemplateEngine
         });
         this.partialsTransformer = new PartialsTransformer({
             renderEngine: this.renderEngine,
-            getPartials: this.getPartials
+            getPartials: this.getPartials,
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
         });
         this.urlTransformer = new UrlTransformer();
         this.assetTransformer = new AssetTransformer();
@@ -83,13 +84,17 @@ class TemplateEngine
         ];
     }
 
-    async processAllTemplateFunctions(template, domain, req, systemVariables)
+    async processAllTemplateFunctions(template, domain, req, systemVariables, enhancedData = {})
     {
         let processedTemplate = template;
         for(let transformer of this.transformers){
-            if(sc.isFunction(transformer.transform)){
-                processedTemplate = await transformer.transform(processedTemplate, domain, req, systemVariables);
+            if(!transformer){
+                continue;
+            }
+            if(!sc.isFunction(transformer.transform)){
+                continue;
             }
+            processedTemplate = await transformer.transform(processedTemplate, domain, req, systemVariables, enhancedData);
         }
         return processedTemplate;
     }
@@ -134,7 +139,8 @@ class TemplateEngine
             beforeProcessData.content,
             domain,
             req,
-            eventData.variables
+            eventData.variables,
+            enhancedData
         );
         let afterProcessData = {
             processedContent: processedTemplate,