@reldens/cms 0.18.0 → 0.19.0

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

@@ -0,0 +1,353 @@
+/**
+ *
+ * Reldens - CMS - CollectionsTransformer
+ *
+ */
+
+const { CollectionsTransformerBase } = require('./collections-transformer-base');
+const { PaginationHandler } = require('../pagination-handler');
+const { Logger, sc } = require('@reldens/utils');
+
+class CollectionsTransformer 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.paginationHandler = new PaginationHandler();
+    }
+
+    getLoopCollectionStartRegex()
+    {
+        return /<collection\s+([^>]+)>/g;
+    }
+
+    getLoopCollectionEndRegex()
+    {
+        return new RegExp('<\\/collection>');
+    }
+
+    async transform(template, domain, req)
+    {
+        let processedTemplate = template;
+        let matches = [...template.matchAll(this.getLoopCollectionStartRegex())];
+        for(let i = matches.length - 1; i >= 0; i--){
+            let startMatch = matches[i];
+            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 paginationId = this.extractAttributeValue(tagContent, 'pagination');
+            if(paginationId && '' !== paginationId){
+                let containerName = this.extractAttributeValue(tagContent, 'container');
+                let prevPages = this.extractAttributeValue(tagContent, 'prevPages');
+                let nextPages = this.extractAttributeValue(tagContent, 'nextPages');
+                let loopResult = await this.processPaginatedCollection(
+                    processedTemplate,
+                    startMatch,
+                    tableName,
+                    filtersJson,
+                    relationsString,
+                    queryOptionsJson,
+                    paginationId,
+                    containerName,
+                    prevPages,
+                    nextPages,
+                    domain,
+                    req
+                );
+                if(loopResult){
+                    processedTemplate = loopResult;
+                }
+                continue;
+            }
+            let loopResult = await this.processLoopCollection(
+                processedTemplate,
+                startMatch,
+                tableName,
+                filtersJson,
+                relationsString,
+                queryOptionsJson,
+                domain
+            );
+            if(loopResult){
+                processedTemplate = loopResult;
+            }
+        }
+        return processedTemplate;
+    }
+
+    async processLoopCollection(
+        template,
+        startMatch,
+        tableName,
+        filtersJson,
+        relationsString,
+        queryOptionsJson,
+        domain
+    ){
+        return await this.processCollectionBase(
+            template,
+            startMatch,
+            tableName,
+            filtersJson,
+            relationsString,
+            queryOptionsJson,
+            domain,
+            false
+        );
+    }
+
+    async processPaginatedCollection(
+        template,
+        startMatch,
+        tableName,
+        filtersJson,
+        relationsString,
+        queryOptionsJson,
+        paginationId,
+        containerName,
+        prevPages,
+        nextPages,
+        domain,
+        req
+    ){
+        if(!req){
+            Logger.warning('No request provided for pagination, falling back to regular collection');
+            return await this.processLoopCollection(
+                template,
+                startMatch,
+                tableName,
+                filtersJson,
+                relationsString,
+                queryOptionsJson,
+                domain
+            );
+        }
+        return await this.processCollectionBase(
+            template,
+            startMatch,
+            tableName,
+            filtersJson,
+            relationsString,
+            queryOptionsJson,
+            domain,
+            {
+                paginationId,
+                containerName,
+                prevPages,
+                nextPages,
+                req
+            }
+        );
+    }
+
+    async processCollectionBase(
+        template,
+        startMatch,
+        tableName,
+        filtersJson,
+        relationsString,
+        queryOptionsJson,
+        domain,
+        paginationOptions
+    ){
+        let startPos = startMatch.index;
+        let startEnd = startPos + startMatch[0].length;
+        let endMatch = this.getLoopCollectionEndRegex().exec(template.substring(startEnd));
+        if(!endMatch){
+            Logger.warning('No matching end tag found for collection: '+tableName);
+            return false;
+        }
+        let endPos = startEnd + endMatch.index;
+        let loopContent = template.substring(startEnd, endPos);
+        let collectionData;
+        let finalContent;
+        if(paginationOptions){
+            let templateParams = this.parseCollectionTemplateParams(filtersJson, queryOptionsJson);
+            let requestParams = this.paginationHandler.extractCollectionKeyFromRequest(
+                paginationOptions.req,
+                paginationOptions.paginationId
+            );
+            let mergedParams = this.paginationHandler.mergeCollectionParameters(
+                templateParams,
+                requestParams
+            );
+            mergedParams.prevPages = paginationOptions.prevPages;
+            mergedParams.nextPages = paginationOptions.nextPages;
+            let entity = this.dataServer.getEntity(tableName);
+            if(!entity){
+                Logger.warning('Entity not found in dataServer: '+tableName);
+                return template.substring(0, startPos) + '' + template.substring(endPos + endMatch[0].length);
+            }
+            let paginationData = this.paginationHandler.calculatePaginationData(
+                await this.paginationHandler.getCollectionTotal(entity, mergedParams.filters),
+                mergedParams.page,
+                mergedParams.limit,
+                this.getCurrentUrl(paginationOptions.req),
+                paginationOptions.paginationId,
+                mergedParams,
+                templateParams
+            );
+            let originalState = entity.preserveEntityState();
+            collectionData = await entity.loadEntityData(mergedParams.filters, {
+                limit: mergedParams.limit,
+                offset: paginationData.offset,
+                sortBy: mergedParams.sortBy,
+                sortDirection: mergedParams.sortDirection
+            }, relationsString);
+            entity.restoreEntityState(originalState);
+            if(this.jsonFieldsParser){
+                collectionData = this.jsonFieldsParser.parseJsonFields(
+                    collectionData,
+                    this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
+                );
+            }
+            let collectionContent = await this.renderCollectionLoop(loopContent, collectionData, domain);
+            finalContent = this.renderEngine.render(
+                1 < paginationData.totalPages
+                    ? this.loadPaginationTemplate(paginationOptions.containerName, domain)
+                    : '{{&collectionContentForCurrentPage}}',
+                Object.assign(
+                    {},
+                    paginationData,
+                    {
+                        collectionContentForCurrentPage: collectionContent,
+                        hasResults: collectionData && 0 < collectionData.length,
+                        noResultsMessage: 'No items found.'
+                    }
+                ),
+                this.getPartials(domain)
+            );
+        }
+        if(!paginationOptions){
+            collectionData = await this.fetchCollectionForTemplate(
+                tableName,
+                filtersJson,
+                queryOptionsJson,
+                relationsString
+            );
+            finalContent = await this.renderCollectionLoop(loopContent, collectionData, domain);
+        }
+        return template.substring(0, startPos) + finalContent + template.substring(endPos + endMatch[0].length);
+    }
+
+    parseCollectionTemplateParams(filtersJson, queryOptionsJson)
+    {
+        let filters = {};
+        let queryOptions = {};
+        if(filtersJson && '' !== filtersJson.trim()){
+            let convertedFiltersJson = this.convertJsObjectToJson(filtersJson);
+            filters = sc.parseJson(convertedFiltersJson, {});
+            if(!filters){
+                Logger.warning('Invalid filters JSON: '+filtersJson);
+                filters = {};
+            }
+        }
+        if(queryOptionsJson && '' !== queryOptionsJson.trim()){
+            let convertedOptionsJson = this.convertJsObjectToJson(queryOptionsJson);
+            queryOptions = sc.parseJson(convertedOptionsJson, {});
+            if(!queryOptions){
+                Logger.warning('Invalid query options JSON: '+queryOptionsJson);
+                queryOptions = {};
+            }
+        }
+        return {
+            filters,
+            limit: sc.get(queryOptions, 'limit', 10),
+            sortBy: sc.get(queryOptions, 'sortBy', 'id'),
+            sortDirection: sc.get(queryOptions, 'sortDirection', 'asc')
+        };
+    }
+
+    loadPaginationTemplate(containerName, domain)
+    {
+        if(!containerName || '' === containerName){
+            containerName = 'pagedCollection';
+        }
+        let partialContent = this.loadPartialTemplate(containerName, domain);
+        if(partialContent){
+            return partialContent;
+        }
+        Logger.critical('Pagination template not found: ' + containerName + '. Please create the template file.');
+        return '{{&collectionContentForCurrentPage}}';
+    }
+
+    async renderCollectionLoop(loopContent, collectionData, domain)
+    {
+        if(!collectionData || 0 === collectionData.length){
+            return this.renderNoResultsMessage(domain);
+        }
+        let renderedContent = '';
+        for(let row of collectionData){
+            renderedContent += await this.processPartialsInLoop(loopContent, row, domain);
+        }
+        return renderedContent;
+    }
+
+    renderNoResultsMessage(domain)
+    {
+        let noResultsTemplate = this.loadPartialTemplate('noResults', domain);
+        if(noResultsTemplate){
+            return this.renderEngine.render(
+                noResultsTemplate,
+                {
+                    message: 'No results found.',
+                    cssClass: 'no-results',
+                    alertClass: 'alert-info'
+                },
+                this.getPartials(domain)
+            );
+        }
+        return '';
+    }
+
+    async processPartialsInLoop(content, rowData, domain)
+    {
+        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, domain);
+            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(domain))
+                    +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(domain));
+    }
+
+    getCurrentUrl(req)
+    {
+        if(!req){
+            return '';
+        }
+        return sc.get(req, 'protocol', 'http') + '://'
+            + (req.get('host') || 'localhost')
+            + sc.get(req, 'originalUrl', sc.get(req, 'path', '/')).split('?')[0];
+    }
+
+}
+
+module.exports.CollectionsTransformer = CollectionsTransformer;

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

@@ -0,0 +1,65 @@
+/**
+ *
+ * Reldens - CMS - EntitiesTransformer
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class EntitiesTransformer
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.jsonFieldsParser = sc.get(props, 'jsonFieldsParser', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
+    }
+
+    getEntityRegex()
+    {
+        return /<entity\s+name="([^"]+)"(?:\s+field="([^"]+)"\s+value="([^"]+)"|\s+id="([^"]+)")?\s*\/?>/g;
+    }
+
+    async transform(template, domain)
+    {
+        let processedTemplate = template;
+        for(let match of template.matchAll(this.getEntityRegex())){
+            let tableName = match[1];
+            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', ''),
+                    domain
+                )
+            );
+        }
+        return processedTemplate;
+    }
+
+    async fetchEntityForTemplate(tableName, identifier, identifierField)
+    {
+        let entity = this.dataServer.getEntity(tableName);
+        if(!entity){
+            Logger.warning('Entity not found in dataServer: '+tableName);
+            return false;
+        }
+        let result = await entity.loadOneBy(identifierField, identifier);
+        if(!result){
+            return false;
+        }
+        return this.jsonFieldsParser.parseJsonFields(
+            result,
+            this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
+        );
+    }
+
+}
+
+module.exports.EntitiesTransformer = EntitiesTransformer;

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

@@ -0,0 +1,171 @@
+/**
+ *
+ * Reldens - CMS - PartialsTransformer
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class PartialsTransformer
+{
+
+    constructor(props)
+    {
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+    }
+
+    async transform(template, domain)
+    {
+        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, domain);
+            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, domain)
+    {
+        if(!this.getPartials){
+            return false;
+        }
+        let partials = this.getPartials(domain);
+        if(sc.hasOwn(partials, partialName)){
+            return partials[partialName];
+        }
+        return false;
+    }
+
+}
+
+module.exports.PartialsTransformer = PartialsTransformer;