@reldens/cms 0.18.0 → 0.20.0

package/lib/manager.js

@@ -47,7 +47,7 @@ class Manager
         this.projectAdminPath = FileHandler.joinPaths(this.projectRoot, 'admin');
         this.projectAdminTemplatesPath = FileHandler.joinPaths(this.projectAdminPath, 'templates');
         this.mimeTypes = sc.get(props, 'mimeTypes', MimeTypes);
-        this.allowedExtensions = sc.get(props, 'allowedExtensions', AllowedExtensions)
+        this.allowedExtensions = sc.get(props, 'allowedExtensions', AllowedExtensions);
         this.adminRoleId = sc.get(props, 'adminRoleId', 99);
         this.mappedAdminTemplates = TemplatesToPathMapper.map(this.adminTemplatesList, this.projectAdminTemplatesPath);
         this.stylesFilePath = sc.get(props, 'stylesFilePath', '/css/reldens-admin-client.css');
@@ -67,6 +67,19 @@ 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.developmentEnvironments = sc.get(props, 'developmentEnvironments', ['development', 'dev', 'test']);
+        this.developmentPorts = sc.get(props, 'developmentPorts', [3000, 8080, 8081]);
+        this.developmentMultiplier = sc.get(props, 'developmentMultiplier', 10);
+        this.appServerConfig = sc.get(props, 'appServerConfig', {});
+        this.developmentExternalDomains = sc.get(props, 'developmentExternalDomains', {});
         this.appServerFactory = new AppServerFactory();
         this.adminEntitiesGenerator = new AdminEntitiesGenerator();
         this.cacheManager = new CacheManager({projectRoot: this.projectRoot, enabled: this.cache});
@@ -172,7 +185,8 @@ class Manager
     async start()
     {
         if(!this.useProvidedServer){
-            let createdAppServer = this.appServerFactory.createAppServer();
+            let appServerConfig = this.buildAppServerConfiguration();
+            let createdAppServer = this.appServerFactory.createAppServer(appServerConfig);
             if(this.appServerFactory.error.message){
                 Logger.error('App server error: '+this.appServerFactory.error.message);
                 return false;
@@ -199,6 +213,30 @@ class Manager
         }
     }
 
+    buildAppServerConfiguration()
+    {
+        let baseConfig = {
+            port: this.config.port,
+            useHttps: this.config.host.startsWith('https://'),
+            domainMapping: this.domainMapping || {},
+            defaultDomain: this.defaultDomain,
+            developmentPatterns: this.developmentPatterns,
+            developmentEnvironments: this.developmentEnvironments,
+            developmentPorts: this.developmentPorts,
+            developmentMultiplier: this.developmentMultiplier,
+            developmentExternalDomains: this.developmentExternalDomains
+        };
+        let appServerConfig = Object.assign({}, baseConfig, this.appServerConfig);
+        if(this.domainMapping && 'object' === typeof this.domainMapping){
+            let mappingKeys = Object.keys(this.domainMapping);
+            for(let domain of mappingKeys){
+                this.appServerFactory.addDevelopmentDomain(domain);
+            }
+            this.appServerFactory.setDomainMapping(this.domainMapping);
+        }
+        return appServerConfig;
+    }
+
     async initializeCmsAfterInstall(props)
     {
         try {
@@ -325,7 +363,8 @@ class Manager
                 user: this.config.database.user,
                 password: this.config.database.password
             },
-            rawEntities: this.rawRegisteredEntities
+            rawEntities: this.rawRegisteredEntities,
+            entitiesConfig: this.entitiesConfig
         };
         let driverClass = DriversMap[this.config.database.driver];
         if(!driverClass){
@@ -437,6 +476,7 @@ class Manager
         this.frontend = new Frontend({
             app: this.app,
             dataServer: this.dataServer,
+            events: this.events,
             renderEngine: this.renderEngine,
             projectRoot: this.projectRoot,
             appServerFactory: this.appServerFactory,

package/lib/pagination-handler.js

@@ -0,0 +1,243 @@
+/**
+ *
+ * Reldens - CMS - PaginationHandler
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class PaginationHandler
+{
+
+    constructor()
+    {
+        this.defaultLimit = 10;
+        this.prevPageLabel = 'Previous';
+        this.nextPageLabel = 'Next';
+    }
+
+    sanitizeCollectionKey(collectionKey)
+    {
+        if(!collectionKey || 'object' !== typeof collectionKey){
+            return {};
+        }
+        let sanitizedKey = {};
+        let page = sc.parseNumber(sc.get(collectionKey, 'page', 0));
+        if(1 <= page){
+            sanitizedKey.page = page;
+        }
+        let limit = sc.parseNumber(sc.get(collectionKey, 'limit', 0));
+        if(0 < limit){
+            sanitizedKey.limit = limit;
+        }
+        let sortBy = sc.get(collectionKey, 'sortBy', '');
+        if(sc.isString(sortBy) && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(sortBy)){
+            sanitizedKey.sortBy = sortBy;
+        }
+        let sortDirection = sc.get(collectionKey, 'sortDirection');
+        if('asc' === sortDirection || 'desc' === sortDirection){
+            sanitizedKey.sortDirection = sortDirection;
+        }
+        let filters = sc.get(collectionKey, 'filters', false);
+        if('object' === typeof filters){
+            sanitizedKey.filters = this.sanitizeFilters(filters);
+        }
+        return sanitizedKey;
+    }
+
+    sanitizeFilters(filters)
+    {
+        let sanitizedFilters = {};
+        for(let key of Object.keys(filters)){
+            if(!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)){
+                continue;
+            }
+            let value = filters[key];
+            if(sc.isString(value) || sc.isNumber(value) || sc.isBoolean(value)){
+                sanitizedFilters[key] = value;
+            }
+        }
+        return sanitizedFilters;
+    }
+
+    extractCollectionKeyFromRequest(req, collectionId)
+    {
+        if(!req || !req.query){
+            return {};
+        }
+        let paramName = collectionId + '-key';
+        let paramValue = sc.get(req.query, paramName, '');
+        if(!paramValue){
+            return {};
+        }
+        let decodedValue = decodeURIComponent(paramValue);
+        let parsedKey = sc.parseJson(decodedValue, {});
+        if(!parsedKey){
+            Logger.warning('Invalid collection key JSON: ' + decodedValue);
+            return {};
+        }
+        return this.sanitizeCollectionKey(parsedKey);
+    }
+
+    mergeCollectionParameters(templateParams, requestParams)
+    {
+        let templateFilters = sc.get(templateParams, 'filters', {});
+        let requestFilters = sc.get(requestParams, 'filters', {});
+        let mergedFilters = Object.assign({}, templateFilters, requestFilters);
+        return {
+            limit: sc.get(requestParams, 'limit', sc.get(templateParams, 'limit', this.defaultLimit)),
+            page: sc.get(requestParams, 'page', 1),
+            sortBy: sc.get(requestParams, 'sortBy', sc.get(templateParams, 'sortBy', 'id')),
+            sortDirection: sc.get(requestParams, 'sortDirection', sc.get(templateParams, 'sortDirection', 'asc')),
+            filters: mergedFilters
+        };
+    }
+
+    calculatePaginationData(totalRecords, currentPage, limit, baseUrl, collectionId, params, templateDefaults)
+    {
+        if(0 >= totalRecords){
+            return this.createEmptyPaginationData();
+        }
+        let totalPages = Math.ceil(totalRecords / limit);
+        if(currentPage > totalPages){
+            currentPage = totalPages;
+        }
+        let offset = (currentPage - 1) * limit;
+        let hasNextPage = currentPage < totalPages;
+        let hasPrevPage = 1 < currentPage;
+        let prevPageUrl = '';
+        let nextPageUrl = '';
+        if(hasPrevPage){
+            prevPageUrl = this.buildPageUrl(baseUrl, collectionId, params, currentPage - 1, templateDefaults);
+        }
+        if(hasNextPage){
+            nextPageUrl = this.buildPageUrl(baseUrl, collectionId, params, currentPage + 1, templateDefaults);
+        }
+        let prevPages = this.calculatePrevPages(currentPage, params, baseUrl, collectionId, templateDefaults);
+        let nextPages = this.calculateNextPages(
+            currentPage,
+            totalPages,
+            params,
+            baseUrl,
+            collectionId,
+            templateDefaults
+        );
+        return {
+            currentPage,
+            totalPages,
+            totalRecords,
+            limit,
+            offset,
+            hasNextPage,
+            hasPrevPage,
+            prevPageUrl,
+            nextPageUrl,
+            prevPageLabel: this.prevPageLabel,
+            nextPageLabel: this.nextPageLabel,
+            prevPages,
+            nextPages
+        };
+    }
+
+    createEmptyPaginationData()
+    {
+        return {
+            currentPage: 1,
+            totalPages: 0,
+            totalRecords: 0,
+            limit: this.defaultLimit,
+            offset: 0,
+            hasNextPage: false,
+            hasPrevPage: false,
+            prevPageUrl: '',
+            nextPageUrl: '',
+            prevPageLabel: this.prevPageLabel,
+            nextPageLabel: this.nextPageLabel,
+            prevPages: [],
+            nextPages: []
+        };
+    }
+
+    calculatePrevPages(currentPage, params, baseUrl, collectionId, templateDefaults)
+    {
+        let prevPagesCount = sc.parseNumber(sc.get(params, 'prevPages', 2));
+        if(!prevPagesCount || 0 >= prevPagesCount || 1 >= currentPage){
+            return [];
+        }
+        let prevPages = [];
+        let startPage = Math.max(1, currentPage - prevPagesCount);
+        for(let page = startPage; page < currentPage; page++){
+            prevPages.push({
+                pageLabel: page,
+                pageUrl: this.buildPageUrl(baseUrl, collectionId, params, page, templateDefaults)
+            });
+        }
+        return prevPages;
+    }
+
+    calculateNextPages(currentPage, totalPages, params, baseUrl, collectionId, templateDefaults)
+    {
+        let nextPagesCount = sc.parseNumber(sc.get(params, 'nextPages', 2));
+        if(!nextPagesCount || 0 >= nextPagesCount || currentPage >= totalPages){
+            return [];
+        }
+        let nextPages = [];
+        let endPage = Math.min(totalPages, currentPage + nextPagesCount);
+        for(let page = currentPage + 1; page <= endPage; page++){
+            nextPages.push({
+                pageLabel: page,
+                pageUrl: this.buildPageUrl(baseUrl, collectionId, params, page, templateDefaults)
+            });
+        }
+        return nextPages;
+    }
+
+    buildPageUrl(baseUrl, collectionId, params, page, templateDefaults)
+    {
+        let urlParams = {};
+        urlParams.page = page;
+        let templateFilters = sc.get(templateDefaults, 'filters', {});
+        let templateLimit = sc.get(templateDefaults, 'limit', this.defaultLimit);
+        let templateSortBy = sc.get(templateDefaults, 'sortBy', 'id');
+        let templateSortDirection = sc.get(templateDefaults, 'sortDirection', 'asc');
+        let currentFilters = sc.get(params, 'filters', {});
+        for(let filterKey of Object.keys(currentFilters)){
+            if(!sc.hasOwn(templateFilters, filterKey) || templateFilters[filterKey] !== currentFilters[filterKey]){
+                if(!sc.hasOwn(urlParams, 'filters')){
+                    urlParams.filters = {};
+                }
+                urlParams.filters[filterKey] = currentFilters[filterKey];
+            }
+        }
+        if(params.limit !== templateLimit){
+            urlParams.limit = params.limit;
+        }
+        if(params.sortBy !== templateSortBy){
+            urlParams.sortBy = params.sortBy;
+        }
+        if(params.sortDirection !== templateSortDirection){
+            urlParams.sortDirection = params.sortDirection;
+        }
+        let collectionKey = encodeURIComponent(JSON.stringify(urlParams));
+        let paramName = collectionId + '-key';
+        let separator = -1 !== baseUrl.indexOf('?') ? '&' : '?';
+        return baseUrl + separator + paramName + '=' + collectionKey;
+    }
+
+    async getCollectionTotal(entity, filters)
+    {
+        if(!entity || !sc.isFunction(entity.count)){
+            Logger.critical('Entity does not support count method');
+            return 0;
+        }
+        try {
+            return await entity.count(filters || {});
+        } catch (error) {
+            Logger.critical('Failed to count collection records: ' + error.message);
+            return 0;
+        }
+    }
+
+}
+
+module.exports.PaginationHandler = PaginationHandler;

package/lib/search-renderer.js

@@ -0,0 +1,116 @@
+/**
+ *
+ * Reldens - CMS - SearchRenderer
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class SearchRenderer
+{
+
+    constructor(props)
+    {
+        this.renderEngine = sc.get(props, 'renderEngine', false);
+        this.getPartials = sc.get(props, 'getPartials', false);
+    }
+
+    async renderSearchResults(searchResults, config, domain, req)
+    {
+        if(!searchResults || !sc.isArray(searchResults) || 0 === searchResults.length){
+            return this.renderNoSearchResults(domain);
+        }
+        let renderedContent = '';
+        for(let entityResult of searchResults){
+            if(!sc.hasOwn(entityResult, 'results') || !sc.isArray(entityResult.results)){
+                continue;
+            }
+            if(0 === entityResult.results.length){
+                renderedContent += this.renderNoSearchResults(domain);
+                continue;
+            }
+            let partialName = sc.get(config, 'render.partial', 'entriesListView');
+            let partialTemplate = this.loadPartialTemplate(partialName, domain);
+            if(!partialTemplate){
+                Logger.error('Search result partial template not found: ' + partialName);
+                continue;
+            }
+            if(sc.hasOwn(entityResult, 'pagination')){
+                let entityContent = await this.renderSearchEntityResults(entityResult.results, partialTemplate, domain);
+                let totalPages = sc.get(entityResult.pagination, 'totalPages', 1);
+                if(1 < totalPages){
+                    let paginationContainer = sc.get(config, 'render.paginationContainer', 'pagedCollection');
+                    let paginationTemplate = this.loadPaginationTemplate(paginationContainer, domain);
+                    let paginationData = Object.assign({}, entityResult.pagination, {
+                        collectionContentForCurrentPage: entityContent,
+                        hasResults: 0 < entityResult.results.length,
+                        noResultsMessage: entityResult.noResultsMessage || 'No results found.'
+                    });
+                    renderedContent += this.renderEngine.render(paginationTemplate, paginationData, this.getPartialsForDomain(domain));
+                    continue;
+                }
+                renderedContent += entityContent;
+                continue;
+            }
+            renderedContent += await this.renderSearchEntityResults(entityResult.results, partialTemplate, domain);
+        }
+        return renderedContent;
+    }
+
+    async renderSearchEntityResults(results, partialTemplate, domain)
+    {
+        let renderedContent = '';
+        for(let row of results){
+            renderedContent += this.renderEngine.render(partialTemplate, {row}, this.getPartialsForDomain(domain));
+        }
+        return renderedContent;
+    }
+
+    renderNoSearchResults(domain)
+    {
+        let noResultsTemplate = this.loadPartialTemplate('noResults', domain);
+        if(noResultsTemplate){
+            return this.renderEngine.render(
+                noResultsTemplate,
+                {
+                    message: 'No search results found.',
+                    cssClass: 'no-search-results',
+                    alertClass: 'alert-info'
+                },
+                this.getPartialsForDomain(domain)
+            );
+        }
+        return '<div class="no-search-results alert alert-info">No search results found.</div>';
+    }
+
+    loadPartialTemplate(partialName, domain)
+    {
+        let partials = this.getPartialsForDomain(domain);
+        return sc.get(partials, partialName, false);
+    }
+
+    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}}';
+    }
+
+    getPartialsForDomain(domain)
+    {
+        if(!this.getPartials){
+            Logger.error('getPartials function not provided to SearchRenderer');
+            return {};
+        }
+        return this.getPartials(domain);
+    }
+
+}
+
+module.exports.SearchRenderer = SearchRenderer;