@reldens/cms 0.18.0 → 0.20.0

package/lib/search.js

@@ -0,0 +1,344 @@
+/**
+ *
+ * Reldens - CMS - Search
+ *
+ */
+
+const { PaginationHandler } = require('./pagination-handler');
+const { Logger, sc } = require('@reldens/utils');
+
+class Search
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.jsonFieldsParser = sc.get(props, 'jsonFieldsParser', false);
+        this.paginationHandler = new PaginationHandler();
+        this.defaultSetKey = 'cmsPagesSearch';
+        this.searchSets = sc.get(props, 'searchSets', {
+            cmsPagesSearch: {
+                entities: [{
+                    name: 'cmsPages',
+                    fields: [
+                        'title',
+                        'content',
+                        'json_data',
+                        'meta_title',
+                        'meta_description',
+                        'meta_og_title',
+                        'meta_og_description'
+                    ],
+                    relations: 'routes'
+                }],
+                pagination: {active: true, limit: 20, sortBy: 'publish_date', sortDirection: 'desc'}
+            }
+        });
+        this.defaultRenderConfig = {
+            page: 'page',
+            layout: 'search',
+            paginationContainer: 'pagedCollection',
+            partial: 'entriesListView'
+        };
+    }
+
+    parseSearchParameters(query)
+    {
+        let setKey = sc.get(query, 'set-key', this.defaultSetKey);
+        let config = sc.get(this.searchSets, setKey, false);
+        if(!config){
+            Logger.error('Search set not found: ' + setKey);
+            return false;
+        }
+        config = sc.deepJsonClone(config);
+        if(!sc.hasOwn(config, 'entities')){
+            config.entities = [];
+        }
+        if(!sc.hasOwn(config, 'pagination')){
+            config.pagination = {active: false};
+        }
+        config = this.parseEntityParameters(query, config);
+        config = this.parseSearchTerms(query, config);
+        config = this.parseRelationsParameters(query, config);
+        config = this.parsePaginationParameters(query, config);
+        config = this.parseRenderParameters(query, config);
+        return config;
+    }
+
+    parseRelationsParameters(query, config)
+    {
+        for(let i = 0; i < config.entities.length; i++){
+            let entityConfig = config.entities[i];
+            let relationKey = 'relations[' + entityConfig.name + ']';
+            let relationsValue = sc.get(query, relationKey, '');
+            if(relationsValue){
+                entityConfig.relations = relationsValue;
+            }
+        }
+        return config;
+    }
+
+    parseEntityParameters(query, config)
+    {
+        for(let key of Object.keys(query)){
+            if(!key.startsWith('entity[')){
+                continue;
+            }
+            let entityMatch = key.match(/entity\[([^\]]+)\]/);
+            if(!entityMatch){
+                continue;
+            }
+            let entityName = entityMatch[1];
+            let fields = query[key];
+            if(sc.isString(fields)){
+                fields = fields.split(',').map(f => f.trim()).filter(f => '' !== f);
+            }
+            if(!sc.isArray(fields)){
+                continue;
+            }
+            let existingEntity = sc.fetchByProperty(config.entities, 'name', entityName);
+            if(existingEntity){
+                existingEntity.fields = fields;
+                continue;
+            }
+            config.entities.push({name: entityName, fields});
+        }
+        return config;
+    }
+
+    parseSearchTerms(query, config)
+    {
+        config.searchTerms = {};
+        let globalSearch = sc.get(query, 'search', '');
+        if(globalSearch && sc.isString(globalSearch)){
+            config.searchTerms.global = globalSearch;
+            return config;
+        }
+        for(let key of Object.keys(query)){
+            if(!key.startsWith('search[')){
+                continue;
+            }
+            let searchMatch = key.match(/search\[([^\]]+)\](?:\[([^\]]+)\])?/);
+            if(!searchMatch){
+                continue;
+            }
+            let entityName = searchMatch[1];
+            let fieldName = searchMatch[2];
+            let searchValue = query[key];
+            if(!sc.hasOwn(config.searchTerms, entityName)){
+                config.searchTerms[entityName] = {};
+            }
+            if(fieldName){
+                config.searchTerms[entityName][fieldName] = searchValue;
+                continue;
+            }
+            config.searchTerms[entityName].global = searchValue;
+        }
+        return config;
+    }
+
+    parsePaginationParameters(query, config)
+    {
+        let limit = sc.get(query, 'limit', '');
+        if(limit && sc.isValidInteger(Number(limit), 1)){
+            config.pagination.limit = Number(limit);
+            config.pagination.active = true;
+        }
+        let offset = sc.get(query, 'offset', '');
+        if(offset && sc.isValidInteger(Number(offset), 0)){
+            config.pagination.offset = Number(offset);
+            config.pagination.active = true;
+        }
+        let page = sc.get(query, 'pageNumber', '');
+        if(page && sc.isValidInteger(Number(page), 1)){
+            config.pagination.page = Number(page);
+            config.pagination.active = true;
+        }
+        let sortBy = sc.get(query, 'sortBy', '');
+        if(sortBy){
+            config.pagination.sortBy = sortBy;
+        }
+        let sortDirection = sc.get(query, 'sortDirection', '');
+        if(sortDirection && ('asc' === sortDirection || 'desc' === sortDirection)){
+            config.pagination.sortDirection = sortDirection;
+        }
+        return config;
+    }
+
+    parseRenderParameters(query, config)
+    {
+        config.render = Object.assign({}, this.defaultRenderConfig);
+        let page = sc.get(query, 'renderPage', '');
+        if(page){
+            config.render.page = page;
+        }
+        let layout = sc.get(query, 'renderLayout', '');
+        if(layout){
+            config.render.layout = layout;
+        }
+        let paginationContainer = sc.get(query, 'renderPaginationContainer', '');
+        if(paginationContainer){
+            config.render.paginationContainer = paginationContainer;
+        }
+        let partial = sc.get(query, 'renderPartial', '');
+        if(partial){
+            config.render.partial = partial;
+        }
+        return config;
+    }
+
+    async executeSearch(config)
+    {
+        if(!config || !sc.isArray(config.entities) || 0 === config.entities.length){
+            Logger.error('Invalid search configuration');
+            return false;
+        }
+        let searchTerms = sc.get(config, 'searchTerms', {});
+        let hasSearchTerms = false;
+        if(sc.hasOwn(searchTerms, 'global') && '' !== searchTerms.global){
+            hasSearchTerms = true;
+        }
+        if(!hasSearchTerms){
+            for(let entityName of Object.keys(searchTerms)){
+                let entityTerms = searchTerms[entityName];
+                if(sc.isObject(entityTerms)){
+                    for(let termKey of Object.keys(entityTerms)){
+                        if('' !== entityTerms[termKey]){
+                            hasSearchTerms = true;
+                            break;
+                        }
+                    }
+                }
+                if(hasSearchTerms){
+                    break;
+                }
+            }
+        }
+        if(!hasSearchTerms){
+            let results = [];
+            for(let entityConfig of config.entities){
+                results.push({
+                    entity: entityConfig.name,
+                    results: [],
+                    hasResults: false,
+                    noResultsMessage: 'No search term provided.'
+                });
+            }
+            return results;
+        }
+        try {
+            let results = [];
+            for(let entityConfig of config.entities){
+                let entityResult = await this.searchEntity(entityConfig, config);
+                if(false === entityResult){
+                    continue;
+                }
+                results.push(entityResult);
+            }
+            return results;
+        } catch(error) {
+            Logger.error('Search execution failed: ' + error.message);
+            return false;
+        }
+    }
+
+    async searchEntity(entityConfig, config)
+    {
+        let entity = this.dataServer.getEntity(entityConfig.name);
+        if(!entity){
+            Logger.error('Entity not found: ' + entityConfig.name);
+            return false;
+        }
+        let searchFilters = this.buildSearchFilters(entityConfig, config);
+        if(!searchFilters){
+            Logger.error('No search filters built for entity: ' + entityConfig.name);
+            return false;
+        }
+        try {
+            let results;
+            let paginationData = null;
+            let relationsString = sc.get(entityConfig, 'relations', '');
+            let originalState = entity.preserveEntityState();
+            if(config.pagination && config.pagination.active){
+                let totalRecords = await this.paginationHandler.getCollectionTotal(entity, searchFilters);
+                let currentPage = sc.get(config.pagination, 'page', 1);
+                let limit = sc.get(config.pagination, 'limit', 20);
+                let offset = (currentPage - 1) * limit;
+                let sortBy = sc.get(config.pagination, 'sortBy', 'id');
+                let sortDirection = sc.get(config.pagination, 'sortDirection', 'asc');
+                let queryOptions = {
+                    limit,
+                    offset,
+                    sortBy,
+                    sortDirection
+                };
+                results = await entity.loadEntityData(searchFilters, queryOptions, relationsString);
+                paginationData = this.paginationHandler.calculatePaginationData(
+                    totalRecords,
+                    currentPage,
+                    limit,
+                    '',
+                    entityConfig.name,
+                    config.pagination,
+                    {}
+                );
+            }
+            if(!results){
+                results = await entity.loadEntityData(searchFilters, {}, relationsString);
+            }
+            entity.restoreEntityState(originalState);
+            if(this.jsonFieldsParser){
+                results = this.jsonFieldsParser.parseJsonFields(
+                    results,
+                    this.jsonFieldsParser.getJsonFieldsForEntity(entityConfig.name)
+                );
+            }
+            let entityResult = {
+                entity: entityConfig.name,
+                results: results || [],
+                hasResults: results && 0 < results.length,
+                noResultsMessage: 'No results found for your search.'
+            };
+            if(paginationData){
+                entityResult.pagination = paginationData;
+            }
+            return entityResult;
+        } catch(error) {
+            Logger.error('Search entity failed for ' + entityConfig.name + ': ' + error.message);
+            return {
+                entity: entityConfig.name,
+                results: [],
+                hasResults: false,
+                noResultsMessage: 'Search failed. Please try again.',
+                error: true
+            };
+        }
+    }
+
+    buildSearchFilters(entityConfig, config)
+    {
+        let searchTerms = sc.get(config, 'searchTerms', {});
+        let globalTerm = sc.get(searchTerms, 'global', '');
+        let entityTerms = sc.get(searchTerms, entityConfig.name, {});
+        let entityGlobalTerm = sc.get(entityTerms, 'global', '');
+        let searchTerm = entityGlobalTerm || globalTerm;
+        if(!searchTerm){
+            return false;
+        }
+        let entity = this.dataServer.getEntity(entityConfig.name);
+        if(!entity){
+            return false;
+        }
+        let searchableFields = entityConfig.fields;
+        let orConditions = [];
+        for(let field of searchableFields){
+            orConditions.push({
+                [field]: {operator: 'LIKE', value: '%' + searchTerm + '%'}
+            });
+        }
+        return {OR: orConditions};
+    }
+
+}
+
+module.exports.Search = Search;

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

@@ -0,0 +1,41 @@
+/**
+ *
+ * Reldens - CMS - AssetTransformer
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class AssetTransformer
+{
+
+    async transform(template, domain, req, systemVariables)
+    {
+        if(!template){
+            return template;
+        }
+        let currentRequest = sc.get(systemVariables, 'currentRequest', {});
+        let assetPattern = /\[asset\(([^)]+)\)\]/g;
+        let matches = [...template.matchAll(assetPattern)];
+        for(let i = matches.length - 1; i >= 0; i--){
+            let match = matches[i];
+            let assetPath = match[1].replace(/['"]/g, '');
+            let absoluteUrl = this.buildAssetUrl(assetPath, currentRequest);
+            template = template.substring(0, match.index) +
+                absoluteUrl +
+                template.substring(match.index + match[0].length);
+        }
+        return template;
+    }
+
+    buildAssetUrl(assetPath, currentRequest)
+    {
+        if(!assetPath || assetPath.startsWith('http')){
+            return assetPath;
+        }
+        return sc.get(currentRequest, 'baseUrl', '')+'/assets'+(assetPath.startsWith('/') ? assetPath : '/'+assetPath);
+    }
+
+}
+
+module.exports.AssetTransformer = AssetTransformer;

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

@@ -0,0 +1,70 @@
+/**
+ *
+ * Reldens - CMS - CollectionsSingleTransformer
+ *
+ */
+
+const { CollectionsTransformerBase } = require('./collections-transformer-base');
+const { sc } = require('@reldens/utils');
+
+class CollectionsSingleTransformer extends CollectionsTransformerBase
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+        this.findAllPartialTags = sc.get(props, 'findAllPartialTags', false);
+        this.loadPartialTemplate = sc.get(props, 'loadPartialTemplate', false);
+        this.processAllTemplateFunctions = sc.get(props, 'processAllTemplateFunctions', false);
+    }
+
+    getSingleFieldCollectionRegex()
+    {
+        return /<collection\s+([^>]+)\/>/g;
+    }
+
+    async transform(template, domain, req, systemVariables)
+    {
+        let processedTemplate = template;
+        for(let match of template.matchAll(this.getSingleFieldCollectionRegex())){
+            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],
+                await this.extractFieldValues(
+                    await this.fetchCollectionForTemplate(tableName, filtersJson, queryOptionsJson, relationsString),
+                    fieldName,
+                    domain,
+                    req,
+                    systemVariables
+                )
+            );
+        }
+        return processedTemplate;
+    }
+
+    async extractFieldValues(collectionData, fieldName, domain, req, systemVariables)
+    {
+        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);
+            }
+            fieldValues += fieldValue;
+        }
+        return fieldValues;
+    }
+
+}
+
+module.exports.CollectionsSingleTransformer = CollectionsSingleTransformer;

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

@@ -0,0 +1,84 @@
+/**
+ *
+ * Reldens - CMS - CollectionsTransformerBase
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class CollectionsTransformerBase
+{
+
+    constructor(props)
+    {
+        this.dataServer = sc.get(props, 'dataServer', false);
+        this.jsonFieldsParser = sc.get(props, 'jsonFieldsParser', false);
+    }
+
+    extractAttributeValue(tagContent, attributeName)
+    {
+        let doubleQuoteRegex = new RegExp(attributeName + '="([^"]*)"');
+        let singleQuoteRegex = new RegExp(attributeName + "='([^']*)'");
+        let doubleMatch = tagContent.match(doubleQuoteRegex);
+        if(doubleMatch){
+            return doubleMatch[1];
+        }
+        let singleMatch = tagContent.match(singleQuoteRegex);
+        if(singleMatch){
+            return singleMatch[1];
+        }
+        return '';
+    }
+
+    convertJsObjectToJson(jsObjectString)
+    {
+        if(!jsObjectString || '' === jsObjectString.trim()){
+            return '';
+        }
+        return jsObjectString
+            .replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":')
+            .replace(/:\s*'([^']*)'/g, ': "$1"');
+    }
+
+    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 = {};
+        if(filtersJson && '' !== filtersJson.trim()){
+            let convertedFiltersJson = this.convertJsObjectToJson(filtersJson);
+            let parsedFilters = sc.parseJson(convertedFiltersJson, false);
+            if(parsedFilters){
+                filters = parsedFilters;
+            }
+            if(!parsedFilters){
+                Logger.warning('Invalid filters JSON: '+filtersJson);
+            }
+        }
+        let originalState = entity.preserveEntityState();
+        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 = {};
+            }
+        }
+        let result = await entity.loadEntityData(filters, queryOptions, relationsString);
+        entity.restoreEntityState(originalState);
+        if(this.jsonFieldsParser){
+            result = this.jsonFieldsParser.parseJsonFields(
+                result,
+                this.jsonFieldsParser.getJsonFieldsForEntity(tableName)
+            );
+        }
+        return result;
+    }
+
+}
+
+module.exports.CollectionsTransformerBase = CollectionsTransformerBase;