@reldens/cms 0.15.0 → 0.18.0

package/lib/template-engine.js

@@ -5,6 +5,7 @@
  */
 
 const { Logger, sc } = require('@reldens/utils');
+const { JsonFieldsParser } = require('./json-fields-parser');
 
 class TemplateEngine
 {
@@ -13,6 +14,27 @@ class TemplateEngine
     {
         this.renderEngine = sc.get(props, 'renderEngine', false);
         this.dataServer = sc.get(props, 'dataServer', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+        this.currentDomain = '';
+        this.jsonFieldsParser = new JsonFieldsParser({
+            entitiesConfig: sc.get(props, 'entitiesConfig', {})
+        });
+    }
+
+    setCurrentDomain(domain)
+    {
+        this.currentDomain = domain;
+    }
+
+    async processAllTemplateFunctions(template)
+    {
+        return await this.processCustomPartials(
+            await this.processLoopCollections(
+                await this.processSingleFieldCollections(
+                    await this.processEntityFunctions(template)
+                )
+            )
+        );
     }
 
     async render(template, data, partials)
@@ -26,37 +48,50 @@ class TemplateEngine
             return '';
         }
         return this.renderEngine.render(
-            await this.processLoopCollections(
-                await this.processSingleFieldCollections(
-                    await this.processEntityFunctions(template)
-                )
-            ),
+            this.unescapeHtml(await this.processAllTemplateFunctions(template)),
             data,
             partials
         );
     }
 
+    unescapeHtml(text)
+    {
+        return text
+            .replace(/"/g, '"')
+            .replace(/'/g, "'")
+            .replace(/'/g, "'")
+            .replace(/=/g, '=')
+            .replace(///g, '/')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&amp;/g, '&');
+    }
+
     getEntityRegex()
     {
-        return /\{\{\s*entity\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"]\s*)?\)\s*\}\}/g;
+        return /<entity\s+name="([^"]+)"(?:\s+field="([^"]+)"\s+value="([^"]+)"|\s+id="([^"]+)")?\s*\/?>/g;
     }
 
     getSingleFieldCollectionRegex()
     {
-        return /\{\{\s*collection\(\s*['"]([^'"]+)['"]\s*,\s*(\{[^}]*\})\s*,\s*['"]([^'"]+)['"]\s*\)\s*\}\}/g;
+        return /<collection\s+([^>]+)\/>/g;
     }
 
     getLoopCollectionStartRegex()
     {
-        return /\{\{\s*#collection\(\s*['"]([^'"]+)['"]\s*,\s*(\{[^}]*\})\s*\)\s*\}\}/g;
+        return /<collection\s+([^>]+)>/g;
     }
 
-    getLoopCollectionEndRegex(tableName)
+    getLoopCollectionEndRegex()
     {
-        return new RegExp('\\{\\{\\s*\\/collection\\(\\s*[\'"]'
-            +this.escapeRegex(tableName)
-            +'[\'"]\\s*\\)\\s*\\}\\}'
-        );
+        return new RegExp('<\\/collection>');
+    }
+
+    extractAttributeValue(tagContent, attributeName)
+    {
+        let regex = new RegExp(attributeName + '=([\'"])([^\'"]*)\\1');
+        let match = tagContent.match(regex);
+        return match ? match[2] : '';
     }
 
     async processEntityFunctions(template)
@@ -64,10 +99,18 @@ class TemplateEngine
         let processedTemplate = template;
         for(let match of template.matchAll(this.getEntityRegex())){
             let tableName = match[1];
-            let identifier = match[2];
-            let identifierField = match[3] || 'id';
-            let entityData = await this.fetchEntityForTemplate(tableName, identifier, identifierField);
-            processedTemplate = processedTemplate.replace(match[0], sc.get(entityData, 'content', ''));
+            let field = sc.get(match, '2', 'id');
+            let value = sc.get(match, '3', sc.get(match, '4', ''));
+            if(!value){
+                Logger.warning('Entity tag missing value: '+match[0]);
+                continue;
+            }
+            processedTemplate = processedTemplate.replace(
+                match[0],
+                await this.processAllTemplateFunctions(
+                    sc.get(await this.fetchEntityForTemplate(tableName, value, field), 'content', '')
+                )
+            );
         }
         return processedTemplate;
     }
@@ -76,13 +119,19 @@ class TemplateEngine
     {
         let processedTemplate = template;
         for(let match of template.matchAll(this.getSingleFieldCollectionRegex())){
-            let tableName = match[1];
-            let filtersJson = match[2];
-            let fieldName = match[3];
+            let tagContent = match[1];
+            if(!tagContent.includes('field=')){
+                continue;
+            }
+            let tableName = this.extractAttributeValue(tagContent, 'name');
+            let filtersJson = this.extractAttributeValue(tagContent, 'filters');
+            let queryOptionsJson = this.extractAttributeValue(tagContent, 'data');
+            let relationsString = this.extractAttributeValue(tagContent, 'relations');
+            let fieldName = this.extractAttributeValue(tagContent, 'field');
             processedTemplate = processedTemplate.replace(
                 match[0],
                 this.extractFieldValues(
-                    await this.fetchCollectionForTemplate(tableName, filtersJson),
+                    await this.fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson, relationsString),
                     fieldName
                 )
             );
@@ -96,17 +145,181 @@ class TemplateEngine
         let matches = [...template.matchAll(this.getLoopCollectionStartRegex())];
         for(let i = matches.length - 1; i >= 0; i--){
             let startMatch = matches[i];
-            let tableName = startMatch[1];
-            let filtersJson = startMatch[2];
-            let loopResult = await this.processLoopCollection(processedTemplate, startMatch, tableName, filtersJson);
-            if(false !== loopResult){
+            let tagContent = startMatch[1];
+            if(tagContent.includes('field=')){
+                continue;
+            }
+            let tableName = this.extractAttributeValue(tagContent, 'name');
+            let filtersJson = this.extractAttributeValue(tagContent, 'filters');
+            let queryOptionsJson = this.extractAttributeValue(tagContent, 'data');
+            let relationsString = this.extractAttributeValue(tagContent, 'relations');
+            let loopResult = await this.processLoopCollection(
+                processedTemplate,
+                startMatch,
+                tableName,
+                filtersJson,
+                relationsString,
+                queryOptionsJson
+            );
+            if(loopResult){
                 processedTemplate = loopResult;
             }
         }
         return processedTemplate;
     }
 
-    async processLoopCollection(template, startMatch, tableName, filtersJson)
+    async processCustomPartials(template)
+    {
+        let processedTemplate = template;
+        let partialTags = this.findAllPartialTags(template);
+        for(let i = partialTags.length - 1; i >= 0; i--){
+            let tag = partialTags[i];
+            let partialContent = this.loadPartialTemplate(tag.name);
+            if(!partialContent){
+                Logger.warning('Partial template not found: ' + tag.name);
+                processedTemplate = processedTemplate.substring(0, tag.start)+''+processedTemplate.substring(tag.end);
+                continue;
+            }
+            let wrapperTemplate = '{{#vars}}{{> ' + tag.name + '}}{{/vars}}';
+            let renderData = { vars: tag.attributes };
+            let partials = {[tag.name]: partialContent};
+            processedTemplate = processedTemplate.substring(0, tag.start) +
+                this.renderEngine.render(wrapperTemplate, renderData, partials) +
+                processedTemplate.substring(tag.end);
+        }
+        return processedTemplate;
+    }
+
+    findAllPartialTags(template)
+    {
+        let partialTags = [];
+        let pos = 0;
+        let partial = '<partial';
+        for(let tagStart = template.indexOf(partial, pos); -1 !== tagStart; tagStart=template.indexOf(partial, pos)){
+            let tagEnd = this.findPartialTagEnd(template, tagStart);
+            if(-1 === tagEnd){
+                pos = tagStart + partial.length;
+                continue;
+            }
+            let fullTag = template.substring(tagStart, tagEnd);
+            let nameMatch = fullTag.match(/name=["']([^"']+)["']/);
+            if(!nameMatch){
+                pos = tagStart + partial.length;
+                continue;
+            }
+            let partialName = nameMatch[1];
+            let attributes = this.parsePartialAttributes(fullTag, partialName);
+            partialTags.push({
+                start: tagStart,
+                end: tagEnd,
+                name: partialName,
+                attributes: attributes,
+                fullTag: fullTag
+            });
+            pos = tagEnd;
+        }
+        return partialTags;
+    }
+
+    findPartialTagEnd(template, tagStart)
+    {
+        let inQuotes = false;
+        let quoteChar = '';
+        let selfCloseTag = '/>';
+        let openCloseTag = '</partial>';
+        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;
+    }
+
+    parsePartialAttributes(fullTag, partialName)
+    {
+        let namePattern = 'name=' + this.getQuotePattern(fullTag, partialName);
+        let nameIndex = fullTag.indexOf(namePattern);
+        if(-1 === nameIndex){
+            return {};
+        }
+        let attributesStart = nameIndex + namePattern.length;
+        let attributesEnd = fullTag.lastIndexOf('/>');
+        if(-1 === attributesEnd){
+            attributesEnd = fullTag.lastIndexOf('</partial>');
+        }
+        if(-1 === attributesEnd){
+            attributesEnd = fullTag.lastIndexOf('>');
+        }
+        if(-1 === attributesEnd || attributesEnd <= attributesStart){
+            return {};
+        }
+        let attributesString = fullTag.substring(attributesStart, attributesEnd).trim();
+        return this.extractAttributesObject(attributesString);
+    }
+
+    getQuotePattern(fullTag, partialName)
+    {
+        if(fullTag.includes('name="' + partialName + '"')){
+            return '"' + partialName + '"';
+        }
+        if(fullTag.includes("name='" + partialName + "'")){
+            return "'" + partialName + "'";
+        }
+        return '"' + partialName + '"';
+    }
+
+    extractAttributesObject(attributesString)
+    {
+        if(!attributesString){
+            return {};
+        }
+        let attributes = {};
+        let valueRegex = /(\w+)=(['"])((?:(?!\2)[^\\]|\\.)*)(\2)/g;
+        for(let match of attributesString.matchAll(valueRegex)){
+            attributes[match[1]] = match[3];
+        }
+        let booleanRegex = /\b(\w+)(?!\s*=)/g;
+        for(let match of attributesString.matchAll(booleanRegex)){
+            if(!sc.hasOwn(attributes, match[1])){
+                attributes[match[1]] = true;
+            }
+        }
+        return attributes;
+    }
+
+    loadPartialTemplate(partialName)
+    {
+        if(!this.getPartials){
+            return false;
+        }
+        let partials = this.getPartials(this.currentDomain);
+        if(sc.hasOwn(partials, partialName)){
+            return partials[partialName];
+        }
+        return false;
+    }
+
+    async processLoopCollection(template, startMatch, tableName, filtersJson, relationsString, queryOptionsJson)
     {
         let startPos = startMatch.index;
         let startEnd = startPos + startMatch[0].length;
@@ -116,10 +329,14 @@ class TemplateEngine
             return false;
         }
         let endPos = startEnd + endMatch.index;
-        let renderedContent = await this.renderCollectionLoop(
-            template.substring(startEnd, endPos),
-            await this.fetchCollectionForTemplate(tableName, filtersJson)
+        let loopContent = template.substring(startEnd, endPos);
+        let collectionData = await this.fetchCollectionForTemplate(
+            tableName,
+            filtersJson,
+            queryOptionsJson,
+            relationsString
         );
+        let renderedContent = await this.renderCollectionLoop(loopContent, collectionData);
         return template.substring(0, startPos) + renderedContent + template.substring(endPos + endMatch[0].length);
     }
 
@@ -127,11 +344,39 @@ class TemplateEngine
     {
         let renderedContent = '';
         for(let row of collectionData){
-            renderedContent += this.renderEngine.render(loopContent, {row}, {});
+            renderedContent += await this.processPartialsInLoop(loopContent, row);
         }
         return renderedContent;
     }
 
+    async processPartialsInLoop(content, rowData)
+    {
+        let processedContent = content;
+        let partialTags = this.findAllPartialTags(content);
+        for(let i = partialTags.length - 1; i >= 0; i--){
+            let tag = partialTags[i];
+            let partialContent = this.loadPartialTemplate(tag.name);
+            if(!partialContent){
+                Logger.warning('Partial template not found: ' + tag.name);
+                processedContent = processedContent.substring(0, tag.start)+''+processedContent.substring(tag.end);
+                continue;
+            }
+            if(sc.hasOwn(tag.attributes, 'row')){
+                processedContent = processedContent.substring(0, tag.start)
+                    +this.renderEngine.render(partialContent, {row: rowData}, this.getPartials(this.currentDomain))
+                    +processedContent.substring(tag.end);
+                continue;
+            }
+            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);
+        }
+        return this.renderEngine.render(processedContent, {row: rowData}, this.getPartials(this.currentDomain));
+    }
+
     extractFieldValues(collectionData, fieldName)
     {
         let fieldValues = '';
@@ -141,11 +386,6 @@ class TemplateEngine
         return fieldValues;
     }
 
-    escapeRegex(string)
-    {
-        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
-
     async fetchEntityForTemplate(tableName, identifier, identifierField)
     {
         let entity = this.dataServer.getEntity(tableName);
@@ -153,21 +393,101 @@ class TemplateEngine
             Logger.warning('Entity not found in dataServer: '+tableName);
             return false;
         }
-        return await entity.loadOneBy(identifierField, identifier);
+        let result = await entity.loadOneBy(identifierField, identifier);
+        if(!result){
+            return false;
+        }
+        return this.jsonFieldsParser.parseJsonFields(
+            result,
+            this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
+        );
+    }
+
+    convertJsObjectToJson(jsObjectString)
+    {
+        if(!jsObjectString || '' === jsObjectString.trim()){
+            return '';
+        }
+        return jsObjectString.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":');
+    }
+
+    parseRelationsString(relationsString)
+    {
+        if(!relationsString || '' === relationsString.trim()){
+            return [];
+        }
+        return relationsString.split(',').map(relation => relation.trim()).filter(relation => '' !== relation);
     }
 
-    async fetchCollectionForTemplate(tableName, filtersJson)
+    async fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson, relationsString)
     {
         let entity = this.dataServer.getEntity(tableName);
         if(!entity){
             Logger.warning('Entity not found in dataServer: '+tableName);
             return [];
         }
-        let filters = sc.toJson(filtersJson);
-        if(!filters){
-            return await entity.loadAll();
+        let filters = false;
+        if(filtersJson && '' !== filtersJson.trim()){
+            let convertedFiltersJson = this.convertJsObjectToJson(filtersJson);
+            filters = sc.parseJson(convertedFiltersJson, false);
+            if(!filters){
+                Logger.warning('Invalid filters JSON: '+filtersJson);
+            }
+        }
+        let originalState = this.preserveEntityState(entity);
+        let queryOptions = {};
+        if(queryOptionsJson && '' !== queryOptionsJson.trim()){
+            let convertedOptionsJson = this.convertJsObjectToJson(queryOptionsJson);
+            queryOptions = sc.parseJson(convertedOptionsJson, {});
+            if(!queryOptions){
+                Logger.warning('Invalid query options JSON: '+queryOptionsJson);
+                queryOptions = {};
+            }
+        }
+        this.applyQueryOptions(entity, queryOptions);
+        let relations = this.parseRelationsString(relationsString);
+        let result = 0 < relations.length
+            ? await entity.loadWithRelations(filters || {}, relations)
+            : filters ? await entity.load(filters) : await entity.loadAll();
+        this.restoreEntityState(entity, originalState);
+        return this.jsonFieldsParser.parseJsonFields(
+            result,
+            this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
+        );
+    }
+
+    preserveEntityState(entity)
+    {
+        return {
+            limit: entity.limit,
+            offset: entity.offset,
+            sortBy: entity.sortBy,
+            sortDirection: entity.sortDirection
+        };
+    }
+
+    restoreEntityState(entity, originalState)
+    {
+        entity.limit = originalState.limit;
+        entity.offset = originalState.offset;
+        entity.sortBy = originalState.sortBy;
+        entity.sortDirection = originalState.sortDirection;
+    }
+
+    applyQueryOptions(entity, queryOptions)
+    {
+        if(sc.hasOwn(queryOptions, 'limit')){
+            entity.limit = queryOptions.limit;
+        }
+        if(sc.hasOwn(queryOptions, 'offset')){
+            entity.offset = queryOptions.offset;
+        }
+        if(sc.hasOwn(queryOptions, 'sortBy')){
+            entity.sortBy = queryOptions.sortBy;
+        }
+        if(sc.hasOwn(queryOptions, 'sortDirection')){
+            entity.sortDirection = queryOptions.sortDirection;
         }
-        return await entity.load(filters);
     }
 
 }

package/lib/templates-list.js

@@ -18,9 +18,11 @@ module.exports.TemplatesList = {
     sideBarItem: 'sidebar-item.html',
     paginationLink: 'pagination-link.html',
     defaultCopyRight: 'default-copyright.html',
+    cacheCleanButton: 'cache-clean-button.html',
     fields: {
         view: {
             text: 'text.html',
+            textarea: 'textarea.html',
             image: 'image.html',
             images: 'images.html',
             link: 'link.html',
@@ -37,5 +39,13 @@ module.exports.TemplatesList = {
             button: 'button.html',
             file: 'file.html'
         }
+    },
+    sections: {
+        viewForm: {
+            'cms-pages': 'cms-pages.html',
+        },
+        editForm: {
+            'cms-pages': 'cms-pages.html',
+        }
     }
 };

package/migrations/default-blocks.sql

@@ -1,7 +1,7 @@
 
 -- Default CMS blocks:
 
-REPLACE INTO `cms_blocks` (`name`, `title`, `content`, `is_active`) VALUES
+REPLACE INTO `cms_blocks` (`name`, `title`, `content`, `enabled`) VALUES
     ('header-main', 'Main Header', '{{>header}}', 1),
     ('sidebar-left', 'Left Sidebar', '<aside class="sidebar-left">{{>sidebar}}</aside>', 1),
     ('sidebar-right', 'Right Sidebar', '<aside class="sidebar-right">{{>sidebar}}</aside>', 1),

package/migrations/default-entity-access.sql

@@ -1,9 +1,9 @@
 
 -- Default entity access rules:
 
-REPLACE INTO `cms_entity_access` (`entity_name`, `is_public`, `allowed_operations`) VALUES
+REPLACE INTO `entities_access` (`entity_name`, `is_public`, `allowed_operations`) VALUES
     ('cms_pages', TRUE, '["read"]'),
     ('routes', FALSE, '[]'),
     ('users', FALSE, '[]'),
     ('cms_blocks', FALSE, '[]'),
-    ('cms_entity_access', FALSE, '[]');
+    ('entities_access', FALSE, '[]');

package/migrations/default-homepage.sql

@@ -1,10 +1,30 @@
-
 -- Default homepage:
 
--- Create a default homepage route if not exists
-REPLACE INTO `cms_pages` (`id`, `title`, `content`, `template`, `created_at`) VALUES
-(1, 'Home', '<h1>Welcome to Reldens CMS</h1><p>This is your homepage. Edit this content in the admin panel.</p>', NULL, NOW());
+-- Create a default route first
+REPLACE INTO `routes` (`id`, `path`, `router`, `cache_ttl_seconds`, `enabled`, `created_at`) VALUES (1, '/home', 'cmsPages', 3600, 1, NOW());
 
--- Create a default route to the homepage
-REPLACE INTO `routes` (`id`, `path`, `router`, `content_id`, `title`, `meta_description`, `status`, `created_at`) VALUES
-(1, '/home', 'cmsPages', 1, 'Home', 'Welcome to Reldens CMS', 'published', NOW());
+-- Create a default homepage with route_id reference
+REPLACE INTO `cms_pages` (
+    `id`, `title`, `content`, `template`, `route_id`, `meta_title`, `meta_description`,
+    `canonical_url`, `meta_robots`, `meta_og_title`, `meta_og_description`,
+    `meta_og_image`, `meta_twitter_card_type`, `status`, `locale`, `publish_date`, `expire_date`, `created_at`
+) VALUES (
+    1,
+    'Home',
+    '<h1>Welcome to Reldens CMS</h1><p>This is your homepage. Edit this content in the admin panel.</p>',
+    NULL,
+    1,
+    'Home - Reldens CMS',
+    'Welcome to Reldens CMS',
+    NULL,
+    'index,follow',
+    'Home - Reldens CMS',
+    'Welcome to the Reldens CMS homepage',
+    NULL,
+    'summary',
+    'published',
+    'en',
+    NOW(),
+    NULL,
+    NOW()
+);