@reldens/cms 0.16.0 → 0.18.0

package/lib/frontend.js

@@ -28,7 +28,9 @@ 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);
     }
 
     async initialize()
@@ -56,7 +58,8 @@ 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
         });
         await this.loadPartials();
         await this.setupDomainTemplates();
@@ -251,19 +254,24 @@ class Frontend
         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);
             }
             let entityResult = await this.findEntityByPath(path);
             if(entityResult){
-                return await this.renderEntity(entityResult, domain, res);
+                return await this.renderEntityWithCache(entityResult, domain, res, path);
             }
             let templatePath = this.findTemplateByPath(path, domain);
             if(templatePath){
-                return await this.renderTemplate(templatePath, domain, res);
+                return await this.renderTemplateWithCache(templatePath, domain, res, path);
             }
             return await this.renderNotFound(domain, res);
         } catch (error) {
@@ -276,23 +284,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,36 +350,153 @@ class Frontend
         return this.findTemplatePath(templatePath, domain);
     }
 
+    async renderRouteWithCache(route, domain, res, path)
+    {
+        let renderedContent = await this.generateRouteContent(route, domain);
+        if(!renderedContent){
+            return await this.renderNotFound(domain, res);
+        }
+        if(this.cacheManager && this.cacheManager.isEnabled()){
+            await this.cacheManager.set(domain, path, renderedContent);
+        }
+        return res.send(renderedContent);
+    }
+
+    async renderEntityWithCache(entityResult, domain, res, path)
+    {
+        let renderedContent = await this.generateEntityContent(entityResult, domain);
+        if(!renderedContent){
+            return await this.renderNotFound(domain, res);
+        }
+        if(this.cacheManager && this.cacheManager.isEnabled()){
+            await this.cacheManager.set(domain, path, renderedContent);
+        }
+        return res.send(renderedContent);
+    }
+
+    async renderTemplateWithCache(templatePath, domain, res, path)
+    {
+        let renderedContent = await this.generateTemplateContent(templatePath, domain);
+        if(!renderedContent){
+            return res.status(500).send('Template error: '+templatePath);
+        }
+        if(this.cacheManager && this.cacheManager.isEnabled()){
+            await this.cacheManager.set(domain, path, renderedContent);
+        }
+        let layoutContent = await this.processContentWithLayout({content: renderedContent}, {}, 'default', domain);
+        let pagePath = this.findTemplatePath('page', domain);
+        if(!pagePath){
+            return res.send(layoutContent);
+        }
+        let pageTemplate = FileHandler.readFile(pagePath);
+        if(!pageTemplate){
+            return res.send(layoutContent);
+        }
+        let finalContent = await this.templateEngine.render(
+            pageTemplate,
+            Object.assign({}, {}, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
+            this.getPartialsForDomain(domain)
+        );
+        return res.send(finalContent);
+    }
+
+    async generateRouteContent(route, domain)
+    {
+        if(!route.router){
+            return false;
+        }
+        let entity = this.dataServer.getEntity(route.router);
+        if(!entity){
+            return false;
+        }
+        let content = await entity.loadOne({route_id: route.id});
+        if(!content){
+            return false;
+        }
+        return await this.renderWithTemplateContent(content, Object.assign({}, route, content), domain);
+    }
+
+    async generateEntityContent(entityResult, domain)
+    {
+        return await this.renderWithTemplateContent(entityResult.entity, entityResult.entity, domain);
+    }
+
+    async generateTemplateContent(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));
+    }
+
     async renderRoute(route, domain, res)
     {
-        if(!route.router || !route.cms_page_id){
+        if(!route.router){
             return await this.renderNotFound(domain, res);
         }
         let entity = this.dataServer.getEntity(route.router);
         if(!entity){
             return await this.renderNotFound(domain, res);
         }
-        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 await this.renderWithLayout(
-            content,
-            Object.assign({}, route, content),
-            sc.get(content, 'layout', 'default'),
-            domain,
-            res
-        );
+        return await this.renderWithTemplate(content, Object.assign({}, route, content), domain, res);
     }
 
     async renderEntity(entityResult, domain, res)
     {
-        return await this.renderWithLayout(
-            entityResult.entity,
-            Object.assign({}, entityResult.entity),
-            sc.get(entityResult.entity, 'layout', 'default'),
-            domain,
-            res
+        return await this.renderWithTemplate(entityResult.entity, entityResult.entity, domain, res);
+    }
+
+    async renderWithTemplate(content, data, domain, res)
+    {
+        let templateName = sc.get(content, 'template', '');
+        let layoutName = sc.get(content, 'layout', 'default');
+        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain);
+        if(!templateName){
+            templateName = 'page';
+        }
+        let templatePath = this.findTemplatePath(templateName, domain);
+        if(!templatePath){
+            return res.send(layoutContent);
+        }
+        let pageTemplate = FileHandler.readFile(templatePath);
+        if(!pageTemplate){
+            return res.send(layoutContent);
+        }
+        return res.send(
+            await this.templateEngine.render(
+                pageTemplate,
+                Object.assign({}, data, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
+                this.getPartialsForDomain(domain)
+            )
+        );
+    }
+
+    async renderWithTemplateContent(content, data, domain)
+    {
+        let templateName = sc.get(content, 'template', '');
+        let layoutName = sc.get(content, 'layout', 'default');
+        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain);
+        if(!templateName){
+            templateName = 'page';
+        }
+        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({}, data, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
+            this.getPartialsForDomain(domain)
         );
     }
 
@@ -392,38 +521,49 @@ class Frontend
 
     async renderWithLayout(content, data, layoutName, domain, res)
     {
+        let layoutContent = await this.processContentWithLayout(content, data, layoutName, domain);
+        let pagePath = this.findTemplatePath('page', domain);
+        if(!pagePath){
+            return res.send(layoutContent);
+        }
+        let pageTemplate = FileHandler.readFile(pagePath);
+        if(!pageTemplate){
+            return res.send(layoutContent);
+        }
+        return res.send(
+            await this.templateEngine.render(
+                pageTemplate,
+                Object.assign({}, data, {content: layoutContent, siteHandle: this.resolveDomainToSiteKey(domain)}),
+                this.getPartialsForDomain(domain)
+            )
+        );
+    }
+
+    async processContentWithLayout(content, data, layoutName, domain)
+    {
+        let processedContent = await this.processContent(content, data, domain);
         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)
+        );
+    }
+
+    async processContent(content, data, domain)
+    {
+        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));
     }
 
     async renderNotFound(domain, res)

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;

package/lib/manager.js

@@ -17,6 +17,7 @@ const { AdminManager } = require('./admin-manager');
 const { CmsPagesRouteManager } = require('./cms-pages-route-manager');
 const { Installer } = require('./installer');
 const { Frontend } = require('./frontend');
+const { CacheManager } = require('./cache/cache-manager');
 const { EventsManagerSingleton, Logger, sc } = require('@reldens/utils');
 const { DriversMap } = require('@reldens/storage');
 const { AppServerFactory, FileHandler, Encryptor } = require('@reldens/server-utils');
@@ -58,6 +59,7 @@ class Manager
         this.domainMapping = sc.get(props, 'domainMapping', sc.toJson(process.env.RELDENS_DOMAIN_MAPPING));
         this.siteKeyMapping = sc.get(props, 'siteKeyMapping', sc.toJson(process.env.RELDENS_SITE_KEY_MAPPING));
         this.templateExtensions = sc.get(props, 'templateExtensions', ['.html', '.template']);
+        this.cache = sc.get(props, 'cache', false);
         this.app = sc.get(props, 'app', false);
         this.appServer = sc.get(props, 'appServer', false);
         this.dataServer = sc.get(props, 'dataServer', false);
@@ -67,6 +69,7 @@ class Manager
         this.prismaClient = sc.get(props, 'prismaClient', false);
         this.appServerFactory = new AppServerFactory();
         this.adminEntitiesGenerator = new AdminEntitiesGenerator();
+        this.cacheManager = new CacheManager({projectRoot: this.projectRoot, enabled: this.cache});
         this.installer = new Installer({
             projectRoot: this.projectRoot,
             prismaClient: this.prismaClient,
@@ -395,6 +398,7 @@ class Manager
             adminRoleId: this.adminRoleId,
             stylesFilePath: this.stylesFilePath,
             scriptsFilePath: this.scriptsFilePath,
+            cacheManager: this.cacheManager,
             branding: {
                 companyName: this.companyName,
                 logo: this.logo,
@@ -439,7 +443,9 @@ class Manager
             defaultDomain: this.defaultDomain,
             domainMapping: this.domainMapping,
             siteKeyMapping: this.siteKeyMapping,
-            templateExtensions: this.templateExtensions
+            templateExtensions: this.templateExtensions,
+            entitiesConfig: this.entitiesConfig,
+            cacheManager: this.cacheManager
         });
         return await this.frontend.initialize();
     }