@reldens/cms 0.16.0 → 0.19.0

package/lib/frontend.js

@@ -4,9 +4,11 @@
  *
  */
 
+const { TemplateEngine } = require('./template-engine');
+const { Search } = require('./search');
+const { SearchRenderer } = require('./search-renderer');
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
-const { TemplateEngine } = require('./template-engine');
 
 class Frontend
 {
@@ -28,7 +30,27 @@ class Frontend
         this.domainPartialsCache = new Map();
         this.domainTemplatesMap = new Map();
         this.entityAccessCache = new Map();
+        this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
         this.templateEngine = false;
+        this.cacheManager = sc.get(props, 'cacheManager', false);
+        this.searchPath = sc.get(props, 'searchPath', '/search');
+        this.searchSets = sc.get(props, 'searchSets', false);
+        this.searchConfig = {dataServer: this.dataServer};
+        if(this.searchSets){
+            this.searchConfig.searchSets = this.searchSets;
+        }
+        this.search = new Search(this.searchConfig);
+        this.searchRenderer = new SearchRenderer({
+            renderEngine: this.renderEngine,
+            getPartials: this.getPartialsForDomain.bind(this)
+        });
+        this.metaDefaults = sc.get(props, 'metaDefaults', {
+            locale: 'en',
+            viewport: 'width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes, viewport-fit=cover',
+            meta_robots: 'index,follow',
+            meta_theme_color: '#000000',
+            meta_twitter_card_type: 'summary'
+        });
     }
 
     async initialize()
@@ -56,12 +78,17 @@ class Frontend
         this.templateEngine = new TemplateEngine({
             renderEngine: this.renderEngine,
             dataServer: this.dataServer,
-            getPartials: this.getPartialsForDomain.bind(this)
+            getPartials: this.getPartialsForDomain.bind(this),
+            entitiesConfig: this.entitiesConfig
         });
+        this.searchConfig.jsonFieldsParser = this.templateEngine.jsonFieldsParser;
         await this.loadPartials();
         await this.setupDomainTemplates();
         await this.loadEntityAccessRules();
         this.setupStaticAssets();
+        this.app.get(this.searchPath, async (req, res) => {
+            return await this.handleSearchRequest(req, res);
+        });
         this.app.get('*', async (req, res) => {
             return await this.handleRequest(req, res);
         });
@@ -246,26 +273,114 @@ class Frontend
         return false;
     }
 
+    fetchMetaFields(data)
+    {
+        if(!sc.isObject(data) || 0 === Object.keys(data).length){
+            return this.metaDefaults;
+        }
+        let result = Object.assign({}, this.metaDefaults);
+        for(let key of Object.keys(data)){
+            let value = data[key];
+            if(null !== value && '' !== value && 'undefined' !== typeof value){
+                result[key] = value;
+            }
+        }
+        let titleValue = sc.get(result, 'title', '');
+        let metaTitleValue = sc.get(result, 'meta_title', titleValue);
+        if(metaTitleValue && '' !== metaTitleValue){
+            result.meta_title = metaTitleValue;
+        }
+        let metaOgTitleValue = sc.get(result, 'meta_og_title', metaTitleValue);
+        if(metaOgTitleValue && '' !== metaOgTitleValue){
+            result.meta_og_title = metaOgTitleValue;
+        }
+        let metaDescValue = sc.get(result, 'meta_description', '');
+        let metaOgDescValue = sc.get(result, 'meta_og_description', metaDescValue);
+        if(metaOgDescValue && '' !== metaOgDescValue){
+            result.meta_og_description = metaOgDescValue;
+        }
+        let jsonData = sc.get(result, 'json_data', null);
+        if(sc.isString(jsonData)){
+            jsonData = sc.toJson(jsonData, {});
+        }
+        if(!sc.isObject(jsonData)){
+            jsonData = {};
+        }
+        let viewportValue = sc.get(jsonData, 'viewport', this.metaDefaults.viewport);
+        if(viewportValue && '' !== viewportValue){
+            jsonData.viewport = viewportValue;
+        }
+        result.json_data = jsonData;
+        return result;
+    }
+
+    async handleSearchRequest(req, res)
+    {
+        try {
+            let domain = this.getDomainFromRequest(req);
+            let config = this.search.parseSearchParameters(req.query);
+            if(!config){
+                return res.redirect('/?error-message=searchInvalidParameters');
+            }
+            let cacheKey = this.buildCacheKey(req.path, req);
+            if(this.cacheManager && this.cacheManager.isEnabled()){
+                let cachedContent = await this.cacheManager.get(domain, cacheKey);
+                if(cachedContent){
+                    return res.send(cachedContent);
+                }
+            }
+            let searchResults = await this.search.executeSearch(config);
+            if(false === searchResults){
+                return res.redirect('/?error-message=searchExecutionFailed');
+            }
+            let content = await this.renderWithTemplateContent(
+                {
+                    template: config.render.page,
+                    layout: config.render.layout,
+                    content: await this.searchRenderer.renderSearchResults(searchResults, config, domain, req)
+                },
+                Object.assign({}, {
+                    search_query: sc.get(req.query, 'search', ''),
+                    searchConfig: config,
+                    query: req.query
+                }),
+                domain,
+                req
+            );
+            if(this.cacheManager && this.cacheManager.isEnabled()){
+                await this.cacheManager.set(domain, cacheKey, content);
+            }
+            return res.send(content);
+        } catch (error) {
+            Logger.error('Search request handling error: ' + error.message);
+            return res.redirect('/?error-message=searchError');
+        }
+    }
+
     async handleRequest(req, res)
     {
         try {
             let path = req.path;
             let domain = this.getDomainFromRequest(req);
-            console.log('---------------> ', {path, domain});
-            this.templateEngine.setCurrentDomain(domain);
+            if(this.cacheManager && this.cacheManager.isEnabled()){
+                let cachedContent = await this.cacheManager.get(domain, path);
+                if(cachedContent){
+                    return res.send(cachedContent);
+                }
+            }
             let route = await this.findRouteByPath(path, domain);
             if(route){
-                return await this.renderRoute(route, domain, res);
+                return await this.renderRouteWithCache(route, domain, res, path, req);
             }
             let entityResult = await this.findEntityByPath(path);
             if(entityResult){
-                return await this.renderEntity(entityResult, domain, res);
+                return await this.renderEntityWithCache(entityResult, domain, res, path, req);
             }
             let templatePath = this.findTemplateByPath(path, domain);
             if(templatePath){
-                return await this.renderTemplate(templatePath, domain, res);
+                return await this.renderTemplateWithCache(templatePath, domain, res, path, req);
             }
-            return await this.renderNotFound(domain, res);
+            return await this.renderNotFound(domain, res, req);
         } catch (error) {
             Logger.error('Request handling error: '+error.message);
             return res.status(500).send('Internal server error');
@@ -276,23 +391,27 @@ class Frontend
     {
         let routesEntity = this.dataServer.getEntity('routes');
         if(!routesEntity){
-            Logger.error('Routes entity not found in dataServer');
+            Logger.error('Routes entity not found in dataServer.');
             return false;
         }
         let domainFilter = domain || null;
         let routeFilters = {path, enabled: 1};
         let routes = await routesEntity.load(routeFilters);
         let matchingRoute = false;
+        let nullDomain = false;
         for(let route of routes){
-            if(!route.domain || route.domain === domainFilter){
+            if(route.domain === domainFilter){
                 matchingRoute = route;
                 break;
             }
+            if(!route.domain){
+                nullDomain = route;
+            }
         }
         if(matchingRoute){
             return matchingRoute;
         }
-        return false;
+        return nullDomain;
     }
 
     async isEntityAccessible(entityName)
@@ -338,107 +457,205 @@ class Frontend
         return this.findTemplatePath(templatePath, domain);
     }
 
-    async renderRoute(route, domain, res)
+    async renderRouteWithCache(route, domain, res, path, req)
+    {
+        let renderedContent = await this.generateRouteContent(route, domain, req);
+        if(!renderedContent){
+            return await this.renderNotFound(domain, res, req);
+        }
+        if(this.cacheManager && this.cacheManager.isEnabled()){
+            let cacheKey = this.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
+        }
+        return res.send(renderedContent);
+    }
+
+    async renderEntityWithCache(entityResult, domain, res, path, req)
+    {
+        let renderedContent = await this.generateEntityContent(entityResult, domain, req);
+        if(!renderedContent){
+            return await this.renderNotFound(domain, res, req);
+        }
+        if(this.cacheManager && this.cacheManager.isEnabled()){
+            let cacheKey = this.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
+        }
+        return res.send(renderedContent);
+    }
+
+    async renderTemplateWithCache(templatePath, domain, res, path, req)
+    {
+        let renderedContent = await this.generateTemplateContent(templatePath, domain, req);
+        if(!renderedContent){
+            return res.status(500).send('Template error: '+templatePath);
+        }
+        if(this.cacheManager && this.cacheManager.isEnabled()){
+            let cacheKey = this.buildCacheKey(path, req);
+            await this.cacheManager.set(domain, cacheKey, renderedContent);
+        }
+        return await this.renderWithLayout({content: renderedContent}, {}, 'default', domain, res, req);
+    }
+
+    async generateRouteContent(route, domain, req)
     {
-        if(!route.router || !route.cms_page_id){
-            return await this.renderNotFound(domain, res);
+        if(!route.router){
+            return false;
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
-            return await this.renderNotFound(domain, res);
+            return false;
         }
-        let content = await entity.loadById(route.cms_page_id);
+        let content = await entity.loadOne({route_id: route.id});
         if(!content){
-            return await this.renderNotFound(domain, res);
+            return false;
         }
-        return await this.renderWithLayout(
-            content,
-            Object.assign({}, route, content),
-            sc.get(content, 'layout', 'default'),
-            domain,
-            res
-        );
+        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain, req);
     }
 
-    async renderEntity(entityResult, domain, res)
+    async generateEntityContent(entityResult, domain, req)
     {
-        return await this.renderWithLayout(
-            entityResult.entity,
-            Object.assign({}, entityResult.entity),
-            sc.get(entityResult.entity, 'layout', 'default'),
-            domain,
-            res
-        );
+        return await this.renderWithTemplateContent(entityResult.entity, entityResult.entity, domain, req);
     }
 
-    async renderTemplate(templatePath, domain, res)
+    async generateTemplateContent(templatePath, domain, req)
     {
-        let content = await this.renderContentWithTemplate(templatePath, {}, domain);
+        let template = FileHandler.readFile(templatePath);
+        if(!template){
+            Logger.error('Failed to read template: ' + templatePath);
+            return false;
+        }
+        return await this.templateEngine.render(template, {}, this.getPartialsForDomain(domain), domain, req);
+    }
+
+    async renderRoute(route, domain, res, req)
+    {
+        if(!route.router){
+            return await this.renderNotFound(domain, res, req);
+        }
+        let entity = this.dataServer.getEntity(route.router);
+        if(!entity){
+            return await this.renderNotFound(domain, res, req);
+        }
+        let content = await entity.loadOne({route_id: route.id});
         if(!content){
-            return res.status(500).send('Template error: '+templatePath);
+            return await this.renderNotFound(domain, res, req);
         }
-        return await this.renderWithLayout({content}, {}, 'default', domain, res);
+        return await this.renderWithTemplate(content, Object.assign({}, route, content), domain, res, req);
+    }
+
+    async renderWithTemplate(content, data, domain, res, req)
+    {
+        return res.send(await this.renderWithTemplateContent(content, data, domain, req));
     }
 
-    async renderContentWithTemplate(templatePath, data, domain)
+    async renderWithTemplateContent(content, data, domain, req)
+    {
+        let templateName = sc.get(content, 'template', 'page');
+        if(!templateName){
+            templateName = 'page';
+        }
+        let layoutName = sc.get(content, 'layout', '');
+        if(!layoutName){
+            layoutName = 'default';
+        }
+        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain, req);
+        let templatePath = this.findTemplatePath(templateName, domain);
+        if(!templatePath){
+            return layoutContent;
+        }
+        let pageTemplate = FileHandler.readFile(templatePath);
+        if(!pageTemplate){
+            return layoutContent;
+        }
+        return await this.templateEngine.render(
+            pageTemplate,
+            Object.assign({}, this.fetchMetaFields(data), {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
+            this.getPartialsForDomain(domain),
+            domain,
+            req
+        );
+    }
+
+    async renderContentWithTemplate(templatePath, data, domain, req)
     {
         let template = FileHandler.readFile(templatePath);
         if(!template){
             Logger.error('Failed to read template: ' + templatePath);
             return false;
         }
-        return await this.templateEngine.render(template, data, this.getPartialsForDomain(domain));
+        return await this.templateEngine.render(template, data, this.getPartialsForDomain(domain), domain, req);
+    }
+
+    async renderWithLayout(content, data, layoutName, domain, res, req)
+    {
+        return res.send(await this.renderWithTemplateContent(content, data, domain, req));
     }
 
-    async renderWithLayout(content, data, layoutName, domain, res)
+    async processContentWithLayout(content, data, layoutName, domain, req)
     {
+        let processedContent = await this.processContent(content, data, domain, req);
         let layoutPath = this.findLayoutPath(layoutName, domain);
-        let layoutContent = '';
-        if(layoutPath){
-            let layoutTemplate = FileHandler.readFile(layoutPath);
-            if(layoutTemplate){
-                let processedContent = sc.get(content, 'content', '');
-                if(processedContent){
-                    processedContent = await this.templateEngine.render(
-                        processedContent,
-                        data,
-                        this.getPartialsForDomain(domain)
-                    );
-                }
-                layoutContent = await this.templateEngine.render(
-                    layoutTemplate,
-                    Object.assign({}, data, {content: processedContent}),
-                    this.getPartialsForDomain(domain)
-                );
-            }
+        if(!layoutPath){
+            return processedContent;
         }
-        if('' === layoutContent){
-            let processedContent = sc.get(content, 'content', '');
-            if(processedContent){
-                layoutContent = await this.templateEngine.render(
-                    processedContent,
-                    data,
-                    this.getPartialsForDomain(domain)
-                );
-            }
+        let layoutTemplate = FileHandler.readFile(layoutPath);
+        if(!layoutTemplate){
+            return processedContent;
+        }
+        return await this.templateEngine.render(
+            layoutTemplate,
+            Object.assign({}, data, {content: processedContent}),
+            this.getPartialsForDomain(domain),
+            domain,
+            req
+        );
+    }
+
+    async processContent(content, data, domain, req)
+    {
+        let contentText = sc.get(content, 'content', '');
+        if(!contentText){
+            return '';
         }
-        res.setHeader('Content-Type', 'text/html; charset=utf-8');
-        return res.send(layoutContent);
+        return await this.templateEngine.render(contentText, data, this.getPartialsForDomain(domain), domain, req);
     }
 
-    async renderNotFound(domain, res)
+    async renderNotFound(domain, res, req)
     {
         let notFoundPath = this.findTemplatePath('404', domain);
         if(notFoundPath){
-            let content = await this.renderContentWithTemplate(notFoundPath, {}, domain);
+            let content = await this.renderContentWithTemplate(notFoundPath, {}, domain, req);
             if(content){
                 res.status(404);
-                return await this.renderWithLayout({content}, {}, 'default', domain, res);
+                return await this.renderWithLayout({content}, {}, 'default', domain, res, req);
             }
         }
         return res.status(404).send('Page not found');
     }
 
+    buildCacheKey(path, req)
+    {
+        if(!req || !req.query){
+            return path;
+        }
+        for(let key of Object.keys(req.query)){
+            if(key.endsWith('-key')){
+                let queryString = '';
+                for(let qKey of Object.keys(req.query)){
+                    queryString += (queryString ? '&' : '') + qKey + '=' + req.query[qKey];
+                }
+                let hash = 0;
+                for(let i = 0; i < queryString.length; i++){
+                    let char = queryString.charCodeAt(i);
+                    hash = ((hash << 5) - hash) + char;
+                    hash = hash & hash;
+                }
+                return path + '_' + Math.abs(hash);
+            }
+        }
+        return path;
+    }
+
 }
 
 module.exports.Frontend = Frontend;

package/lib/installer.js

@@ -243,11 +243,11 @@ class Installer
         return '';
     }
 
-    async generateEntities(server, isOverride = false, isInstallationMode = false)
+    async generateEntities(server, isOverride = false, isInstallationMode = false, isDryPrisma = false)
     {
         let driverType = sc.get(DriversClassMap, server.constructor.name, '');
         Logger.debug('Driver type detected: '+driverType+', Server constructor: '+server.constructor.name);
-        if('prisma' === driverType && !isInstallationMode){
+        if('prisma' === driverType && !isInstallationMode && !isDryPrisma){
             Logger.info('Running prisma introspect "npx prisma db pull"...');
             let dbConfig = this.extractDbConfigFromServer(server);
             Logger.debug('Extracted DB config:', dbConfig);
@@ -260,6 +260,9 @@ class Installer
                 Logger.info('Generated Prisma schema for entities generation.');
             }
         }
+        if('prisma' === driverType && isDryPrisma){
+            Logger.info('Skipping Prisma schema generation due to --dry-prisma flag.');
+        }
         let generatorConfig = {
             server,
             projectPath: this.projectRoot,

package/lib/json-fields-parser.js

@@ -0,0 +1,74 @@
+/**
+ *
+ * Reldens - CMS - JsonFieldsParser
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class JsonFieldsParser
+{
+
+    constructor(props)
+    {
+        this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
+        this.jsonFieldsCache = new Map();
+    }
+
+    getJsonFieldsForEntity(entityName)
+    {
+        if(this.jsonFieldsCache.has(entityName)){
+            return this.jsonFieldsCache.get(entityName);
+        }
+        let jsonFields = [];
+        let entityConfig = sc.get(this.entitiesConfig, entityName);
+        if(!entityConfig){
+            Logger.error('Entity not found in configuration: '+entityName);
+            return jsonFields;
+        }
+        if(!sc.hasOwn(entityConfig, 'properties')){
+            Logger.error('Missing properties on entity configuration: '+entityName);
+            return jsonFields;
+        }
+        for(let fieldName of Object.keys(entityConfig.properties)){
+            if('json' === sc.get(entityConfig.properties[fieldName], 'dbType', '')){
+                jsonFields.push(fieldName);
+            }
+        }
+        this.jsonFieldsCache.set(entityName, jsonFields);
+        return jsonFields;
+    }
+
+    parseJsonFields(data, jsonFields)
+    {
+        if(!sc.isArray(jsonFields) || 0 === jsonFields.length){
+            return data;
+        }
+        if(sc.isArray(data)){
+            for(let item of data){
+                this.parseEntityJsonFields(item, jsonFields);
+            }
+            return data;
+        }
+        if(sc.isObject(data)){
+            this.parseEntityJsonFields(data, jsonFields);
+        }
+        return data;
+    }
+
+    parseEntityJsonFields(entity, jsonFields)
+    {
+        for(let fieldName of jsonFields){
+            if(!sc.hasOwn(entity, fieldName) || !sc.isString(entity[fieldName])){
+                continue;
+            }
+            let parsed = sc.parseJson(entity[fieldName], false);
+            if(false !== parsed){
+                entity[fieldName] = parsed;
+            }
+        }
+    }
+
+}
+
+module.exports.JsonFieldsParser = JsonFieldsParser;