@reldens/cms 0.20.0 → 0.23.0

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

@@ -0,0 +1,187 @@
+/**
+ *
+ * Reldens - CMS - FormsTransformer
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class FormsTransformer
+{
+
+    constructor(props)
+    {
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
+        this.dynamicForm = sc.get(props, 'dynamicForm', false);
+        this.dynamicFormRenderer = sc.get(props, 'dynamicFormRenderer', false);
+        this.events = sc.get(props, 'events', false);
+        if(!this.events){
+            Logger.error('EventsManager not provided to FormsTransformer - forms functionality disabled');
+            this.isDisabled = true;
+        }
+    }
+
+    async transform(template, domain, req, systemVariables, enhancedData = {})
+    {
+        if(this.isDisabled){
+            return template;
+        }
+        let processedTemplate = template;
+        let formTags = this.findAllFormTags(template);
+        for(let i = formTags.length - 1; i >= 0; i--){
+            let tag = formTags[i];
+            let formKey = sc.get(tag.attributes, 'key', '');
+            if(!formKey){
+                Logger.warning('cmsForm tag missing key attribute');
+                processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
+                continue;
+            }
+            let formConfig = await this.dynamicForm.getFormConfig(formKey);
+            if(!formConfig){
+                Logger.warning('Form not found or disabled: '+formKey);
+                processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
+                continue;
+            }
+            let fieldsToRender = this.parseFieldsFilter(tag.attributes, formConfig);
+            if(!sc.isArray(fieldsToRender) || 0 === fieldsToRender.length){
+                processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
+                continue;
+            }
+            await this.events.emit('reldens.formsTransformer.beforeRender', {
+                formKey,
+                formConfig,
+                fieldsToRender,
+                formAttributes: tag.attributes,
+                domain,
+                req,
+                systemVariables,
+                enhancedData
+            });
+            let formContent = await this.dynamicFormRenderer.renderForm(
+                formConfig,
+                fieldsToRender,
+                domain,
+                req,
+                Object.assign({}, tag.attributes, {
+                    successRedirect: sc.get(tag.attributes, 'successRedirect', req.path),
+                    errorRedirect: sc.get(tag.attributes, 'errorRedirect', req.path)
+                }),
+                systemVariables,
+                enhancedData
+            );
+            await this.events.emit('reldens.formsTransformer.afterRender', {
+                formKey,
+                formConfig,
+                formContent,
+                domain,
+                req,
+                systemVariables,
+                enhancedData
+            });
+            processedTemplate = processedTemplate.substring(0, tag.start) +
+                formContent +
+                processedTemplate.substring(tag.end);
+        }
+        return processedTemplate;
+    }
+
+    findAllFormTags(template)
+    {
+        let formTags = [];
+        let pos = 0;
+        let cmsForm = '<cmsForm';
+        for(let tagStart = template.indexOf(cmsForm, pos); -1 !== tagStart; tagStart=template.indexOf(cmsForm, pos)){
+            let tagEnd = this.findFormTagEnd(template, tagStart);
+            if(-1 === tagEnd){
+                pos = tagStart + cmsForm.length;
+                continue;
+            }
+            let fullTag = template.substring(tagStart, tagEnd);
+            let attributes = this.parseFormAttributes(fullTag);
+            formTags.push({
+                start: tagStart,
+                end: tagEnd,
+                attributes: attributes,
+                fullTag: fullTag
+            });
+            pos = tagEnd;
+        }
+        return formTags;
+    }
+
+    findFormTagEnd(template, tagStart)
+    {
+        let inQuotes = false;
+        let quoteChar = '';
+        let selfCloseTag = '/>';
+        let openCloseTag = '</cmsForm>';
+        for(let i = tagStart; i < template.length; i++){
+            let char = template[i];
+            if(!inQuotes && ('"' === char || "'" === char)){
+                inQuotes = true;
+                quoteChar = char;
+                continue;
+            }
+            if(inQuotes && char === quoteChar && '\\' !== template[i - 1]){
+                inQuotes = false;
+                quoteChar = '';
+                continue;
+            }
+            if(!inQuotes){
+                if(template.substring(i, i + selfCloseTag.length) === selfCloseTag){
+                    return i + selfCloseTag.length;
+                }
+                if('>' === char){
+                    let closeIndex = template.indexOf(openCloseTag, i);
+                    if(-1 !== closeIndex){
+                        return closeIndex + openCloseTag.length;
+                    }
+                    return i + 1;
+                }
+            }
+        }
+        return -1;
+    }
+
+    parseFormAttributes(fullTag)
+    {
+        let attributes = {};
+        let valueRegex = /(\w+)=(['"])((?:(?!\2)[^\\]|\\.)*)(\2)/g;
+        for(let match of fullTag.matchAll(valueRegex)){
+            attributes[match[1]] = match[3];
+        }
+        let booleanRegex = /\b(\w+)(?!\s*=)/g;
+        for(let match of fullTag.matchAll(booleanRegex)){
+            if(!sc.hasOwn(attributes, match[1]) && 'cmsForm' !== match[1]){
+                attributes[match[1]] = true;
+            }
+        }
+        return attributes;
+    }
+
+    parseFieldsFilter(attributes, formConfig)
+    {
+        let fieldsFilter = sc.get(attributes, 'fields', '');
+        if(!fieldsFilter){
+            return formConfig.fields_schema;
+        }
+        let fieldsSchema = sc.isString(formConfig.fields_schema) ? sc.toJson(formConfig.fields_schema) : formConfig.fields_schema;
+        if(!sc.isArray(fieldsSchema)){
+            return [];
+        }
+        let requestedFields = fieldsFilter.split(',').map(f => f.trim()).filter(f => '' !== f);
+        let filteredFields = [];
+        for(let fieldName of requestedFields){
+            let field = sc.fetchByProperty(fieldsSchema, 'name', fieldName);
+            if(field){
+                filteredFields.push(field);
+            }
+        }
+        return filteredFields;
+    }
+
+}
+
+module.exports.FormsTransformer = FormsTransformer;

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

@@ -9,6 +9,7 @@ const { EntitiesTransformer } = require('./template-engine/entities-transformer'
 const { CollectionsTransformer } = require('./template-engine/collections-transformer');
 const { CollectionsSingleTransformer } = require('./template-engine/collections-single-transformer');
 const { PartialsTransformer } = require('./template-engine/partials-transformer');
+const { FormsTransformer } = require('./template-engine/forms-transformer');
 const { UrlTransformer } = require('./template-engine/url-transformer');
 const { AssetTransformer } = require('./template-engine/asset-transformer');
 const { DateTransformer } = require('./template-engine/date-transformer');
@@ -28,6 +29,8 @@ class TemplateEngine
         this.defaultDomain = sc.get(props, 'defaultDomain', 'default');
         this.projectRoot = sc.get(props, 'projectRoot', './');
         this.publicPath = sc.get(props, 'publicPath', './public');
+        this.dynamicForm = sc.get(props, 'dynamicForm', false);
+        this.dynamicFormRenderer = sc.get(props, 'dynamicFormRenderer', false);
         this.jsonFieldsParser = new JsonFieldsParser({entitiesConfig: sc.get(props, 'entitiesConfig', {})});
         this.systemVariablesProvider = new SystemVariablesProvider({
             defaultDomain: this.defaultDomain,
@@ -59,8 +62,20 @@ class TemplateEngine
         });
         this.partialsTransformer = new PartialsTransformer({
             renderEngine: this.renderEngine,
-            getPartials: this.getPartials
+            getPartials: this.getPartials,
+            processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this)
         });
+        this.formsTransformer = false;
+        if(this.dynamicForm && this.dynamicFormRenderer){
+            this.formsTransformer = new FormsTransformer({
+                renderEngine: this.renderEngine,
+                getPartials: this.getPartials,
+                processAllTemplateFunctions: this.processAllTemplateFunctions.bind(this),
+                dynamicForm: this.dynamicForm,
+                dynamicFormRenderer: this.dynamicFormRenderer,
+                events: this.events
+            });
+        }
         this.urlTransformer = new UrlTransformer();
         this.assetTransformer = new AssetTransformer();
         this.dateTransformer = new DateTransformer({
@@ -81,15 +96,22 @@ class TemplateEngine
             this.dateTransformer,
             this.translateTransformer
         ];
+        if(this.formsTransformer){
+            this.transformers.push(this.formsTransformer);
+        }
     }
 
-    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 +156,8 @@ class TemplateEngine
             beforeProcessData.content,
             domain,
             req,
-            eventData.variables
+            eventData.variables,
+            enhancedData
         );
         let afterProcessData = {
             processedContent: processedTemplate,

package/lib/template-reloader.js

@@ -0,0 +1,307 @@
+/**
+ *
+ * Reldens - CMS - TemplateReloader
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { sc } = require('@reldens/utils');
+
+class TemplateReloader
+{
+
+    constructor(props = {})
+    {
+        this.reloadTime = sc.get(props, 'reloadTime', 0);
+        this.events = sc.get(props, 'events', false);
+        this.fileTracking = {};
+        this.reloadInterval = false;
+        this.isActive = -1 === this.reloadTime || 0 < this.reloadTime;
+        this.adminTemplatesLoader = sc.get(props, 'adminTemplatesLoader', false);
+        this.mappedAdminTemplates = sc.get(props, 'mappedAdminTemplates', {});
+        this.templatesPath = sc.get(props, 'templatesPath', '');
+        this.templateExtensions = sc.get(props, 'templateExtensions', []);
+        this.setupReloadInterval();
+    }
+
+    setupReloadInterval()
+    {
+        if(0 >= this.reloadTime){
+            return true;
+        }
+        if(this.reloadInterval){
+            clearInterval(this.reloadInterval);
+        }
+        this.reloadInterval = setInterval(() => {
+            this.checkAndReloadChangedTemplates();
+        }, this.reloadTime);
+    }
+
+    iterateTemplateFiles(templatesPaths, callback)
+    {
+        if(!templatesPaths){
+            return false;
+        }
+        if(sc.isString(templatesPaths)){
+            return callback(templatesPaths);
+        }
+        if(Array.isArray(templatesPaths)){
+            let result = false;
+            for(let filePath of templatesPaths){
+                if(callback(filePath)){
+                    result = true;
+                }
+            }
+            return result;
+        }
+        if(sc.isObject(templatesPaths)){
+            let result = false;
+            for(let key of Object.keys(templatesPaths)){
+                let templateData = templatesPaths[key];
+                if(sc.isObject(templateData)){
+                    if(this.iterateTemplateFiles(templateData, callback)){
+                        result = true;
+                    }
+                    continue;
+                }
+                if(callback(templateData)){
+                    result = true;
+                }
+            }
+            return result;
+        }
+        return false;
+    }
+
+    trackTemplateFiles(templatesPaths)
+    {
+        if(0 === this.reloadTime){
+            return true;
+        }
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            if(!FileHandler.exists(filePath)){
+                return false;
+            }
+            let modTime = FileHandler.getFileModificationTime(filePath);
+            if(!modTime){
+                return false;
+            }
+            this.fileTracking[filePath] = {
+                lastModified: modTime,
+                isChanged: false
+            };
+            return true;
+        });
+    }
+
+    checkTemplateChanges(templatesPaths)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            if(!FileHandler.exists(filePath)){
+                return false;
+            }
+            let trackedFile = this.fileTracking[filePath];
+            if(!trackedFile){
+                this.trackTemplateFiles(filePath);
+                return false;
+            }
+            let currentModTime = FileHandler.getFileModificationTime(filePath);
+            if(!currentModTime){
+                return false;
+            }
+            if(currentModTime.getTime() > trackedFile.lastModified.getTime()){
+                if(-1 !== this.reloadTime){
+                    trackedFile.lastModified = currentModTime;
+                }
+                trackedFile.isChanged = true;
+                return true;
+            }
+            return false;
+        });
+    }
+
+    hasChangedTemplates(templatesPaths)
+    {
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            let trackedFile = this.fileTracking[filePath];
+            return trackedFile ? trackedFile.isChanged : false;
+        });
+    }
+
+    markTemplatesAsReloaded(templatesPaths)
+    {
+        if(0 === this.reloadTime){
+            return true;
+        }
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            let trackedFile = this.fileTracking[filePath];
+            if(trackedFile){
+                trackedFile.isChanged = false;
+            }
+            return true;
+        });
+    }
+
+    shouldReloadAdminTemplates(mappedAdminTemplates)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        if(-1 === this.reloadTime){
+            return this.checkTemplateChanges(mappedAdminTemplates);
+        }
+        return this.hasChangedTemplates(mappedAdminTemplates);
+    }
+
+    shouldReloadFrontendTemplates(templatesPath, templateExtensions)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        let templateFiles = this.collectTemplateFiles(templatesPath, templateExtensions);
+        if(-1 === this.reloadTime){
+            return this.checkTemplateChanges(templateFiles);
+        }
+        return this.hasChangedTemplates(templateFiles);
+    }
+
+    collectTemplateFiles(templatesPath, templateExtensions)
+    {
+        let templateFiles = [];
+        if(!FileHandler.exists(templatesPath)){
+            return templateFiles;
+        }
+        let partialsPath = FileHandler.joinPaths(templatesPath, 'partials');
+        if(FileHandler.exists(partialsPath)){
+            let partialFiles = FileHandler.getFilesInFolder(partialsPath, templateExtensions);
+            for(let file of partialFiles){
+                templateFiles.push(FileHandler.joinPaths(partialsPath, file));
+            }
+        }
+        let domainsPath = FileHandler.joinPaths(templatesPath, 'domains');
+        if(FileHandler.exists(domainsPath)){
+            let domainFolders = FileHandler.fetchSubFoldersList(domainsPath);
+            for(let domain of domainFolders){
+                let domainPath = FileHandler.joinPaths(domainsPath, domain);
+                let domainPartialsPath = FileHandler.joinPaths(domainPath, 'partials');
+                if(FileHandler.exists(domainPartialsPath)){
+                    let domainPartialFiles = FileHandler.getFilesInFolder(domainPartialsPath, templateExtensions);
+                    for(let file of domainPartialFiles){
+                        templateFiles.push(FileHandler.joinPaths(domainPartialsPath, file));
+                    }
+                }
+            }
+        }
+        return templateFiles;
+    }
+
+    checkAndReloadChangedTemplates()
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        let hasChanges = false;
+        for(let filePath of Object.keys(this.fileTracking)){
+            if(this.checkTemplateChanges(filePath)){
+                hasChanges = true;
+            }
+        }
+        if(hasChanges && this.events){
+            this.events.emit('reldens.templateReloader.templatesChanged', {
+                reloader: this,
+                changedFiles: this.getChangedFiles()
+            });
+        }
+        return hasChanges;
+    }
+
+    getChangedFiles()
+    {
+        let changedFiles = [];
+        for(let filePath of Object.keys(this.fileTracking)){
+            let trackedFile = this.fileTracking[filePath];
+            if(trackedFile && trackedFile.isChanged){
+                changedFiles.push(filePath);
+            }
+        }
+        return changedFiles;
+    }
+
+    destroy()
+    {
+        if(this.reloadInterval){
+            clearInterval(this.reloadInterval);
+            this.reloadInterval = false;
+        }
+        this.fileTracking = {};
+    }
+
+    async checkAndReloadAdminTemplates()
+    {
+        if(!this.adminTemplatesLoader){
+            return false;
+        }
+        if(!this.shouldReloadAdminTemplates(this.mappedAdminTemplates)){
+            return false;
+        }
+        let newAdminFilesContents = await this.adminTemplatesLoader.fetchAdminFilesContents(this.mappedAdminTemplates);
+        if(!newAdminFilesContents){
+            return false;
+        }
+        this.markTemplatesAsReloaded(this.mappedAdminTemplates);
+        return newAdminFilesContents;
+    }
+
+    async checkAndReloadFrontendTemplates()
+    {
+        if(!this.shouldReloadFrontendTemplates(this.templatesPath, this.templateExtensions)){
+            return false;
+        }
+        let templateFiles = this.collectTemplateFiles(this.templatesPath, this.templateExtensions);
+        this.markTemplatesAsReloaded(templateFiles);
+        return true;
+    }
+
+    async updateAdminContentsAfterReload(newAdminFilesContents, adminManager)
+    {
+        if(!newAdminFilesContents || !adminManager){
+            return false;
+        }
+        adminManager.adminFilesContents = newAdminFilesContents;
+        adminManager.contentsBuilder.adminFilesContents = newAdminFilesContents;
+        adminManager.routerContents.adminFilesContents = newAdminFilesContents;
+        adminManager.addCacheButtonSubscriber.cacheCleanButton = newAdminFilesContents.cacheCleanButton;
+        adminManager.addCacheButtonSubscriber.clearAllCacheButton = newAdminFilesContents.clearAllCacheButton;
+        await adminManager.contentsBuilder.buildAdminContents();
+        return true;
+    }
+
+    async handleAdminTemplateReload(adminManager)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        let reloadedContents = await this.checkAndReloadAdminTemplates();
+        if(reloadedContents){
+            await this.updateAdminContentsAfterReload(reloadedContents, adminManager);
+        }
+        return reloadedContents;
+    }
+
+    async handleFrontendTemplateReload(templateCache, templateResolver)
+    {
+        let reloadResult = await this.checkAndReloadFrontendTemplates();
+        if(reloadResult){
+            await templateCache.loadPartials();
+            await templateCache.setupDomainTemplates();
+            templateResolver.domainTemplatesMap = templateCache.getDomainTemplatesMap();
+        }
+        return reloadResult;
+    }
+
+}
+
+module.exports.TemplateReloader = TemplateReloader;

package/lib/templates-list.js

@@ -22,6 +22,8 @@ module.exports.TemplatesList = {
     clearAllCacheButton: 'clear-all-cache-button.html',
     fields: {
         view: {
+            audio: 'audio.html',
+            audios: 'audios.html',
             text: 'text.html',
             textarea: 'textarea.html',
             image: 'image.html',

package/migrations/default-forms.sql

@@ -0,0 +1,22 @@
+
+-- Default CMS Forms
+
+CREATE TABLE `cms_forms` (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `form_key` VARCHAR(255) NOT NULL COLLATE 'utf8mb4_0900_ai_ci',
+    `fields_schema` JSON NOT NULL,
+    `enabled` TINYINT UNSIGNED NOT NULL DEFAULT '0',
+    `created_at` TIMESTAMP NOT NULL DEFAULT (NOW()),
+    `updated_at` TIMESTAMP NOT NULL DEFAULT (NOW()) ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`id`) USING BTREE,
+    UNIQUE INDEX `form_key` (`form_key`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+
+
+CREATE TABLE `cms_forms_submitted` (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `form_id` INT UNSIGNED NOT NULL,
+    `submitted_values` JSON NOT NULL,
+    PRIMARY KEY (`id`) USING BTREE,
+    INDEX `FK__cms_forms` (`form_id`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.20.0",
+    "version": "0.23.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -33,10 +33,10 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.21.0",
-        "@reldens/storage": "^0.61.0",
-        "@reldens/utils": "^0.50.0",
-        "dotenv": "^17.0.1",
+        "@reldens/server-utils": "^0.24.0",
+        "@reldens/storage": "^0.65.0",
+        "@reldens/utils": "^0.52.0",
+        "dotenv": "^17.2.1",
         "mustache": "^4.2.0"
     }
 }

package/templates/{browserconfig.xml → assets/favicons/default/browserconfig.xml}

@@ -2,7 +2,7 @@
 <browserconfig>
     <msapplication>
         <tile>
-            <square150x150logo src="/assets/favicons/mstile-150x150.png"/>
+            <square150x150logo src="/assets/favicons/default/mstile-150x150.png"/>
             <TileColor>#000000</TileColor>
         </tile>
     </msapplication>